Services/Sync/Getting Started

From MozillaWiki
< Services‎ | Sync
Jump to: navigation, search


Source Code

Once you have a copy of the Mozilla source tree (read below for how to obtain a copy), you can find the core Sync source code in:


You can view this online at

This is just the core JavaScript APIs and logic. Additional Sync code for integration with Firefox lives in:


Look for files with sync in their name. Files here define the integration between Firefox and Sync. This includes all the Sync UI.

Debugging Sync

If you are debugging Sync in your browser, the first thing you want to do is crank up the logging. In about:config, set the following preferences:

# Enable logging to Error Console
services.sync.log.appender.console Debug
# Enable logging to STDOUT
services.sync.log.appender.dump Debug
# Log full sync logs on sync success (typically they are only saved on failure)
services.sync.log.appender.file.logOnSuccess true

Once you've updated those settings, restart Firefox for them to take effect.

If you are logging to STDOUT, you may want to set the environment variable MOZ_QUIET to silence a lot of spew from other parts of Firefox:

export MOZ_QUIET=1

You can view full sync logs by opening about:sync-log in Firefox.

Building Sync

The party line to rebuild the tree after making changes is to run:

$ make -f
or from the object directory:
$ make -sj8

However, this is slow. If you have simply changed a JS file in services/sync/, it is sufficient to run the following from your object directory:

$ make -sj8 -C services/sync

The xpcshell tests will pick up changes immediately. However, if you launch Firefox, your changes won't be reflected. For that, you'll also need to rebuild the browser component:

$ make -sj8 -C services/sync && make -sj8 -C browser

A handy alias to have around is:

$ alias sync-launch make -sj8 -C services/sync && make -sj8 -C browser && dist/bin/firefox -no-remote -ProfileManager

Or, on OS X:

$ alias sync-launch make -sj8 -C services/sync && make -sj8 -C browser && dist/ -no-remote -ProfileManager

Using Bugzilla

Every code change starts out as a bug in Bugzilla where the general approach can be discussed. The bug should eventually be assigned to somebody who will upload one or more patches for review. Code can only be reviewed by module owners and their peers; see code review policy for more information. If the review has been granted and all review comments have been addressed, the patches may be checked into services-central, which is the Mercurial repository used for Services client work.

On rare occasions it will make more sense to land work on mozilla-central instead — for example, if a change needs to propagate upstream before the regular merge from services-central to mozilla-central. This might involve additional procedures (e.g., you need to request approval in addition to review.)

For server code written in Python, Tarek has provided a useful tool called flake8 which does Python style checks against your code.

You probably also want to get up to speed on Bugzilla if you're not already.

  • A good start is to go watch Jonath's "Bugzilla for Humans" video.
  • Our bugs are currently under "Other Products", "Mozilla Services" or just bookmark "Add a bug" and "Browse bugs".
  • Don't forget to add a Bugzilla ID shortcut string to your Bugzilla account preferences. The current standard practice is to append "<whitespace>[:irc_nick]" to your Real Name field.
  • You also want to watch the components relevant to your work so you automatically get emails for all bug changes in those components. The easiest way to do this is to add the default QA contact for each component to the list of users your are watching in Bugzilla
    • Open the list of Services components
    • In another tab go to your Bugzilla email preferences
    • At the bottom of the page under the User Watching section there is an input form that takes a comma separated list of email addresses
    • If you're working on server side components, you will want to add at least:
      • core-server@services.bugs
      • sync-server@services.bugs
  • A useful Firefox add-on that makes life in Bugzilla a bit easier is Bugzilla Tweaks. Highly recommended!

Using Mercurial

Mozilla's development process is very much patch driven. Mozilla uses Mercurial (as well as git for some projects) as the version control system. Mercurial Patch Queues, although a bit awkward to use at times, fit this process rather well. It is recommended you familiarize yourself with them and use them.

You can find the Services team's code repository at [1].


Marco Bonardo has some general purpose tips for Mozilla developers on how to format patches before uploading them to Bugzilla.

Essentially it is recommended you put the following in your ~/.hgrc:

 username = Your Name <>
 [extensions] = 
 git = 1
 unified = 8
 diff = -pU8
 qdiff = -pU8
 qnew = -U
 qseries = -sv

If you find yourself mixing up `hg qpush` (push a patch onto your queue) and `hg push` (irreversibly push your changes out into the world) try adding this:

 preoutgoing.confirm = read -p 'Are you sure you want to push to remote? (y/n): '; echo $REPLY | grep -q 'y'

