Merge lp:~urbanape/bindwood/dbus-and-local-uuids into lp:~urbanape/bindwood/trunk

[Zachery Bir]

[Zachery Bir (urbanape)]

This has lp:~sil/bindwood/design-view and lp:~sil/bindwood/find-desktop-couch-with-dbus merged in, as well as the work I did supporting internally-generated uuids for bookmarks. There are still a few rough spots to be worked out:

=== TODO ===

This code has been fixed to use the suggested style (creating a new nsIURI, rather than just poking the .spec struct member):

... sync.js +341
                    if (metadata.spec != bm.uri) {
                        try {
                            metadata = Bindwood.ioService.newURI(bm.uri, null, null);
                        } catch(e) {
                            Bindwood.writeError("Problem creating a new URI for bookmark", e);
                        }
                        Bindwood.bookmarksService.changeBookmarkURI(itemId, metadata);
                    }
...

This fails when dealing with a bookmark whose URI looks like this:
  `place:folder=BOOKMARKS_MENU&folder=UNFILED_BOOKMARKS&folder=TOOLBAR&queryType=1&sort=12&excludeItemIfParentHasAnnotation=livemark%2FfeedURI&maxResults=10&excludeQueries=1`

The problem is that while bookmarksService.getBookmarkURI(thatBookmark) will produce the `place:folder=...` URI spec, the IIOService.newURI() function fails when given that spec to create a URI for the updated bookmark. So, we'll likely need to special case these and either ignore them or find the proper way to spell BookmarkURIs for livemarks, &c.

[Zachery Bir (urbanape)]

Also, missed in my checkin messages, I've removed the menuitem from the Bookmarks menu. We no longer have any need for manually triggering the pull.

I've also pushed the interval back to 30sec, though this isn't set in stone, naturally. I just got tired of seeing my console zoom by.

review: Abstain

[Stuart Langridge (sil)]

I'm getting an error:
Error: guid is not defined
Source File: chrome://bindwood/content/sync.js
Line: 385

                doc.application_annotations.Firefox.uuid = uuid;
                couch.save(doc);
                doc.application_annotations.Firefox.guid = guid;

Where is "guid" coming from?

review: Needs Fixing

[Zachery Bir (urbanape)]

On Jul 9, 2009, at 8:03 AM, Stuart Langridge wrote:

> Review: Needs Fixing
> I'm getting an error:
> Error: guid is not defined
> Source File: chrome://bindwood/content/sync.js
> Line: 385
>
> doc.application_annotations.Firefox.uuid = uuid;
> couch.save(doc);
> doc.application_annotations.Firefox.guid = guid;
>
> Where is "guid" coming from?

Must have been from the merge. One moment.

Zac

[lp:~urbanape/bindwood/dbus-and-local-uuids]

13. By Zachery Bir <email address hidden> on 2009-07-09

Fix merge cruft

=== modified file 'chrome.manifest'
--- chrome.manifest	2009-06-30 13:47:50 +0000
+++ chrome.manifest	2009-07-02 13:41:07 +0000
@@ -1,2 +1,3 @@
-content ubuntuone-firefox-bookmark-sync chrome/content/
-overlay chrome://browser/content/browser.xul    chrome://ubuntuone-firefox-bookmark-sync/content/browserOverlay.xul
+content bindwood chrome/content/
+locale  bindwood en     chrome/locale/en/
+overlay chrome://browser/content/browser.xul    chrome://bindwood/content/browserOverlay.xul

=== modified file 'chrome/content/browserOverlay.xul'
--- chrome/content/browserOverlay.xul	2009-06-30 13:47:50 +0000
+++ chrome/content/browserOverlay.xul	2009-07-07 21:45:47 +0000
@@ -1,15 +1,20 @@
 <?xml version="1.0"?>
 
-<!DOCTYPE overlay SYSTEM "chrome://ubuntuone-firefox-bookmark-sync/locale/ubuntuone-firefox-bookmark-sync.dtd">
+<!DOCTYPE overlay SYSTEM "chrome://bindwood/locale/en/bindwood.dtd">
 
-<overlay id="ubuntuone-firefox-bookmark-sync"
+<overlay id="bindwood"
          xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
 
-  <menupopup id="menu_ToolsPopup">
-    <menuitem id="UbuntuOneFirefoxBookmarkSync"
-              label="Sync Bookmarks (well, alert)"
-              insertbefore="javascriptConsole"
-              oncommand="alert('syncing...');" />
-  </menupopup>
+  <script type="application/x-javascript" src="chrome://bindwood/content/couch.js" />
+  <script type="application/x-javascript" src="chrome://bindwood/content/sync.js" />
+
+  <window id="main-window">
+    <script type="application/x-javascript">
+      window.addEventListener("load", Bindwood.init, true);
+
+      var bmsvc = Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"].getService(Components.interfaces.nsINavBookmarksService);
+      window.addEventListener("load", function() { bmsvc.addObserver(Bindwood.Observer, false); }, false);
+    </script>
+  </window>
 
 </overlay>

