mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
1002 lines
30 KiB
JavaScript
1002 lines
30 KiB
JavaScript
const Cm = Components.manager;
|
|
|
|
// Shared logging for all HTTP server functions.
|
|
Cu.import("resource://gre/modules/Log.jsm");
|
|
const SYNC_HTTP_LOGGER = "Sync.Test.Server";
|
|
const SYNC_API_VERSION = "1.1";
|
|
|
|
// Use the same method that record.js does, which mirrors the server.
|
|
// The server returns timestamps with 1/100 sec granularity. Note that this is
|
|
// subject to change: see Bug 650435.
|
|
function new_timestamp() {
|
|
return Math.round(Date.now() / 10) / 100;
|
|
}
|
|
|
|
function return_timestamp(request, response, timestamp) {
|
|
if (!timestamp) {
|
|
timestamp = new_timestamp();
|
|
}
|
|
let body = "" + timestamp;
|
|
response.setHeader("X-Weave-Timestamp", body);
|
|
response.setStatusLine(request.httpVersion, 200, "OK");
|
|
response.bodyOutputStream.write(body, body.length);
|
|
return timestamp;
|
|
}
|
|
|
|
function basic_auth_header(user, password) {
|
|
return "Basic " + btoa(user + ":" + Utils.encodeUTF8(password));
|
|
}
|
|
|
|
function basic_auth_matches(req, user, password) {
|
|
if (!req.hasHeader("Authorization")) {
|
|
return false;
|
|
}
|
|
|
|
let expected = basic_auth_header(user, Utils.encodeUTF8(password));
|
|
return req.getHeader("Authorization") == expected;
|
|
}
|
|
|
|
function httpd_basic_auth_handler(body, metadata, response) {
|
|
if (basic_auth_matches(metadata, "guest", "guest")) {
|
|
response.setStatusLine(metadata.httpVersion, 200, "OK, authorized");
|
|
response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
|
|
} else {
|
|
body = "This path exists and is protected - failed";
|
|
response.setStatusLine(metadata.httpVersion, 401, "Unauthorized");
|
|
response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
|
|
}
|
|
response.bodyOutputStream.write(body, body.length);
|
|
}
|
|
|
|
/*
|
|
* Represent a WBO on the server
|
|
*/
|
|
function ServerWBO(id, initialPayload, modified) {
|
|
if (!id) {
|
|
throw "No ID for ServerWBO!";
|
|
}
|
|
this.id = id;
|
|
if (!initialPayload) {
|
|
return;
|
|
}
|
|
|
|
if (typeof initialPayload == "object") {
|
|
initialPayload = JSON.stringify(initialPayload);
|
|
}
|
|
this.payload = initialPayload;
|
|
this.modified = modified || new_timestamp();
|
|
}
|
|
ServerWBO.prototype = {
|
|
|
|
get data() {
|
|
return JSON.parse(this.payload);
|
|
},
|
|
|
|
get: function() {
|
|
return JSON.stringify(this, ["id", "modified", "payload"]);
|
|
},
|
|
|
|
put: function(input) {
|
|
input = JSON.parse(input);
|
|
this.payload = input.payload;
|
|
this.modified = new_timestamp();
|
|
},
|
|
|
|
delete: function() {
|
|
delete this.payload;
|
|
delete this.modified;
|
|
},
|
|
|
|
// This handler sets `newModified` on the response body if the collection
|
|
// timestamp has changed. This allows wrapper handlers to extract information
|
|
// that otherwise would exist only in the body stream.
|
|
handler: function() {
|
|
let self = this;
|
|
|
|
return function(request, response) {
|
|
var statusCode = 200;
|
|
var status = "OK";
|
|
var body;
|
|
|
|
switch(request.method) {
|
|
case "GET":
|
|
if (self.payload) {
|
|
body = self.get();
|
|
} else {
|
|
statusCode = 404;
|
|
status = "Not Found";
|
|
body = "Not Found";
|
|
}
|
|
break;
|
|
|
|
case "PUT":
|
|
self.put(readBytesFromInputStream(request.bodyInputStream));
|
|
body = JSON.stringify(self.modified);
|
|
response.setHeader("Content-Type", "application/json");
|
|
response.newModified = self.modified;
|
|
break;
|
|
|
|
case "DELETE":
|
|
self.delete();
|
|
let ts = new_timestamp();
|
|
body = JSON.stringify(ts);
|
|
response.setHeader("Content-Type", "application/json");
|
|
response.newModified = ts;
|
|
break;
|
|
}
|
|
response.setHeader("X-Weave-Timestamp", "" + new_timestamp(), false);
|
|
response.setStatusLine(request.httpVersion, statusCode, status);
|
|
response.bodyOutputStream.write(body, body.length);
|
|
};
|
|
}
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* Represent a collection on the server. The '_wbos' attribute is a
|
|
* mapping of id -> ServerWBO objects.
|
|
*
|
|
* Note that if you want these records to be accessible individually,
|
|
* you need to register their handlers with the server separately, or use a
|
|
* containing HTTP server that will do so on your behalf.
|
|
*
|
|
* @param wbos
|
|
* An object mapping WBO IDs to ServerWBOs.
|
|
* @param acceptNew
|
|
* If true, POSTs to this collection URI will result in new WBOs being
|
|
* created and wired in on the fly.
|
|
* @param timestamp
|
|
* An optional timestamp value to initialize the modified time of the
|
|
* collection. This should be in the format returned by new_timestamp().
|
|
*
|
|
* @return the new ServerCollection instance.
|
|
*
|
|
*/
|
|
function ServerCollection(wbos, acceptNew, timestamp) {
|
|
this._wbos = wbos || {};
|
|
this.acceptNew = acceptNew || false;
|
|
|
|
/*
|
|
* Track modified timestamp.
|
|
* We can't just use the timestamps of contained WBOs: an empty collection
|
|
* has a modified time.
|
|
*/
|
|
this.timestamp = timestamp || new_timestamp();
|
|
this._log = Log.repository.getLogger(SYNC_HTTP_LOGGER);
|
|
}
|
|
ServerCollection.prototype = {
|
|
|
|
/**
|
|
* Convenience accessor for our WBO keys.
|
|
* Excludes deleted items, of course.
|
|
*
|
|
* @param filter
|
|
* A predicate function (applied to the ID and WBO) which dictates
|
|
* whether to include the WBO's ID in the output.
|
|
*
|
|
* @return an array of IDs.
|
|
*/
|
|
keys: function keys(filter) {
|
|
return [id for ([id, wbo] in Iterator(this._wbos))
|
|
if (wbo.payload &&
|
|
(!filter || filter(id, wbo)))];
|
|
},
|
|
|
|
/**
|
|
* Convenience method to get an array of WBOs.
|
|
* Optionally provide a filter function.
|
|
*
|
|
* @param filter
|
|
* A predicate function, applied to the WBO, which dictates whether to
|
|
* include the WBO in the output.
|
|
*
|
|
* @return an array of ServerWBOs.
|
|
*/
|
|
wbos: function wbos(filter) {
|
|
let os = [wbo for ([id, wbo] in Iterator(this._wbos))
|
|
if (wbo.payload)];
|
|
if (filter) {
|
|
return os.filter(filter);
|
|
}
|
|
return os;
|
|
},
|
|
|
|
/**
|
|
* Convenience method to get an array of parsed ciphertexts.
|
|
*
|
|
* @return an array of the payloads of each stored WBO.
|
|
*/
|
|
payloads: function () {
|
|
return this.wbos().map(function (wbo) {
|
|
return JSON.parse(JSON.parse(wbo.payload).ciphertext);
|
|
});
|
|
},
|
|
|
|
// Just for syntactic elegance.
|
|
wbo: function wbo(id) {
|
|
return this._wbos[id];
|
|
},
|
|
|
|
payload: function payload(id) {
|
|
return this.wbo(id).payload;
|
|
},
|
|
|
|
/**
|
|
* Insert the provided WBO under its ID.
|
|
*
|
|
* @return the provided WBO.
|
|
*/
|
|
insertWBO: function insertWBO(wbo) {
|
|
return this._wbos[wbo.id] = wbo;
|
|
},
|
|
|
|
/**
|
|
* Insert the provided payload as part of a new ServerWBO with the provided
|
|
* ID.
|
|
*
|
|
* @param id
|
|
* The GUID for the WBO.
|
|
* @param payload
|
|
* The payload, as provided to the ServerWBO constructor.
|
|
* @param modified
|
|
* An optional modified time for the ServerWBO.
|
|
*
|
|
* @return the inserted WBO.
|
|
*/
|
|
insert: function insert(id, payload, modified) {
|
|
return this.insertWBO(new ServerWBO(id, payload, modified));
|
|
},
|
|
|
|
/**
|
|
* Removes an object entirely from the collection.
|
|
*
|
|
* @param id
|
|
* (string) ID to remove.
|
|
*/
|
|
remove: function remove(id) {
|
|
delete this._wbos[id];
|
|
},
|
|
|
|
_inResultSet: function(wbo, options) {
|
|
return wbo.payload
|
|
&& (!options.ids || (options.ids.indexOf(wbo.id) != -1))
|
|
&& (!options.newer || (wbo.modified > options.newer));
|
|
},
|
|
|
|
count: function(options) {
|
|
options = options || {};
|
|
let c = 0;
|
|
for (let [id, wbo] in Iterator(this._wbos)) {
|
|
if (wbo.modified && this._inResultSet(wbo, options)) {
|
|
c++;
|
|
}
|
|
}
|
|
return c;
|
|
},
|
|
|
|
get: function(options) {
|
|
let result;
|
|
if (options.full) {
|
|
let data = [wbo.get() for ([id, wbo] in Iterator(this._wbos))
|
|
// Drop deleted.
|
|
if (wbo.modified &&
|
|
this._inResultSet(wbo, options))];
|
|
if (options.limit) {
|
|
data = data.slice(0, options.limit);
|
|
}
|
|
// Our implementation of application/newlines.
|
|
result = data.join("\n") + "\n";
|
|
|
|
// Use options as a backchannel to report count.
|
|
options.recordCount = data.length;
|
|
} else {
|
|
let data = [id for ([id, wbo] in Iterator(this._wbos))
|
|
if (this._inResultSet(wbo, options))];
|
|
if (options.limit) {
|
|
data = data.slice(0, options.limit);
|
|
}
|
|
result = JSON.stringify(data);
|
|
options.recordCount = data.length;
|
|
}
|
|
return result;
|
|
},
|
|
|
|
post: function(input) {
|
|
input = JSON.parse(input);
|
|
let success = [];
|
|
let failed = {};
|
|
|
|
// This will count records where we have an existing ServerWBO
|
|
// registered with us as successful and all other records as failed.
|
|
for each (let record in input) {
|
|
let wbo = this.wbo(record.id);
|
|
if (!wbo && this.acceptNew) {
|
|
this._log.debug("Creating WBO " + JSON.stringify(record.id) +
|
|
" on the fly.");
|
|
wbo = new ServerWBO(record.id);
|
|
this.insertWBO(wbo);
|
|
}
|
|
if (wbo) {
|
|
wbo.payload = record.payload;
|
|
wbo.modified = new_timestamp();
|
|
success.push(record.id);
|
|
} else {
|
|
failed[record.id] = "no wbo configured";
|
|
}
|
|
}
|
|
return {modified: new_timestamp(),
|
|
success: success,
|
|
failed: failed};
|
|
},
|
|
|
|
delete: function(options) {
|
|
let deleted = [];
|
|
for (let [id, wbo] in Iterator(this._wbos)) {
|
|
if (this._inResultSet(wbo, options)) {
|
|
this._log.debug("Deleting " + JSON.stringify(wbo));
|
|
deleted.push(wbo.id);
|
|
wbo.delete();
|
|
}
|
|
}
|
|
return deleted;
|
|
},
|
|
|
|
// This handler sets `newModified` on the response body if the collection
|
|
// timestamp has changed.
|
|
handler: function() {
|
|
let self = this;
|
|
|
|
return function(request, response) {
|
|
var statusCode = 200;
|
|
var status = "OK";
|
|
var body;
|
|
|
|
// Parse queryString
|
|
let options = {};
|
|
for each (let chunk in request.queryString.split("&")) {
|
|
if (!chunk) {
|
|
continue;
|
|
}
|
|
chunk = chunk.split("=");
|
|
if (chunk.length == 1) {
|
|
options[chunk[0]] = "";
|
|
} else {
|
|
options[chunk[0]] = chunk[1];
|
|
}
|
|
}
|
|
if (options.ids) {
|
|
options.ids = options.ids.split(",");
|
|
}
|
|
if (options.newer) {
|
|
options.newer = parseFloat(options.newer);
|
|
}
|
|
if (options.limit) {
|
|
options.limit = parseInt(options.limit, 10);
|
|
}
|
|
|
|
switch(request.method) {
|
|
case "GET":
|
|
body = self.get(options);
|
|
// "If supported by the db, this header will return the number of
|
|
// records total in the request body of any multiple-record GET
|
|
// request."
|
|
let records = options.recordCount;
|
|
self._log.info("Records: " + records);
|
|
if (records != null) {
|
|
response.setHeader("X-Weave-Records", "" + records);
|
|
}
|
|
break;
|
|
|
|
case "POST":
|
|
let res = self.post(readBytesFromInputStream(request.bodyInputStream));
|
|
body = JSON.stringify(res);
|
|
response.newModified = res.modified;
|
|
break;
|
|
|
|
case "DELETE":
|
|
self._log.debug("Invoking ServerCollection.DELETE.");
|
|
let deleted = self.delete(options);
|
|
let ts = new_timestamp();
|
|
body = JSON.stringify(ts);
|
|
response.newModified = ts;
|
|
response.deleted = deleted;
|
|
break;
|
|
}
|
|
response.setHeader("X-Weave-Timestamp",
|
|
"" + new_timestamp(),
|
|
false);
|
|
response.setStatusLine(request.httpVersion, statusCode, status);
|
|
response.bodyOutputStream.write(body, body.length);
|
|
|
|
// Update the collection timestamp to the appropriate modified time.
|
|
// This is either a value set by the handler, or the current time.
|
|
if (request.method != "GET") {
|
|
this.timestamp = (response.newModified >= 0) ?
|
|
response.newModified :
|
|
new_timestamp();
|
|
}
|
|
};
|
|
}
|
|
|
|
};
|
|
|
|
/*
|
|
* Test setup helpers.
|
|
*/
|
|
function sync_httpd_setup(handlers) {
|
|
handlers["/1.1/foo/storage/meta/global"]
|
|
= (new ServerWBO("global", {})).handler();
|
|
return httpd_setup(handlers);
|
|
}
|
|
|
|
/*
|
|
* Track collection modified times. Return closures.
|
|
*/
|
|
function track_collections_helper() {
|
|
|
|
/*
|
|
* Our tracking object.
|
|
*/
|
|
let collections = {};
|
|
|
|
/*
|
|
* Update the timestamp of a collection.
|
|
*/
|
|
function update_collection(coll, ts) {
|
|
_("Updating collection " + coll + " to " + ts);
|
|
let timestamp = ts || new_timestamp();
|
|
collections[coll] = timestamp;
|
|
}
|
|
|
|
/*
|
|
* Invoke a handler, updating the collection's modified timestamp unless
|
|
* it's a GET request.
|
|
*/
|
|
function with_updated_collection(coll, f) {
|
|
return function(request, response) {
|
|
f.call(this, request, response);
|
|
|
|
// Update the collection timestamp to the appropriate modified time.
|
|
// This is either a value set by the handler, or the current time.
|
|
if (request.method != "GET") {
|
|
update_collection(coll, response.newModified)
|
|
}
|
|
};
|
|
}
|
|
|
|
/*
|
|
* Return the info/collections object.
|
|
*/
|
|
function info_collections(request, response) {
|
|
let body = "Error.";
|
|
switch(request.method) {
|
|
case "GET":
|
|
body = JSON.stringify(collections);
|
|
break;
|
|
default:
|
|
throw "Non-GET on info_collections.";
|
|
}
|
|
|
|
response.setHeader("Content-Type", "application/json");
|
|
response.setHeader("X-Weave-Timestamp",
|
|
"" + new_timestamp(),
|
|
false);
|
|
response.setStatusLine(request.httpVersion, 200, "OK");
|
|
response.bodyOutputStream.write(body, body.length);
|
|
}
|
|
|
|
return {"collections": collections,
|
|
"handler": info_collections,
|
|
"with_updated_collection": with_updated_collection,
|
|
"update_collection": update_collection};
|
|
}
|
|
|
|
//===========================================================================//
|
|
// httpd.js-based Sync server. //
|
|
//===========================================================================//
|
|
|
|
/**
|
|
* In general, the preferred way of using SyncServer is to directly introspect
|
|
* it. Callbacks are available for operations which are hard to verify through
|
|
* introspection, such as deletions.
|
|
*
|
|
* One of the goals of this server is to provide enough hooks for test code to
|
|
* find out what it needs without monkeypatching. Use this object as your
|
|
* prototype, and override as appropriate.
|
|
*/
|
|
let SyncServerCallback = {
|
|
onCollectionDeleted: function onCollectionDeleted(user, collection) {},
|
|
onItemDeleted: function onItemDeleted(user, collection, wboID) {},
|
|
|
|
/**
|
|
* Called at the top of every request.
|
|
*
|
|
* Allows the test to inspect the request. Hooks should be careful not to
|
|
* modify or change state of the request or they may impact future processing.
|
|
*/
|
|
onRequest: function onRequest(request) {},
|
|
};
|
|
|
|
/**
|
|
* Construct a new test Sync server. Takes a callback object (e.g.,
|
|
* SyncServerCallback) as input.
|
|
*/
|
|
function SyncServer(callback) {
|
|
this.callback = callback || {__proto__: SyncServerCallback};
|
|
this.server = new HttpServer();
|
|
this.started = false;
|
|
this.users = {};
|
|
this._log = Log.repository.getLogger(SYNC_HTTP_LOGGER);
|
|
|
|
// Install our own default handler. This allows us to mess around with the
|
|
// whole URL space.
|
|
let handler = this.server._handler;
|
|
handler._handleDefault = this.handleDefault.bind(this, handler);
|
|
}
|
|
SyncServer.prototype = {
|
|
server: null, // HttpServer.
|
|
users: null, // Map of username => {collections, password}.
|
|
|
|
/**
|
|
* Start the SyncServer's underlying HTTP server.
|
|
*
|
|
* @param port
|
|
* The numeric port on which to start. A falsy value implies the
|
|
* default, a randomly chosen port.
|
|
* @param cb
|
|
* A callback function (of no arguments) which is invoked after
|
|
* startup.
|
|
*/
|
|
start: function start(port, cb) {
|
|
if (this.started) {
|
|
this._log.warn("Warning: server already started on " + this.port);
|
|
return;
|
|
}
|
|
try {
|
|
this.server.start(port);
|
|
let i = this.server.identity;
|
|
this.port = i.primaryPort;
|
|
this.baseURI = i.primaryScheme + "://" + i.primaryHost + ":" +
|
|
i.primaryPort + "/";
|
|
this.started = true;
|
|
if (cb) {
|
|
cb();
|
|
}
|
|
} catch (ex) {
|
|
_("==========================================");
|
|
_("Got exception starting Sync HTTP server.");
|
|
_("Error: " + Utils.exceptionStr(ex));
|
|
_("Is there a process already listening on port " + port + "?");
|
|
_("==========================================");
|
|
do_throw(ex);
|
|
}
|
|
|
|
},
|
|
|
|
/**
|
|
* Stop the SyncServer's HTTP server.
|
|
*
|
|
* @param cb
|
|
* A callback function. Invoked after the server has been stopped.
|
|
*
|
|
*/
|
|
stop: function stop(cb) {
|
|
if (!this.started) {
|
|
this._log.warn("SyncServer: Warning: server not running. Can't stop me now!");
|
|
return;
|
|
}
|
|
|
|
this.server.stop(cb);
|
|
this.started = false;
|
|
},
|
|
|
|
/**
|
|
* Return a server timestamp for a record.
|
|
* The server returns timestamps with 1/100 sec granularity. Note that this is
|
|
* subject to change: see Bug 650435.
|
|
*/
|
|
timestamp: function timestamp() {
|
|
return new_timestamp();
|
|
},
|
|
|
|
/**
|
|
* Create a new user, complete with an empty set of collections.
|
|
*
|
|
* @param username
|
|
* The username to use. An Error will be thrown if a user by that name
|
|
* already exists.
|
|
* @param password
|
|
* A password string.
|
|
*
|
|
* @return a user object, as would be returned by server.user(username).
|
|
*/
|
|
registerUser: function registerUser(username, password) {
|
|
if (username in this.users) {
|
|
throw new Error("User already exists.");
|
|
}
|
|
this.users[username] = {
|
|
password: password,
|
|
collections: {}
|
|
};
|
|
return this.user(username);
|
|
},
|
|
|
|
userExists: function userExists(username) {
|
|
return username in this.users;
|
|
},
|
|
|
|
getCollection: function getCollection(username, collection) {
|
|
return this.users[username].collections[collection];
|
|
},
|
|
|
|
_insertCollection: function _insertCollection(collections, collection, wbos) {
|
|
let coll = new ServerCollection(wbos, true);
|
|
coll.collectionHandler = coll.handler();
|
|
collections[collection] = coll;
|
|
return coll;
|
|
},
|
|
|
|
createCollection: function createCollection(username, collection, wbos) {
|
|
if (!(username in this.users)) {
|
|
throw new Error("Unknown user.");
|
|
}
|
|
let collections = this.users[username].collections;
|
|
if (collection in collections) {
|
|
throw new Error("Collection already exists.");
|
|
}
|
|
return this._insertCollection(collections, collection, wbos);
|
|
},
|
|
|
|
/**
|
|
* Accept a map like the following:
|
|
* {
|
|
* meta: {global: {version: 1, ...}},
|
|
* crypto: {"keys": {}, foo: {bar: 2}},
|
|
* bookmarks: {}
|
|
* }
|
|
* to cause collections and WBOs to be created.
|
|
* If a collection already exists, no error is raised.
|
|
* If a WBO already exists, it will be updated to the new contents.
|
|
*/
|
|
createContents: function createContents(username, collections) {
|
|
if (!(username in this.users)) {
|
|
throw new Error("Unknown user.");
|
|
}
|
|
let userCollections = this.users[username].collections;
|
|
for (let [id, contents] in Iterator(collections)) {
|
|
let coll = userCollections[id] ||
|
|
this._insertCollection(userCollections, id);
|
|
for (let [wboID, payload] in Iterator(contents)) {
|
|
coll.insert(wboID, payload);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Insert a WBO in an existing collection.
|
|
*/
|
|
insertWBO: function insertWBO(username, collection, wbo) {
|
|
if (!(username in this.users)) {
|
|
throw new Error("Unknown user.");
|
|
}
|
|
let userCollections = this.users[username].collections;
|
|
if (!(collection in userCollections)) {
|
|
throw new Error("Unknown collection.");
|
|
}
|
|
userCollections[collection].insertWBO(wbo);
|
|
return wbo;
|
|
},
|
|
|
|
/**
|
|
* Delete all of the collections for the named user.
|
|
*
|
|
* @param username
|
|
* The name of the affected user.
|
|
*
|
|
* @return a timestamp.
|
|
*/
|
|
deleteCollections: function deleteCollections(username) {
|
|
if (!(username in this.users)) {
|
|
throw new Error("Unknown user.");
|
|
}
|
|
let userCollections = this.users[username].collections;
|
|
for each (let [name, coll] in Iterator(userCollections)) {
|
|
this._log.trace("Bulk deleting " + name + " for " + username + "...");
|
|
coll.delete({});
|
|
}
|
|
this.users[username].collections = {};
|
|
return this.timestamp();
|
|
},
|
|
|
|
/**
|
|
* Simple accessor to allow collective binding and abbreviation of a bunch of
|
|
* methods. Yay!
|
|
* Use like this:
|
|
*
|
|
* let u = server.user("john");
|
|
* u.collection("bookmarks").wbo("abcdefg").payload; // Etc.
|
|
*
|
|
* @return a proxy for the user data stored in this server.
|
|
*/
|
|
user: function user(username) {
|
|
let collection = this.getCollection.bind(this, username);
|
|
let createCollection = this.createCollection.bind(this, username);
|
|
let createContents = this.createContents.bind(this, username);
|
|
let modified = function (collectionName) {
|
|
return collection(collectionName).timestamp;
|
|
}
|
|
let deleteCollections = this.deleteCollections.bind(this, username);
|
|
return {
|
|
collection: collection,
|
|
createCollection: createCollection,
|
|
createContents: createContents,
|
|
deleteCollections: deleteCollections,
|
|
modified: modified
|
|
};
|
|
},
|
|
|
|
/*
|
|
* Regular expressions for splitting up Sync request paths.
|
|
* Sync URLs are of the form:
|
|
* /$apipath/$version/$user/$further
|
|
* where $further is usually:
|
|
* storage/$collection/$wbo
|
|
* or
|
|
* storage/$collection
|
|
* or
|
|
* info/$op
|
|
* We assume for the sake of simplicity that $apipath is empty.
|
|
*
|
|
* N.B., we don't follow any kind of username spec here, because as far as I
|
|
* can tell there isn't one. See Bug 689671. Instead we follow the Python
|
|
* server code.
|
|
*
|
|
* Path: [all, version, username, first, rest]
|
|
* Storage: [all, collection?, id?]
|
|
*/
|
|
pathRE: /^\/([0-9]+(?:\.[0-9]+)?)\/([-._a-zA-Z0-9]+)(?:\/([^\/]+)(?:\/(.+))?)?$/,
|
|
storageRE: /^([-_a-zA-Z0-9]+)(?:\/([-_a-zA-Z0-9]+)\/?)?$/,
|
|
|
|
defaultHeaders: {},
|
|
|
|
/**
|
|
* HTTP response utility.
|
|
*/
|
|
respond: function respond(req, resp, code, status, body, headers) {
|
|
resp.setStatusLine(req.httpVersion, code, status);
|
|
for each (let [header, value] in Iterator(headers || this.defaultHeaders)) {
|
|
resp.setHeader(header, value);
|
|
}
|
|
resp.setHeader("X-Weave-Timestamp", "" + this.timestamp(), false);
|
|
resp.bodyOutputStream.write(body, body.length);
|
|
},
|
|
|
|
/**
|
|
* This is invoked by the HttpServer. `this` is bound to the SyncServer;
|
|
* `handler` is the HttpServer's handler.
|
|
*
|
|
* TODO: need to use the correct Sync API response codes and errors here.
|
|
* TODO: Basic Auth.
|
|
* TODO: check username in path against username in BasicAuth.
|
|
*/
|
|
handleDefault: function handleDefault(handler, req, resp) {
|
|
try {
|
|
this._handleDefault(handler, req, resp);
|
|
} catch (e) {
|
|
if (e instanceof HttpError) {
|
|
this.respond(req, resp, e.code, e.description, "", {});
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
},
|
|
|
|
_handleDefault: function _handleDefault(handler, req, resp) {
|
|
this._log.debug("SyncServer: Handling request: " + req.method + " " + req.path);
|
|
|
|
if (this.callback.onRequest) {
|
|
this.callback.onRequest(req);
|
|
}
|
|
|
|
let parts = this.pathRE.exec(req.path);
|
|
if (!parts) {
|
|
this._log.debug("SyncServer: Unexpected request: bad URL " + req.path);
|
|
throw HTTP_404;
|
|
}
|
|
|
|
let [all, version, username, first, rest] = parts;
|
|
// Doing a float compare of the version allows for us to pretend there was
|
|
// a node-reassignment - eg, we could re-assign from "1.1/user/" to
|
|
// "1.10/user" - this server will then still accept requests with the new
|
|
// URL while any code in sync itself which compares URLs will see a
|
|
// different URL.
|
|
if (parseFloat(version) != parseFloat(SYNC_API_VERSION)) {
|
|
this._log.debug("SyncServer: Unknown version.");
|
|
throw HTTP_404;
|
|
}
|
|
|
|
if (!this.userExists(username)) {
|
|
this._log.debug("SyncServer: Unknown user.");
|
|
throw HTTP_401;
|
|
}
|
|
|
|
// Hand off to the appropriate handler for this path component.
|
|
if (first in this.toplevelHandlers) {
|
|
let handler = this.toplevelHandlers[first];
|
|
return handler.call(this, handler, req, resp, version, username, rest);
|
|
}
|
|
this._log.debug("SyncServer: Unknown top-level " + first);
|
|
throw HTTP_404;
|
|
},
|
|
|
|
/**
|
|
* Compute the object that is returned for an info/collections request.
|
|
*/
|
|
infoCollections: function infoCollections(username) {
|
|
let responseObject = {};
|
|
let colls = this.users[username].collections;
|
|
for (let coll in colls) {
|
|
responseObject[coll] = colls[coll].timestamp;
|
|
}
|
|
this._log.trace("SyncServer: info/collections returning " +
|
|
JSON.stringify(responseObject));
|
|
return responseObject;
|
|
},
|
|
|
|
/**
|
|
* Collection of the handler methods we use for top-level path components.
|
|
*/
|
|
toplevelHandlers: {
|
|
"storage": function handleStorage(handler, req, resp, version, username, rest) {
|
|
let respond = this.respond.bind(this, req, resp);
|
|
if (!rest || !rest.length) {
|
|
this._log.debug("SyncServer: top-level storage " +
|
|
req.method + " request.");
|
|
|
|
// TODO: verify if this is spec-compliant.
|
|
if (req.method != "DELETE") {
|
|
respond(405, "Method Not Allowed", "[]", {"Allow": "DELETE"});
|
|
return undefined;
|
|
}
|
|
|
|
// Delete all collections and track the timestamp for the response.
|
|
let timestamp = this.user(username).deleteCollections();
|
|
|
|
// Return timestamp and OK for deletion.
|
|
respond(200, "OK", JSON.stringify(timestamp));
|
|
return undefined;
|
|
}
|
|
|
|
let match = this.storageRE.exec(rest);
|
|
if (!match) {
|
|
this._log.warn("SyncServer: Unknown storage operation " + rest);
|
|
throw HTTP_404;
|
|
}
|
|
let [all, collection, wboID] = match;
|
|
let coll = this.getCollection(username, collection);
|
|
switch (req.method) {
|
|
case "GET":
|
|
if (!coll) {
|
|
if (wboID) {
|
|
respond(404, "Not found", "Not found");
|
|
return undefined;
|
|
}
|
|
// *cries inside*: Bug 687299.
|
|
respond(200, "OK", "[]");
|
|
return undefined;
|
|
}
|
|
if (!wboID) {
|
|
return coll.collectionHandler(req, resp);
|
|
}
|
|
let wbo = coll.wbo(wboID);
|
|
if (!wbo) {
|
|
respond(404, "Not found", "Not found");
|
|
return undefined;
|
|
}
|
|
return wbo.handler()(req, resp);
|
|
|
|
// TODO: implement handling of X-If-Unmodified-Since for write verbs.
|
|
case "DELETE":
|
|
if (!coll) {
|
|
respond(200, "OK", "{}");
|
|
return undefined;
|
|
}
|
|
if (wboID) {
|
|
let wbo = coll.wbo(wboID);
|
|
if (wbo) {
|
|
wbo.delete();
|
|
this.callback.onItemDeleted(username, collection, wboID);
|
|
}
|
|
respond(200, "OK", "{}");
|
|
return undefined;
|
|
}
|
|
coll.collectionHandler(req, resp);
|
|
|
|
// Spot if this is a DELETE for some IDs, and don't blow away the
|
|
// whole collection!
|
|
//
|
|
// We already handled deleting the WBOs by invoking the deleted
|
|
// collection's handler. However, in the case of
|
|
//
|
|
// DELETE storage/foobar
|
|
//
|
|
// we also need to remove foobar from the collections map. This
|
|
// clause tries to differentiate the above request from
|
|
//
|
|
// DELETE storage/foobar?ids=foo,baz
|
|
//
|
|
// and do the right thing.
|
|
// TODO: less hacky method.
|
|
if (-1 == req.queryString.indexOf("ids=")) {
|
|
// When you delete the entire collection, we drop it.
|
|
this._log.debug("Deleting entire collection.");
|
|
delete this.users[username].collections[collection];
|
|
this.callback.onCollectionDeleted(username, collection);
|
|
}
|
|
|
|
// Notify of item deletion.
|
|
let deleted = resp.deleted || [];
|
|
for (let i = 0; i < deleted.length; ++i) {
|
|
this.callback.onItemDeleted(username, collection, deleted[i]);
|
|
}
|
|
return undefined;
|
|
case "POST":
|
|
case "PUT":
|
|
if (!coll) {
|
|
coll = this.createCollection(username, collection);
|
|
}
|
|
if (wboID) {
|
|
let wbo = coll.wbo(wboID);
|
|
if (!wbo) {
|
|
this._log.trace("SyncServer: creating WBO " + collection + "/" + wboID);
|
|
wbo = coll.insert(wboID);
|
|
}
|
|
// Rather than instantiate each WBO's handler function, do it once
|
|
// per request. They get hit far less often than do collections.
|
|
wbo.handler()(req, resp);
|
|
coll.timestamp = resp.newModified;
|
|
return resp;
|
|
}
|
|
return coll.collectionHandler(req, resp);
|
|
default:
|
|
throw "Request method " + req.method + " not implemented.";
|
|
}
|
|
},
|
|
|
|
"info": function handleInfo(handler, req, resp, version, username, rest) {
|
|
switch (rest) {
|
|
case "collections":
|
|
let body = JSON.stringify(this.infoCollections(username));
|
|
this.respond(req, resp, 200, "OK", body, {
|
|
"Content-Type": "application/json"
|
|
});
|
|
return;
|
|
case "collection_usage":
|
|
case "collection_counts":
|
|
case "quota":
|
|
// TODO: implement additional info methods.
|
|
this.respond(req, resp, 200, "OK", "TODO");
|
|
return;
|
|
default:
|
|
// TODO
|
|
this._log.warn("SyncServer: Unknown info operation " + rest);
|
|
throw HTTP_404;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Test helper.
|
|
*/
|
|
function serverForUsers(users, contents, callback) {
|
|
let server = new SyncServer(callback);
|
|
for (let [user, pass] in Iterator(users)) {
|
|
server.registerUser(user, pass);
|
|
server.createContents(user, contents);
|
|
}
|
|
server.start();
|
|
return server;
|
|
}
|