(Note from philikon: I consider this hook pretty much useless. Mercurial will warn and abort if you're trying to with patches applied. So if you have any applied patches, it's very hard to accidentally push them. If you don't have applied patches, you're most likely not to have anything the remote repo doesn't have either.)

Also, useful path definitions:

 try = ssh://
 places = ssh://
 mc = ssh://

Landing patches

You have items in a patch queue that you'd like to push to s-c. Here's the thorough set of steps to follow to get them into the tree (assuming you have commit access, of course).

Make sure services-central is open and green

Check TBPL.

Make sure your tree is up to date

 hg qpop --all
 hg pull -u

Make sure that all the patches have a proper commit message

For simple bugs, the format is

 Bug NNNNNN - Bug Summary here. r=your_reviewers_IRC_nickname

For bugs with several parts, you can do

 Bug NNNNNN - Bug Summary here. r=your_reviewers_IRC_nickname
 Part X: Frobnicate the majiggaberator

Or simply

 Bug NNNNNN - Part X: Frobnicate the majiggaberator. r=your_reviewers_IRC_nickname

Run hg qser -sv (omit the -sv if you're using the config above). The output will look something like

 0 U favicons-1a: Bug 675996 - Part 1: extend moz_favicons with GUID to support Sync. r=mak
 1 U favicons-1b: Bug 675996 - Part 2: adjust Places migration tests to expect current version, not v11; tests for GUIDs in favicons. r=mak

If they don't, hg qpush each one and edit the summary with hg qref -e.

Ensure that the only patches you have applied are the ones you want to push

… and that they're the ones that were reviewed. You can reorder patches by hg qpop --all then hg qpush --move $patchname, or by manually reordering .hg/patches/series. Only edit the series file when all patches have been popped.

Applied patches are indicated by an 'A' in the 2nd column of qseries. Unapplied are 'U'.

Run tests

Now is a great time to run tests, because this is the state in which services-central will be after you push. If you apply a tests patch to re-enable disabled tests, make sure you pop it when you're done.

Finish the applied patches

 hg qfinish --applied

Verify what you're going to upload

 hg out

If the command shows anything other than the patches you're expecting (or they're wrong in some way), stop and ask for help.


If all is good, push:

 hg push

Using Git

Various projects exist as Git repositories instead of Mercurial repositories. Even when projects are officially hosted in Mercurial, Git mirrors are maintained.

The Services team maintains a GitHub organization at A mirror of services-central can be found at

Configuring Git

If this is your first time using Git, you'll need for perform some one-time configuration:

# Configure your global name and email. These will be used for commit info.
$ git config --global "John Doe"
$ git config --global ""
# Enable color output for all commands
$ git config --global color.branch auto
$ git config --global color.diff auto
$ git config --global color.grep auto
$ git config --global color.interactive auto
$ git config --global color.status auto
$ git config --global color.ui auto
# Highlight whitespace
$ git config --global core.whitespace "trailing-space,space-before-tab,tab-in-indent"
# Define your editor for commits, other tools
$ git config --global core.editor vim

Android Sync

You should carefully read the previous sections on Git and landing patches on services-central.

For the moment we assume that you have a working checkout of android-sync. The rudiments of landing code are this:


# In your services-central checkout, create a new patch.
# Ensure that you're correctly carrying over the author from the Git commit.
cd $SC
hg qnew -m "Bug 123456 - Part 1: frob the noo. r=foobar, a=blocking-fennec" --user "John Smith <>" frob-noo

# For each merged piece of work that you'd like to land...
# Ensure you're on the correct git branch. That's typically develop, or an
# ancestor thereof if you've merged multiple feature branches since your last landing.
cd $AS
git checkout develop

# Run the appropriate copy-code script, targeting the correct upstream hg repository.
ANDROID=$SC/mobile/android SYNC=$SC/mobile/android/sync ./

# Refresh the patch, adding and removing any files.
cd $SC
hg st
hg add
hg rm
hg qref

# Check that the patch is what you want to commit.
# You are responsible for anything that you land in the tree,
# so it behooves you to make sure you get this right.
less .hg/patches/frob-noo

# Ensure that everything builds.
make -sj4 -C objdir-droid

# And runs...
make -C objdir-droid package
adb install -r objdir-droid/dist/

Now follow the steps for a regular services-central landing.

This is all eminently scriptable, of course.


Getting a checkout of a large Mercurial repository can be a pain if you're remote. Nobody wants to wait 6 hours while Python drools on its shoes. The answer is bundles. Follow the directions. The services-central bundle is here.


services-central is the clone of mozilla-central in which the Sync client (and other stable Services client-side projects) are developed.

Things that live there:

  • The Services client libraries in services/crypto/ and services/sync.
  • Built-in UI in browser/base/content/.


Sync was primarily developed in the fx-sync repository. The code there includes support for the Sync add-on; it's deprecated since Firefox 4.

Things that live there:

  • The Services client libraries in services/crypto/ and services/sync.
  • The Firefox Sync add-on in addon/*
  • The Firefox 3.x and Fennec 1.x UIs for the Sync add-on in ui/*


mozilla-central is the repository for Firefox and the base repository for other Mozilla-based applications. How mozilla-central is relevant to Sync:

  • The integrated UI for Firefox Sync lives in browser/base/*, along with the rest of the Firefox UI.
  • Firefox releases are spun from mozilla-central. Changes made to services-central don't directly reach users.

Try server

Because Sync is developed in a clone of mozilla-central, you can use ordinary "try build" procedures to test your changes. (You don't always need to, though; one of the advantages of having an integration branch like services-central is that we're at liberty to break it!)

To push to try, teave your changes as applied mq patches. Then run:

 hg push -f ssh://


Writing xpcshell-based unit testing.

Python Functional Tests

In the services/ tree are a handful of HTTP servers implemented in JS. These are effectively lightweight clones of the services described by the specs at

The main implementations of these services are in Python. And, there exist a Python test suite that you can point at any HTTP endpoint and they will validate the functional behavior of the server. We use these Python functional tests to validate that the in-tree JS server implementations are functionally proper.

To run these functional tests, you'll need a built Firefox source tree and will need to obtain the Python server code, which contains the tests.

Running JS Servers

There is Makefile magic in services/common/Makefile that can launch a standalone JS server instance. From your object directory:

make -C services/common storage-server
make -C services/common aitc-server

Running Python Functional Tests

You'll need to obtain the server source code, then launch the tests. For example:

git clone git://
cd server-syncstorage
source bin/activate
python syncstorage/tests/functional/ http://localhost:8080

If you see lots of errors like

Traceback (most recent call last):
 File "syncstorage/tests/functional/", line 52, in setUp
   super(TestStorage, self).setUp()
 File "/Users/ncalexan/Mozilla/server-syncstorage/syncstorage/tests/functional/", line 36, in setUp
 File "/Users/ncalexan/Mozilla/server-syncstorage/syncstorage/tests/functional/", line 49, in _authenticate
   auth_policy = self.config.registry.getUtility(IAuthenticationPolicy)
 File "/Users/ncalexan/Mozilla/server-syncstorage/lib/python2.7/site-packages/zope/interface/", line 169, in getUtility
   raise ComponentLookupError(provided, name)
ComponentLookupError: (<InterfaceClass pyramid.interfaces.IAuthenticationPolicy>, u)

you may need to follow the instructions at



Being a geographically distributed group, we tend to hang out on IRC. One thing you may wish to consider is running an irssi client in a screen session on a shell host. Here's a truncated config file you can use to connect:

servers = (
   address = "";
   chatnet = "mozilla";
   port = "6697";
   autoconnect = "yes";
   use_ssl = "yes";
chatnets = { type = "IRC"; }; 

channels = { 
   comment = "Public channel for Sync";
   name = "#sync";
   chatnet = "mozilla";
   comment = "Public channel for Identity";
   name = "#identity";
   chatnet = "mozilla";

Team Meetings

  • Services Weekly Status: Every Tuesday at 9:15 PT in North Bridge (4th floor), conference dial in number is #8616. Meeting notes live under Services/Meetings.
  • Mozilla Weekly Updates: Every Monday at 11:00 PT in 10-Forward (you'll need to attend the first one in person since we want to show you off.)
  • Out-of-office, PTO, and other kinds of availability is managed in a shared "Services Team Availability" calendar. See Shared Company Calenders for details on how to set it up.


  • You also want to grab a Nightly build of Firefox. Everybody in the company should be running a nightly build: it's a great way to find bugs before the code goes out to the general public. If you want to run against different profiles (which is useful for development), you will be interested in two extra command flags: "-P and --no-remote"
    • -P forces the Profile Picker (You probably want to have more than one.)
    • --no-remote allows multiple versions to run on one machine at the same time.