=== added file 'chrome/content/couch.js'
--- chrome/content/couch.js	1970-01-01 00:00:00 +0000
+++ chrome/content/couch.js	2009-07-08 01:24:33 +0000
@@ -0,0 +1,397 @@
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+// A simple class to represent a database. Uses XMLHttpRequest to interface with
+// the CouchDB server.
+
+function CouchDB(name, httpHeaders) {
+  this.name = name;
+  this.uri = "/" + encodeURIComponent(name) + "/";
+
+  // The XMLHttpRequest object from the most recent request. Callers can
+  // use this to check result http status and headers.
+  this.last_req = null;
+
+  this.request = function(method, uri, requestOptions) {
+      requestOptions = requestOptions || {}
+      requestOptions.headers = combine(requestOptions.headers, httpHeaders)
+      return CouchDB.request(method, uri, requestOptions);
+    }
+
+  // Creates the database on the server
+  this.createDb = function() {
+    this.last_req = this.request("PUT", this.uri);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Deletes the database on the server
+  this.deleteDb = function() {
+    this.last_req = this.request("DELETE", this.uri);
+    if (this.last_req.status == 404)
+      return false;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Save a document to the database
+  this.save = function(doc, options) {
+    if (doc._id == undefined)
+      doc._id = CouchDB.newUuids(1)[0];
+
+    this.last_req = this.request("PUT", this.uri  +
+        encodeURIComponent(doc._id) + encodeOptions(options),
+        {body: JSON.stringify(doc)});
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev;
+    return result;
+  }
+
+  // Open a document from the database
+  this.open = function(docId, options) {
+    this.last_req = this.request("GET", this.uri + encodeURIComponent(docId) + encodeOptions(options));
+    if (this.last_req.status == 404)
+      return null;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Deletes a document from the database
+  this.deleteDoc = function(doc) {
+    this.last_req = this.request("DELETE", this.uri + encodeURIComponent(doc._id) + "?rev=" + doc._rev);
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev; //record rev in input document
+    doc._deleted = true;
+    return result;
+  }
+
+  // Deletes an attachment from a document
+  this.deleteDocAttachment = function(doc, attachment_name) {
+    this.last_req = this.request("DELETE", this.uri + encodeURIComponent(doc._id) + "/" + attachment_name + "?rev=" + doc._rev);
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev; //record rev in input document
+    return result;
+  }
+
+  this.bulkSave = function(docs, options) {
+    // first prepoulate the UUIDs for new documents
+    var newCount = 0
+    for (var i=0; i<docs.length; i++) {
+      if (docs[i]._id == undefined)
+        newCount++;
+    }
+    var newUuids = CouchDB.newUuids(docs.length);
+    var newCount = 0
+    for (var i=0; i<docs.length; i++) {
+      if (docs[i]._id == undefined)
+        docs[i]._id = newUuids.pop();
+    }
+    var json = {"docs": docs};
+    // put any options in the json
+    for (var option in options) {
+      json[option] = options[option];
+    }
+    this.last_req = this.request("POST", this.uri + "_bulk_docs", {
+      body: JSON.stringify(json)
+    });
+    if (this.last_req.status == 417) {
+      return {errors: JSON.parse(this.last_req.responseText)};
+    }
+    else {
+      CouchDB.maybeThrowError(this.last_req);
+      var results = JSON.parse(this.last_req.responseText);
+      for (var i = 0; i < docs.length; i++) {
+        if(results[i].rev)
+          docs[i]._rev = results[i].rev;
+      }
+      return results;
+    }
+  }
+
+  this.ensureFullCommit = function() {
+    this.last_req = this.request("POST", this.uri + "_ensure_full_commit");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Applies the map function to the contents of database and returns the results.
+  this.query = function(mapFun, reduceFun, options, keys) {
+    var body = {language: "javascript"};
+    if(keys) {
+      body.keys = keys ;
+    }
+    if (typeof(mapFun) != "string")
+      mapFun = mapFun.toSource ? mapFun.toSource() : "(" + mapFun.toString() + ")";
+    body.map = mapFun;
+    if (reduceFun != null) {
+      if (typeof(reduceFun) != "string")
+        reduceFun = reduceFun.toSource ? reduceFun.toSource() : "(" + reduceFun.toString() + ")";
+      body.reduce = reduceFun;
+    }
+    if (options && options.options != undefined) {
+        body.options = options.options;
+        delete options.options;
+    }
+    this.last_req = this.request("POST", this.uri + "_temp_view" + encodeOptions(options), {
+      headers: {"Content-Type": "application/json"},
+      body: JSON.stringify(body)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.view = function(viewname, options, keys) {
+    var viewParts = viewname.split('/');
+    var viewPath = this.uri + "_design/" + viewParts[0] + "/_view/"
+        + viewParts[1] + encodeOptions(options);
+    if(!keys) {
+      this.last_req = this.request("GET", viewPath);
+    } else {
+      this.last_req = this.request("POST", viewPath, {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });
+    }
+    if (this.last_req.status == 404)
+      return null;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // gets information about the database
+  this.info = function() {
+    this.last_req = this.request("GET", this.uri);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.allDocs = function(options,keys) {
+    if(!keys) {
+      this.last_req = this.request("GET", this.uri + "_all_docs" + encodeOptions(options));
+    } else {
+      this.last_req = this.request("POST", this.uri + "_all_docs" + encodeOptions(options), {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });
+    }
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.designDocs = function() {
+    return this.allDocs({startkey:"_design", endkey:"_design0"});
+  };
+
+  this.allDocsBySeq = function(options,keys) {
+    var req = null;
+    if(!keys) {
+      req = this.request("GET", this.uri + "_all_docs_by_seq" + encodeOptions(options));
+    } else {
+      req = this.request("POST", this.uri + "_all_docs_by_seq" + encodeOptions(options), {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });
+    }
+    CouchDB.maybeThrowError(req);
+    return JSON.parse(req.responseText);
+  }
+
+  this.compact = function() {
+    this.last_req = this.request("POST", this.uri + "_compact");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.setDbProperty = function(propId, propValue) {
+    this.last_req = this.request("PUT", this.uri + propId,{
+      body:JSON.stringify(propValue)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.getDbProperty = function(propId) {
+    this.last_req = this.request("GET", this.uri + propId);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.setAdmins = function(adminsArray) {
+    this.last_req = this.request("PUT", this.uri + "_admins",{
+      body:JSON.stringify(adminsArray)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.getAdmins = function() {
+    this.last_req = this.request("GET", this.uri + "_admins");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Convert a options object to an url query string.
+  // ex: {key:'value',key2:'value2'} becomes '?key="value"&key2="value2"'
+  function encodeOptions(options) {
+    var buf = []
+    if (typeof(options) == "object" && options !== null) {
+      for (var name in options) {
+        if (!options.hasOwnProperty(name)) continue;
+        var value = options[name];
+        if (name == "key" || name == "startkey" || name == "endkey") {
+          value = toJSON(value);
+        }
+        buf.push(encodeURIComponent(name) + "=" + encodeURIComponent(value));
+      }
+    }
+    if (!buf.length) {
+      return "";
+    }
+    return "?" + buf.join("&");
+  }
+
+  function toJSON(obj) {
+    return obj !== null ? JSON.stringify(obj) : null;
+  }
+
+  function combine(object1, object2) {
+    if (!object2)
+      return object1;
+    if (!object1)
+      return object2;
+
+    for (var name in object2)
+      object1[name] = object2[name];
+
+    return object1;
+  }
+
+
+}
+
+CouchDB.PORT_NUMBER = 5984; // default
+
+// this is the XMLHttpRequest object from last request made by the following
+// CouchDB.* functions (except for calls to request itself).
+// Use this from callers to check HTTP status or header values of requests.
+CouchDB.last_req = null;
+
+
+CouchDB.allDbs = function() {
+  CouchDB.last_req = CouchDB.request("GET", "/_all_dbs");
+    CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText);
+}
+
+CouchDB.allDesignDocs = function() {
+  var ddocs = {}, dbs = CouchDB.allDbs();
+  for (var i=0; i < dbs.length; i++) {
+    var db = new CouchDB(dbs[i]);
+    ddocs[dbs[i]] = db.designDocs();
+  };
+  return ddocs;
+};
+
+CouchDB.getVersion = function() {
+  CouchDB.last_req = CouchDB.request("GET", "/");
+  CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText).version;
+}
+
+CouchDB.replicate = function(source, target, rep_options) {
+  rep_options = rep_options || {};
+  var headers = rep_options.headers || {};
+  CouchDB.last_req = CouchDB.request("POST", "/_replicate", {
+    headers: headers,
+    body: JSON.stringify({source: source, target: target})
+  });
+  CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText);
+}
+
+CouchDB.request = function(method, uri, options) {
+  options = options || {};
+  var req = null;
+  if (typeof(XMLHttpRequest) != "undefined") {
+    req = new XMLHttpRequest();
+  } else if (typeof(ActiveXObject) != "undefined") {
+    req = new ActiveXObject("Microsoft.XMLHTTP");
+  } else {
+    throw new Error("No XMLHTTPRequest support detected");
+  }
+  req.open(method, "http://localhost:" + CouchDB.PORT_NUMBER + uri, false);
+  if (options.headers) {
+    var headers = options.headers;
+    for (var headerName in headers) {
+      if (!headers.hasOwnProperty(headerName)) continue;
+      req.setRequestHeader(headerName, headers[headerName]);
+    }
+  }
+  req.send(options.body || "");
+  return req;
+}
+
+CouchDB.requestStats = function(module, key, test) {
+  var query_arg = "";
+  if(test !== null) {
+    query_arg = "?flush=true";
+  }
+
+  var stat = CouchDB.request("GET", "/_stats/" + module + "/" + key + query_arg).responseText;
+  return JSON.parse(stat)[module][key];
+}
+
+CouchDB.uuids_cache = [];
+
+CouchDB.newUuids = function(n) {
+  if (CouchDB.uuids_cache.length >= n) {
+    var uuids = CouchDB.uuids_cache.slice(CouchDB.uuids_cache.length - n);
+    if(CouchDB.uuids_cache.length - n == 0) {
+      CouchDB.uuids_cache = [];
+    } else {
+      CouchDB.uuids_cache =
+          CouchDB.uuids_cache.slice(0, CouchDB.uuids_cache.length - n);
+    }
+    return uuids;
+  } else {
+    CouchDB.last_req = CouchDB.request("GET", "/_uuids?count=" + (100 + n));
+    CouchDB.maybeThrowError(CouchDB.last_req);
+    var result = JSON.parse(CouchDB.last_req.responseText);
+    CouchDB.uuids_cache =
+        CouchDB.uuids_cache.concat(result.uuids.slice(0, 100));
+    return result.uuids.slice(100);
+  }
+}
+
+CouchDB.maybeThrowError = function(req) {
+  if (req.status >= 400) {
+    try {
+      var result = JSON.parse(req.responseText);
+    } catch (ParseError) {
+      var result = {error:"unknown", reason:req.responseText};
+    }
+    throw result;
+  }
+}
+
+CouchDB.params = function(options) {
+  options = options || {};
+  var returnArray = [];
+  for(var key in options) {
+    var value = options[key];
+    returnArray.push(key + "=" + value);
+  }
+  return returnArray.join("&");
+}

=== added file 'chrome/content/dbus.sh'
--- chrome/content/dbus.sh	1970-01-01 00:00:00 +0000
+++ chrome/content/dbus.sh	2009-07-07 10:47:14 +0000
@@ -0,0 +1,11 @@
+#!/bin/bash
+OUT=$1
+PORT=$(dbus-send --session --dest=org.desktopcouch.CouchDB --print-reply --type=method_call / org.desktopcouch.CouchDB.getPort 2>/dev/null | grep int32 | awk '{print $2}' )
+if [ -z "$PORT" ]; then
+  # D-Bus call failed for some reason, so use default port
+  echo 5984 > $OUT
+else
+  echo $PORT > $OUT
+fi
+
+

=== added file 'chrome/content/sync.js'
--- chrome/content/sync.js	1970-01-01 00:00:00 +0000
+++ chrome/content/sync.js	2009-07-08 01:24:33 +0000
@@ -0,0 +1,524 @@
+/* Lots and lots of debugging information */
+var Bindwood = {
+    bookmarksService: Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"]
+        .getService(Components.interfaces.nsINavBookmarksService),
+    uuidService: Components.classes["@mozilla.org/uuid-generator;1"]
+        .getService(Components.interfaces.nsIUUIDGenerator),
+    annotationService: Components.classes["@mozilla.org/browser/annotation-service;1"]
+        .getService(Components.interfaces.nsIAnnotationService),
+    consoleService: Components.classes["@mozilla.org/consoleservice;1"]
+        .getService(Components.interfaces.nsIConsoleService),
+    historyService: Components.classes["@mozilla.org/browser/nav-history-service;1"]
+        .getService(Components.interfaces.nsINavHistoryService),
+    ioService: Components.classes["@mozilla.org/network/io-service;1"]
+        .getService(Components.interfaces.nsIIOService),
+
+    annotationKey: "bindwood/uuid",
+    uuidItemIdMap: {},
+
+    generateUUIDString: function() {
+        return Bindwood.uuidService.generateUUID().toString();
+    },
+
+    annotateItemWithUUID: function(itemId) {
+        var uuid = Bindwood.generateUUIDString();
+        Bindwood.annotationService.setItemAnnotation(itemId, Bindwood.annotationKey, uuid, 0, Bindwood.annotationService.EXPIRE_NEVER);
+        // Whenever we create a new UUID, stash it and the itemId in
+        // our local cache.
+        Bindwood.uuidItemIdMap[uuid] = itemId;
+        return uuid;
+    },
+
+    itemIdForUUID: function(uuid) {
+        // First, try to look it up in our local cache, barring that
+        // (which shouldn't happen), look it up slowly.
+        var itemId = Bindwood.uuidItemIdMap[uuid];
+
+        if (!itemId) {
+            var items = Bindwood.annotationService.getItemsWithAnnotation(Bindwood.annotationKey, {});
+            for (var i = 0; i < items.length; i++) {
+                if (Bindwood.annotationService.getItemAnnotation(items[i], Bindwood.annotationKey) == uuid) {
+                    Bindwood.uuidItemIdMap[uuid] = itemId = items[i];
+                    break;
+                }
+            }
+        }
+        return itemId;
+    },
+
+    uuidForItemId: function(itemId) {
+        // Try to look up the uuid, and failing that, assign a new one
+        // and return it.
+        var uuid;
+        var found = false;
+        try {
+            uuid = Bindwood.annotationService.getItemAnnotation(itemId, Bindwood.annotationKey);
+            found = true;
+        } catch(e) {
+            uuid = Bindwood.annotateItemWithUUID(itemId);
+        }
+
+        return uuid;
+    },
+
+    writeMessage: function(aMessage) {
+        // convenience method for logging. Way better than alert()s.
+        Bindwood.consoleService.logStringMessage("Bindwood: " + aMessage);
+    },
+
+    writeError: function(aMessage, e) {
+        Bindwood.writeMessage(aMessage + "message: '" + e.message + "', reason: '" + e.reason + "', description: '" + e.description + "', error: '" + e.error + "'");
+    },
+
+
+
+    init: function() {
+        // Start the process and de-register ourself
+        // http://forums.mozillazine.org/viewtopic.php?f=19&t=657911&start=0
+        // It ensures that we're only running that code on the first window.
+
+        if(Components.classes["@mozilla.org/appshell/window-mediator;1"]
+           .getService(Components.interfaces.nsIWindowMediator)
+           .getEnumerator("").getNext() == window) {
+            Bindwood.getCouchPortNumber(Bindwood.startProcess);
+        }
+    },
+
+    getCouchPortNumber: function(continueFunction) {
+        // find the desktop Couch port number by making a D-Bus call
+        // we call D-Bus by shelling out to a bash script which calls
+        // it for us, and writes the port number into a temp file
+
+        // find OS temp dir to put the tempfile in
+        // https://developer.mozilla.org/index.php?title=File_I%2F%2FO#Getting_special_files
+        var tmpdir = Components.classes["@mozilla.org/file/directory_service;1"]
+                     .getService(Components.interfaces.nsIProperties)
+                     .get("TmpD", Components.interfaces.nsIFile);
+        // create a randomly named tempfile in the tempdir
+        var tmpfile = Components.classes["@mozilla.org/file/local;1"]
+                     .createInstance(Components.interfaces.nsILocalFile);
+        tmpfile.initWithPath(tmpdir.path + "/desktopcouch." + Math.random());
+        tmpfile.createUnique(tmpfile.NORMAL_FILE_TYPE, 0600);
+        Bindwood.writeMessage("Tempfile for Couch port number: " + tmpfile.path);
+
+        // find the D-Bus bash script, which is in our extension folder
+        var MY_ID = "[e-mail]";
+        var em = Components.classes["@mozilla.org/extensions/manager;1"].
+            getService(Components.interfaces.nsIExtensionManager);
+        var dbus_script = em.getInstallLocation(MY_ID).getItemFile(MY_ID,
+            "chrome/content/dbus.sh");
+        // create an nsILocalFile for the executable
+        var nsifile = Components.classes["@mozilla.org/file/local;1"]
+                     .createInstance(Components.interfaces.nsILocalFile);
+        nsifile.initWithPath(dbus_script.path);
+
+        // create an nsIProcess2 to execute this bash script
+        var process = Components.classes["@mozilla.org/process/util;1"]
+                        .createInstance(Components.interfaces.nsIProcess2);
+        process.init(nsifile);
+
+        // Run the process, passing the tmpfile path
+        var args = [tmpfile.path];
+        process.runAsync(args, args.length, {
+            observe: function(process, finishState, data) {
+                var port = 5984;
+                if (finishState == "process-finished") {
+                    // read temp file to find port number
+                    // https://developer.mozilla.org/en/Code_snippets/File_I%2f%2fO#Reading_from_a_file
+                    var data = "";
+                    var fstream = Components.classes["@mozilla.org/network/file-input-stream;1"].
+                        createInstance(Components.interfaces.nsIFileInputStream);
+                    var cstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"].
+                        createInstance(Components.interfaces.nsIConverterInputStream);
+                    fstream.init(tmpfile, -1, 0, 0);
+                    cstream.init(fstream, "UTF-8", 0, 0);
+                    let (str = {}) {
+                      cstream.readString(-1, str); // read the whole file and put it in str.value
+                      data = str.value;
+                    }
+                    cstream.close(); // this closes fstream
+                    data = data.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+                    if (/^[0-9]+$/.test(data)) {
+                        port = data;
+                    } else {
+                        Bindwood.writeMessage("D-Bus port data is not a number (" + data + ")");
+                    }
+                } else {
+                    // fall back to system CouchDB
+                    Bindwood.writeMessage("D-Bus port find failed");
+                }
+                tmpfile.remove(false);
+                continueFunction(port);
+        }
+        });
+    },
+
+    startProcess: function(couchPortNumber) {
+        Bindwood.writeMessage("Starting process with Couch on port " + couchPortNumber);
+        CouchDB.PORT_NUMBER = couchPortNumber;
+        try {
+            Bindwood.pushBookmarks();
+        } catch(e) {
+            Bindwood.writeError("Error when calling pushBookmarks: ", e);
+        }
+        Bindwood.createView();
+        Bindwood.pullBookmarks();
+    },
+
+    createView: function() {
+        var DDID = "_design/views";
+        var couch = new CouchDB('bookmarks');
+        var current_doc;
+        try {
+            current_doc = couch.open(DDID);
+            if (current_doc !== null) {
+                Bindwood.writeMessage("View already exists; leaving it alone");
+            } else {
+                new_doc = {
+                    _id: DDID,
+                    views: {
+                        display: {
+                         map: "function(doc) { " +
+                           "var scheme = doc.uri.split(':',1)[0]; " +
+                           "var uri; " +
+                           "if (scheme == 'http' || scheme == 'https') {" +
+                             "uri = doc.uri.split('/')[2];" +
+                             "if (uri.length < 30) {" +
+                               " uri += '/' + " +
+                               "doc.uri.split('/',4)[3].substr(0,30-uri.length) + '...';" +
+                             "}" +
+                           "} else {" +
+                           "uri = scheme + ' URL';" +
+                           "}" +
+                           "emit(doc.title, uri);" +
+                         "}"
+                       }
+                    }
+                };
+                try {
+                    couch.save(new_doc);
+                } catch(e) {
+                    Bindwood.writeError("Problem saving view: ", e);
+                }
+            }
+        } catch(e) {
+            // some kind of error fetching the existing design doc
+            Bindwood.writeError("Problem checking for view: ", e);
+        }
+    },
+
+    pushBookmarks: function() {
+        // Prime the pump, so to speak, by uploading all our local
+        // bookmarks to CouchDB (if they're not there already).
+        var couch = new CouchDB('bookmarks');
+        // Create the DB if it doesn't already exist
+        try {
+            couch.createDb();
+        } catch (e) {
+            Bindwood.writeError("Error when creating database in pushBookmarks (file_exists is OK here): ", e);
+        }
+
+        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.toolbarFolder,
+            "toolbarFolder", couch);
+        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.bookmarksMenuFolder,
+            "bookmarksMenuFolder", couch);
+    },
+
+    getBookmarksFromList: function(bookmarksList) {
+        var retval = [];
+        var options = Bindwood.historyService.getNewQueryOptions();
+        var query = Bindwood.historyService.getNewQuery();
+        query.setFolders([bookmarksList], 1);
+        var result = Bindwood.historyService.executeQuery(query, options);
+        var rootNode = result.root;
+        rootNode.containerOpen = true;
+        for (var i=0; i<rootNode.childCount; i++) {
+            var node = rootNode.getChild(i);
+            if (Bindwood.bookmarksService.getItemType(node.itemId) !=
+                Bindwood.bookmarksService.TYPE_BOOKMARK) {
+                continue;
+            }
+
+            var title = Bindwood.bookmarksService.getItemTitle(node.itemId);
+            try {
+                var metadata = Bindwood.bookmarksService.getBookmarkURI(node.itemId);
+            } catch(e) {
+                Bindwood.writeError("problem fetching metadata for bookmark '" + title + "': ", e);
+                continue;
+            }
+            var uuid = Bindwood.uuidForItemId(node.itemId);
+            retval.push({
+                title: title,
+                metadata: metadata,
+                uuid: uuid,
+                id: node.itemId});
+        }
+        rootNode.containerOpen = false;
+        return retval;
+    },
+
+    pushBookmarksFromList: function(bookmarksList, bookmarksListName, db) {
+        var bookmarkData = Bindwood.getBookmarksFromList(bookmarksList);
+        for (var i = 0; i < bookmarkData.length; i++) {
+            // find this bookmark in CouchDB
+            var uuid = Bindwood.uuidForItemId(bookmarkData[i].id);
+            var uri =  bookmarkData[i].metadata.spec;
+            var title = bookmarkData[i].title;
+
+            var results = db.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.uuid) {
+                    emit(doc.application_annotations.Firefox.uuid, doc);
+                }
+            }, null, {
+                startkey: uuid, endkey: uuid
+            });
+
+            if (results.rows.length === 0) {
+                // this bookmark is not in CouchDB, so write it
+                var record = {
+                    record_type: "http://example.com/bookmark",
+                    uri: uri,
+                    title: title,
+                    application_annotations: {
+                        Firefox: {
+                            uuid: uuid,
+                            list: bookmarksListName
+                        }
+                    }
+                };
+                try {
+                    db.save(record);
+                } catch(e) {
+                    Bindwood.writeError("Problem saving bookmark to CouchDB; bookmark is " + JSON.stringify(record) + ": ", e);
+                }
+            } else {
+                // bookmark is already in CouchDB, so do nothing
+            }
+        }
+    },
+
+    pullBookmarks: function() {
+        var couch = new CouchDB('bookmarks');
+        // Fetch all bookmark documents from the database
+        // the query function is evaluated by Couch, which doesn't know
+        // what Bindwood.RECORD_TYPE is, so we string-encode it first to
+        // include the literal value
+        try {
+            var rows = couch.query(function (doc) {
+                if (doc.record_type == "http://example.com/bookmark") {
+                    emit(doc._id,doc);
+                }
+            });
+        } catch(e) {
+            Bindwood.writeError("Problem fetching all bookmarks from Couch:", e);
+        }
+        for (var i = 0; i < rows.rows.length; i++) {
+            var recordid = rows.rows[i].id;
+            var bm = rows.rows[i].value;
+            if (bm.application_annotations &&
+                bm.application_annotations.Firefox &&
+                bm.application_annotations.Firefox.uuid) {
+                // this bookmark has a uuid, so check its values haven't changed
+                // find the bookmark with this uuid
+                var itemId = Bindwood.itemIdForUUID(
+                    bm.application_annotations.Firefox.uuid);
+                if (!itemId) {
+                    // This bookmark has a uuid, but it's not one of ours.
+                    // We need to work out whether (a) it's the same as one
+                    //   of ours but with a different uuid (so we need to
+                    //   make the uuids the same), or (b) it's a new one
+                    //   that happens to have been created on a different
+                    //   machine.
+                    // For the moment, punt on this.
+                } else {
+                    var title = Bindwood.bookmarksService.getItemTitle(itemId);
+                    var metadata = Bindwood.bookmarksService.getBookmarkURI(itemId);
+                    if (title != bm.title) {
+                        Bindwood.bookmarksService.setItemTitle(itemId, bm.title);
+                    }
+                    if (metadata.spec != bm.uri) {
+                        try {
+                            metadata = Bindwood.ioService.newURI(bm.uri, null, null);
+                        } catch(e) {
+                            Bindwood.writeError("Problem creating a new URI for bookmark", e);
+                        }
+                        Bindwood.bookmarksService.changeBookmarkURI(itemId, metadata);
+                    }
+                }
+            } else {
+                // this bookmark has no uuid, so create it from fresh in Firefox
+                var list;
+                if (bm.application_annotations &&
+                    bm.application_annotations.Firefox &&
+                    bm.application_annotations.Firefox.list) {
+                    switch (bm.application_annotations.Firefox.list) {
+                        case "toolbarFolder":
+                            list = Bindwood.bookmarksService.toolbarFolder;
+                            break;
+                        case "bookmarksMenuFolder":
+                            list = Bindwood.bookmarksService.bookmarksMenuFolder;
+                            break;
+                        default:
+                            list = Bindwood.bookmarksService.toolbarFolder;
+                            break;
+                    }
+                } else {
+                    list = Bindwood.bookmarksService.toolbarFolder;
+                }
+                var metadata = Bindwood.ioService.newURI(bm.uri, null, null);
+
+                var itemId = Bindwood.bookmarksService.insertBookmark(list,
+                    metadata, -1, bm.title);
+                // and then write the new uuid back to the record
+                var uuid = Bindwood.uuidForItemId(itemId);
+                var doc = couch.open(recordid);
+                if (!doc.application_annotations) {
+                    doc.application_annotations = {};
+                }
+                if (!doc.application_annotations.Firefox) {
+                    doc.application_annotations.Firefox = {};
+                }
+                doc.application_annotations.Firefox.uuid = uuid;
+                couch.save(doc);
+                doc.application_annotations.Firefox.guid = guid;
+                try {
+                    couch.save(doc);
+                } catch(e) {
+                    Bindwood.writeError("Problem writing record for new bookmark: ",e);
+                }
+            }
+        }
+        // reschedule ourself
+        setTimeout(Bindwood.pullBookmarks, 30000);
+    },
+
+    Observer: {
+        // An nsINavBookmarkObserver
+        onItemAdded: function(aItemId, aFolder, aIndex) {
+            // A bookmark has been added, so we create a blank entry
+            // in Couch with our local itemId attached.
+            netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+
+            var couch = new CouchDB('bookmarks');
+
+            var uuid = Bindwood.uuidForItemId(aItemId);
+
+            var list;
+            switch(aFolder) {
+                case Bindwood.bookmarksService.toolbarFolder:
+                    list = "toolbarFolder";
+                    break;
+                case Bindwood.bookmarksService.bookmarksMenuFolder:
+                    list = "bookmarksMenuFolder";
+                    break;
+                default:
+                    list = "toolbarFolder";
+                    break;
+            }
+
+            var doc = {
+                record_type: "http://example.com/bookmark",
+                application_annotations: {
+                    Firefox: {
+                        uuid: uuid,
+                        list: list
+                    }
+                }
+            };
+
+            try {
+                var result = couch.save(doc);
+            } catch(e) {
+                Bindwood.writeError("Problem saving new bookmark to Couch", e);
+            }
+        },
+        onBeforeItemRemoved: function(aItemId) {
+            // A bookmark has been removed. This is called before it's
+            // been removed locally, though we're passed the itemId,
+            // which we use to delete from Couch.
+            netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+
+            var couch = new CouchDB('bookmarks');
+
+            var uuid = Bindwood.uuidForItemId(aItemId);
+
+            var results = couch.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.uuid) {
+                    emit(doc.application_annotations.Firefox.uuid, doc);
+                }
+            }, null, {
+                startkey: uuid, endkey: uuid
+            });
+
+            if (results.rows.length === 0) {
+                Bindwood.writeMessage("A bookmark was deleted, but this bookmark isn't in CouchDB. This isn't supposed to happen.");
+                return;
+            }
+
+            var doc = couch.open(results.rows[0].id);
+
+            try {
+                var result = couch.deleteDoc(doc);
+                // Also remove from our local cache and remove
+                // annotation from service.
+                delete Bindwood.uuidItemIdMap[uuid];
+            } catch(e) {
+                Bindwood.writeError("Problem deleting record from Couch", e);
+            }
+        },
+        onItemRemoved: function(aItemId, aFolder, aIndex) {
+            Bindwood.annotationService.removeItemAnnotation(aItemId, Bindwood.annotationKey);
+        },
+        onItemChanged: function(aBookmarkId, aProperty, aIsAnnotationProperty, aValue) {
+            // A property of a bookmark has changed. On multiple
+            // property updates, this will be called multiple times,
+            // once per property (i.e., for title and URI)
+            netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+
+            var couch = new CouchDB('bookmarks');
+
+            var uuid = Bindwood.uuidForItemId(aBookmarkId);
+
+            var results = couch.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.uuid) {
+                    emit(doc.application_annotations.Firefox.uuid, doc);
+                }
+            }, null, {
+                startkey: uuid, endkey: uuid
+            });
+
+            if (results.rows.length === 0) {
+                Bindwood.writeMessage("a bookmark has changed, but this bookmark isn't in CouchDB. this isn't supposed to happen.");
+                return;
+            }
+
+            var doc = couch.open(results.rows[0].id);
+            doc[aProperty.toString()] = aValue.toString();
+
+            try {
+                var result = couch.save(doc);
+            } catch(e) {
+                Bindwood.writeError("Problem saving updated bookmark to Couch", e);
+            }
+        },
+
+        onBeginUpdateBatch: function() {},
+        onEndUpdateBatch: function() {},
+        onItemVisited: function(aBookmarkId, aVisitID, time) {},
+        onItemMoved: function(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex) {},
+        QueryInterface: function(iid) {
+            if (iid.equals(Components.interfaces.nsINavBookmarkObserver) ||
+                iid.equals(Components.interfaces.nsINavBookmarkObserver_MOZILLA_1_9_1_ADDITIONS) ||
+                iid.equals(Components.interfaces.nsISupports)) {
+                return this;
+            }
+            throw Cr.NS_ERROR_NO_INTERFACE;
+        }
+    }
+};

=== added file 'chrome/content/tutorial.html'
--- chrome/content/tutorial.html	1970-01-01 00:00:00 +0000
+++ chrome/content/tutorial.html	2009-07-02 13:41:07 +0000
@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <title>BindWood Tutorial</title>
+  </head>
+  <body>
+    This is BindWood.
+  </body>
+</html>

=== added directory 'chrome/locale'
=== added directory 'chrome/locale/en'
=== added file 'chrome/locale/en/bindwood.dtd'
=== modified file 'install.rdf'
--- install.rdf	2009-06-30 13:47:50 +0000
+++ install.rdf	2009-07-06 20:00:16 +0000
@@ -3,7 +3,7 @@
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 
   <Description about="urn:mozilla:install-manifest">
-    <em:id>[e-mail]</em:id>
+    <em:id>[e-mail]</em:id>
     <em:version>1.0</em:version>
     <em:type>2</em:type>
 
@@ -18,9 +18,9 @@
     </em:targetApplication>
 
     <!-- Front End MetaData -->
-    <em:name>UbuntuOne Bookmarks Sync</em:name>
-    <em:description>An extension to synchronize your bookmarks to UbuntuOne.</em:description>
+    <em:name>Bindwood</em:name>
+    <em:description>An extension to synchronize your bookmarks to a local CouchDB.</em:description>
     <em:creator>Zachery Bir</em:creator>
-    <em:homepageURL>http://launchpad.net/ubuntuone-firefox-bookmark-sync</em:homepageURL>
+    <em:homepageURL>http://launchpad.net/bindwood</em:homepageURL>
   </Description>
 </RDF>