308 lines
10 KiB
JavaScript
308 lines
10 KiB
JavaScript
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"use strict";
|
|
|
|
const Cu = Components.utils;
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
const CC = Components.Constructor;
|
|
|
|
this.EXPORTED_SYMBOLS = ["OfflineCacheInstaller"];
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
Cu.import("resource://gre/modules/AppsUtils.jsm");
|
|
Cu.import("resource://gre/modules/NetUtil.jsm");
|
|
|
|
var Namespace = CC('@mozilla.org/network/application-cache-namespace;1',
|
|
'nsIApplicationCacheNamespace',
|
|
'init');
|
|
var makeFile = CC('@mozilla.org/file/local;1',
|
|
'nsIFile',
|
|
'initWithPath');
|
|
var MutableArray = CC('@mozilla.org/array;1', 'nsIMutableArray');
|
|
|
|
var {LoadContextInfo} = Cu.import("resource://gre/modules/LoadContextInfo.jsm", {});
|
|
|
|
const nsICacheStorage = Ci.nsICacheStorage;
|
|
const nsIApplicationCache = Ci.nsIApplicationCache;
|
|
const applicationCacheService =
|
|
Cc['@mozilla.org/network/application-cache-service;1']
|
|
.getService(Ci.nsIApplicationCacheService);
|
|
|
|
|
|
function debug(aMsg) {
|
|
//dump("-*-*- OfflineCacheInstaller.jsm : " + aMsg + "\n");
|
|
}
|
|
|
|
|
|
function enableOfflineCacheForApp(aPrincipal) {
|
|
Services.perms.addFromPrincipal(aPrincipal, 'offline-app',
|
|
Ci.nsIPermissionManager.ALLOW_ACTION);
|
|
// Prevent cache from being evicted:
|
|
Services.perms.addFromPrincipal(aPrincipal, 'pin-app',
|
|
Ci.nsIPermissionManager.ALLOW_ACTION);
|
|
}
|
|
|
|
|
|
function storeCache(applicationCache, url, file, itemType, metadata) {
|
|
let storage =
|
|
Services.cache2.appCacheStorage(LoadContextInfo.default, applicationCache);
|
|
let uri = Services.io.newURI(url, null, null);
|
|
let nowGMT = new Date().toGMTString();
|
|
metadata = metadata || {};
|
|
metadata.lastFetched = metadata.lastFetched || nowGMT;
|
|
metadata.lastModified = metadata.lastModified || nowGMT;
|
|
storage.asyncOpenURI(uri, "", nsICacheStorage.OPEN_TRUNCATE, {
|
|
onCacheEntryAvailable:
|
|
function (cacheEntry, isNew, appCache, result) {
|
|
cacheEntry.setMetaDataElement("request-method", "GET");
|
|
cacheEntry.setMetaDataElement("response-head",
|
|
"HTTP/1.1 200 OK\r\n" +
|
|
"Date: " + metadata.lastFetched + "\r\n" +
|
|
"Last-Modified: " + metadata.lastModified + "\r\n" +
|
|
"Cache-Control: no-cache\r\n");
|
|
|
|
let outputStream = cacheEntry.openOutputStream(0);
|
|
|
|
// Input-Output stream machinery in order to push nsIFile content into
|
|
// cache
|
|
let inputStream = Cc["@mozilla.org/network/file-input-stream;1"]
|
|
.createInstance(Ci.nsIFileInputStream);
|
|
inputStream.init(file, 1, -1, null);
|
|
let bufferedOutputStream =
|
|
Cc["@mozilla.org/network/buffered-output-stream;1"]
|
|
.createInstance(Ci.nsIBufferedOutputStream);
|
|
bufferedOutputStream.init(outputStream, 1024);
|
|
bufferedOutputStream.writeFrom(inputStream, inputStream.available());
|
|
bufferedOutputStream.flush();
|
|
bufferedOutputStream.close();
|
|
inputStream.close();
|
|
|
|
cacheEntry.setExpirationTime(0);
|
|
cacheEntry.markValid();
|
|
debug (file.path + " -> " + url + " (" + itemType + ")");
|
|
applicationCache.markEntry(url, itemType);
|
|
cacheEntry.close();
|
|
}
|
|
});
|
|
}
|
|
|
|
function readFile(aFile, aPrincipal, aCallback) {
|
|
|
|
let channel = NetUtil.newChannel({
|
|
uri: NetUtil.newURI(aFile),
|
|
loadingPrincipal: aPrincipal,
|
|
contentPolicyType: Ci.nsIContentPolicy.TYPE_OTHER});
|
|
channel.contentType = "plain/text";
|
|
NetUtil.asyncFetch(channel, function(aStream, aResult) {
|
|
if (!Components.isSuccessCode(aResult)) {
|
|
Cu.reportError("OfflineCacheInstaller: Could not read file " + aFile.path);
|
|
if (aCallback)
|
|
aCallback(null);
|
|
return;
|
|
}
|
|
|
|
// Obtain a converter to read from a UTF-8 encoded input stream.
|
|
let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
|
|
.createInstance(Ci.nsIScriptableUnicodeConverter);
|
|
converter.charset = "UTF-8";
|
|
|
|
let data = NetUtil.readInputStreamToString(aStream,
|
|
aStream.available());
|
|
aCallback(converter.ConvertToUnicode(data));
|
|
});
|
|
}
|
|
|
|
function parseCacheLine(app, urls, line) {
|
|
try {
|
|
let url = Services.io.newURI(line, null, app.origin);
|
|
urls.push(url.spec);
|
|
} catch(e) {
|
|
throw new Error('Unable to parse cache line: ' + line + '(' + e + ')');
|
|
}
|
|
}
|
|
|
|
function parseFallbackLine(app, urls, namespaces, fallbacks, line) {
|
|
let split = line.split(/[ \t]+/);
|
|
if (split.length != 2) {
|
|
throw new Error('Should be made of two URLs seperated with spaces')
|
|
}
|
|
let type = Ci.nsIApplicationCacheNamespace.NAMESPACE_FALLBACK;
|
|
let [ namespace, fallback ] = split;
|
|
|
|
// Prepend webapp origin in case of absolute path
|
|
try {
|
|
namespace = Services.io.newURI(namespace, null, app.origin).spec;
|
|
fallback = Services.io.newURI(fallback, null, app.origin).spec;
|
|
} catch(e) {
|
|
throw new Error('Unable to parse fallback line: ' + line + '(' + e + ')');
|
|
}
|
|
|
|
namespaces.push([type, namespace, fallback]);
|
|
fallbacks.push(fallback);
|
|
urls.push(fallback);
|
|
}
|
|
|
|
function parseNetworkLine(namespaces, line) {
|
|
let type = Ci.nsIApplicationCacheNamespace.NAMESPACE_BYPASS;
|
|
if (line[0] == '*' && (line.length == 1 || line[1] == ' '
|
|
|| line[1] == '\t')) {
|
|
namespaces.push([type, '', '']);
|
|
} else {
|
|
namespaces.push([type, namespace, '']);
|
|
}
|
|
}
|
|
|
|
function parseAppCache(app, path, content) {
|
|
let lines = content.split(/\r?\n/);
|
|
|
|
let urls = [];
|
|
let namespaces = [];
|
|
let fallbacks = [];
|
|
|
|
let currentSection = 'CACHE';
|
|
for (let i = 0; i < lines.length; i++) {
|
|
let line = lines[i];
|
|
|
|
// Ignore comments
|
|
if (/^#/.test(line) || !line.length)
|
|
continue;
|
|
|
|
// Process section headers
|
|
if (line == 'CACHE MANIFEST')
|
|
continue;
|
|
if (line == 'CACHE:') {
|
|
currentSection = 'CACHE';
|
|
continue;
|
|
} else if (line == 'NETWORK:') {
|
|
currentSection = 'NETWORK';
|
|
continue;
|
|
} else if (line == 'FALLBACK:') {
|
|
currentSection = 'FALLBACK';
|
|
continue;
|
|
}
|
|
|
|
// Process cache, network and fallback rules
|
|
try {
|
|
if (currentSection == 'CACHE') {
|
|
parseCacheLine(app, urls, line);
|
|
} else if (currentSection == 'NETWORK') {
|
|
parseNetworkLine(namespaces, line);
|
|
} else if (currentSection == 'FALLBACK') {
|
|
parseFallbackLine(app, urls, namespaces, fallbacks, line);
|
|
}
|
|
} catch(e) {
|
|
throw new Error('Invalid ' + currentSection + ' line in appcache ' +
|
|
'manifest:\n' + e.message +
|
|
'\nFrom: ' + path +
|
|
'\nLine ' + i + ': ' + line);
|
|
}
|
|
}
|
|
|
|
return {
|
|
urls: urls,
|
|
namespaces: namespaces,
|
|
fallbacks: fallbacks
|
|
};
|
|
}
|
|
|
|
function installCache(app) {
|
|
if (!app.cachePath) {
|
|
return;
|
|
}
|
|
|
|
let cacheDir = makeFile(app.cachePath);
|
|
cacheDir.append(app.appId);
|
|
|
|
let resourcesMetadata = cacheDir.clone();
|
|
resourcesMetadata.append('resources_metadata.json');
|
|
|
|
cacheDir.append('cache');
|
|
if (!cacheDir.exists())
|
|
return;
|
|
|
|
let cacheManifest = cacheDir.clone();
|
|
cacheManifest.append('manifest.appcache');
|
|
if (!cacheManifest.exists())
|
|
return;
|
|
|
|
let principal =
|
|
Services.scriptSecurityManager.createCodebasePrincipal(app.origin, {appId: app.localId});
|
|
|
|
// If the build has been correctly configured, this should not happen!
|
|
// If we install the cache anyway, it won't be updateable. If we don't install
|
|
// it, the application won't be useable offline.
|
|
let metadataLoaded;
|
|
if (!resourcesMetadata.exists()) {
|
|
// Not debug, since this is something that should be logged always!
|
|
dump("OfflineCacheInstaller: App " + app.appId + " does have an app cache" +
|
|
" but does not have a resources_metadata.json file!");
|
|
metadataLoaded = Promise.resolve({});
|
|
} else {
|
|
metadataLoaded = new Promise(
|
|
(resolve, reject) =>
|
|
readFile(resourcesMetadata, principal, content => resolve(JSON.parse(content))));
|
|
}
|
|
|
|
metadataLoaded.then(function(metadata) {
|
|
enableOfflineCacheForApp(principal);
|
|
|
|
// Get the url for the manifest.
|
|
let appcacheURL = app.appcache_path;
|
|
|
|
// The group ID contains application id and 'f' for not being hosted in
|
|
// a browser element, but a mozbrowser iframe.
|
|
// See netwerk/cache/nsDiskCacheDeviceSQL.cpp: AppendJARIdentifier
|
|
let groupID = appcacheURL + '#' + app.localId+ '+f';
|
|
let applicationCache = applicationCacheService.createApplicationCache(groupID);
|
|
applicationCache.activate();
|
|
|
|
readFile(cacheManifest, principal, function readAppCache(content) {
|
|
let entries = parseAppCache(app, cacheManifest.path, content);
|
|
|
|
entries.urls.forEach(function processCachedFile(url) {
|
|
// Get this nsIFile from cache folder for this URL
|
|
// We have absolute urls, so remove the origin part to locate the
|
|
// files.
|
|
let path = url.replace(app.origin.spec, '');
|
|
let file = cacheDir.clone();
|
|
let paths = path.split('/');
|
|
paths.forEach(file.append);
|
|
|
|
if (!file.exists()) {
|
|
let msg = 'File ' + file.path + ' exists in the manifest but does ' +
|
|
'not points to a real file.';
|
|
throw new Error(msg);
|
|
}
|
|
|
|
let itemType = nsIApplicationCache.ITEM_EXPLICIT;
|
|
if (entries.fallbacks.indexOf(url) > -1) {
|
|
debug('add fallback: ' + url + '\n');
|
|
itemType |= nsIApplicationCache.ITEM_FALLBACK;
|
|
}
|
|
storeCache(applicationCache, url, file, itemType, metadata[path]);
|
|
});
|
|
|
|
let array = new MutableArray();
|
|
entries.namespaces.forEach(function processNamespace([type, spec, data]) {
|
|
debug('add namespace: ' + type + ' - ' + spec + ' - ' + data + '\n');
|
|
array.appendElement(new Namespace(type, spec, data), false);
|
|
});
|
|
applicationCache.addNamespaces(array);
|
|
|
|
storeCache(applicationCache, appcacheURL, cacheManifest,
|
|
nsIApplicationCache.ITEM_MANIFEST);
|
|
});
|
|
});
|
|
}
|
|
|
|
|
|
// Public API
|
|
|
|
this.OfflineCacheInstaller = {
|
|
installCache: installCache
|
|
};
|
|
|