Version v1.09

windows: make tests work properly
windows: Stop drive letters (eg C:) getting mixed up with remotes (eg drive:)
2025-12-15 15:53:41 +00:00 · 2015-02-07 22:44:23 +00:00 · 2015-02-07 22:32:51 +00:00 · 2015-02-07 22:32:51 +00:00 · 2015-02-07 22:32:51 +00:00 · 2015-02-07 22:32:51 +00:00
47 changed files with 4057 additions and 673 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,12 @@
+language: go
+
+go:
+  - 1.1.2
+  - 1.2.2
+  - 1.3.3
+  - 1.4
+  - tip
+
+script:
+  - go get ./...
+  - go test -v ./...
--- a/25
+++ b/25
@@ -1,10 +1,14 @@
 TAG := $(shell git describe --tags)
 LAST_TAG := $(shell git describe --tags --abbrev=0)
-NEW_TAG := $(shell echo $(LAST_TAG) | perl -lpe 's/v//; $$_ += 0.01; $$_ = "v" . $$_')
+NEW_TAG := $(shell echo $(LAST_TAG) | perl -lpe 's/v//; $$_ += 0.01; $$_ = sprintf("v%.2f", $$_)')

-rclone:	*.go */*.go
+rclone:
 	@go version
-	go build
+	go install -v ./...
+
+test:	rclone
+	go test ./...
+	cd fs && ./test_all.sh

 doc:	rclone.1 README.html README.txt

@@ -19,7 +23,7 @@ README.txt:	README.md

 install: rclone
 	install -d ${DESTDIR}/usr/bin
-	install -t ${DESTDIR}/usr/bin rclone 
+	install -t ${DESTDIR}/usr/bin ${GOPATH}/bin/rclone

 clean:
 	go clean ./...
@@ -31,10 +35,10 @@ website:
 	cd docs && hugo

 upload_website:	website
-	./rclone -v sync docs/public memstore:www-rclone-org
+	rclone -v sync docs/public memstore:www-rclone-org

 upload:
-	./rclone -v copy build/ memstore:downloads-rclone-org
+	rclone -v copy build/ memstore:downloads-rclone-org

 cross:	doc
 	./cross-compile $(TAG)
@@ -45,17 +49,18 @@ serve:
 tag:
 	@echo "Old tag is $(LAST_TAG)"
 	@echo "New tag is $(NEW_TAG)"
-	echo -e "package main\n const Version = \"$(NEW_TAG)\"\n" | gofmt > version.go
-	cp -av version.go rclonetest/version.go
+	echo -e "package fs\n const Version = \"$(NEW_TAG)\"\n" | gofmt > fs/version.go
 	perl -lpe 's/VERSION/${NEW_TAG}/g; s/DATE/'`date -I`'/g;' docs/content/downloads.md.in > docs/content/downloads.md
 	git tag $(NEW_TAG)
 	@echo "Add this to changelog in README.md"
-	@echo "  * $(NEW_TAG) - " `date -I`
+	@echo "  * $(NEW_TAG) -" `date -I`
 	@git log $(LAST_TAG)..$(NEW_TAG) --oneline
 	@echo "Then commit the changes"
 	@echo git commit -m "Version $(NEW_TAG)" -a -v
 	@echo "And finally run make retag before make cross etc"

 retag:
-	echo git tag -f $(LAST_TAG)
+	git tag -f $(LAST_TAG)

+gen_tests:
+	cd fstest/fstests && go run gen_tests.go
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 % rclone(1) User Manual
 % Nick Craig-Wood
-% Apr 24, 2014
+% Jul 7, 2014

 Rclone
 ======
@@ -12,6 +12,8 @@ Rclone is a command line program to sync files and directories to and from
  * Google Drive
  * Amazon S3
  * Openstack Swift / Rackspace cloud files / Memset Memstore
+  * Dropbox
+  * Google Cloud Storage
  * The local filesystem

 Features
@@ -86,7 +88,11 @@ first with the `--dry-run` flag.

    rclone ls [remote:path]

-List all the objects in the the path.
+List all the objects in the the path with sizes.
+
+    rclone lsl [remote:path]
+
+List all the objects in the the path with sizes and timestamps.

    rclone lsd [remote:path]

@@ -111,6 +117,11 @@ Checks the files in the source and destination match.  It
 compares sizes and MD5SUMs and prints a report of files which
 don't match.  It doesn't alter the source or destination.

+    rclone md5sum remote:path
+
+Produces an md5sum file for all the objects in the path.  This is in
+the same format as the standard md5sum tool produces.
+
 General options:

 ```
@@ -173,7 +184,7 @@ The modified time is stored as metadata on the object as
 Google drive
 ------------

-Paths are specified as drive:path  Drive paths may be as deep as required.
+Paths are specified as remote:path  Drive paths may be as deep as required.

 The initial setup for drive involves getting a token from Google drive
 which you need to do in your browser.  `rclone config` walks you
@@ -181,9 +192,45 @@ through it.

 To copy a local directory to a drive directory called backup

-    rclone copy /home/source drv:backup
+    rclone copy /home/source remote:backup

-Google drive stores modification times accurate to 1 ms.
+Google drive stores modification times accurate to 1 ms natively.
+
+Dropbox
+-------
+
+Paths are specified as remote:path  Dropbox paths may be as deep as required.
+
+The initial setup for dropbox involves getting a token from Dropbox
+which you need to do in your browser.  `rclone config` walks you
+through it.
+
+To copy a local directory to a drive directory called backup
+
+    rclone copy /home/source dropbox:backup
+
+Md5sums and timestamps in RFC3339 format accurate to 1ns are stored in
+a Dropbox datastore called "rclone".  Dropbox datastores are limited
+to 100,000 rows so this is the maximum number of files rclone can
+manage on Dropbox.
+
+Google Cloud Storage
+--------------------
+
+Paths are specified as remote:path Google Cloud Storage paths may be
+as deep as required.
+
+The initial setup for Google Cloud Storage involves getting a token
+from Google which you need to do in your browser.  `rclone config`
+walks you through it.
+
+To copy a local directory to a google cloud storage directory called backup
+
+    rclone copy /home/source remote:backup
+
+Google google cloud storage stores md5sums natively and rclone stores
+modification times as metadata on the object, under the "mtime" key in
+RFC3339 format accurate to 1ns.

 Single file copies
 ------------------
@@ -207,14 +254,55 @@ COPYING file included in this package).
 Bugs
 ----

-  * Drive: Sometimes get: Failed to copy: Upload failed: googleapi: Error 403: Rate Limit Exceeded
-    * quota is 100.0 requests/second/user
  * Empty directories left behind with Local and Drive
    * eg purging a local directory with subdirectories doesn't work

 Changelog
 ---------
-
+  * v1.09 - 2015-02-07
+    * windows: Stop drive letters (eg C:) getting mixed up with remotes (eg drive:)
+    * local: Fix directory separators on Windows
+    * drive: fix rate limit exceeded errors
+  * v1.08 - 2015-02-04
+    * drive: fix subdirectory listing to not list entire drive
+    * drive: Fix SetModTime
+    * dropbox: adapt code to recent library changes
+  * v1.07 - 2014-12-23
+    * google cloud storage: fix memory leak
+  * v1.06 - 2014-12-12
+    * Fix "Couldn't find home directory" on OSX
+    * swift: Add tenant parameter
+    * Use new location of Google API packages
+  * v1.05 - 2014-08-09
+    * Improved tests and consequently lots of minor fixes
+    * core: Fix race detected by go race detector
+    * core: Fixes after running errcheck
+    * drive: reset root directory on Rmdir and Purge
+    * fs: Document that Purger returns error on empty directory, test and fix
+    * google cloud storage: fix ListDir on subdirectory
+    * google cloud storage: re-read metadata in SetModTime
+    * s3: make reading metadata more reliable to work around eventual consistency problems
+    * s3: strip trailing / from ListDir()
+    * swift: return directories without / in ListDir
+  * v1.04 - 2014-07-21
+    * google cloud storage: Fix crash on Update
+  * v1.03 - 2014-07-20
+    * swift, s3, dropbox: fix updated files being marked as corrupted
+    * Make compile with go 1.1 again
+  * v1.02 - 2014-07-19
+    * Implement Dropbox remote
+    * Implement Google Cloud Storage remote
+    * Verify Md5sums and Sizes after copies
+    * Remove times from "ls" command - lists sizes only
+    * Add add "lsl" - lists times and sizes
+    * Add "md5sum" command
+  * v1.01 - 2014-07-04
+    * drive: fix transfer of big files using up lots of memory
+  * v1.00 - 2014-07-03
+    * drive: fix whole second dates
+  * v0.99 - 2014-06-26
+    * Fix --dry-run not working
+    * Make compatible with go 1.1
  * v0.98 - 2014-05-30
    * s3: Treat missing Content-Length as 0 for some ceph installations
    * rclonetest: add file with a space in
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -0,0 +1,19 @@
+Required software for making a release
+  * [github-release](https://github.com/aktau/github-release) for uploading packages
+  * [gox](https://github.com/mitchellh/gox) for cross compiling
+    * Run `gox -build-toolchain`
+    * This assumes you have your own source checkout
+  * pandoc for making the html and man pages
+
+Making a release
+  * go get -u -f -v ./...
+  * make test
+  * make tag
+  * edit README.md
+  * git commit fs/version.go README.md docs/content/downloads.md
+  * make retag
+  * # Set the GOPATH for a gox enabled compiler - . ~/bin/go-cross
+  * make cross
+  * make upload
+  * make upload_website
+  * git push --tags origin master
--- a/docs/config.json
+++ b/docs/config.json
@@ -5,7 +5,7 @@
        "menu": "menu"
    },
    "baseurl": "http://rclone.org",
-    "title": "rclone - rsync for object storage",
-    "description": "rclone - rsync for object storage: google drive, s3, swift, cloudfiles, memstore...",
+    "title": "rclone - rsync for cloud storage",
+    "description": "rclone - rsync for cloud storage: google drive, s3, swift, cloudfiles, dropbox, memstore...",
    "canonifyurls": true
 }
--- a/docs/content/about.md
+++ b/docs/content/about.md
@@ -1,8 +1,8 @@
 ---
 title: "Rclone"
-description: "rclone syncs files to and from Google Drive, S3, Swift and Cloudfiles."
+description: "rclone syncs files to and from Google Drive, S3, Swift, Cloudfiles, Dropbox and Google Cloud Storage."
 type: page
-date: "2014-04-26"
+date: "2014-07-17"
 groups: ["about"]
 ---

@@ -16,6 +16,8 @@ Rclone is a command line program to sync files and directories to and from
  * Google Drive
  * Amazon S3
  * Openstack Swift / Rackspace cloud files / Memset Memstore
+  * Dropbox
+  * Google Cloud Storage
  * The local filesystem

 Features
--- a/docs/content/docs.md
+++ b/docs/content/docs.md
@@ -1,7 +1,7 @@
 ---
 title: "Documentation"
 description: "Rclone Documentation"
-date: "2014-04-26"
+date: "2014-07-17"
 ---

 Install
@@ -71,11 +71,15 @@ first with the -dry-run flag.

    rclone ls [remote:path]

-List all the objects in the the path.
+List all the objects in the the path with sizes.
+
+    rclone lsl [remote:path]
+
+List all the objects in the the path with sizes and timestamps.

    rclone lsd [remote:path]

-List all directoryes/objects/buckets in the the path.
+List all directories/objects/buckets in the the path.

    rclone mkdir remote:path

@@ -96,6 +100,10 @@ Checks the files in the source and destination match.  It
 compares sizes and MD5SUMs and prints a report of files which
 don't match.  It doesn't alter the source or destination.

+    rclone md5sum remote:path
+
+Produces an md5sum file for all the objects in the path.  This is in
+the same format as the standard md5sum tool produces.
 General options:

 ```
@@ -124,9 +132,6 @@ COPYING file included in this package).
 Bugs
 ----

-  * Doesn't sync individual files yet, only directories.
-  * Drive: Sometimes get: Failed to copy: Upload failed: googleapi: Error 403: Rate Limit Exceeded
-    * quota is 100.0 requests/second/user
  * Empty directories left behind with Local and Drive
    * eg purging a local directory with subdirectories doesn't work

--- a/docs/content/downloads.md
+++ b/docs/content/downloads.md
@@ -2,34 +2,34 @@
 title: "Rclone downloads"
 description: "Download rclone binaries for your OS."
 type: page
-date: "2014-05-30"
+date: "2015-02-07"
 ---

-Rclone Download v0.98
+Rclone Download v1.09
 =====================

  * Windows
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-windows-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-windows-amd64.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-windows-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-windows-amd64.zip)
  * OSX
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-osx-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-osx-amd64.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-osx-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-osx-amd64.zip)
  * Linux
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-linux-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-linux-amd64.zip)
-    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v0.98-linux-arm.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-linux-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-linux-amd64.zip)
+    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v1.09-linux-arm.zip)
  * FreeBSD
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-freebsd-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-freebsd-amd64.zip)
-    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v0.98-freebsd-arm.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-freebsd-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-freebsd-amd64.zip)
+    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v1.09-freebsd-arm.zip)
  * NetBSD
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-netbsd-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-netbsd-amd64.zip)
-    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v0.98-netbsd-arm.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-netbsd-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-netbsd-amd64.zip)
+    * [ARM - 32 Bit](http://downloads.rclone.org/rclone-v1.09-netbsd-arm.zip)
  * OpenBSD
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-openbsd-386.zip)
-    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v0.98-openbsd-amd64.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-openbsd-386.zip)
+    * [AMD64 - 64 Bit](http://downloads.rclone.org/rclone-v1.09-openbsd-amd64.zip)
  * Plan 9
-    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v0.98-plan9-386.zip)
+    * [386 - 32 Bit](http://downloads.rclone.org/rclone-v1.09-plan9-386.zip)

 Older downloads can be found [here](http://downloads.rclone.org/)
--- a/docs/content/drive.md
+++ b/docs/content/drive.md
@@ -4,10 +4,12 @@ description: "Rclone docs for Google drive"
 date: "2014-04-26"
 ---

+<i class="fa fa-google"></i> Google Drive
+-----------------------------------------
+
 Paths are specified as `drive:path`

-Drive paths may be as deep as required, eg
-`drive:directory/subdirectory`.
+Drive paths may be as deep as required, eg `drive:directory/subdirectory`.

 The initial setup for drive involves getting a token from Google drive
 which you need to do in your browser.  `rclone config` walks you
--- a/docs/content/dropbox.md
+++ b/docs/content/dropbox.md
@@ -0,0 +1,80 @@
+---
+title: "Dropbox"
+description: "Rclone docs for Dropbox"
+date: "2014-07-17"
+---
+
+<i class="fa fa-dropbox"></i> Dropbox
+---------------------------------
+
+Paths are specified as `remote:path`
+
+Dropbox paths may be as deep as required, eg
+`remote:directory/subdirectory`.
+
+The initial setup for dropbox involves getting a token from Dropbox
+which you need to do in your browser.  `rclone config` walks you
+through it.
+
+Here is an example of how to make a remote called `remote`.  First run:
+
+     rclone config
+
+This will guide you through an interactive setup process:
+
+```
+n) New remote
+d) Delete remote
+q) Quit config
+e/n/d/q> n
+name> remote
+What type of source is it?
+Choose a number from below
+ 1) swift
+ 2) s3
+ 3) local
+ 4) google cloud storage
+ 5) dropbox
+ 6) drive
+type> 5
+Dropbox App Key - leave blank to use rclone's.
+app_key> 
+Dropbox App Secret - leave blank to use rclone's.
+app_secret> 
+Remote config
+Please visit:
+https://www.dropbox.com/1/oauth2/authorize?client_id=XXXXXXXXXXXXXXX&response_type=code
+Enter the code: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXXXXXXXX
+--------------------
+[remote]
+app_key = 
+app_secret = 
+token = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXX_XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+--------------------
+y) Yes this is OK
+e) Edit this remote
+d) Delete this remote
+y/e/d> y
+```
+
+You can then use it like this,
+
+List directories in top level of your dropbox
+
+    rclone lsd remote:
+
+List all the files in your dropbox
+
+    rclone ls remote:
+
+To copy a local directory to a dropbox directory called backup
+
+    rclone copy /home/source remote:backup
+
+Modified time
+-------------
+
+Md5sums and timestamps in RFC3339 format accurate to 1ns are stored in
+a Dropbox datastore called "rclone".  Dropbox datastores are limited
+to 100,000 rows so this is the maximum number of files rclone can
+manage on Dropbox.
--- a/docs/content/googlecloudstorage.md
+++ b/docs/content/googlecloudstorage.md
@@ -0,0 +1,117 @@
+---
+title: "Google Cloud Storage"
+description: "Rclone docs for Google Cloud Storage"
+date: "2014-07-17"
+---
+
+<i class="fa fa-google"></i> Google Cloud Storage
+-------------------------------------------------
+
+Paths are specified as `remote:bucket` (or `remote:` for the `lsd`
+command.)  You may put subdirectories in too, eg `remote:bucket/path/to/dir`.
+
+The initial setup for google cloud storage involves getting a token from Google Cloud Storage
+which you need to do in your browser.  `rclone config` walks you
+through it.
+
+Here is an example of how to make a remote called `remote`.  First run:
+
+     rclone config
+
+This will guide you through an interactive setup process:
+
+```
+n) New remote
+d) Delete remote
+q) Quit config
+e/n/d/q> n
+name> remote
+What type of source is it?
+Choose a number from below
+ 1) swift
+ 2) s3
+ 3) local
+ 4) google cloud storage
+ 5) dropbox
+ 6) drive
+type> 4
+Google Application Client Id - leave blank to use rclone's.
+client_id> 
+Google Application Client Secret - leave blank to use rclone's.
+client_secret> 
+Project number optional - needed only for list/create/delete buckets - see your developer console.
+project_number> 12345678
+Access Control List for new objects.
+Choose a number from below, or type in your own value
+ * Object owner gets OWNER access, and all Authenticated Users get READER access.
+ 1) authenticatedRead
+ * Object owner gets OWNER access, and project team owners get OWNER access.
+ 2) bucketOwnerFullControl
+ * Object owner gets OWNER access, and project team owners get READER access.
+ 3) bucketOwnerRead
+ * Object owner gets OWNER access [default if left blank].
+ 4) private
+ * Object owner gets OWNER access, and project team members get access according to their roles.
+ 5) projectPrivate
+ * Object owner gets OWNER access, and all Users get READER access.
+ 6) publicRead
+object_acl> 4
+Access Control List for new buckets.
+Choose a number from below, or type in your own value
+ * Project team owners get OWNER access, and all Authenticated Users get READER access.
+ 1) authenticatedRead
+ * Project team owners get OWNER access [default if left blank].
+ 2) private
+ * Project team members get access according to their roles.
+ 3) projectPrivate
+ * Project team owners get OWNER access, and all Users get READER access.
+ 4) publicRead
+ * Project team owners get OWNER access, and all Users get WRITER access.
+ 5) publicReadWrite
+bucket_acl> 2
+Remote config
+Go to the following link in your browser
+https://accounts.google.com/o/oauth2/auth?access_type=&approval_prompt=&client_id=XXXXXXXXXXXX.apps.googleusercontent.com&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&response_type=code&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdevstorage.full_control&state=state
+Log in, then type paste the token that is returned in the browser here
+Enter verification code> x/xxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxx_xxxxxxxx
+--------------------
+[remote]
+type = google cloud storage
+client_id = 
+client_secret = 
+token = {"AccessToken":"xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"x/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxx","Expiry":"2014-07-17T20:49:14.929208288+01:00","Extra":null}
+project_number = 12345678
+object_acl = private
+bucket_acl = private
+--------------------
+y) Yes this is OK
+e) Edit this remote
+d) Delete this remote
+y/e/d> y
+```
+
+This remote is called `remote` and can now be used like this
+
+See all the buckets in your project
+
+    rclone lsd remote:
+
+Make a new bucket
+
+    rclone mkdir remote:bucket
+
+List the contents of a bucket
+
+    rclone ls remote:bucket
+
+Sync `/home/local/directory` to the remote bucket, deleting any excess
+files in the bucket.
+
+    rclone sync /home/local/directory remote:bucket
+
+Modified time
+-------------
+
+Google google cloud storage stores md5sums natively and rclone stores
+modification times as metadata on the object, under the "mtime" key in
+RFC3339 format accurate to 1ns.
--- a/docs/content/local.md
+++ b/docs/content/local.md
@@ -4,8 +4,8 @@ description: "Rclone docs for the local filesystem"
 date: "2014-04-26"
 ---

-Local Filesystem
----------------
+<i class="fa fa-file"></i> Local Filesystem
+-------------------------------------------

 Local paths are specified as normal filesystem paths, eg `/path/to/wherever`, so

--- a/docs/content/s3.md
+++ b/docs/content/s3.md
@@ -4,13 +4,11 @@ description: "Rclone docs for Amazon S3"
 date: "2014-04-26"
 ---

-Paths are specified as `remote:bucket` or `remote:`
+<i class="fa fa-archive"></i> Amazon S3
+---------------------------------------

-S3 paths can't refer to subdirectories within a bucket (yet).
-
-So to copy a local directory to a s3 container called backup
-
-    rclone sync /home/source s3:backup
+Paths are specified as `remote:bucket` (or `remote:` for the `lsd`
+command.)  You may put subdirectories in too, eg `remote:bucket/path/to/dir`.

 Here is an example of making an s3 configuration.  First run

--- a/docs/content/swift.md
+++ b/docs/content/swift.md
@@ -4,13 +4,17 @@ description: "Swift"
 date: "2014-04-26"
 ---

+<i class="fa fa-space-shuttle"></i>Swift
+----------------------------------------
+
 Swift refers to [Openstack Object Storage](http://www.openstack.org/software/openstack-storage/).
 Commercial implementations of that being:

  * [Rackspace Cloud Files](http://www.rackspace.com/cloud/files/)
  * [Memset Memstore](http://www.memset.com/cloud/storage/)

-Paths are specified as `remote:container` or `remote:`
+Paths are specified as `remote:container` (or `remote:` for the `lsd`
+command.)  You may put subdirectories in too, eg `remote:container/path/to/dir`.

 Here is an example of making a swift configuration.  First run

@@ -48,12 +52,15 @@ Choose a number from below, or type in your own value
 * Memset Memstore UK v2
 5) https://auth.storage.memset.com/v2.0
 auth> 1
+Tenant name - optional
+tenant>
 Remote config
 --------------------
 [remote]
 user = user_name
 key = password_or_api_key
 auth = https://auth.api.rackspacecloud.com/v1.0
+tenant =
 --------------------
 y) Yes this is OK
 e) Edit this remote
--- a/docs/layouts/chrome/navbar.html
+++ b/docs/layouts/chrome/navbar.html
@@ -20,6 +20,8 @@
                    <li><a href="/drive/"><i class="fa fa-google"></i> Drive</a></li>
                    <li><a href="/s3/"><i class="fa fa-archive"></i> S3</a></li>
                    <li><a href="/swift/"><i class="fa fa-space-shuttle"></i> Swift</a></li>
+                    <li><a href="/dropbox/"><i class="fa fa-dropbox"></i> Dropbox</a></li>
+                    <li><a href="/googlecloudstorage/"><i class="fa fa-google"></i> Google Cloud Storage</a></li>
                    <li><a href="/local/"><i class="fa fa-file"></i> Local</a></li>
                  </ul>
                </li>
--- a/drive/drive.go
+++ b/drive/drive.go
@@ -1,14 +1,6 @@
 // Drive interface
 package drive

-// Gets this quite often
-// Failed to set mtime: googleapi: Error 403: Rate Limit Exceeded
-
-// FIXME list containers equivalent should list directories?
-
-// FIXME list directory should list to channel for concurrency not
-// append to array
-
 // FIXME need to deal with some corner cases
 // * multiple files with the same name
 // * files can be in multiple directories
@@ -16,7 +8,6 @@ package drive
 // * files with / in name

 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"log"
@@ -27,9 +18,11 @@ import (
 	"sync"
 	"time"

-	"code.google.com/p/goauth2/oauth"
-	"code.google.com/p/google-api-go-client/drive/v2"
+	"google.golang.org/api/drive/v2"
+	"google.golang.org/api/googleapi"
+
 	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/googleauth"
 	"github.com/ogier/pflag"
 )

@@ -38,20 +31,33 @@ const (
 	rcloneClientId     = "202264815644.apps.googleusercontent.com"
 	rcloneClientSecret = "X4Z3ca8xfWDb1Voo-F9a7ZxJ"
 	driveFolderType    = "application/vnd.google-apps.folder"
+	timeFormatIn       = time.RFC3339
+	timeFormatOut      = "2006-01-02T15:04:05.000000000Z07:00"
+	minSleep           = 10 * time.Millisecond
+	maxSleep           = 2 * time.Second
+	decayConstant      = 2 // bigger for slower decay, exponential
 )

 // Globals
 var (
 	// Flags
 	driveFullList = pflag.BoolP("drive-full-list", "", true, "Use a full listing for directory list. More data but usually quicker.")
+	// Description of how to auth for this app
+	driveAuth = &googleauth.Auth{
+		Scope:               "https://www.googleapis.com/auth/drive",
+		DefaultClientId:     rcloneClientId,
+		DefaultClientSecret: rcloneClientSecret,
+	}
 )

 // Register with Fs
 func init() {
 	fs.Register(&fs.FsInfo{
-		Name:   "drive",
-		NewFs:  NewFs,
-		Config: Config,
+		Name:  "drive",
+		NewFs: NewFs,
+		Config: func(name string) {
+			driveAuth.Config(name)
+		},
 		Options: []fs.Option{{
 			Name: "client_id",
 			Help: "Google Application Client Id - leave blank to use rclone's.",
@@ -62,77 +68,6 @@ func init() {
 	})
 }

-// Configuration helper - called after the user has put in the defaults
-func Config(name string) {
-	// See if already have a token
-	tokenString := fs.ConfigFile.MustValue(name, "token")
-	if tokenString != "" {
-		fmt.Printf("Already have a drive token - refresh?\n")
-		if !fs.Confirm() {
-			return
-		}
-	}
-
-	// Get a drive transport
-	t, err := newDriveTransport(name)
-	if err != nil {
-		log.Fatalf("Couldn't make drive transport: %v", err)
-	}
-
-	// Generate a URL for the user to visit for authorization.
-	authUrl := t.Config.AuthCodeURL("state")
-	fmt.Printf("Go to the following link in your browser\n")
-	fmt.Printf("%s\n", authUrl)
-	fmt.Printf("Log in, then type paste the token that is returned in the browser here\n")
-
-	// Read the code, and exchange it for a token.
-	fmt.Printf("Enter verification code> ")
-	authCode := fs.ReadLine()
-	_, err = t.Exchange(authCode)
-	if err != nil {
-		log.Fatalf("Failed to get token: %v", err)
-	}
-
-}
-
-// A token cache to save the token in the config file section named
-type tokenCache string
-
-// Get the token from the config file - returns an error if it isn't present
-func (name tokenCache) Token() (*oauth.Token, error) {
-	tokenString, err := fs.ConfigFile.GetValue(string(name), "token")
-	if err != nil {
-		return nil, err
-	}
-	if tokenString == "" {
-		return nil, fmt.Errorf("Empty token found - please reconfigure")
-	}
-	token := new(oauth.Token)
-	err = json.Unmarshal([]byte(tokenString), token)
-	if err != nil {
-		return nil, err
-	}
-	return token, nil
-
-}
-
-// Save the token to the config file
-//
-// This saves the config file if it changes
-func (name tokenCache) PutToken(token *oauth.Token) error {
-	tokenBytes, err := json.Marshal(token)
-	if err != nil {
-		return err
-	}
-	tokenString := string(tokenBytes)
-	old := fs.ConfigFile.MustValue(string(name), "token")
-	if tokenString != old {
-		fs.ConfigFile.SetValue(string(name), "token", tokenString)
-		fs.SaveConfig()
-	}
-	return nil
-}
-
 // FsDrive represents a remote drive server
 type FsDrive struct {
 	svc          *drive.Service // the connection to the drive server
@@ -144,6 +79,8 @@ type FsDrive struct {
 	findRootLock sync.Mutex     // Protect findRoot from concurrent use
 	dirCache     dirCache       // Map of directory path to directory id
 	findDirLock  sync.Mutex     // Protect findDir from concurrent use
+	pacer        chan struct{}  // To pace the operations
+	sleepTime    time.Duration  // Time to sleep for each transaction
 }

 // FsObjectDrive describes a drive object
@@ -210,6 +147,74 @@ func (f *FsDrive) String() string {
 	return fmt.Sprintf("Google drive root '%s'", f.root)
 }

+// Wait for the pace
+func (f *FsDrive) paceWait() {
+	// pacer starts with a token in and whenever we take one out
+	// XXX ms later we put another in.  We could do this with a
+	// Ticker more accurately, but then we'd have to work out how
+	// not to run it when it wasn't needed
+	<-f.pacer
+
+	// Restart the timer
+	go func(t time.Duration) {
+		// fs.Debug(f, "New sleep for %v at %v", t, time.Now())
+		time.Sleep(t)
+		f.pacer <- struct{}{}
+	}(f.sleepTime)
+}
+
+// Refresh the pace given an error that was returned.  It returns a
+// boolean as to whether the operation should be retried.
+//
+// See https://developers.google.com/drive/web/handle-errors
+// http://stackoverflow.com/questions/18529524/403-rate-limit-after-only-1-insert-per-second
+func (f *FsDrive) paceRefresh(err error) bool {
+	again := false
+	oldSleepTime := f.sleepTime
+	if err == nil {
+		f.sleepTime = (f.sleepTime<<decayConstant - f.sleepTime) >> decayConstant
+		if f.sleepTime < minSleep {
+			f.sleepTime = minSleep
+		}
+		if f.sleepTime != oldSleepTime {
+			fs.Debug(f, "Reducing sleep to %v", f.sleepTime)
+		}
+	} else {
+		fs.Debug(f, "Error recived: %v", err)
+		if gerr, ok := err.(*googleapi.Error); ok {
+			if len(gerr.Errors) > 0 {
+				reason := gerr.Errors[0].Reason
+				if reason == "rateLimitExceeded" || reason == "userRateLimitExceeded" {
+					f.sleepTime *= 2
+					if f.sleepTime > maxSleep {
+						f.sleepTime = maxSleep
+					}
+					if f.sleepTime != oldSleepTime {
+						fs.Debug(f, "Rate limited, increasing sleep to %v", f.sleepTime)
+					}
+					again = true
+				}
+			}
+		}
+	}
+
+	return again
+}
+
+// Pace the remote operations to not exceed Google's limits and retry
+// on 403 rate limit exceeded
+//
+// This calls fn, expecting it to place its error in perr
+func (f *FsDrive) pace(perr *error, fn func()) {
+	for {
+		f.paceWait()
+		fn()
+		if !f.paceRefresh(*perr) {
+			break
+		}
+	}
+}
+
 // parseParse parses a drive 'url'
 func parseDrivePath(path string) (root string, err error) {
 	root = strings.Trim(path, "/")
@@ -247,7 +252,10 @@ func (f *FsDrive) listAll(dirId string, title string, directoriesOnly bool, file
 	list := f.svc.Files.List().Q(query).MaxResults(1000)
 OUTER:
 	for {
-		files, err := list.Do()
+		var files *drive.FileList
+		f.pace(&err, func() {
+			files, err = list.Do()
+		})
 		if err != nil {
 			return false, fmt.Errorf("Couldn't list directory: %s", err)
 		}
@@ -265,39 +273,9 @@ OUTER:
 	return
 }

-// Makes a new drive transport from the config
-func newDriveTransport(name string) (*oauth.Transport, error) {
-	clientId := fs.ConfigFile.MustValue(name, "client_id")
-	if clientId == "" {
-		clientId = rcloneClientId
-	}
-	clientSecret := fs.ConfigFile.MustValue(name, "client_secret")
-	if clientSecret == "" {
-		clientSecret = rcloneClientSecret
-	}
-
-	// Settings for authorization.
-	var driveConfig = &oauth.Config{
-		ClientId:     clientId,
-		ClientSecret: clientSecret,
-		Scope:        "https://www.googleapis.com/auth/drive",
-		RedirectURL:  "urn:ietf:wg:oauth:2.0:oob",
-		AuthURL:      "https://accounts.google.com/o/oauth2/auth",
-		TokenURL:     "https://accounts.google.com/o/oauth2/token",
-		TokenCache:   tokenCache(name),
-	}
-
-	t := &oauth.Transport{
-		Config:    driveConfig,
-		Transport: http.DefaultTransport,
-	}
-
-	return t, nil
-}
-
 // NewFs contstructs an FsDrive from the path, container:path
 func NewFs(name, path string) (fs.Fs, error) {
-	t, err := newDriveTransport(name)
+	t, err := driveAuth.NewTransport(name)
 	if err != nil {
 		return nil, err
 	}
@@ -306,17 +284,16 @@ func NewFs(name, path string) (fs.Fs, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	f := &FsDrive{
-		root:     root,
-		dirCache: newDirCache(),
+		root:      root,
+		dirCache:  newDirCache(),
+		pacer:     make(chan struct{}, 1),
+		sleepTime: minSleep,
 	}

-	// Try to pull the token from the cache; if this fails, we need to get one.
-	token, err := t.Config.TokenCache.Token()
-	if err != nil {
-		return nil, fmt.Errorf("Failed to get token: %s", err)
-	}
-	t.Token = token
+	// Put the first pacing token in
+	f.pacer <- struct{}{}

 	// Create a new authorized Drive client.
 	f.client = t.Client()
@@ -326,15 +303,15 @@ func NewFs(name, path string) (fs.Fs, error) {
 	}

 	// Read About so we know the root path
-	f.about, err = f.svc.About.Get().Do()
+	f.pace(&err, func() {
+		f.about, err = f.svc.About.Get().Do()
+	})
 	if err != nil {
 		return nil, fmt.Errorf("Couldn't read info about Drive: %s", err)
 	}

-	// Find the Id of the root directory and the Id of its parent
-	f.rootId = f.about.RootFolderId
-	// Put the root directory in
-	f.dirCache.Put("", f.rootId)
+	// Find the Id of the true root and clear everything
+	f.resetRoot()
 	// Find the current root
 	err = f.findRoot(false)
 	if err != nil {
@@ -348,7 +325,7 @@ func NewFs(name, path string) (fs.Fs, error) {
 			// No root so return old f
 			return f, nil
 		}
-		obj, err := newF.newFsObjectWithInfo(remote, nil)
+		obj, err := newF.newFsObjectWithInfoErr(remote, nil)
 		if err != nil {
 			// File doesn't exist so return old f
 			return f, nil
@@ -361,7 +338,7 @@ func NewFs(name, path string) (fs.Fs, error) {
 }

 // Return an FsObject from a path
-func (f *FsDrive) newFsObjectWithInfo(remote string, info *drive.File) (fs.Object, error) {
+func (f *FsDrive) newFsObjectWithInfoErr(remote string, info *drive.File) (fs.Object, error) {
 	fs := &FsObjectDrive{
 		drive:  f,
 		remote: remote,
@@ -381,8 +358,8 @@ func (f *FsDrive) newFsObjectWithInfo(remote string, info *drive.File) (fs.Objec
 // Return an FsObject from a path
 //
 // May return nil if an error occurred
-func (f *FsDrive) NewFsObjectWithInfo(remote string, info *drive.File) fs.Object {
-	fs, _ := f.newFsObjectWithInfo(remote, info)
+func (f *FsDrive) newFsObjectWithInfo(remote string, info *drive.File) fs.Object {
+	fs, _ := f.newFsObjectWithInfoErr(remote, info)
 	// Errors have already been logged
 	return fs
 }
@@ -391,7 +368,7 @@ func (f *FsDrive) NewFsObjectWithInfo(remote string, info *drive.File) fs.Object
 //
 // May return nil if an error occurred
 func (f *FsDrive) NewFsObject(remote string) fs.Object {
-	return f.NewFsObjectWithInfo(remote, nil)
+	return f.newFsObjectWithInfo(remote, nil)
 }

 // Path should be directory path either "" or "path/"
@@ -415,7 +392,7 @@ func (f *FsDrive) listDirRecursive(dirId string, path string, out fs.ObjectsChan
 		} else {
 			// If item has no MD5 sum it isn't stored on drive, so ignore it
 			if item.Md5Checksum != "" {
-				if fs := f.NewFsObjectWithInfo(path+item.Title, item); fs != nil {
+				if fs := f.newFsObjectWithInfo(path+item.Title, item); fs != nil {
 					out <- fs
 				}
 			}
@@ -465,7 +442,7 @@ func (f *FsDrive) listDirFull(dirId string, path string, out fs.ObjectsChan) err
 			// fmt.Printf("file %s %s %s\n", path, item.Title, item.Id)
 			// If item has no MD5 sum it isn't stored on drive, so ignore it
 			if item.Md5Checksum != "" {
-				if fs := f.NewFsObjectWithInfo(path, item); fs != nil {
+				if fs := f.newFsObjectWithInfo(path, item); fs != nil {
 					out <- fs
 				}
 			}
@@ -588,15 +565,18 @@ func (f *FsDrive) _findDir(path string, create bool) (pathId string, err error)
 		if create {
 			// fmt.Println("Making", path)
 			// Define the metadata for the directory we are going to create.
-			info := &drive.File{
+			createInfo := &drive.File{
 				Title:       leaf,
 				Description: leaf,
 				MimeType:    driveFolderType,
 				Parents:     []*drive.ParentReference{{Id: pathId}},
 			}
-			info, err := f.svc.Files.Insert(info).Do()
+			var info *drive.File
+			f.pace(&err, func() {
+				info, err = f.svc.Files.Insert(createInfo).Do()
+			})
 			if err != nil {
-				return pathId, fmt.Errorf("Failed to make directory")
+				return pathId, fmt.Errorf("Failed to make directory: %v", err)
 			}
 			pathId = info.Id
 		} else {
@@ -634,6 +614,20 @@ func (f *FsDrive) findRoot(create bool) error {
 	return nil
 }

+// Resets the root directory to the absolute root and clears the dirCache
+func (f *FsDrive) resetRoot() {
+	f.findRootLock.Lock()
+	defer f.findRootLock.Unlock()
+	f.foundRoot = false
+	f.dirCache.Flush()
+
+	// Put the true root in
+	f.rootId = f.about.RootFolderId
+
+	// Put the root directory in
+	f.dirCache.Put("", f.rootId)
+}
+
 // Walk the path returning a channel of FsObjects
 func (f *FsDrive) List() fs.ObjectsChan {
 	out := make(fs.ObjectsChan, fs.Config.Checkers)
@@ -644,7 +638,7 @@ func (f *FsDrive) List() fs.ObjectsChan {
 			fs.Stats.Error()
 			log.Printf("Couldn't find root: %s", err)
 		} else {
-			if *driveFullList {
+			if f.root == "" && *driveFullList {
 				err = f.listDirFull(f.rootId, "", out)
 			} else {
 				err = f.listDirRecursive(f.rootId, "", out)
@@ -674,7 +668,7 @@ func (f *FsDrive) ListDir() fs.DirChan {
 					Bytes: -1,
 					Count: -1,
 				}
-				dir.When, _ = time.Parse(time.RFC3339, item.ModifiedDate)
+				dir.When, _ = time.Parse(timeFormatIn, item.ModifiedDate)
 				out <- dir
 				return false
 			})
@@ -711,10 +705,10 @@ func (f *FsDrive) Put(in io.Reader, remote string, modTime time.Time, size int64
 	if mimeType == "" {
 		mimeType = "application/octet-stream"
 	}
-	modifiedDate := modTime.Format(time.RFC3339Nano)
+	modifiedDate := modTime.Format(timeFormatOut)

 	// Define the metadata for the file we are going to create.
-	info := &drive.File{
+	createInfo := &drive.File{
 		Title:        leaf,
 		Description:  leaf,
 		Parents:      []*drive.ParentReference{{Id: directoryId}},
@@ -723,7 +717,14 @@ func (f *FsDrive) Put(in io.Reader, remote string, modTime time.Time, size int64
 	}

 	// Make the API request to upload metadata and file data.
-	info, err = f.svc.Files.Insert(info).Media(in).Do()
+	in = &fs.SeekWrapper{In: in, Size: size}
+	var info *drive.File
+	// Don't retry, return a retry error instead
+	f.paceWait()
+	info, err = f.svc.Files.Insert(createInfo).Media(in).Do()
+	if f.paceRefresh(err) {
+		return o, fs.RetryErrorf("Upload failed - retry: %s", err)
+	}
 	if err != nil {
 		return o, fmt.Errorf("Upload failed: %s", err)
 	}
@@ -744,7 +745,10 @@ func (f *FsDrive) Rmdir() error {
 	if err != nil {
 		return err
 	}
-	children, err := f.svc.Children.List(f.rootId).MaxResults(10).Do()
+	var children *drive.ChildList
+	f.pace(&err, func() {
+		children, err = f.svc.Children.List(f.rootId).MaxResults(10).Do()
+	})
 	if err != nil {
 		return err
 	}
@@ -753,11 +757,14 @@ func (f *FsDrive) Rmdir() error {
 	}
 	// Delete the directory if it isn't the root
 	if f.root != "" {
-		err = f.svc.Files.Delete(f.rootId).Do()
+		f.pace(&err, func() {
+			err = f.svc.Files.Delete(f.rootId).Do()
+		})
 		if err != nil {
 			return err
 		}
 	}
+	f.resetRoot()
 	return nil
 }

@@ -768,7 +775,9 @@ func (fs *FsDrive) Precision() time.Duration {

 // Purge deletes all the files and the container
 //
-// Returns an error if it isn't empty
+// Optional interface: Only implement this if you have a way of
+// deleting all the files quicker than just running Remove() on the
+// result of List()
 func (f *FsDrive) Purge() error {
 	if f.root == "" {
 		return fmt.Errorf("Can't purge root directory")
@@ -777,7 +786,10 @@ func (f *FsDrive) Purge() error {
 	if err != nil {
 		return err
 	}
-	err = f.svc.Files.Delete(f.rootId).Do()
+	f.pace(&err, func() {
+		err = f.svc.Files.Delete(f.rootId).Do()
+	})
+	f.resetRoot()
 	if err != nil {
 		return err
 	}
@@ -864,7 +876,7 @@ func (o *FsObjectDrive) ModTime() time.Time {
 		fs.Log(o, "Failed to read metadata: %s", err)
 		return time.Now()
 	}
-	modTime, err := time.Parse(time.RFC3339, o.modifiedDate)
+	modTime, err := time.Parse(timeFormatIn, o.modifiedDate)
 	if err != nil {
 		fs.Log(o, "Failed to read mtime from object: %s", err)
 		return time.Now()
@@ -881,15 +893,20 @@ func (o *FsObjectDrive) SetModTime(modTime time.Time) {
 		return
 	}
 	// New metadata
-	info := &drive.File{
-		ModifiedDate: modTime.Format(time.RFC3339Nano),
+	updateInfo := &drive.File{
+		ModifiedDate: modTime.Format(timeFormatOut),
 	}
 	// Set modified date
-	_, err = o.drive.svc.Files.Update(o.id, info).SetModifiedDate(true).Do()
+	var info *drive.File
+	o.drive.pace(&err, func() {
+		info, err = o.drive.svc.Files.Update(o.id, updateInfo).SetModifiedDate(true).Do()
+	})
 	if err != nil {
 		fs.Stats.Error()
 		fs.Log(o, "Failed to update remote mtime: %s", err)
 	}
+	// Update info from read data
+	o.setMetaData(info)
 }

 // Is this object storable
@@ -899,14 +916,20 @@ func (o *FsObjectDrive) Storable() bool {

 // Open an object for read
 func (o *FsObjectDrive) Open() (in io.ReadCloser, err error) {
-	req, _ := http.NewRequest("GET", o.url, nil)
-	req.Header.Set("User-Agent", "rclone/1.0")
-	res, err := o.drive.client.Do(req)
+	req, err := http.NewRequest("GET", o.url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", fs.UserAgent)
+	var res *http.Response
+	o.drive.pace(&err, func() {
+		res, err = o.drive.client.Do(req)
+	})
 	if err != nil {
 		return nil, err
 	}
 	if res.StatusCode != 200 {
-		res.Body.Close()
+		_ = res.Body.Close() // ignore error
 		return nil, fmt.Errorf("Bad response: %d: %s", res.StatusCode, res.Status)
 	}
 	return res.Body, nil
@@ -918,13 +941,21 @@ func (o *FsObjectDrive) Open() (in io.ReadCloser, err error) {
 //
 // The new object may have been created if an error is returned
 func (o *FsObjectDrive) Update(in io.Reader, modTime time.Time, size int64) error {
-	info := &drive.File{
+	updateInfo := &drive.File{
 		Id:           o.id,
-		ModifiedDate: modTime.Format(time.RFC3339Nano),
+		ModifiedDate: modTime.Format(timeFormatOut),
 	}

 	// Make the API request to upload metadata and file data.
-	info, err := o.drive.svc.Files.Update(info.Id, info).SetModifiedDate(true).Media(in).Do()
+	in = &fs.SeekWrapper{In: in, Size: size}
+	var err error
+	var info *drive.File
+	// Don't retry, return a retry error instead
+	o.drive.paceWait()
+	info, err = o.drive.svc.Files.Update(updateInfo.Id, updateInfo).SetModifiedDate(true).Media(in).Do()
+	if o.drive.paceRefresh(err) {
+		return fs.RetryErrorf("Update failed - retry: %s", err)
+	}
 	if err != nil {
 		return fmt.Errorf("Update failed: %s", err)
 	}
@@ -934,7 +965,11 @@ func (o *FsObjectDrive) Update(in io.Reader, modTime time.Time, size int64) erro

 // Remove an object
 func (o *FsObjectDrive) Remove() error {
-	return o.drive.svc.Files.Delete(o.id).Do()
+	var err error
+	o.drive.pace(&err, func() {
+		err = o.drive.svc.Files.Delete(o.id).Do()
+	})
+	return err
 }

 // Check the interfaces are satisfied
--- a/drive/drive_test.go
+++ b/drive/drive_test.go
@@ -0,0 +1,53 @@
+// Test Drive filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package drive_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/drive"
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*drive.FsObjectDrive)(nil))
+	fstests.RemoteName = "TestDrive:"
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/dropbox/dropbox.go
+++ b/dropbox/dropbox.go
@@ -0,0 +1,742 @@
+// Dropbox interface
+package dropbox
+
+/*
+Limitations of dropbox
+
+File system is case insensitive
+
+The datastore is limited to 100,000 records which therefore is the
+limit of the number of files that rclone can use on dropbox.
+
+FIXME only open datastore if we need it?
+
+FIXME Getting this sometimes
+Failed to copy: Upload failed: invalid character '<' looking for beginning of value
+This is a JSON decode error - from Update / UploadByChunk
+- Caused by 500 error from dropbox
+- See https://github.com/stacktic/dropbox/issues/1
+- Possibly confusing dropbox with excess concurrency?
+*/
+
+import (
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"path"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/stacktic/dropbox"
+)
+
+// Constants
+const (
+	rcloneAppKey     = "5jcck7diasz0rqy"
+	rcloneAppSecret  = "1n9m04y2zx7bf26"
+	uploadChunkSize  = 64 * 1024                    // chunk size for upload
+	metadataLimit    = dropbox.MetadataLimitDefault // max items to fetch at once
+	datastoreName    = "rclone"
+	tableName        = "metadata"
+	md5sumField      = "md5sum"
+	mtimeField       = "mtime"
+	maxCommitRetries = 5
+	timeFormatIn     = time.RFC3339
+	timeFormatOut    = "2006-01-02T15:04:05.000000000Z07:00"
+)
+
+// Register with Fs
+func init() {
+	fs.Register(&fs.FsInfo{
+		Name:   "dropbox",
+		NewFs:  NewFs,
+		Config: configHelper,
+		Options: []fs.Option{{
+			Name: "app_key",
+			Help: "Dropbox App Key - leave blank to use rclone's.",
+		}, {
+			Name: "app_secret",
+			Help: "Dropbox App Secret - leave blank to use rclone's.",
+		}},
+	})
+}
+
+// Configuration helper - called after the user has put in the defaults
+func configHelper(name string) {
+	// See if already have a token
+	token := fs.ConfigFile.MustValue(name, "token")
+	if token != "" {
+		fmt.Printf("Already have a dropbox token - refresh?\n")
+		if !fs.Confirm() {
+			return
+		}
+	}
+
+	// Get a dropbox
+	db := newDropbox(name)
+
+	// This method will ask the user to visit an URL and paste the generated code.
+	if err := db.Auth(); err != nil {
+		log.Fatalf("Failed to authorize: %v", err)
+	}
+
+	// Get the token
+	token = db.AccessToken()
+
+	// Stuff it in the config file if it has changed
+	old := fs.ConfigFile.MustValue(name, "token")
+	if token != old {
+		fs.ConfigFile.SetValue(name, "token", token)
+		fs.SaveConfig()
+	}
+}
+
+// FsDropbox represents a remote dropbox server
+type FsDropbox struct {
+	db               *dropbox.Dropbox // the connection to the dropbox server
+	root             string           // the path we are working on
+	slashRoot        string           // root with "/" prefix
+	slashRootSlash   string           // root with "/" prefix and postix
+	datastoreManager *dropbox.DatastoreManager
+	datastore        *dropbox.Datastore
+	table            *dropbox.Table
+	datastoreMutex   sync.Mutex // lock this when using the datastore
+	datastoreErr     error      // pending errors on the datastore
+}
+
+// FsObjectDropbox describes a dropbox object
+type FsObjectDropbox struct {
+	dropbox *FsDropbox // what this object is part of
+	remote  string     // The remote path
+	md5sum  string     // md5sum of the object
+	bytes   int64      // size of the object
+	modTime time.Time  // time it was last modified
+}
+
+// ------------------------------------------------------------
+
+// String converts this FsDropbox to a string
+func (f *FsDropbox) String() string {
+	return fmt.Sprintf("Dropbox root '%s'", f.root)
+}
+
+// Makes a new dropbox from the config
+func newDropbox(name string) *dropbox.Dropbox {
+	db := dropbox.NewDropbox()
+
+	appKey := fs.ConfigFile.MustValue(name, "app_key")
+	if appKey == "" {
+		appKey = rcloneAppKey
+	}
+	appSecret := fs.ConfigFile.MustValue(name, "app_secret")
+	if appSecret == "" {
+		appSecret = rcloneAppSecret
+	}
+
+	db.SetAppInfo(appKey, appSecret)
+
+	return db
+}
+
+// NewFs contstructs an FsDropbox from the path, container:path
+func NewFs(name, root string) (fs.Fs, error) {
+	db := newDropbox(name)
+	f := &FsDropbox{
+		db: db,
+	}
+	f.setRoot(root)
+
+	// Read the token from the config file
+	token := fs.ConfigFile.MustValue(name, "token")
+
+	// Authorize the client
+	db.SetAccessToken(token)
+
+	// Make a db to store rclone metadata in
+	f.datastoreManager = db.NewDatastoreManager()
+
+	// Open the datastore in the background
+	go f.openDataStore()
+
+	// See if the root is actually an object
+	entry, err := f.db.Metadata(f.slashRoot, false, false, "", "", metadataLimit)
+	if err == nil && !entry.IsDir {
+		remote := path.Base(f.root)
+		newRoot := path.Dir(f.root)
+		if newRoot == "." {
+			newRoot = ""
+		}
+		f.setRoot(newRoot)
+		obj := f.NewFsObject(remote)
+		// return a Fs Limited to this object
+		return fs.NewLimited(f, obj), nil
+	}
+
+	return f, nil
+}
+
+// Sets root in f
+func (f *FsDropbox) setRoot(root string) {
+	f.root = strings.Trim(root, "/")
+	f.slashRoot = "/" + f.root
+	f.slashRootSlash = f.slashRoot
+	if f.root != "" {
+		f.slashRootSlash += "/"
+	}
+}
+
+// Opens the datastore in f
+func (f *FsDropbox) openDataStore() {
+	f.datastoreMutex.Lock()
+	defer f.datastoreMutex.Unlock()
+	fs.Debug(f, "Open rclone datastore")
+	// Open the rclone datastore
+	var err error
+	f.datastore, err = f.datastoreManager.OpenDatastore(datastoreName)
+	if err != nil {
+		fs.Log(f, "Failed to open datastore: %v", err)
+		f.datastoreErr = err
+		return
+	}
+
+	// Get the table we are using
+	f.table, err = f.datastore.GetTable(tableName)
+	if err != nil {
+		fs.Log(f, "Failed to open datastore table: %v", err)
+		f.datastoreErr = err
+		return
+	}
+	fs.Debug(f, "Open rclone datastore finished")
+}
+
+// Return an FsObject from a path
+//
+// May return nil if an error occurred
+func (f *FsDropbox) newFsObjectWithInfo(remote string, info *dropbox.Entry) fs.Object {
+	o := &FsObjectDropbox{
+		dropbox: f,
+		remote:  remote,
+	}
+	if info != nil {
+		o.setMetadataFromEntry(info)
+	} else {
+		err := o.readEntryAndSetMetadata()
+		if err != nil {
+			// logged already fs.Debug("Failed to read info: %s", err)
+			return nil
+		}
+	}
+	return o
+}
+
+// Return an FsObject from a path
+//
+// May return nil if an error occurred
+func (f *FsDropbox) NewFsObject(remote string) fs.Object {
+	return f.newFsObjectWithInfo(remote, nil)
+}
+
+// Strips the root off entry and returns it
+func (f *FsDropbox) stripRoot(entry *dropbox.Entry) string {
+	path := entry.Path
+	if strings.HasPrefix(path, f.slashRootSlash) {
+		path = path[len(f.slashRootSlash):]
+	}
+	return path
+}
+
+// Walk the root returning a channel of FsObjects
+func (f *FsDropbox) list(out fs.ObjectsChan) {
+	cursor := ""
+	for {
+		deltaPage, err := f.db.Delta(cursor, f.slashRoot)
+		if err != nil {
+			fs.Stats.Error()
+			fs.Log(f, "Couldn't list: %s", err)
+			break
+		} else {
+			if deltaPage.Reset && cursor != "" {
+				fs.Log(f, "Unexpected reset during listing - try again")
+				fs.Stats.Error()
+				break
+			}
+			fs.Debug(f, "%d delta entries received", len(deltaPage.Entries))
+			for i := range deltaPage.Entries {
+				deltaEntry := &deltaPage.Entries[i]
+				entry := deltaEntry.Entry
+				if entry == nil {
+					// This notifies of a deleted object
+					fs.Debug(f, "Deleting metadata for %q", deltaEntry.Path)
+					key := metadataKey(deltaEntry.Path) // Path is lowercased
+					err := f.deleteMetadata(key)
+					if err != nil {
+						fs.Debug(f, "Failed to delete metadata for %q", deltaEntry.Path)
+						// Don't accumulate Error here
+					}
+
+				} else {
+					if entry.IsDir {
+						// ignore directories
+					} else {
+						path := f.stripRoot(entry)
+						out <- f.newFsObjectWithInfo(path, entry)
+					}
+				}
+			}
+			if !deltaPage.HasMore {
+				break
+			}
+			cursor = deltaPage.Cursor.Cursor
+		}
+	}
+}
+
+// Walk the path returning a channel of FsObjects
+func (f *FsDropbox) List() fs.ObjectsChan {
+	out := make(fs.ObjectsChan, fs.Config.Checkers)
+	go func() {
+		defer close(out)
+		f.list(out)
+	}()
+	return out
+}
+
+// Walk the path returning a channel of FsObjects
+func (f *FsDropbox) ListDir() fs.DirChan {
+	out := make(fs.DirChan, fs.Config.Checkers)
+	go func() {
+		defer close(out)
+		entry, err := f.db.Metadata(f.root, true, false, "", "", metadataLimit)
+		if err != nil {
+			fs.Stats.Error()
+			fs.Log(f, "Couldn't list directories in root: %s", err)
+		} else {
+			for i := range entry.Contents {
+				entry := &entry.Contents[i]
+				if entry.IsDir {
+					out <- &fs.Dir{
+						Name:  f.stripRoot(entry),
+						When:  time.Time(entry.ClientMtime),
+						Bytes: int64(entry.Bytes),
+						Count: -1,
+					}
+				}
+			}
+		}
+	}()
+	return out
+}
+
+// A read closer which doesn't close the input
+type readCloser struct {
+	in io.Reader
+}
+
+// Read bytes from the object - see io.Reader
+func (rc *readCloser) Read(p []byte) (n int, err error) {
+	return rc.in.Read(p)
+}
+
+// Dummy close function
+func (rc *readCloser) Close() error {
+	return nil
+}
+
+// Put the object
+//
+// Copy the reader in to the new object which is returned
+//
+// The new object may have been created if an error is returned
+func (f *FsDropbox) Put(in io.Reader, remote string, modTime time.Time, size int64) (fs.Object, error) {
+	// Temporary FsObject under construction
+	o := &FsObjectDropbox{dropbox: f, remote: remote}
+	return o, o.Update(in, modTime, size)
+}
+
+// Mkdir creates the container if it doesn't exist
+func (f *FsDropbox) Mkdir() error {
+	entry, err := f.db.Metadata(f.slashRoot, false, false, "", "", metadataLimit)
+	if err == nil {
+		if entry.IsDir {
+			return nil
+		}
+		return fmt.Errorf("%q already exists as file", f.root)
+	}
+	_, err = f.db.CreateFolder(f.slashRoot)
+	return err
+}
+
+// Rmdir deletes the container
+//
+// Returns an error if it isn't empty
+func (f *FsDropbox) Rmdir() error {
+	entry, err := f.db.Metadata(f.slashRoot, true, false, "", "", 16)
+	if err != nil {
+		return err
+	}
+	if len(entry.Contents) != 0 {
+		return errors.New("Directory not empty")
+	}
+	return f.Purge()
+}
+
+// Return the precision
+func (fs *FsDropbox) Precision() time.Duration {
+	return time.Nanosecond
+}
+
+// Purge deletes all the files and the container
+//
+// Optional interface: Only implement this if you have a way of
+// deleting all the files quicker than just running Remove() on the
+// result of List()
+func (f *FsDropbox) Purge() error {
+	// Delete metadata first
+	var wg sync.WaitGroup
+	to_be_deleted := f.List()
+	wg.Add(fs.Config.Transfers)
+	for i := 0; i < fs.Config.Transfers; i++ {
+		go func() {
+			defer wg.Done()
+			for dst := range to_be_deleted {
+				o := dst.(*FsObjectDropbox)
+				o.deleteMetadata()
+			}
+		}()
+	}
+	wg.Wait()
+
+	// Let dropbox delete the filesystem tree
+	_, err := f.db.Delete(f.slashRoot)
+	return err
+}
+
+// Tries the transaction in fn then calls commit, repeating until retry limit
+//
+// Holds datastore mutex while in progress
+func (f *FsDropbox) transaction(fn func() error) error {
+	f.datastoreMutex.Lock()
+	defer f.datastoreMutex.Unlock()
+	if f.datastoreErr != nil {
+		return f.datastoreErr
+	}
+	var err error
+	for i := 1; i <= maxCommitRetries; i++ {
+		err = fn()
+		if err != nil {
+			return err
+		}
+
+		err = f.datastore.Commit()
+		if err == nil {
+			break
+		}
+		fs.Debug(f, "Retrying transaction %d/%d", i, maxCommitRetries)
+	}
+	if err != nil {
+		return fmt.Errorf("Failed to commit metadata changes: %s", err)
+	}
+	return nil
+}
+
+// Deletes the medadata associated with this key
+func (f *FsDropbox) deleteMetadata(key string) error {
+	return f.transaction(func() error {
+		record, err := f.table.Get(key)
+		if err != nil {
+			return fmt.Errorf("Couldn't get record: %s", err)
+		}
+		if record == nil {
+			return nil
+		}
+		record.DeleteRecord()
+		return nil
+	})
+}
+
+// Reads the record attached to key
+//
+// Holds datastore mutex while in progress
+func (f *FsDropbox) readRecord(key string) (*dropbox.Record, error) {
+	f.datastoreMutex.Lock()
+	defer f.datastoreMutex.Unlock()
+	if f.datastoreErr != nil {
+		return nil, f.datastoreErr
+	}
+	return f.table.Get(key)
+}
+
+// ------------------------------------------------------------
+
+// Return the parent Fs
+func (o *FsObjectDropbox) Fs() fs.Fs {
+	return o.dropbox
+}
+
+// Return a string version
+func (o *FsObjectDropbox) String() string {
+	if o == nil {
+		return "<nil>"
+	}
+	return o.remote
+}
+
+// Return the remote path
+func (o *FsObjectDropbox) Remote() string {
+	return o.remote
+}
+
+// Md5sum returns the Md5sum of an object returning a lowercase hex string
+//
+// FIXME has to download the file!
+func (o *FsObjectDropbox) Md5sum() (string, error) {
+	if o.md5sum != "" {
+		return o.md5sum, nil
+	}
+	err := o.readMetaData()
+	if err != nil {
+		fs.Log(o, "Failed to read metadata: %s", err)
+		return "", fmt.Errorf("Failed to read metadata: %s", err)
+
+	}
+
+	// For pre-existing files which have no md5sum can read it and set it?
+
+	// in, err := o.Open()
+	// if err != nil {
+	// 	return "", err
+	// }
+	// defer in.Close()
+	// hash := md5.New()
+	// _, err = io.Copy(hash, in)
+	// if err != nil {
+	// 	return "", err
+	// }
+	// o.md5sum = fmt.Sprintf("%x", hash.Sum(nil))
+	return o.md5sum, nil
+}
+
+// Size returns the size of an object in bytes
+func (o *FsObjectDropbox) Size() int64 {
+	return o.bytes
+}
+
+// setMetadataFromEntry sets the fs data from a dropbox.Entry
+//
+// This isn't a complete set of metadata and has an inacurate date
+func (o *FsObjectDropbox) setMetadataFromEntry(info *dropbox.Entry) {
+	o.bytes = int64(info.Bytes)
+	o.modTime = time.Time(info.ClientMtime)
+}
+
+// Reads the entry from dropbox
+func (o *FsObjectDropbox) readEntry() (*dropbox.Entry, error) {
+	entry, err := o.dropbox.db.Metadata(o.remotePath(), false, false, "", "", metadataLimit)
+	if err != nil {
+		fs.Debug(o, "Error reading file: %s", err)
+		return nil, fmt.Errorf("Error reading file: %s", err)
+	}
+	return entry, nil
+}
+
+// Read entry if not set and set metadata from it
+func (o *FsObjectDropbox) readEntryAndSetMetadata() error {
+	// Last resort set time from client
+	if !o.modTime.IsZero() {
+		return nil
+	}
+	entry, err := o.readEntry()
+	if err != nil {
+		return err
+	}
+	o.setMetadataFromEntry(entry)
+	return nil
+}
+
+// Returns the remote path for the object
+func (o *FsObjectDropbox) remotePath() string {
+	return o.dropbox.slashRootSlash + o.remote
+}
+
+// Returns the key for the metadata database for a given path
+func metadataKey(path string) string {
+	// NB File system is case insensitive
+	path = strings.ToLower(path)
+	hash := md5.New()
+	_, _ = hash.Write([]byte(path))
+	return fmt.Sprintf("%x", hash.Sum(nil))
+}
+
+// Returns the key for the metadata database
+func (o *FsObjectDropbox) metadataKey() string {
+	return metadataKey(o.remotePath())
+}
+
+// readMetaData gets the info if it hasn't already been fetched
+func (o *FsObjectDropbox) readMetaData() (err error) {
+	if o.md5sum != "" {
+		return nil
+	}
+
+	// fs.Debug(o, "Reading metadata from datastore")
+	record, err := o.dropbox.readRecord(o.metadataKey())
+	if err != nil {
+		fs.Debug(o, "Couldn't read metadata: %s", err)
+		record = nil
+	}
+
+	if record != nil {
+		// Read md5sum
+		md5sumInterface, ok, err := record.Get(md5sumField)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			fs.Debug(o, "Couldn't find md5sum in record")
+		} else {
+			md5sum, ok := md5sumInterface.(string)
+			if !ok {
+				fs.Debug(o, "md5sum not a string")
+			} else {
+				o.md5sum = md5sum
+			}
+		}
+
+		// read mtime
+		mtimeInterface, ok, err := record.Get(mtimeField)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			fs.Debug(o, "Couldn't find mtime in record")
+		} else {
+			mtime, ok := mtimeInterface.(string)
+			if !ok {
+				fs.Debug(o, "mtime not a string")
+			} else {
+				modTime, err := time.Parse(timeFormatIn, mtime)
+				if err != nil {
+					return err
+				}
+				o.modTime = modTime
+			}
+		}
+	}
+
+	// Last resort
+	return o.readEntryAndSetMetadata()
+}
+
+// ModTime returns the modification time of the object
+//
+// It attempts to read the objects mtime and if that isn't present the
+// LastModified returned in the http headers
+func (o *FsObjectDropbox) ModTime() time.Time {
+	err := o.readMetaData()
+	if err != nil {
+		fs.Log(o, "Failed to read metadata: %s", err)
+		return time.Now()
+	}
+	return o.modTime
+}
+
+// Sets the modification time of the local fs object into the record
+// FIXME if we don't set md5sum what will that do?
+func (o *FsObjectDropbox) setModTimeAndMd5sum(modTime time.Time, md5sum string) error {
+	key := o.metadataKey()
+	// fs.Debug(o, "Writing metadata to datastore")
+	return o.dropbox.transaction(func() error {
+		record, err := o.dropbox.table.GetOrInsert(key)
+		if err != nil {
+			return fmt.Errorf("Couldn't read record: %s", err)
+		}
+
+		if md5sum != "" {
+			err = record.Set(md5sumField, md5sum)
+			if err != nil {
+				return fmt.Errorf("Couldn't set md5sum record: %s", err)
+			}
+			o.md5sum = md5sum
+		}
+
+		if !modTime.IsZero() {
+			mtime := modTime.Format(timeFormatOut)
+			err := record.Set(mtimeField, mtime)
+			if err != nil {
+				return fmt.Errorf("Couldn't set mtime record: %s", err)
+			}
+			o.modTime = modTime
+		}
+
+		return nil
+	})
+}
+
+// Deletes the medadata associated with this file
+//
+// It logs any errors
+func (o *FsObjectDropbox) deleteMetadata() {
+	fs.Debug(o, "Deleting metadata from datastore")
+	err := o.dropbox.deleteMetadata(o.metadataKey())
+	if err != nil {
+		fs.Log(o, "Error deleting metadata: %v", err)
+		fs.Stats.Error()
+	}
+}
+
+// Sets the modification time of the local fs object
+//
+// Commits the datastore
+func (o *FsObjectDropbox) SetModTime(modTime time.Time) {
+	err := o.setModTimeAndMd5sum(modTime, "")
+	if err != nil {
+		fs.Stats.Error()
+		fs.Log(o, err.Error())
+	}
+}
+
+// Is this object storable
+func (o *FsObjectDropbox) Storable() bool {
+	return true
+}
+
+// Open an object for read
+func (o *FsObjectDropbox) Open() (in io.ReadCloser, err error) {
+	in, _, err = o.dropbox.db.Download(o.remotePath(), "", 0)
+	return
+}
+
+// Update the already existing object
+//
+// Copy the reader into the object updating modTime and size
+//
+// The new object may have been created if an error is returned
+func (o *FsObjectDropbox) Update(in io.Reader, modTime time.Time, size int64) error {
+	// Calculate md5sum as we upload it
+	hash := md5.New()
+	rc := &readCloser{in: io.TeeReader(in, hash)}
+	entry, err := o.dropbox.db.UploadByChunk(rc, uploadChunkSize, o.remotePath(), true, "")
+	if err != nil {
+		return fmt.Errorf("Upload failed: %s", err)
+	}
+	o.setMetadataFromEntry(entry)
+
+	md5sum := fmt.Sprintf("%x", hash.Sum(nil))
+	return o.setModTimeAndMd5sum(modTime, md5sum)
+}
+
+// Remove an object
+func (o *FsObjectDropbox) Remove() error {
+	o.deleteMetadata()
+	_, err := o.dropbox.db.Delete(o.remotePath())
+	return err
+}
+
+// Check the interfaces are satisfied
+var _ fs.Fs = &FsDropbox{}
+var _ fs.Purger = &FsDropbox{}
+var _ fs.Object = &FsObjectDropbox{}
--- a/dropbox/dropbox_test.go
+++ b/dropbox/dropbox_test.go
@@ -0,0 +1,53 @@
+// Test Dropbox filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package dropbox_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/dropbox"
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*dropbox.FsObjectDropbox)(nil))
+	fstests.RemoteName = "TestDropbox:"
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/fs/config.go
+++ b/fs/config.go
@@ -56,11 +56,21 @@ type ConfigInfo struct {
 func configHome() string {
 	// Find users home directory
 	usr, err := user.Current()
-	if err != nil {
-		log.Printf("Couldn't find home directory: %v", err)
-		return ""
+	if err == nil {
+		return usr.HomeDir
 	}
-	return usr.HomeDir
+	// Fall back to reading $HOME - work around user.Current() not
+	// working for cross compiled binaries on OSX.
+	// https://github.com/golang/go/issues/6376
+	home := os.Getenv("HOME")
+	if home != "" {
+		return home
+	}
+	log.Printf("Couldn't find home directory or read HOME environment variable.")
+	log.Printf("Defaulting to storing config in current directory.")
+	log.Printf("Use -config flag to workaround.")
+	log.Printf("Error was: %v", err)
+	return ""
 }

 // Loads the config file
@@ -70,10 +80,10 @@ func LoadConfig() {
 	// FIXME read these from the config file too
 	Config.Verbose = *verbose
 	Config.Quiet = *quiet
-	Config.Quiet = *dryRun
 	Config.ModifyWindow = *modifyWindow
 	Config.Checkers = *checkers
 	Config.Transfers = *transfers
+	Config.DryRun = *dryRun

 	ConfigPath = *configFile

@@ -147,7 +157,7 @@ func Command(commands []string) byte {
 		if len(result) != 1 {
 			continue
 		}
-		i := strings.IndexByte(optString, result[0])
+		i := strings.Index(optString, string(result[0]))
 		if i >= 0 {
 			return result[0]
 		}
@@ -320,9 +330,19 @@ func EditConfig() {
 			name := ChooseRemote()
 			EditRemote(name)
 		case 'n':
-			fmt.Printf("name> ")
-			name := ReadLine()
-			NewRemote(name)
+			for {
+				fmt.Printf("name> ")
+				name := ReadLine()
+				switch {
+				case name == "":
+					fmt.Printf("Can't use empty name\n")
+				case isDriveLetter(name):
+					fmt.Printf("Can't use %q as it can be confused a drive letter\n", name)
+				default:
+					NewRemote(name)
+					break
+				}
+			}
 		case 'd':
 			name := ChooseRemote()
 			DeleteRemote(name)
--- a/fs/driveletter.go
+++ b/fs/driveletter.go
@@ -0,0 +1,12 @@
+// +build !windows
+
+package fs
+
+// isDriveLetter returns a bool indicating whether name is a valid
+// Windows drive letter
+//
+// On non windows platforms we don't have drive letters so we always
+// return false
+func isDriveLetter(name string) bool {
+	return false
+}
--- a/fs/driveletter_windows.go
+++ b/fs/driveletter_windows.go
@@ -0,0 +1,13 @@
+// +build windows
+
+package fs
+
+// isDriveLetter returns a bool indicating whether name is a valid
+// Windows drive letter
+func isDriveLetter(name string) bool {
+	if len(name) != 1 {
+		return false
+	}
+	c := name[0]
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+}
--- a/fs/fs.go
+++ b/fs/fs.go
@@ -10,10 +10,18 @@ import (
 	"time"
 )

+// Constants
+const (
+	// User agent for Fs which can set it
+	UserAgent = "rclone/" + Version
+)
+
 // Globals
 var (
 	// Filesystem registry
 	fsRegistry []*FsInfo
+	// Error returned by NewFs if not found in config file
+	NotFoundInConfigFile = fmt.Errorf("Didn't find section in config file")
 )

 // Filesystem info
@@ -73,9 +81,13 @@ type Fs interface {
 	Put(in io.Reader, remote string, modTime time.Time, size int64) (Object, error)

 	// Make the directory (container, bucket)
+	//
+	// Shouldn't return an error if it already exists
 	Mkdir() error

 	// Remove the directory (container, bucket) if empty
+	//
+	// Return an error if it doesn't exist or isn't empty
 	Rmdir() error

 	// Precision of the ModTimes in this Fs
@@ -125,9 +137,40 @@ type Purger interface {
 	//
 	// Implement this if you have a way of deleting all the files
 	// quicker than just running Remove() on the result of List()
+	//
+	// Return an error if it doesn't exist
 	Purge() error
 }

+// An optional interface for error as to whether the operation should be retried
+//
+// This should be returned from Update or Put methods as required
+type Retry interface {
+	error
+	Retry() bool
+}
+
+// A type of error
+type retryError string
+
+// Error interface
+func (r retryError) Error() string {
+	return string(r)
+}
+
+// Retry interface
+func (r retryError) Retry() bool {
+	return true
+}
+
+// Check interface
+var _ Retry = retryError("")
+
+// RetryErrorf makes an error which indicates it would like to be retried
+func RetryErrorf(format string, a ...interface{}) error {
+	return retryError(fmt.Sprintf(format, a...))
+}
+
 // A channel of Objects
 type ObjectsChan chan Object

@@ -153,9 +196,6 @@ type Dir struct {
 // A channel of Dir objects
 type DirChan chan *Dir

-// Pattern to match a url
-var matcher = regexp.MustCompile(`^([\w_-]+):(.*)$`)
-
 // Finds a FsInfo object for the name passed in
 //
 // Services are looked up in the config file
@@ -168,20 +208,27 @@ func Find(name string) (*FsInfo, error) {
 	return nil, fmt.Errorf("Didn't find filing system for %q", name)
 }

+// Pattern to match an rclone url
+var matcher = regexp.MustCompile(`^([\w_-]+):(.*)$`)
+
 // NewFs makes a new Fs object from the path
 //
-// The path is of the form service://path
+// The path is of the form remote:path
 //
-// Services are looked up in the config file
+// Remotes are looked up in the config file.  If the remote isn't
+// found then NotFoundInConfigFile will be returned.
+//
+// On Windows avoid single character remote names as they can be mixed
+// up with drive letters.
 func NewFs(path string) (Fs, error) {
 	parts := matcher.FindStringSubmatch(path)
 	fsName, configName, fsPath := "local", "local", path
-	if parts != nil {
+	if parts != nil && !isDriveLetter(parts[1]) {
 		configName, fsPath = parts[1], parts[2]
 		var err error
 		fsName, err = ConfigFile.GetValue(configName, "type")
 		if err != nil {
-			return nil, fmt.Errorf("Didn't find section in config file for %q", configName)
+			return nil, NotFoundInConfigFile
 		}
 	}
 	fs, err := Find(fsName)
--- a/fs/operations.go
+++ b/fs/operations.go
@@ -4,7 +4,7 @@ package fs

 import (
 	"fmt"
-	"log"
+	"io"
 	"sync"
 )

@@ -97,12 +97,27 @@ func Equal(src, dst Object) bool {
 	return true
 }

+// Used to remove a failed copy
+func removeFailedCopy(dst Object) {
+	if dst != nil {
+		Debug(dst, "Removing failed copy")
+		removeErr := dst.Remove()
+		if removeErr != nil {
+			Debug(dst, "Failed to remove failed copy: %s", removeErr)
+		}
+	}
+}
+
 // Copy src object to dst or f if nil
 //
 // If dst is nil then the object must not exist already.  If you do
 // call Copy() with dst nil on a pre-existing file then some filing
 // systems (eg Drive) may duplicate the file.
 func Copy(f Fs, dst, src Object) {
+	const maxTries = 10
+	tries := 0
+	doUpdate := dst != nil
+tryAgain:
 	in0, err := src.Open()
 	if err != nil {
 		Stats.Error()
@@ -112,7 +127,7 @@ func Copy(f Fs, dst, src Object) {
 	in := NewAccount(in0) // account the transfer

 	var actionTaken string
-	if dst != nil {
+	if doUpdate {
 		actionTaken = "Copied (updated existing)"
 		err = dst.Update(in, src.ModTime(), src.Size())
 	} else {
@@ -120,22 +135,51 @@ func Copy(f Fs, dst, src Object) {
 		dst, err = f.Put(in, src.Remote(), src.ModTime(), src.Size())
 	}
 	inErr := in.Close()
+	// Retry if err returned a retry error
+	if r, ok := err.(Retry); ok && r.Retry() && tries < maxTries {
+		tries++
+		Log(src, "Received error: %v - retrying %d/%d", err, tries, maxTries)
+		removeFailedCopy(dst)
+		goto tryAgain
+	}
 	if err == nil {
 		err = inErr
 	}
 	if err != nil {
 		Stats.Error()
 		Log(src, "Failed to copy: %s", err)
-		if dst != nil {
-			Debug(dst, "Removing failed copy")
-			removeErr := dst.Remove()
-			if removeErr != nil {
-				Stats.Error()
-				Log(dst, "Failed to remove failed copy: %s", removeErr)
-			}
-		}
+		removeFailedCopy(dst)
 		return
 	}
+
+	// Verify sizes are the same after transfer
+	if src.Size() != dst.Size() {
+		Stats.Error()
+		err = fmt.Errorf("Corrupted on transfer: sizes differ %d vs %d", src.Size(), dst.Size())
+		Log(dst, "%s", err)
+		removeFailedCopy(dst)
+		return
+	}
+
+	// Verify md5sums are the same after transfer - ignoring blank md5sums
+	srcMd5sum, md5sumErr := src.Md5sum()
+	if md5sumErr != nil {
+		Stats.Error()
+		Log(src, "Failed to read md5sum: %s", md5sumErr)
+	} else if srcMd5sum != "" {
+		dstMd5sum, md5sumErr := dst.Md5sum()
+		if md5sumErr != nil {
+			Stats.Error()
+			Log(dst, "Failed to read md5sum: %s", md5sumErr)
+		} else if dstMd5sum != "" && srcMd5sum != dstMd5sum {
+			Stats.Error()
+			err = fmt.Errorf("Corrupted on transfer: md5sums differ %q vs %q", srcMd5sum, dstMd5sum)
+			Log(dst, "%s", err)
+			removeFailedCopy(dst)
+			return
+		}
+	}
+
 	Debug(src, actionTaken)
 }

@@ -159,7 +203,7 @@ func checkOne(pair ObjectPair, out ObjectPairChan) {
 	out <- pair
 }

-// Read FsObjects~s on in send to out if they need uploading
+// Read Objects~s on in send to out if they need uploading
 //
 // FIXME potentially doing lots of MD5SUMS at once
 func PairChecker(in ObjectPairChan, out ObjectPairChan, wg *sync.WaitGroup) {
@@ -172,13 +216,17 @@ func PairChecker(in ObjectPairChan, out ObjectPairChan, wg *sync.WaitGroup) {
 	}
 }

-// Read FsObjects on in and copy them
+// Read Objects on in and copy them
 func Copier(in ObjectPairChan, fdst Fs, wg *sync.WaitGroup) {
 	defer wg.Done()
 	for pair := range in {
 		src := pair.src
 		Stats.Transferring(src)
-		Copy(fdst, pair.dst, src)
+		if Config.DryRun {
+			Debug(src, "Not copying as --dry-run")
+		} else {
+			Copy(fdst, pair.dst, src)
+		}
 		Stats.DoneTransferring(src)
 	}
 }
@@ -187,12 +235,10 @@ func Copier(in ObjectPairChan, fdst Fs, wg *sync.WaitGroup) {
 func DeleteFiles(to_be_deleted ObjectsChan) {
 	var wg sync.WaitGroup
 	wg.Add(Config.Transfers)
-	var fs Fs
 	for i := 0; i < Config.Transfers; i++ {
 		go func() {
 			defer wg.Done()
 			for dst := range to_be_deleted {
-				fs = dst.Fs()
 				if Config.DryRun {
 					Debug(dst, "Not deleting as --dry-run")
 				} else {
@@ -209,8 +255,7 @@ func DeleteFiles(to_be_deleted ObjectsChan) {
 			}
 		}()
 	}
-
-	Log(fs, "Waiting for deletions to finish")
+	Log(nil, "Waiting for deletions to finish")
 	wg.Wait()
 }

@@ -372,10 +417,10 @@ func Check(fdst, fsrc Fs) error {
 	return nil
 }

-// List the Fs to stdout
+// List the Fs to the supplied function
 //
 // Lists in parallel which may get them out of order
-func List(f Fs) error {
+func ListFn(f Fs, fn func(Object)) error {
 	in := f.List()
 	var wg sync.WaitGroup
 	wg.Add(Config.Checkers)
@@ -383,10 +428,7 @@ func List(f Fs) error {
 		go func() {
 			defer wg.Done()
 			for o := range in {
-				Stats.Checking(o)
-				modTime := o.ModTime()
-				Stats.DoneChecking(o)
-				fmt.Printf("%9d %19s %s\n", o.Size(), modTime.Format("2006-01-02 15:04:05.00000000"), o.Remote())
+				fn(o)
 			}
 		}()
 	}
@@ -394,10 +436,53 @@ func List(f Fs) error {
 	return nil
 }

+// List the Fs to stdout
+//
+// Shows size and path
+//
+// Lists in parallel which may get them out of order
+func List(f Fs, w io.Writer) error {
+	return ListFn(f, func(o Object) {
+		fmt.Fprintf(w, "%9d %s\n", o.Size(), o.Remote())
+	})
+}
+
+// List the Fs to stdout
+//
+// Shows size, mod time and path
+//
+// Lists in parallel which may get them out of order
+func ListLong(f Fs, w io.Writer) error {
+	return ListFn(f, func(o Object) {
+		Stats.Checking(o)
+		modTime := o.ModTime()
+		Stats.DoneChecking(o)
+		fmt.Fprintf(w, "%9d %s %s\n", o.Size(), modTime.Format("2006-01-02 15:04:05.000000000"), o.Remote())
+	})
+}
+
+// List the Fs to stdout
+//
+// Produces the same output as the md5sum command
+//
+// Lists in parallel which may get them out of order
+func Md5sum(f Fs, w io.Writer) error {
+	return ListFn(f, func(o Object) {
+		Stats.Checking(o)
+		md5sum, err := o.Md5sum()
+		Stats.DoneChecking(o)
+		if err != nil {
+			Debug(o, "Failed to read MD5: %v", err)
+			md5sum = "UNKNOWN"
+		}
+		fmt.Fprintf(w, "%32s  %s\n", md5sum, o.Remote())
+	})
+}
+
 // List the directories/buckets/containers in the Fs to stdout
-func ListDir(f Fs) error {
+func ListDir(f Fs, w io.Writer) error {
 	for dir := range f.ListDir() {
-		fmt.Printf("%12d %13s %9d %s\n", dir.Bytes, dir.When.Format("2006-01-02 15:04:05"), dir.Count, dir.Name)
+		fmt.Fprintf(w, "%12d %13s %9d %s\n", dir.Bytes, dir.When.Format("2006-01-02 15:04:05"), dir.Count, dir.Name)
 	}
 	return nil
 }
@@ -430,16 +515,21 @@ func Rmdir(f Fs) error {
 //
 // FIXME doesn't delete local directories
 func Purge(f Fs) error {
+	var err error
 	if purger, ok := f.(Purger); ok {
-		err := purger.Purge()
-		if err != nil {
-			Stats.Error()
-			return err
+		if Config.DryRun {
+			Debug(f, "Not purging as --dry-run set")
+		} else {
+			err = purger.Purge()
 		}
 	} else {
+		// DeleteFiles and Rmdir observe --dry-run
 		DeleteFiles(f.List())
-		log.Printf("Deleting path")
-		Rmdir(f)
+		err = Rmdir(f)
+	}
+	if err != nil {
+		Stats.Error()
+		return err
 	}
 	return nil
 }
--- a/fs/operations_test.go
+++ b/fs/operations_test.go
@@ -0,0 +1,335 @@
+// Test rclone by doing real transactions to a storage provider to and
+// from the local disk
+
+package fs_test
+
+import (
+	"bytes"
+	"flag"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest"
+
+	// Active file systems
+	_ "github.com/ncw/rclone/drive"
+	_ "github.com/ncw/rclone/dropbox"
+	_ "github.com/ncw/rclone/googlecloudstorage"
+	_ "github.com/ncw/rclone/local"
+	_ "github.com/ncw/rclone/s3"
+	_ "github.com/ncw/rclone/swift"
+)
+
+// Globals
+var (
+	localName, remoteName string
+	flocal, fremote       fs.Fs
+	RemoteName            = flag.String("remote", "", "Remote to test with, defaults to local filesystem")
+	SubDir                = flag.Bool("subdir", false, "Set to test with a sub directory")
+	finalise              func()
+)
+
+// Write a file
+func WriteFile(filePath, content string, t time.Time) {
+	// FIXME make directories?
+	filePath = path.Join(localName, filePath)
+	dirPath := path.Dir(filePath)
+	err := os.MkdirAll(dirPath, 0770)
+	if err != nil {
+		log.Fatalf("Failed to make directories %q: %v", dirPath, err)
+	}
+	err = ioutil.WriteFile(filePath, []byte(content), 0600)
+	if err != nil {
+		log.Fatalf("Failed to write file %q: %v", filePath, err)
+	}
+	err = os.Chtimes(filePath, t, t)
+	if err != nil {
+		log.Fatalf("Failed to chtimes file %q: %v", filePath, err)
+	}
+}
+
+var t1 = fstest.Time("2001-02-03T04:05:06.499999999Z")
+var t2 = fstest.Time("2011-12-25T12:59:59.123456789Z")
+var t3 = fstest.Time("2011-12-30T12:59:59.000000000Z")
+
+func TestInit(t *testing.T) {
+	fs.LoadConfig()
+	fs.Config.Verbose = false
+	fs.Config.Quiet = true
+	var err error
+	fremote, finalise, err = fstest.RandomRemote(*RemoteName, *SubDir)
+	if err != nil {
+		t.Fatalf("Failed to open remote %q: %v", *RemoteName, err)
+	}
+	t.Logf("Testing with remote %v", fremote)
+
+	localName, err = ioutil.TempDir("", "rclone")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	localName = filepath.ToSlash(localName)
+	t.Logf("Testing with local %q", localName)
+	flocal, err = fs.NewFs(localName)
+	if err != nil {
+		t.Fatalf("Failed to make %q: %v", remoteName, err)
+	}
+
+}
+func TestCalculateModifyWindow(t *testing.T) {
+	fs.CalculateModifyWindow(fremote, flocal)
+	t.Logf("ModifyWindow is %q", fs.Config.ModifyWindow)
+}
+
+func TestMkdir(t *testing.T) {
+	fstest.TestMkdir(t, fremote)
+}
+
+// Check dry run is working
+func TestCopyWithDryRun(t *testing.T) {
+	WriteFile("sub dir/hello world", "hello world", t1)
+
+	fs.Config.DryRun = true
+	err := fs.Sync(fremote, flocal, false)
+	fs.Config.DryRun = false
+	if err != nil {
+		t.Fatalf("Copy failed: %v", err)
+	}
+
+	items := []fstest.Item{
+		{Path: "sub dir/hello world", Size: 11, ModTime: t1, Md5sum: "5eb63bbbe01eeed093cb22bb8f5acdc3"},
+	}
+
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, []fstest.Item{}, fs.Config.ModifyWindow)
+}
+
+// Now without dry run
+func TestCopy(t *testing.T) {
+	err := fs.Sync(fremote, flocal, false)
+	if err != nil {
+		t.Fatalf("Copy failed: %v", err)
+	}
+
+	items := []fstest.Item{
+		{Path: "sub dir/hello world", Size: 11, ModTime: t1, Md5sum: "5eb63bbbe01eeed093cb22bb8f5acdc3"},
+	}
+
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+func TestLsd(t *testing.T) {
+	var buf bytes.Buffer
+	err := fs.ListDir(fremote, &buf)
+	if err != nil {
+		t.Fatalf("ListDir failed: %v", err)
+	}
+	res := buf.String()
+	if !strings.Contains(res, "sub dir\n") {
+		t.Fatalf("Result wrong %q", res)
+	}
+}
+
+// Now delete the local file and download it
+func TestCopyAfterDelete(t *testing.T) {
+	err := os.Remove(localName + "/sub dir/hello world")
+	if err != nil {
+		t.Fatalf("Remove failed: %v", err)
+	}
+
+	items := []fstest.Item{
+		{Path: "sub dir/hello world", Size: 11, ModTime: t1, Md5sum: "5eb63bbbe01eeed093cb22bb8f5acdc3"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, []fstest.Item{}, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+func TestCopyRedownload(t *testing.T) {
+	err := fs.Sync(flocal, fremote, false)
+	if err != nil {
+		t.Fatalf("Copy failed: %v", err)
+	}
+
+	items := []fstest.Item{
+		{Path: "sub dir/hello world", Size: 11, ModTime: t1, Md5sum: "5eb63bbbe01eeed093cb22bb8f5acdc3"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+
+	// Clean the directory
+	cleanTempDir(t)
+}
+
+func TestSyncAfterChangingModtimeOnly(t *testing.T) {
+	WriteFile("empty space", "", t1)
+
+	err := os.Chtimes(localName+"/empty space", t2, t2)
+	if err != nil {
+		t.Fatalf("Chtimes failed: %v", err)
+	}
+	err = fs.Sync(fremote, flocal, true)
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+func TestSyncAfterAddingAFile(t *testing.T) {
+	WriteFile("potato", "------------------------------------------------------------", t3)
+	err := fs.Sync(fremote, flocal, true)
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato", Size: 60, ModTime: t3, Md5sum: "d6548b156ea68a4e003e786df99eee76"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+func TestSyncAfterChangingFilesSizeOnly(t *testing.T) {
+	WriteFile("potato", "smaller but same date", t3)
+	err := fs.Sync(fremote, flocal, true)
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato", Size: 21, ModTime: t3, Md5sum: "100defcf18c42a1e0dc42a789b107cd2"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+// Sync after changing a file's contents, modtime but not length
+func TestSyncAfterChangingContentsOnly(t *testing.T) {
+	WriteFile("potato", "SMALLER BUT SAME DATE", t2)
+	err := fs.Sync(fremote, flocal, true)
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato", Size: 21, ModTime: t2, Md5sum: "e4cb6955d9106df6263c45fcfc10f163"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+// Sync after removing a file and adding a file --dry-run
+func TestSyncAfterRemovingAFileAndAddingAFileDryRun(t *testing.T) {
+	WriteFile("potato2", "------------------------------------------------------------", t1)
+	err := os.Remove(localName + "/potato")
+	if err != nil {
+		t.Fatalf("Remove failed: %v", err)
+	}
+	fs.Config.DryRun = true
+	err = fs.Sync(fremote, flocal, true)
+	fs.Config.DryRun = false
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+
+	before := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato", Size: 21, ModTime: t2, Md5sum: "e4cb6955d9106df6263c45fcfc10f163"},
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, before, fs.Config.ModifyWindow)
+}
+
+// Sync after removing a file and adding a file
+func TestSyncAfterRemovingAFileAndAddingAFile(t *testing.T) {
+	err := fs.Sync(fremote, flocal, true)
+	if err != nil {
+		t.Fatalf("Sync failed: %v", err)
+	}
+	items := []fstest.Item{
+		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
+		{Path: "potato2", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"},
+	}
+	fstest.CheckListingWithPrecision(t, flocal, items, fs.Config.ModifyWindow)
+	fstest.CheckListingWithPrecision(t, fremote, items, fs.Config.ModifyWindow)
+}
+
+func TestLs(t *testing.T) {
+	var buf bytes.Buffer
+	err := fs.List(fremote, &buf)
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	res := buf.String()
+	if !strings.Contains(res, "        0 empty space\n") {
+		t.Errorf("empty space missing: %q", res)
+	}
+	if !strings.Contains(res, "       60 potato2\n") {
+		t.Errorf("potato2 missing: %q", res)
+	}
+}
+
+func TestLsLong(t *testing.T) {
+	var buf bytes.Buffer
+	err := fs.ListLong(fremote, &buf)
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	res := buf.String()
+	m1 := regexp.MustCompile(`(?m)^        0 2011-12-25 12:59:59\.\d{9} empty space$`)
+	if !m1.MatchString(res) {
+		t.Errorf("empty space missing: %q", res)
+	}
+	m2 := regexp.MustCompile(`(?m)^       60 2001-02-03 04:05:06\.\d{9} potato2$`)
+	if !m2.MatchString(res) {
+		t.Errorf("potato2 missing: %q", res)
+	}
+}
+
+func TestMd5sum(t *testing.T) {
+	var buf bytes.Buffer
+	err := fs.Md5sum(fremote, &buf)
+	if err != nil {
+		t.Fatalf("List failed: %v", err)
+	}
+	res := buf.String()
+	if !strings.Contains(res, "d41d8cd98f00b204e9800998ecf8427e  empty space\n") {
+		t.Errorf("empty space missing: %q", res)
+	}
+	if !strings.Contains(res, "6548b156ea68a4e003e786df99eee76  potato2\n") {
+		t.Errorf("potato2 missing: %q", res)
+	}
+}
+
+func TestCheck(t *testing.T) {
+}
+
+// Clean the temporary directory
+func cleanTempDir(t *testing.T) {
+	t.Logf("Cleaning temporary directory: %q", localName)
+	err := os.RemoveAll(localName)
+	if err != nil {
+		t.Logf("Failed to remove %q: %v", localName, err)
+	}
+}
+
+func TestFinalise(t *testing.T) {
+	finalise()
+
+	cleanTempDir(t)
+}
--- a/fs/seekwrapper.go
+++ b/fs/seekwrapper.go
@@ -0,0 +1,39 @@
+package fs
+
+import (
+	"io"
+	"os"
+)
+
+// SeekWrapper wraps an io.Reader with a basic Seek method which
+// returns the Size attribute.
+//
+// This is used for google.golang.org/api/googleapi/googleapi.go
+// to detect the length (see getReaderSize function)
+//
+// Without this the getReaderSize function reads the entire file into
+// memory to find its length.
+type SeekWrapper struct {
+	In   io.Reader
+	Size int64
+}
+
+// Read bytes from the object - see io.Reader
+func (file *SeekWrapper) Read(p []byte) (n int, err error) {
+	return file.In.Read(p)
+}
+
+// Seek - minimal implementation for Google API length detection
+func (file *SeekWrapper) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	case os.SEEK_CUR:
+		return 0, nil
+	case os.SEEK_END:
+		return file.Size, nil
+	}
+	return 0, nil
+}
+
+// Interfaces that SeekWrapper implements
+var _ io.Reader = (*SeekWrapper)(nil)
+var _ io.Seeker = (*SeekWrapper)(nil)
--- a/fs/test_all.sh
+++ b/fs/test_all.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+go install
+
+REMOTES="
+TestSwift:
+TestS3:
+TestDrive:
+TestGoogleCloudStorage:
+TestDropbox:
+"
+
+function test_remote {
+    args=$@
+    echo "@go test $args"
+    go test $args || {
+        echo "*** test $args FAILED ***"
+        exit 1
+    }
+}
+
+test_remote
+test_remote --subdir
+for remote in $REMOTES; do
+    test_remote --remote $remote
+    test_remote --remote $remote --subdir
+done
+
+echo "All OK"
--- a/fs/version.go
+++ b/fs/version.go
@@ -0,0 +1,3 @@
+package fs
+
+const Version = "v1.09"
--- a/fstest/fstest.go
+++ b/fstest/fstest.go
@@ -0,0 +1,232 @@
+// Utilities for testing the fs
+
+package fstest
+
+// FIXME put name of test FS in Fs structure
+
+import (
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ncw/rclone/fs"
+)
+
+// Seed the random number generator
+func init() {
+	rand.Seed(time.Now().UnixNano())
+
+}
+
+// Represents an item for checking
+type Item struct {
+	Path    string
+	Md5sum  string
+	ModTime time.Time
+	Size    int64
+}
+
+// check the mod time to the given precision
+func (i *Item) CheckModTime(t *testing.T, obj fs.Object, modTime time.Time, precision time.Duration) {
+	dt := modTime.Sub(i.ModTime)
+	if dt >= precision || dt <= -precision {
+		t.Errorf("%s: Modification time difference too big |%s| > %s (%s vs %s) (precision %s)", obj.Remote(), dt, precision, modTime, i.ModTime, precision)
+	}
+}
+
+func (i *Item) Check(t *testing.T, obj fs.Object, precision time.Duration) {
+	if obj == nil {
+		t.Fatalf("Object is nil")
+	}
+	// Check attributes
+	Md5sum, err := obj.Md5sum()
+	if err != nil {
+		t.Fatalf("Failed to read md5sum for %q: %v", obj.Remote(), err)
+	}
+	if i.Md5sum != Md5sum {
+		t.Errorf("%s: Md5sum incorrect - expecting %q got %q", obj.Remote(), i.Md5sum, Md5sum)
+	}
+	if i.Size != obj.Size() {
+		t.Errorf("%s: Size incorrect - expecting %d got %d", obj.Remote(), i.Size, obj.Size())
+	}
+	i.CheckModTime(t, obj, obj.ModTime(), precision)
+}
+
+// Represents all items for checking
+type Items struct {
+	byName map[string]*Item
+	items  []Item
+}
+
+// Make an Items
+func NewItems(items []Item) *Items {
+	is := &Items{
+		byName: make(map[string]*Item),
+		items:  items,
+	}
+	// Fill up byName
+	for i := range items {
+		is.byName[items[i].Path] = &items[i]
+	}
+	return is
+}
+
+// Check off an item
+func (is *Items) Find(t *testing.T, obj fs.Object, precision time.Duration) {
+	i, ok := is.byName[obj.Remote()]
+	if !ok {
+		t.Errorf("Unexpected file %q", obj.Remote())
+		return
+	}
+	delete(is.byName, obj.Remote())
+	i.Check(t, obj, precision)
+}
+
+// Check all done
+func (is *Items) Done(t *testing.T) {
+	if len(is.byName) != 0 {
+		for name := range is.byName {
+			log.Printf("Not found %q", name)
+		}
+		t.Errorf("%d objects not found", len(is.byName))
+	}
+}
+
+// Checks the fs to see if it has the expected contents
+func CheckListingWithPrecision(t *testing.T, f fs.Fs, items []Item, precision time.Duration) {
+	is := NewItems(items)
+	for obj := range f.List() {
+		if obj == nil {
+			t.Errorf("Unexpected nil in List()")
+			continue
+		}
+		is.Find(t, obj, precision)
+	}
+	is.Done(t)
+}
+
+// Checks the fs to see if it has the expected contents
+func CheckListing(t *testing.T, f fs.Fs, items []Item) {
+	precision := f.Precision()
+	CheckListingWithPrecision(t, f, items, precision)
+}
+
+// Parse a time string or explode
+func Time(timeString string) time.Time {
+	t, err := time.Parse(time.RFC3339Nano, timeString)
+	if err != nil {
+		log.Fatalf("Failed to parse time %q: %v", timeString, err)
+	}
+	return t
+}
+
+// Create a random string
+func RandomString(n int) string {
+	source := "abcdefghijklmnopqrstuvwxyz0123456789"
+	out := make([]byte, n)
+	for i := range out {
+		out[i] = source[rand.Intn(len(source))]
+	}
+	return string(out)
+}
+
+// Creates a temporary directory name for local remotes
+func LocalRemote() (path string, err error) {
+	path, err = ioutil.TempDir("", "rclone")
+	if err == nil {
+		// Now remove the directory
+		err = os.Remove(path)
+	}
+	path = filepath.ToSlash(path)
+	return
+}
+
+// Make a random bucket or subdirectory name
+//
+// Returns a random remote name plus the leaf name
+func RandomRemoteName(remoteName string) (string, string, error) {
+	var err error
+	var leafName string
+
+	// Make a directory if remote name is null
+	if remoteName == "" {
+		remoteName, err = LocalRemote()
+		if err != nil {
+			return "", "", err
+		}
+	} else {
+		if !strings.HasSuffix(remoteName, ":") {
+			remoteName += "/"
+		}
+		leafName = RandomString(32)
+		remoteName += leafName
+	}
+	return remoteName, leafName, nil
+}
+
+// Make a random bucket or subdirectory on the remote
+//
+// Call the finalise function returned to Purge the fs at the end (and
+// the parent if necessary)
+func RandomRemote(remoteName string, subdir bool) (fs.Fs, func(), error) {
+	var err error
+	var parentRemote fs.Fs
+
+	remoteName, _, err = RandomRemoteName(remoteName)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if subdir {
+		parentRemote, err = fs.NewFs(remoteName)
+		if err != nil {
+			return nil, nil, err
+		}
+		remoteName += "/" + RandomString(8)
+	}
+
+	remote, err := fs.NewFs(remoteName)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	finalise := func() {
+		_ = fs.Purge(remote) // ignore error
+		if parentRemote != nil {
+			err = fs.Purge(parentRemote) // ignore error
+			if err != nil {
+				log.Printf("Failed to purge %v: %v", parentRemote, err)
+			}
+		}
+	}
+
+	return remote, finalise, nil
+}
+
+func TestMkdir(t *testing.T, remote fs.Fs) {
+	err := fs.Mkdir(remote)
+	if err != nil {
+		t.Fatalf("Mkdir failed: %v", err)
+	}
+	CheckListing(t, remote, []Item{})
+}
+
+func TestPurge(t *testing.T, remote fs.Fs) {
+	err := fs.Purge(remote)
+	if err != nil {
+		t.Fatalf("Purge failed: %v", err)
+	}
+	CheckListing(t, remote, []Item{})
+}
+
+func TestRmdir(t *testing.T, remote fs.Fs) {
+	err := fs.Rmdir(remote)
+	if err != nil {
+		t.Fatalf("Rmdir failed: %v", err)
+	}
+}
--- a/fstest/fstests/fstests.go
+++ b/fstest/fstests/fstests.go
@@ -0,0 +1,438 @@
+// Generic tests for testing the Fs and Object interfaces
+package fstests
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"io"
+	"log"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest"
+)
+
+var (
+	remote        fs.Fs
+	RemoteName    = ""
+	subRemoteName = ""
+	subRemoteLeaf = ""
+	NilObject     fs.Object
+	file1         = fstest.Item{
+		ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"),
+		Path:    "file name.txt",
+	}
+	file2 = fstest.Item{
+		ModTime: fstest.Time("2001-02-03T04:05:10.123123123Z"),
+		Path:    `hello? sausage/êé/Hello, 世界/ " ' @ < > & ?/z.txt`,
+	}
+)
+
+func TestInit(t *testing.T) {
+	var err error
+	fs.LoadConfig()
+	fs.Config.Verbose = false
+	fs.Config.Quiet = true
+	if RemoteName == "" {
+		RemoteName, err = fstest.LocalRemote()
+		if err != nil {
+			log.Fatalf("Failed to create tmp dir: %v", err)
+		}
+	}
+	subRemoteName, subRemoteLeaf, err = fstest.RandomRemoteName(RemoteName)
+	if err != nil {
+		t.Fatalf("Couldn't make remote name: %v", err)
+	}
+
+	remote, err = fs.NewFs(subRemoteName)
+	if err == fs.NotFoundInConfigFile {
+		log.Printf("Didn't find %q in config file - skipping tests", RemoteName)
+		return
+	}
+	if err != nil {
+		t.Fatalf("Couldn't start FS: %v", err)
+	}
+	fstest.TestMkdir(t, remote)
+}
+
+func skipIfNotOk(t *testing.T) {
+	if remote == nil {
+		t.Skip("FS not configured")
+	}
+}
+
+// String returns a description of the FS
+
+func TestFsString(t *testing.T) {
+	skipIfNotOk(t)
+	str := remote.String()
+	if str == "" {
+		t.Fatal("Bad fs.String()")
+	}
+}
+
+type TestFile struct {
+	ModTime time.Time
+	Path    string
+	Size    int64
+	Md5sum  string
+}
+
+func TestFsRmdirEmpty(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.TestRmdir(t, remote)
+}
+
+func TestFsRmdirNotFound(t *testing.T) {
+	skipIfNotOk(t)
+	err := remote.Rmdir()
+	if err == nil {
+		t.Fatalf("Expecting error on Rmdir non existent")
+	}
+}
+
+func TestFsMkdir(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.TestMkdir(t, remote)
+	fstest.TestMkdir(t, remote)
+}
+
+func TestFsListEmpty(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.CheckListing(t, remote, []fstest.Item{})
+}
+
+func TestFsListDirEmpty(t *testing.T) {
+	skipIfNotOk(t)
+	for obj := range remote.ListDir() {
+		t.Error("Found unexpected item %q", obj.Name)
+	}
+}
+
+func TestFsNewFsObjectNotFound(t *testing.T) {
+	skipIfNotOk(t)
+	if remote.NewFsObject("potato") != nil {
+		t.Fatal("Didn't expect to find object")
+	}
+}
+
+func findObject(t *testing.T, Name string) fs.Object {
+	obj := remote.NewFsObject(Name)
+	if obj == nil {
+		t.Fatalf("Object not found: %q", Name)
+	}
+	return obj
+}
+
+func testPut(t *testing.T, file *fstest.Item) {
+	buf := bytes.NewBufferString(fstest.RandomString(100))
+	hash := md5.New()
+	in := io.TeeReader(buf, hash)
+
+	file.Size = int64(buf.Len())
+	obj, err := remote.Put(in, file.Path, file.ModTime, file.Size)
+	if err != nil {
+		t.Fatal("Put error", err)
+	}
+	file.Md5sum = hex.EncodeToString(hash.Sum(nil))
+	file.Check(t, obj, remote.Precision())
+	// Re-read the object and check again
+	obj = findObject(t, file.Path)
+	file.Check(t, obj, remote.Precision())
+}
+
+func TestFsPutFile1(t *testing.T) {
+	skipIfNotOk(t)
+	testPut(t, &file1)
+}
+
+func TestFsPutFile2(t *testing.T) {
+	skipIfNotOk(t)
+	testPut(t, &file2)
+}
+
+func TestFsListDirFile2(t *testing.T) {
+	skipIfNotOk(t)
+	found := false
+	for obj := range remote.ListDir() {
+		if obj.Name != `hello? sausage` {
+			t.Errorf("Found unexpected item %q", obj.Name)
+		} else {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("Didn't find %q", `hello? sausage`)
+	}
+}
+
+func TestFsListDirRoot(t *testing.T) {
+	skipIfNotOk(t)
+	rootRemote, err := fs.NewFs(RemoteName)
+	if err != nil {
+		t.Fatal("Failed to make remote %q: %v", RemoteName, err)
+	}
+	found := false
+	for obj := range rootRemote.ListDir() {
+		if obj.Name == subRemoteLeaf {
+			found = true
+		}
+	}
+	if !found {
+		t.Errorf("Didn't find %q", subRemoteLeaf)
+	}
+}
+
+func TestFsListRoot(t *testing.T) {
+	skipIfNotOk(t)
+	rootRemote, err := fs.NewFs(RemoteName)
+	if err != nil {
+		t.Fatal("Failed to make remote %q: %v", RemoteName, err)
+	}
+	// Should either find file1 and file2 or nothing
+	found1 := false
+	file1 := subRemoteLeaf + "/" + file1.Path
+	found2 := false
+	file2 := subRemoteLeaf + "/" + file2.Path
+	count := 0
+	errors := fs.Stats.GetErrors()
+	for obj := range rootRemote.List() {
+		count++
+		if obj.Remote() == file1 {
+			found1 = true
+		}
+		if obj.Remote() == file2 {
+			found2 = true
+		}
+	}
+	errors -= fs.Stats.GetErrors()
+	if count == 0 {
+		if errors == 0 {
+			t.Error("Expecting error if count==0")
+		}
+		return
+	}
+	if found1 && found2 {
+		if errors != 0 {
+			t.Error("Not expecting error if found")
+		}
+		return
+	}
+	t.Errorf("Didn't find %q (%v) and %q (%v) or no files (count %d)", file1, found1, file2, found2, count)
+}
+
+func TestFsListFile1(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.CheckListing(t, remote, []fstest.Item{file1, file2})
+}
+
+func TestFsNewFsObject(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	file1.Check(t, obj, remote.Precision())
+}
+
+func TestFsListFile1and2(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.CheckListing(t, remote, []fstest.Item{file1, file2})
+}
+
+func TestFsRmdirFull(t *testing.T) {
+	skipIfNotOk(t)
+	err := remote.Rmdir()
+	if err == nil {
+		t.Fatalf("Expecting error on RMdir on non empty remote")
+	}
+}
+
+func TestFsPrecision(t *testing.T) {
+	skipIfNotOk(t)
+	precision := remote.Precision()
+	if precision > time.Second || precision < 0 {
+		t.Fatalf("Precision out of range %v", precision)
+	}
+	// FIXME check expected precision
+}
+
+func TestObjectString(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	s := obj.String()
+	if s != file1.Path {
+		t.Errorf("String() wrong %v != %v", s, file1.Path)
+	}
+	obj = NilObject
+	s = obj.String()
+	if s != "<nil>" {
+		t.Errorf("String() wrong %v != %v", s, "<nil>")
+	}
+}
+
+func TestObjectFs(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	if obj.Fs() != remote {
+		t.Errorf("Fs is wrong %v != %v", obj.Fs(), remote)
+	}
+}
+
+func TestObjectRemote(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	if obj.Remote() != file1.Path {
+		t.Errorf("Remote is wrong %v != %v", obj.Remote(), file1.Path)
+	}
+}
+
+func TestObjectMd5sum(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	Md5sum, err := obj.Md5sum()
+	if err != nil {
+		t.Errorf("Error in Md5sum: %v", err)
+	}
+	if Md5sum != file1.Md5sum {
+		t.Errorf("Md5sum is wrong %v != %v", Md5sum, file1.Md5sum)
+	}
+}
+
+func TestObjectModTime(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	file1.CheckModTime(t, obj, obj.ModTime(), remote.Precision())
+}
+
+func TestObjectSetModTime(t *testing.T) {
+	skipIfNotOk(t)
+	newModTime := fstest.Time("2011-12-13T14:15:16.999999999Z")
+	obj := findObject(t, file1.Path)
+	obj.SetModTime(newModTime)
+	file1.ModTime = newModTime
+	file1.CheckModTime(t, obj, obj.ModTime(), remote.Precision())
+	// And make a new object and read it from there too
+	TestObjectModTime(t)
+}
+
+func TestObjectSize(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	if obj.Size() != file1.Size {
+		t.Errorf("Size is wrong %v != %v", obj.Size(), file1.Size)
+	}
+}
+
+func TestObjectOpen(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	in, err := obj.Open()
+	if err != nil {
+		t.Fatalf("Open() return error: %v", err)
+	}
+	hash := md5.New()
+	n, err := io.Copy(hash, in)
+	if err != nil {
+		t.Fatalf("io.Copy() return error: %v", err)
+	}
+	if n != file1.Size {
+		t.Fatalf("Read wrong number of bytes %d != %d", n, file1.Size)
+	}
+	err = in.Close()
+	if err != nil {
+		t.Fatalf("in.Close() return error: %v", err)
+	}
+	Md5sum := hex.EncodeToString(hash.Sum(nil))
+	if Md5sum != file1.Md5sum {
+		t.Errorf("Md5sum is wrong %v != %v", Md5sum, file1.Md5sum)
+	}
+}
+
+func TestObjectUpdate(t *testing.T) {
+	skipIfNotOk(t)
+	buf := bytes.NewBufferString(fstest.RandomString(200))
+	hash := md5.New()
+	in := io.TeeReader(buf, hash)
+
+	file1.Size = int64(buf.Len())
+	obj := findObject(t, file1.Path)
+	err := obj.Update(in, file1.ModTime, file1.Size)
+	if err != nil {
+		t.Fatal("Update error", err)
+	}
+	file1.Md5sum = hex.EncodeToString(hash.Sum(nil))
+	file1.Check(t, obj, remote.Precision())
+	// Re-read the object and check again
+	obj = findObject(t, file1.Path)
+	file1.Check(t, obj, remote.Precision())
+}
+
+func TestObjectStorable(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	if !obj.Storable() {
+		t.Fatalf("Expecting %v to be storable", obj)
+	}
+}
+
+func TestLimitedFs(t *testing.T) {
+	skipIfNotOk(t)
+	remoteName := subRemoteName + "/" + file2.Path
+	file2Copy := file2
+	file2Copy.Path = "z.txt"
+	fileRemote, err := fs.NewFs(remoteName)
+	if err != nil {
+		t.Fatal("Failed to make remote %q: %v", remoteName, err)
+	}
+	fstest.CheckListing(t, fileRemote, []fstest.Item{file2Copy})
+	_, ok := fileRemote.(*fs.Limited)
+	if !ok {
+		t.Errorf("%v is not a fs.Limited", fileRemote)
+	}
+}
+
+func TestLimitedFsNotFound(t *testing.T) {
+	skipIfNotOk(t)
+	remoteName := subRemoteName + "/not found.txt"
+	fileRemote, err := fs.NewFs(remoteName)
+	if err != nil {
+		t.Fatal("Failed to make remote %q: %v", remoteName, err)
+	}
+	fstest.CheckListing(t, fileRemote, []fstest.Item{})
+	_, ok := fileRemote.(*fs.Limited)
+	if ok {
+		t.Errorf("%v is is a fs.Limited", fileRemote)
+	}
+}
+
+func TestObjectRemove(t *testing.T) {
+	skipIfNotOk(t)
+	obj := findObject(t, file1.Path)
+	err := obj.Remove()
+	if err != nil {
+		t.Fatal("Remove error", err)
+	}
+	fstest.CheckListing(t, remote, []fstest.Item{file2})
+}
+
+func TestObjectPurge(t *testing.T) {
+	skipIfNotOk(t)
+	fstest.TestPurge(t, remote)
+	err := fs.Purge(remote)
+	if err == nil {
+		t.Fatal("Expecting error after on second purge")
+	}
+}
+
+func TestFinalise(t *testing.T) {
+	skipIfNotOk(t)
+	if strings.HasPrefix(RemoteName, "/") {
+		// Remove temp directory
+		err := os.Remove(RemoteName)
+		if err != nil {
+			log.Printf("Failed to remove %q: %v\n", RemoteName, err)
+		}
+	}
+}
--- a/fstest/fstests/gen_tests.go
+++ b/fstest/fstests/gen_tests.go
@@ -0,0 +1,143 @@
+// +build ignore
+
+// Make the test files from fstests.go
+package main
+
+import (
+	"bufio"
+	"html/template"
+	"log"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+)
+
+// Search fstests.go and return all the test function names
+func findTestFunctions() []string {
+	fns := []string{}
+	matcher := regexp.MustCompile(`^func\s+(Test.*?)\(`)
+
+	in, err := os.Open("fstests.go")
+	if err != nil {
+		log.Fatalf("Couldn't open fstests.go: %v", err)
+	}
+	defer in.Close()
+
+	scanner := bufio.NewScanner(in)
+	for scanner.Scan() {
+		line := scanner.Text()
+		matches := matcher.FindStringSubmatch(line)
+		if len(matches) > 0 {
+			fns = append(fns, matches[1])
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		log.Fatalf("Error scanning file: %v", err)
+	}
+	return fns
+}
+
+// Data to substitute
+type Data struct {
+	Regenerate  string
+	FsName      string
+	UpperFsName string
+	TestName    string
+	ObjectName  string
+	Fns         []string
+}
+
+var testProgram = `
+// Test {{ .UpperFsName }} filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: {{ .Regenerate }}
+package {{ .FsName }}_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+	"github.com/ncw/rclone/{{ .FsName }}"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*{{ .FsName }}.FsObject{{ .ObjectName }})(nil))
+	fstests.RemoteName = "{{ .TestName }}"
+}
+
+// Generic tests for the Fs
+{{ range $fn := .Fns }}func {{ $fn }}(t *testing.T){ fstests.{{ $fn }}(t) }
+{{ end }}
+`
+
+// Generate test file piping it through gofmt
+func generateTestProgram(t *template.Template, fns []string, Fsname string) {
+	fsname := strings.ToLower(Fsname)
+	TestName := "Test" + Fsname + ":"
+	outfile := "../../" + fsname + "/" + fsname + "_test.go"
+	// Find last capitalised group to be object name
+	matcher := regexp.MustCompile(`([A-Z][a-z0-9]+)$`)
+	matches := matcher.FindStringSubmatch(Fsname)
+	if len(matches) == 0 {
+		log.Fatalf("Couldn't find object name in %q", Fsname)
+	}
+	ObjectName := matches[1]
+
+	if fsname == "local" {
+		TestName = ""
+	}
+
+	data := Data{
+		Regenerate:  "go run gen_tests.go or make gen_tests",
+		FsName:      fsname,
+		UpperFsName: Fsname,
+		TestName:    TestName,
+		ObjectName:  ObjectName,
+		Fns:         fns,
+	}
+
+	cmd := exec.Command("gofmt")
+
+	log.Printf("Writing %q", outfile)
+	out, err := os.Create(outfile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	cmd.Stdout = out
+
+	gofmt, err := cmd.StdinPipe()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if err = cmd.Start(); err != nil {
+		log.Fatal(err)
+	}
+	if err = t.Execute(gofmt, data); err != nil {
+		log.Fatal(err)
+	}
+	if err = gofmt.Close(); err != nil {
+		log.Fatal(err)
+	}
+	if err = cmd.Wait(); err != nil {
+		log.Fatal(err)
+	}
+	if err = out.Close(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func main() {
+	fns := findTestFunctions()
+	t := template.Must(template.New("main").Parse(testProgram))
+	generateTestProgram(t, fns, "Local")
+	generateTestProgram(t, fns, "Swift")
+	generateTestProgram(t, fns, "S3")
+	generateTestProgram(t, fns, "Drive")
+	generateTestProgram(t, fns, "GoogleCloudStorage")
+	generateTestProgram(t, fns, "Dropbox")
+	log.Printf("Done")
+}
--- a/googleauth/googleauth.go
+++ b/googleauth/googleauth.go
@@ -0,0 +1,138 @@
+// Common authentication between Google Drive and Google Cloud Storage
+package googleauth
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+
+	"code.google.com/p/goauth2/oauth"
+	"github.com/ncw/rclone/fs"
+)
+
+// A token cache to save the token in the config file section named
+type TokenCache string
+
+// Get the token from the config file - returns an error if it isn't present
+func (name TokenCache) Token() (*oauth.Token, error) {
+	tokenString, err := fs.ConfigFile.GetValue(string(name), "token")
+	if err != nil {
+		return nil, err
+	}
+	if tokenString == "" {
+		return nil, fmt.Errorf("Empty token found - please reconfigure")
+	}
+	token := new(oauth.Token)
+	err = json.Unmarshal([]byte(tokenString), token)
+	if err != nil {
+		return nil, err
+	}
+	return token, nil
+
+}
+
+// Save the token to the config file
+//
+// This saves the config file if it changes
+func (name TokenCache) PutToken(token *oauth.Token) error {
+	tokenBytes, err := json.Marshal(token)
+	if err != nil {
+		return err
+	}
+	tokenString := string(tokenBytes)
+	old := fs.ConfigFile.MustValue(string(name), "token")
+	if tokenString != old {
+		fs.ConfigFile.SetValue(string(name), "token", tokenString)
+		fs.SaveConfig()
+	}
+	return nil
+}
+
+// Auth contains information to authenticate an app against google services
+type Auth struct {
+	Scope               string
+	DefaultClientId     string
+	DefaultClientSecret string
+}
+
+// Makes a new transport using authorisation from the config
+//
+// Doesn't have a token yet
+func (auth *Auth) newTransport(name string) (*oauth.Transport, error) {
+	clientId := fs.ConfigFile.MustValue(name, "client_id")
+	if clientId == "" {
+		clientId = auth.DefaultClientId
+	}
+	clientSecret := fs.ConfigFile.MustValue(name, "client_secret")
+	if clientSecret == "" {
+		clientSecret = auth.DefaultClientSecret
+	}
+
+	// Settings for authorization.
+	var config = &oauth.Config{
+		ClientId:     clientId,
+		ClientSecret: clientSecret,
+		Scope:        auth.Scope,
+		RedirectURL:  "urn:ietf:wg:oauth:2.0:oob",
+		AuthURL:      "https://accounts.google.com/o/oauth2/auth",
+		TokenURL:     "https://accounts.google.com/o/oauth2/token",
+		TokenCache:   TokenCache(name),
+	}
+
+	t := &oauth.Transport{
+		Config:    config,
+		Transport: http.DefaultTransport,
+	}
+
+	return t, nil
+}
+
+// Makes a new transport using authorisation from the config with token
+func (auth *Auth) NewTransport(name string) (*oauth.Transport, error) {
+	t, err := auth.newTransport(name)
+	if err != nil {
+		return nil, err
+	}
+
+	// Try to pull the token from the cache; if this fails, we need to get one.
+	token, err := t.Config.TokenCache.Token()
+	if err != nil {
+		return nil, fmt.Errorf("Failed to get token: %s", err)
+	}
+	t.Token = token
+
+	return t, nil
+}
+
+// Configuration helper - called after the user has put in the defaults
+func (auth *Auth) Config(name string) {
+	// See if already have a token
+	tokenString := fs.ConfigFile.MustValue(name, "token")
+	if tokenString != "" {
+		fmt.Printf("Already have a token - refresh?\n")
+		if !fs.Confirm() {
+			return
+		}
+	}
+
+	// Get a transport
+	t, err := auth.newTransport(name)
+	if err != nil {
+		log.Fatalf("Couldn't make transport: %v", err)
+	}
+
+	// Generate a URL for the user to visit for authorization.
+	authUrl := t.Config.AuthCodeURL("state")
+	fmt.Printf("Go to the following link in your browser\n")
+	fmt.Printf("%s\n", authUrl)
+	fmt.Printf("Log in, then type paste the token that is returned in the browser here\n")
+
+	// Read the code, and exchange it for a token.
+	fmt.Printf("Enter verification code> ")
+	authCode := fs.ReadLine()
+	_, err = t.Exchange(authCode)
+	if err != nil {
+		log.Fatalf("Failed to get token: %v", err)
+	}
+}
--- a/googlecloudstorage/googlecloudstorage.go
+++ b/googlecloudstorage/googlecloudstorage.go
@@ -0,0 +1,583 @@
+// Google Cloud Storage interface
+package googlecloudstorage
+
+/*
+Notes
+
+Can't set Updated but can set Metadata on object creation
+
+Patch needs full_control not just read_write
+
+FIXME Patch/Delete/Get isn't working with files with spaces in - giving 404 error
+- https://code.google.com/p/google-api-go-client/issues/detail?id=64
+*/
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"path"
+	"regexp"
+	"strings"
+	"time"
+
+	"google.golang.org/api/googleapi"
+	"google.golang.org/api/storage/v1"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/googleauth"
+)
+
+const (
+	rcloneClientId     = "202264815644.apps.googleusercontent.com"
+	rcloneClientSecret = "X4Z3ca8xfWDb1Voo-F9a7ZxJ"
+	timeFormatIn       = time.RFC3339
+	timeFormatOut      = "2006-01-02T15:04:05.000000000Z07:00"
+	metaMtime          = "mtime" // key to store mtime under in metadata
+	listChunks         = 256     // chunk size to read directory listings
+)
+
+var (
+	// Description of how to auth for this app
+	storageAuth = &googleauth.Auth{
+		Scope:               storage.DevstorageFull_controlScope,
+		DefaultClientId:     rcloneClientId,
+		DefaultClientSecret: rcloneClientSecret,
+	}
+)
+
+// Register with Fs
+func init() {
+	fs.Register(&fs.FsInfo{
+		Name:  "google cloud storage",
+		NewFs: NewFs,
+		Config: func(name string) {
+			storageAuth.Config(name)
+		},
+		Options: []fs.Option{{
+			Name: "client_id",
+			Help: "Google Application Client Id - leave blank to use rclone's.",
+		}, {
+			Name: "client_secret",
+			Help: "Google Application Client Secret - leave blank to use rclone's.",
+		}, {
+			Name: "project_number",
+			Help: "Project number optional - needed only for list/create/delete buckets - see your developer console.",
+		}, {
+			Name: "object_acl",
+			Help: "Access Control List for new objects.",
+			Examples: []fs.OptionExample{{
+				Value: "authenticatedRead",
+				Help:  "Object owner gets OWNER access, and all Authenticated Users get READER access.",
+			}, {
+				Value: "bucketOwnerFullControl",
+				Help:  "Object owner gets OWNER access, and project team owners get OWNER access.",
+			}, {
+				Value: "bucketOwnerRead",
+				Help:  "Object owner gets OWNER access, and project team owners get READER access.",
+			}, {
+				Value: "private",
+				Help:  "Object owner gets OWNER access [default if left blank].",
+			}, {
+				Value: "projectPrivate",
+				Help:  "Object owner gets OWNER access, and project team members get access according to their roles.",
+			}, {
+				Value: "publicRead",
+				Help:  "Object owner gets OWNER access, and all Users get READER access.",
+			}},
+		}, {
+			Name: "bucket_acl",
+			Help: "Access Control List for new buckets.",
+			Examples: []fs.OptionExample{{
+				Value: "authenticatedRead",
+				Help:  "Project team owners get OWNER access, and all Authenticated Users get READER access.",
+			}, {
+				Value: "private",
+				Help:  "Project team owners get OWNER access [default if left blank].",
+			}, {
+				Value: "projectPrivate",
+				Help:  "Project team members get access according to their roles.",
+			}, {
+				Value: "publicRead",
+				Help:  "Project team owners get OWNER access, and all Users get READER access.",
+			}, {
+				Value: "publicReadWrite",
+				Help:  "Project team owners get OWNER access, and all Users get WRITER access.",
+			}},
+		}},
+	})
+}
+
+// FsStorage represents a remote storage server
+type FsStorage struct {
+	svc           *storage.Service // the connection to the storage server
+	client        *http.Client     // authorized client
+	bucket        string           // the bucket we are working on
+	root          string           // the path we are working on if any
+	projectNumber string           // used for finding buckets
+	objectAcl     string           // used when creating new objects
+	bucketAcl     string           // used when creating new buckets
+}
+
+// FsObjectStorage describes a storage object
+//
+// Will definitely have info but maybe not meta
+type FsObjectStorage struct {
+	storage *FsStorage // what this object is part of
+	remote  string     // The remote path
+	url     string     // download path
+	md5sum  string     // The MD5Sum of the object
+	bytes   int64      // Bytes in the object
+	modTime time.Time  // Modified time of the object
+}
+
+// ------------------------------------------------------------
+
+// String converts this FsStorage to a string
+func (f *FsStorage) String() string {
+	if f.root == "" {
+		return fmt.Sprintf("Storage bucket %s", f.bucket)
+	}
+	return fmt.Sprintf("Storage bucket %s path %s", f.bucket, f.root)
+}
+
+// Pattern to match a storage path
+var matcher = regexp.MustCompile(`^([^/]*)(.*)$`)
+
+// parseParse parses a storage 'url'
+func parsePath(path string) (bucket, directory string, err error) {
+	parts := matcher.FindStringSubmatch(path)
+	if parts == nil {
+		err = fmt.Errorf("Couldn't find bucket in storage path %q", path)
+	} else {
+		bucket, directory = parts[1], parts[2]
+		directory = strings.Trim(directory, "/")
+	}
+	return
+}
+
+// NewFs contstructs an FsStorage from the path, bucket:path
+func NewFs(name, root string) (fs.Fs, error) {
+	t, err := storageAuth.NewTransport(name)
+	if err != nil {
+		return nil, err
+	}
+
+	bucket, directory, err := parsePath(root)
+	if err != nil {
+		return nil, err
+	}
+
+	f := &FsStorage{
+		bucket:        bucket,
+		root:          directory,
+		projectNumber: fs.ConfigFile.MustValue(name, "project_number"),
+		objectAcl:     fs.ConfigFile.MustValue(name, "object_acl"),
+		bucketAcl:     fs.ConfigFile.MustValue(name, "bucket_acl"),
+	}
+	if f.objectAcl == "" {
+		f.objectAcl = "private"
+	}
+	if f.bucketAcl == "" {
+		f.bucketAcl = "private"
+	}
+
+	// Create a new authorized Drive client.
+	f.client = t.Client()
+	f.svc, err = storage.New(f.client)
+	if err != nil {
+		return nil, fmt.Errorf("Couldn't create Google Cloud Storage client: %s", err)
+	}
+
+	if f.root != "" {
+		f.root += "/"
+		// Check to see if the object exists
+		_, err = f.svc.Objects.Get(bucket, directory).Do()
+		if err == nil {
+			remote := path.Base(directory)
+			f.root = path.Dir(directory)
+			if f.root == "." {
+				f.root = ""
+			} else {
+				f.root += "/"
+			}
+			obj := f.NewFsObject(remote)
+			// return a Fs Limited to this object
+			return fs.NewLimited(f, obj), nil
+		}
+	}
+	return f, nil
+}
+
+// Return an FsObject from a path
+//
+// May return nil if an error occurred
+func (f *FsStorage) newFsObjectWithInfo(remote string, info *storage.Object) fs.Object {
+	o := &FsObjectStorage{
+		storage: f,
+		remote:  remote,
+	}
+	if info != nil {
+		o.setMetaData(info)
+	} else {
+		err := o.readMetaData() // reads info and meta, returning an error
+		if err != nil {
+			// logged already FsDebug("Failed to read info: %s", err)
+			return nil
+		}
+	}
+	return o
+}
+
+// Return an FsObject from a path
+//
+// May return nil if an error occurred
+func (f *FsStorage) NewFsObject(remote string) fs.Object {
+	return f.newFsObjectWithInfo(remote, nil)
+}
+
+// list the objects into the function supplied
+//
+// If directories is set it only sends directories
+func (f *FsStorage) list(directories bool, fn func(string, *storage.Object)) {
+	list := f.svc.Objects.List(f.bucket).Prefix(f.root).MaxResults(listChunks)
+	if directories {
+		list = list.Delimiter("/")
+	}
+	rootLength := len(f.root)
+	for {
+		objects, err := list.Do()
+		if err != nil {
+			fs.Stats.Error()
+			fs.Log(f, "Couldn't read bucket %q: %s", f.bucket, err)
+			return
+		}
+		if !directories {
+			for _, object := range objects.Items {
+				if !strings.HasPrefix(object.Name, f.root) {
+					fs.Log(f, "Odd name received %q", object.Name)
+					continue
+				}
+				remote := object.Name[rootLength:]
+				fn(remote, object)
+			}
+		} else {
+			var object storage.Object
+			for _, prefix := range objects.Prefixes {
+				if !strings.HasSuffix(prefix, "/") {
+					continue
+				}
+				fn(prefix[:len(prefix)-1], &object)
+			}
+		}
+		if objects.NextPageToken == "" {
+			break
+		}
+		list.PageToken(objects.NextPageToken)
+	}
+}
+
+// Walk the path returning a channel of FsObjects
+func (f *FsStorage) List() fs.ObjectsChan {
+	out := make(fs.ObjectsChan, fs.Config.Checkers)
+	if f.bucket == "" {
+		// Return no objects at top level list
+		close(out)
+		fs.Stats.Error()
+		fs.Log(f, "Can't list objects at root - choose a bucket using lsd")
+	} else {
+		// List the objects
+		go func() {
+			defer close(out)
+			f.list(false, func(remote string, object *storage.Object) {
+				if fs := f.newFsObjectWithInfo(remote, object); fs != nil {
+					out <- fs
+				}
+			})
+		}()
+	}
+	return out
+}
+
+// Lists the buckets
+func (f *FsStorage) ListDir() fs.DirChan {
+	out := make(fs.DirChan, fs.Config.Checkers)
+	if f.bucket == "" {
+		// List the buckets
+		go func() {
+			defer close(out)
+			if f.projectNumber == "" {
+				fs.Stats.Error()
+				fs.Log(f, "Can't list buckets without project number")
+				return
+			}
+			listBuckets := f.svc.Buckets.List(f.projectNumber).MaxResults(listChunks)
+			for {
+				buckets, err := listBuckets.Do()
+				if err != nil {
+					fs.Stats.Error()
+					fs.Log(f, "Couldn't list buckets: %v", err)
+					break
+				} else {
+					for _, bucket := range buckets.Items {
+						out <- &fs.Dir{
+							Name:  bucket.Name,
+							Bytes: 0,
+							Count: 0,
+						}
+					}
+				}
+				if buckets.NextPageToken == "" {
+					break
+				}
+				listBuckets.PageToken(buckets.NextPageToken)
+			}
+		}()
+	} else {
+		// List the directories in the path in the bucket
+		go func() {
+			defer close(out)
+			f.list(true, func(remote string, object *storage.Object) {
+				out <- &fs.Dir{
+					Name:  remote,
+					Bytes: int64(object.Size),
+					Count: 0,
+				}
+			})
+		}()
+	}
+	return out
+}
+
+// Put the object into the bucket
+//
+// Copy the reader in to the new object which is returned
+//
+// The new object may have been created if an error is returned
+func (f *FsStorage) Put(in io.Reader, remote string, modTime time.Time, size int64) (fs.Object, error) {
+	// Temporary FsObject under construction
+	o := &FsObjectStorage{storage: f, remote: remote}
+	in = &fs.SeekWrapper{In: in, Size: size}
+	return o, o.Update(in, modTime, size)
+}
+
+// Mkdir creates the bucket if it doesn't exist
+func (f *FsStorage) Mkdir() error {
+	_, err := f.svc.Buckets.Get(f.bucket).Do()
+	if err == nil {
+		// Bucket already exists
+		return nil
+	}
+
+	if f.projectNumber == "" {
+		return fmt.Errorf("Can't make bucket without project number")
+	}
+
+	bucket := storage.Bucket{
+		Name: f.bucket,
+	}
+	_, err = f.svc.Buckets.Insert(f.projectNumber, &bucket).PredefinedAcl(f.bucketAcl).Do()
+	return err
+}
+
+// Rmdir deletes the bucket
+//
+// Returns an error if it isn't empty: Error 409: The bucket you tried
+// to delete was not empty.
+func (f *FsStorage) Rmdir() error {
+	return f.svc.Buckets.Delete(f.bucket).Do()
+}
+
+// Return the precision
+func (fs *FsStorage) Precision() time.Duration {
+	return time.Nanosecond
+}
+
+// ------------------------------------------------------------
+
+// Return the parent Fs
+func (o *FsObjectStorage) Fs() fs.Fs {
+	return o.storage
+}
+
+// Return a string version
+func (o *FsObjectStorage) String() string {
+	if o == nil {
+		return "<nil>"
+	}
+	return o.remote
+}
+
+// Return the remote path
+func (o *FsObjectStorage) Remote() string {
+	return o.remote
+}
+
+// Md5sum returns the Md5sum of an object returning a lowercase hex string
+func (o *FsObjectStorage) Md5sum() (string, error) {
+	return o.md5sum, nil
+}
+
+// Size returns the size of an object in bytes
+func (o *FsObjectStorage) Size() int64 {
+	return o.bytes
+}
+
+// setMetaData sets the fs data from a storage.Object
+func (o *FsObjectStorage) setMetaData(info *storage.Object) {
+	o.url = info.MediaLink
+	o.bytes = int64(info.Size)
+
+	// Read md5sum
+	md5sumData, err := base64.StdEncoding.DecodeString(info.Md5Hash)
+	if err != nil {
+		fs.Log(o, "Bad MD5 decode: %v", err)
+	} else {
+		o.md5sum = hex.EncodeToString(md5sumData)
+	}
+
+	// read mtime out of metadata if available
+	mtimeString, ok := info.Metadata[metaMtime]
+	if ok {
+		modTime, err := time.Parse(timeFormatIn, mtimeString)
+		if err == nil {
+			o.modTime = modTime
+			return
+		} else {
+			fs.Debug(o, "Failed to read mtime from metadata: %s", err)
+		}
+	}
+
+	// Fallback to the Updated time
+	modTime, err := time.Parse(timeFormatIn, info.Updated)
+	if err != nil {
+		fs.Log(o, "Bad time decode: %v", err)
+	} else {
+		o.modTime = modTime
+	}
+}
+
+// readMetaData gets the metadata if it hasn't already been fetched
+//
+// it also sets the info
+func (o *FsObjectStorage) readMetaData() (err error) {
+	if !o.modTime.IsZero() {
+		return nil
+	}
+	object, err := o.storage.svc.Objects.Get(o.storage.bucket, o.storage.root+o.remote).Do()
+	if err != nil {
+		fs.Debug(o, "Failed to read info: %s", err)
+		return err
+	}
+	o.setMetaData(object)
+	return nil
+}
+
+// ModTime returns the modification time of the object
+//
+// It attempts to read the objects mtime and if that isn't present the
+// LastModified returned in the http headers
+func (o *FsObjectStorage) ModTime() time.Time {
+	err := o.readMetaData()
+	if err != nil {
+		// fs.Log(o, "Failed to read metadata: %s", err)
+		return time.Now()
+	}
+	return o.modTime
+}
+
+// Returns metadata for an object
+func metadataFromModTime(modTime time.Time) map[string]string {
+	metadata := make(map[string]string, 1)
+	metadata[metaMtime] = modTime.Format(timeFormatOut)
+	return metadata
+}
+
+// Sets the modification time of the local fs object
+func (o *FsObjectStorage) SetModTime(modTime time.Time) {
+	// This only adds metadata so will perserve other metadata
+	object := storage.Object{
+		Bucket:   o.storage.bucket,
+		Name:     o.storage.root + o.remote,
+		Metadata: metadataFromModTime(modTime),
+	}
+	newObject, err := o.storage.svc.Objects.Patch(o.storage.bucket, o.storage.root+o.remote, &object).Do()
+	if err != nil {
+		fs.Stats.Error()
+		fs.Log(o, "Failed to update remote mtime: %s", err)
+	}
+	o.setMetaData(newObject)
+}
+
+// Is this object storable
+func (o *FsObjectStorage) Storable() bool {
+	return true
+}
+
+// Open an object for read
+func (o *FsObjectStorage) Open() (in io.ReadCloser, err error) {
+	// This is slightly complicated by Go here insisting on
+	// decoding the %2F in URLs into / which is legal in http, but
+	// unfortunately not what the storage server wants.
+	//
+	// So first encode all the % into their encoded form
+	// URL will decode them giving our original escaped string
+	url := strings.Replace(o.url, "%", "%25", -1)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	// SetOpaque sets Opaque such that HTTP requests to it don't
+	// alter any hex-escaped characters
+	googleapi.SetOpaque(req.URL)
+	req.Header.Set("User-Agent", fs.UserAgent)
+	res, err := o.storage.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != 200 {
+		_ = res.Body.Close() // ignore error
+		return nil, fmt.Errorf("Bad response: %d: %s", res.StatusCode, res.Status)
+	}
+	return res.Body, nil
+}
+
+// Update the object with the contents of the io.Reader, modTime and size
+//
+// The new object may have been created if an error is returned
+func (o *FsObjectStorage) Update(in io.Reader, modTime time.Time, size int64) error {
+	// Guess the content type
+	contentType := mime.TypeByExtension(path.Ext(o.remote))
+	if contentType == "" {
+		contentType = "application/octet-stream"
+	}
+
+	object := storage.Object{
+		Bucket:      o.storage.bucket,
+		Name:        o.storage.root + o.remote,
+		ContentType: contentType,
+		Size:        uint64(size),
+		Updated:     modTime.Format(timeFormatOut), // Doesn't get set
+		Metadata:    metadataFromModTime(modTime),
+	}
+	in = &fs.SeekWrapper{In: in, Size: size}
+	newObject, err := o.storage.svc.Objects.Insert(o.storage.bucket, &object).Media(in).Name(object.Name).PredefinedAcl(o.storage.objectAcl).Do()
+	if err != nil {
+		return err
+	}
+	// Set the metadata for the new object while we have it
+	o.setMetaData(newObject)
+	return nil
+}
+
+// Remove an object
+func (o *FsObjectStorage) Remove() error {
+	return o.storage.svc.Objects.Delete(o.storage.bucket, o.storage.root+o.remote).Do()
+}
+
+// Check the interfaces are satisfied
+var _ fs.Fs = &FsStorage{}
+var _ fs.Object = &FsObjectStorage{}
--- a/googlecloudstorage/googlecloudstorage_test.go
+++ b/googlecloudstorage/googlecloudstorage_test.go
@@ -0,0 +1,53 @@
+// Test GoogleCloudStorage filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package googlecloudstorage_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+	"github.com/ncw/rclone/googlecloudstorage"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*googlecloudstorage.FsObjectStorage)(nil))
+	fstests.RemoteName = "TestGoogleCloudStorage:"
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/graphics/rclone-256x256.png
+++ b/graphics/rclone-256x256.png
--- a/graphics/rclone-64x64.png
+++ b/graphics/rclone-64x64.png
--- a/local/local.go
+++ b/local/local.go
@@ -1,12 +1,18 @@
 // Local filesystem interface
 package local

+// Note that all rclone paths should be / separated.  Anything coming
+// from the filepath module will have \ separators on windows so
+// should be converted using filepath.ToSlash.  Windows is quite happy
+// with / separators so there is no need to convert them back.
+
 import (
 	"crypto/md5"
+	"encoding/hex"
 	"fmt"
+	"hash"
 	"io"
 	"io/ioutil"
-	"log"
 	"os"
 	"path"
 	"path/filepath"
@@ -36,14 +42,15 @@ type FsObjectLocal struct {
 	local  fs.Fs       // The Fs this object is part of
 	remote string      // The remote path
 	path   string      // The local path
-	info   os.FileInfo // Interface for file info
+	info   os.FileInfo // Interface for file info (always present)
+	md5sum string      // the md5sum of the object or "" if not calculated
 }

 // ------------------------------------------------------------

 // NewFs contstructs an FsLocal from the path
 func NewFs(name, root string) (fs.Fs, error) {
-	root = path.Clean(root)
+	root = filepath.ToSlash(path.Clean(root))
 	f := &FsLocal{root: root}
 	// Check to see if this points to a file
 	fi, err := os.Lstat(f.root)
@@ -66,8 +73,9 @@ func (f *FsLocal) String() string {
 // Return an FsObject from a path
 //
 // May return nil if an error occurred
-func (f *FsLocal) NewFsObjectWithInfo(remote string, info os.FileInfo) fs.Object {
-	path := filepath.Join(f.root, remote)
+func (f *FsLocal) newFsObjectWithInfo(remote string, info os.FileInfo) fs.Object {
+	remote = filepath.ToSlash(remote)
+	path := path.Join(f.root, remote)
 	o := &FsObjectLocal{local: f, remote: remote, path: path}
 	if info != nil {
 		o.info = info
@@ -85,7 +93,7 @@ func (f *FsLocal) NewFsObjectWithInfo(remote string, info os.FileInfo) fs.Object
 //
 // May return nil if an error occurred
 func (f *FsLocal) NewFsObject(remote string) fs.Object {
-	return f.NewFsObjectWithInfo(remote, nil)
+	return f.newFsObjectWithInfo(remote, nil)
 }

 // List the path returning a channel of FsObjects
@@ -97,19 +105,19 @@ func (f *FsLocal) List() fs.ObjectsChan {
 		err := filepath.Walk(f.root, func(path string, fi os.FileInfo, err error) error {
 			if err != nil {
 				fs.Stats.Error()
-				log.Printf("Failed to open directory: %s: %s", path, err)
+				fs.Log(f, "Failed to open directory: %s: %s", path, err)
 			} else {
 				remote, err := filepath.Rel(f.root, path)
 				if err != nil {
 					fs.Stats.Error()
-					log.Printf("Failed to get relative path %s: %s", path, err)
+					fs.Log(f, "Failed to get relative path %s: %s", path, err)
 					return nil
 				}
 				if remote == "." {
 					return nil
 					// remote = ""
 				}
-				if fs := f.NewFsObjectWithInfo(remote, fi); fs != nil {
+				if fs := f.newFsObjectWithInfo(remote, fi); fs != nil {
 					if fs.Storable() {
 						out <- fs
 					}
@@ -119,7 +127,7 @@ func (f *FsLocal) List() fs.ObjectsChan {
 		})
 		if err != nil {
 			fs.Stats.Error()
-			log.Printf("Failed to open directory: %s: %s", f.root, err)
+			fs.Log(f, "Failed to open directory: %s: %s", f.root, err)
 		}
 		close(out)
 	}()
@@ -134,7 +142,7 @@ func (f *FsLocal) ListDir() fs.DirChan {
 		items, err := ioutil.ReadDir(f.root)
 		if err != nil {
 			fs.Stats.Error()
-			log.Printf("Couldn't find read directory: %s", err)
+			fs.Log(f, "Couldn't find read directory: %s", err)
 		} else {
 			for _, item := range items {
 				if item.IsDir() {
@@ -149,7 +157,7 @@ func (f *FsLocal) ListDir() fs.DirChan {
 					err := filepath.Walk(dirpath, func(path string, fi os.FileInfo, err error) error {
 						if err != nil {
 							fs.Stats.Error()
-							log.Printf("Failed to open directory: %s: %s", path, err)
+							fs.Log(f, "Failed to open directory: %s: %s", path, err)
 						} else {
 							dir.Count += 1
 							dir.Bytes += fi.Size()
@@ -158,7 +166,7 @@ func (f *FsLocal) ListDir() fs.DirChan {
 					})
 					if err != nil {
 						fs.Stats.Error()
-						log.Printf("Failed to open directory: %s: %s", dirpath, err)
+						fs.Log(f, "Failed to open directory: %s: %s", dirpath, err)
 					}
 					out <- dir
 				}
@@ -171,10 +179,14 @@ func (f *FsLocal) ListDir() fs.DirChan {

 // Puts the FsObject to the local filesystem
 func (f *FsLocal) Put(in io.Reader, remote string, modTime time.Time, size int64) (fs.Object, error) {
-	dstPath := filepath.Join(f.root, remote)
-	// Temporary FsObject under construction
-	fs := &FsObjectLocal{local: f, remote: remote, path: dstPath}
-	return fs, fs.Update(in, modTime, size)
+	dstPath := path.Join(f.root, remote)
+	// Temporary FsObject under construction - info filled in by Update()
+	o := &FsObjectLocal{local: f, remote: remote, path: dstPath}
+	err := o.Update(in, modTime, size)
+	if err != nil {
+		return nil, err
+	}
+	return o, nil
 }

 // Mkdir creates the directory if it doesn't exist
@@ -211,12 +223,15 @@ func (f *FsLocal) readPrecision() (precision time.Duration) {
 	}
 	path := fd.Name()
 	// fmt.Println("Created temp file", path)
-	fd.Close()
+	err = fd.Close()
+	if err != nil {
+		return time.Second
+	}

 	// Delete it on return
 	defer func() {
 		// fmt.Println("Remove temp file")
-		os.Remove(path)
+		_ = os.Remove(path) // ignore error
 	}()

 	// Find the minimum duration we can detect
@@ -246,6 +261,22 @@ func (f *FsLocal) readPrecision() (precision time.Duration) {
 	return
 }

+// Purge deletes all the files and directories
+//
+// Optional interface: Only implement this if you have a way of
+// deleting all the files quicker than just running Remove() on the
+// result of List()
+func (f *FsLocal) Purge() error {
+	fi, err := os.Lstat(f.root)
+	if err != nil {
+		return err
+	}
+	if !fi.Mode().IsDir() {
+		return fmt.Errorf("Can't Purge non directory: %q", f.root)
+	}
+	return os.RemoveAll(f.root)
+}
+
 // ------------------------------------------------------------

 // Return the parent Fs
@@ -268,21 +299,30 @@ func (o *FsObjectLocal) Remote() string {

 // Md5sum calculates the Md5sum of a file returning a lowercase hex string
 func (o *FsObjectLocal) Md5sum() (string, error) {
+	if o.md5sum != "" {
+		return o.md5sum, nil
+	}
 	in, err := os.Open(o.path)
 	if err != nil {
 		fs.Stats.Error()
 		fs.Log(o, "Failed to open: %s", err)
 		return "", err
 	}
-	defer in.Close() // FIXME ignoring error
 	hash := md5.New()
 	_, err = io.Copy(hash, in)
+	closeErr := in.Close()
 	if err != nil {
 		fs.Stats.Error()
 		fs.Log(o, "Failed to read: %s", err)
 		return "", err
 	}
-	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+	if closeErr != nil {
+		fs.Stats.Error()
+		fs.Log(o, "Failed to close: %s", closeErr)
+		return "", closeErr
+	}
+	o.md5sum = hex.EncodeToString(hash.Sum(nil))
+	return o.md5sum, nil
 }

 // Size returns the size of an object in bytes
@@ -300,6 +340,13 @@ func (o *FsObjectLocal) SetModTime(modTime time.Time) {
 	err := os.Chtimes(o.path, modTime, modTime)
 	if err != nil {
 		fs.Debug(o, "Failed to set mtime on file: %s", err)
+		return
+	}
+	// Re-read metadata
+	err = o.lstat()
+	if err != nil {
+		fs.Debug(o, "Failed to stat: %s", err)
+		return
 	}
 }

@@ -310,15 +357,53 @@ func (o *FsObjectLocal) Storable() bool {
 		fs.Debug(o, "Can't transfer non file/directory")
 		return false
 	} else if mode&os.ModeDir != 0 {
-		fs.Debug(o, "FIXME Skipping directory")
+		// fs.Debug(o, "Skipping directory")
 		return false
 	}
 	return true
 }

+// localOpenFile wraps an io.ReadCloser and updates the md5sum of the
+// object that is read
+type localOpenFile struct {
+	o    *FsObjectLocal // object that is open
+	in   io.ReadCloser  // handle we are wrapping
+	hash hash.Hash      // currently accumulating MD5
+}
+
+// Read bytes from the object - see io.Reader
+func (file *localOpenFile) Read(p []byte) (n int, err error) {
+	n, err = file.in.Read(p)
+	if n > 0 {
+		// Hash routines never return an error
+		_, _ = file.hash.Write(p[:n])
+	}
+	return
+}
+
+// Close the object and update the md5sum
+func (file *localOpenFile) Close() (err error) {
+	err = file.in.Close()
+	if err == nil {
+		file.o.md5sum = hex.EncodeToString(file.hash.Sum(nil))
+	} else {
+		file.o.md5sum = ""
+	}
+	return err
+}
+
 // Open an object for read
 func (o *FsObjectLocal) Open() (in io.ReadCloser, err error) {
 	in, err = os.Open(o.path)
+	if err != nil {
+		return
+	}
+	// Update the md5sum as we go along
+	in = &localOpenFile{
+		o:    o,
+		in:   in,
+		hash: md5.New(),
+	}
 	return
 }

@@ -335,6 +420,10 @@ func (o *FsObjectLocal) Update(in io.Reader, modTime time.Time, size int64) erro
 		return err
 	}

+	// Calculate the md5sum of the object we are reading as we go along
+	hash := md5.New()
+	in = io.TeeReader(in, hash)
+
 	_, err = io.Copy(out, in)
 	outErr := out.Close()
 	if err != nil {
@@ -344,9 +433,14 @@ func (o *FsObjectLocal) Update(in io.Reader, modTime time.Time, size int64) erro
 		return outErr
 	}

+	// All successful so update the md5sum
+	o.md5sum = hex.EncodeToString(hash.Sum(nil))
+
 	// Set the mtime
 	o.SetModTime(modTime)
-	return nil
+
+	// ReRead info now that we have finished
+	return o.lstat()
 }

 // Stat a FsObject into info
@@ -363,4 +457,5 @@ func (o *FsObjectLocal) Remove() error {

 // Check the interfaces are satisfied
 var _ fs.Fs = &FsLocal{}
+var _ fs.Purger = &FsLocal{}
 var _ fs.Object = &FsObjectLocal{}
--- a/local/local_test.go
+++ b/local/local_test.go
@@ -0,0 +1,53 @@
+// Test Local filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package local_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+	"github.com/ncw/rclone/local"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*local.FsObjectLocal)(nil))
+	fstests.RemoteName = ""
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/notes.txt
+++ b/notes.txt
@@ -1,3 +1,17 @@
+Change lsd command so it doesn't show -1
+  * Make sure all Fses show -1 for objects Zero for dates etc
+  * Make test?
+
+Put the TestRemote names into the Fs description
+Make test_all.sh use the TestRemote name automatically
+
+Run errcheck and go vet in the make file
+.. Also race detector?
+
+Get rid of Storable?
+
+Write developer manual
+
 Todo
  * FIXME: More -dry-run checks for object transfer
  * Might be quicker to check md5sums first? for swift <-> swift certainly, and maybe for small files
@@ -15,6 +29,20 @@ Todo
  * Make a fs.Errorf and count errors and log them at a different level
  * Add max object size to fs metadata - 5GB for swift, infinite for local, ? for s3
    * tie into -max-size flag
+  * FIXME Make NewFs to return err.IsAnObject so can put the LimitedFs
+    creation in common code? Or try for as much as possible?
+  * FIXME Account all the transactons (ls etc) using a different
+    Roundtripper wrapper which wraps the transactions?
+  * FIXME write tests for local file system
+  * FIXME implement tests for single file operations in rclonetest
+  * Need to make directory objects otherwise can't upload an empty directory
+    * Or could upload empty directories only?
+
+More rsync features
+  * include
+  * exclude
+  * max size
+  * bandwidth limit

 Ideas
  * could do encryption - put IV into metadata?
@@ -23,16 +51,9 @@ Ideas
  * support
      * sftp
      * scp
-      * Google cloud storage: https://developers.google.com/storage/
      * rsync over ssh
-      * dropbox: https://github.com/nickoneill/go-dropbox (no MD5s)
-  * control times sync (which is slow) with -a --archive flag?
-
-Need to make directory objects otherwise can't upload an empty directory
-  * Or could upload empty directories only?
-  * Can't purge a local filesystem because it leaves the directories behind
-
-Copying a single file? Or maybe with a glob pattern? Could do with LimitedFs
+  * control times sync (which is slow with some remotes) with -a --archive flag?
+  * Copy a glob pattern - could do with LimitedFs

 s3
  * Can maybe set last modified?
@@ -44,21 +65,3 @@ Bugs
  * Non verbose - not sure number transferred got counted up? CHECK
  * When doing copy it recurses the whole of the destination FS which isn't necessary

-Making a release
-  * go build ./...
-  * cd rclonetest
-  * go build
-  * ./rclonetest memstore:
-  * ./rclonetest s3:
-  * ./rclonetest drive2:
-  * ./rclonetest /tmp/z
-  * cd ..
-  * make tag
-  * edit README.md Changelog
-  * git commit version.go rclonetest/version.go README.md docs/content/downloads.md
-  * make retag
-  * . ~/bin/go-cross
-  * make cross
-  * make upload
-  * make upload_website
-  * git push --tags
--- a/rclone.go
+++ b/rclone.go
@@ -17,6 +17,8 @@ import (
 	"github.com/ncw/rclone/fs"
 	// Active file systems
 	_ "github.com/ncw/rclone/drive"
+	_ "github.com/ncw/rclone/dropbox"
+	_ "github.com/ncw/rclone/googlecloudstorage"
 	_ "github.com/ncw/rclone/local"
 	_ "github.com/ncw/rclone/s3"
 	_ "github.com/ncw/rclone/swift"
@@ -92,9 +94,9 @@ var Commands = []Command{
 		Name:     "ls",
 		ArgsHelp: "[remote://path]",
 		Help: `
-        List all the objects in the the path.`,
+        List all the objects in the the path with size and path.`,
 		Run: func(fdst, fsrc fs.Fs) {
-			err := fs.List(fdst)
+			err := fs.List(fdst, os.Stdout)
 			if err != nil {
 				log.Fatalf("Failed to list: %v", err)
 			}
@@ -108,7 +110,7 @@ var Commands = []Command{
 		Help: `
        List all directories/containers/buckets in the the path.`,
 		Run: func(fdst, fsrc fs.Fs) {
-			err := fs.ListDir(fdst)
+			err := fs.ListDir(fdst, os.Stdout)
 			if err != nil {
 				log.Fatalf("Failed to listdir: %v", err)
 			}
@@ -116,6 +118,34 @@ var Commands = []Command{
 		MinArgs: 1,
 		MaxArgs: 1,
 	},
+	{
+		Name:     "lsl",
+		ArgsHelp: "[remote://path]",
+		Help: `
+        List all the objects in the the path with modification time, size and path.`,
+		Run: func(fdst, fsrc fs.Fs) {
+			err := fs.ListLong(fdst, os.Stdout)
+			if err != nil {
+				log.Fatalf("Failed to list long: %v", err)
+			}
+		},
+		MinArgs: 1,
+		MaxArgs: 1,
+	},
+	{
+		Name:     "md5sum",
+		ArgsHelp: "[remote://path]",
+		Help: `
+        Produces an md5sum file for all the objects in the path.`,
+		Run: func(fdst, fsrc fs.Fs) {
+			err := fs.Md5sum(fdst, os.Stdout)
+			if err != nil {
+				log.Fatalf("Failed to list: %v", err)
+			}
+		},
+		MinArgs: 1,
+		MaxArgs: 1,
+	},
 	{
 		Name:     "mkdir",
 		ArgsHelp: "remote://path",
@@ -200,7 +230,7 @@ Syntax: [options] subcommand <parameters> <parameters...>

 Subcommands:

-`, Version)
+`, fs.Version)
 	for i := range Commands {
 		cmd := &Commands[i]
 		fmt.Fprintf(os.Stderr, "    %s %s\n", cmd.Name, cmd.ArgsHelp)
@@ -235,7 +265,11 @@ func ParseFlags() {
 			fs.Stats.Error()
 			log.Fatal(err)
 		}
-		pprof.StartCPUProfile(f)
+		err = pprof.StartCPUProfile(f)
+		if err != nil {
+			fs.Stats.Error()
+			log.Fatal(err)
+		}
 		defer pprof.StopCPUProfile()
 	}
 }
@@ -301,7 +335,7 @@ func StartStats() {
 func main() {
 	ParseFlags()
 	if *version {
-		fmt.Printf("rclone %s\n", Version)
+		fmt.Printf("rclone %s\n", fs.Version)
 		os.Exit(0)
 	}
 	command, args := ParseCommand()
--- a/rclonetest/rclonetest.go
+++ b/rclonetest/rclonetest.go
@@ -1,334 +0,0 @@
-// Test rclone by doing real transactions to a storage provider to and
-// from the local disk
-
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"math/rand"
-	"os"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/ncw/rclone/fs"
-	"github.com/ogier/pflag"
-
-	// Active file systems
-	_ "github.com/ncw/rclone/drive"
-	_ "github.com/ncw/rclone/local"
-	_ "github.com/ncw/rclone/s3"
-	_ "github.com/ncw/rclone/swift"
-)
-
-// Globals
-var (
-	localName, remoteName string
-	version               = pflag.BoolP("version", "V", false, "Print the version number")
-)
-
-// Represents an item for checking
-type Item struct {
-	Path    string
-	Md5sum  string
-	ModTime time.Time
-	Size    int64
-}
-
-// Represents all items for checking
-type Items struct {
-	byName map[string]*Item
-	items  []Item
-}
-
-// Make an Items
-func NewItems(items []Item) *Items {
-	is := &Items{
-		byName: make(map[string]*Item),
-		items:  items,
-	}
-	// Fill up byName
-	for i := range items {
-		is.byName[items[i].Path] = &items[i]
-	}
-	return is
-}
-
-// Check off an item
-func (is *Items) Find(obj fs.Object) {
-	i, ok := is.byName[obj.Remote()]
-	if !ok {
-		log.Fatalf("Unexpected file %q", obj.Remote())
-	}
-	delete(is.byName, obj.Remote())
-	// Check attributes
-	Md5sum, err := obj.Md5sum()
-	if err != nil {
-		log.Fatalf("Failed to read md5sum for %q: %v", obj.Remote(), err)
-	}
-	if i.Md5sum != Md5sum {
-		log.Fatalf("%s: Md5sum incorrect - expecting %q got %q", obj.Remote(), i.Md5sum, Md5sum)
-	}
-	if i.Size != obj.Size() {
-		log.Fatalf("%s: Size incorrect - expecting %d got %d", obj.Remote(), i.Size, obj.Size())
-	}
-	// check the mod time to the given precision
-	modTime := obj.ModTime()
-	dt := modTime.Sub(i.ModTime)
-	if dt >= fs.Config.ModifyWindow || dt <= -fs.Config.ModifyWindow {
-		log.Fatalf("%s: Modification time difference too big |%s| > %s (%s vs %s)", obj.Remote(), dt, fs.Config.ModifyWindow, modTime, i.ModTime)
-	}
-
-}
-
-// Check all done
-func (is *Items) Done() {
-	if len(is.byName) != 0 {
-		for name := range is.byName {
-			log.Printf("Not found %q", name)
-		}
-		log.Fatalf("%d objects not found", len(is.byName))
-	}
-}
-
-// Checks the fs to see if it has the expected contents
-func CheckListing(f fs.Fs, items []Item) {
-	is := NewItems(items)
-	for obj := range f.List() {
-		is.Find(obj)
-	}
-	is.Done()
-}
-
-// Parse a time string or explode
-func Time(timeString string) time.Time {
-	t, err := time.Parse(time.RFC3339Nano, timeString)
-	if err != nil {
-		log.Fatalf("Failed to parse time %q: %v", timeString, err)
-	}
-	return t
-}
-
-// Write a file
-func WriteFile(filePath, content string, t time.Time) {
-	// FIXME make directories?
-	filePath = path.Join(localName, filePath)
-	err := ioutil.WriteFile(filePath, []byte(content), 0600)
-	if err != nil {
-		log.Fatalf("Failed to write file %q: %v", filePath, err)
-	}
-	err = os.Chtimes(filePath, t, t)
-	if err != nil {
-		log.Fatalf("Failed to chtimes file %q: %v", filePath, err)
-	}
-}
-
-// Create a random string
-func RandomString(n int) string {
-	source := "abcdefghijklmnopqrstuvwxyz0123456789"
-	out := make([]byte, n)
-	for i := range out {
-		out[i] = source[rand.Intn(len(source))]
-	}
-	return string(out)
-}
-
-func TestMkdir(flocal, fremote fs.Fs) {
-	err := fs.Mkdir(fremote)
-	if err != nil {
-		log.Fatalf("Mkdir failed: %v", err)
-	}
-	items := []Item{}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-}
-
-var t1 = Time("2001-02-03T04:05:06.999999999Z")
-var t2 = Time("2011-12-25T12:59:59.123456789Z")
-
-func TestCopy(flocal, fremote fs.Fs) {
-	WriteFile("empty space", "", t1)
-
-	err := fs.Sync(fremote, flocal, false)
-	if err != nil {
-		log.Fatalf("Copy failed: %v", err)
-	}
-
-	items := []Item{
-		{Path: "empty space", Size: 0, ModTime: t1, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
-	}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-}
-
-func TestSync(flocal, fremote fs.Fs) {
-	log.Printf("Sync after changing file modtime only")
-	err := os.Chtimes(localName+"/empty space", t2, t2)
-	if err != nil {
-		log.Fatalf("Chtimes failed: %v", err)
-	}
-	err = fs.Sync(fremote, flocal, true)
-	if err != nil {
-		log.Fatalf("Sync failed: %v", err)
-	}
-	items := []Item{
-		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
-	}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-
-	// ------------------------------------------------------------
-
-	log.Printf("Sync after adding a file")
-	WriteFile("potato", "------------------------------------------------------------", t1)
-	err = fs.Sync(fremote, flocal, true)
-	if err != nil {
-		log.Fatalf("Sync failed: %v", err)
-	}
-	items = []Item{
-		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
-		{Path: "potato", Size: 60, ModTime: t1, Md5sum: "d6548b156ea68a4e003e786df99eee76"},
-	}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-
-	// ------------------------------------------------------------
-
-	log.Printf("Sync after changing a file's size only")
-	WriteFile("potato", "smaller but same date", t1)
-	err = fs.Sync(fremote, flocal, true)
-	if err != nil {
-		log.Fatalf("Sync failed: %v", err)
-	}
-	items = []Item{
-		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
-		{Path: "potato", Size: 21, ModTime: t1, Md5sum: "100defcf18c42a1e0dc42a789b107cd2"},
-	}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-
-	// ------------------------------------------------------------
-
-	log.Printf("Sync after removing a file")
-	err = os.Remove(localName + "/potato")
-	if err != nil {
-		log.Fatalf("Remove failed: %v", err)
-	}
-	err = fs.Sync(fremote, flocal, true)
-	if err != nil {
-		log.Fatalf("Sync failed: %v", err)
-	}
-
-	items = []Item{
-		{Path: "empty space", Size: 0, ModTime: t2, Md5sum: "d41d8cd98f00b204e9800998ecf8427e"},
-	}
-	CheckListing(flocal, items)
-	CheckListing(fremote, items)
-
-}
-
-func TestLs(flocal, fremote fs.Fs) {
-	// Underlying List has been tested above, so we just make sure it runs
-	err := fs.List(fremote)
-	if err != nil {
-		log.Fatalf("List failed: %v", err)
-	}
-}
-
-func TestLsd(flocal, fremote fs.Fs) {
-}
-
-func TestCheck(flocal, fremote fs.Fs) {
-}
-
-func TestPurge(flocal, fremote fs.Fs) {
-	err := fs.Purge(fremote)
-	if err != nil {
-		log.Fatalf("Purge failed: %v", err)
-	}
-}
-
-func TestRmdir(flocal, fremote fs.Fs) {
-	err := fs.Rmdir(fremote)
-	if err != nil {
-		log.Fatalf("Rmdir failed: %v", err)
-	}
-}
-
-func syntaxError() {
-	fmt.Fprintf(os.Stderr, `Test rclone with a remote to find bugs in either - %s.
-
-Syntax: [options] remote:
-
-Need a remote: as argument.  This will create a random container or
-directory under it and perform tests on it, deleting it at the end.
-
-Options:
-
-`, Version)
-	pflag.PrintDefaults()
-}
-
-// Clean the temporary directory
-func cleanTempDir() {
-	log.Printf("Cleaning temporary directory: %q", localName)
-	err := os.RemoveAll(localName)
-	if err != nil {
-		log.Printf("Failed to remove %q: %v", localName, err)
-	}
-}
-
-func main() {
-	pflag.Usage = syntaxError
-	pflag.Parse()
-	if *version {
-		fmt.Printf("rclonetest %s\n", Version)
-		os.Exit(0)
-	}
-	fs.LoadConfig()
-	rand.Seed(time.Now().UnixNano())
-	args := pflag.Args()
-
-	if len(args) != 1 {
-		syntaxError()
-		os.Exit(1)
-	}
-
-	remoteName = args[0]
-	if !strings.HasSuffix(remoteName, ":") {
-		remoteName += "/"
-	}
-	remoteName += RandomString(32)
-	log.Printf("Testing with remote %q", remoteName)
-	var err error
-	localName, err = ioutil.TempDir("", "rclone")
-	if err != nil {
-		log.Fatalf("Failed to create temp dir: %v", err)
-	}
-	log.Printf("Testing with local %q", localName)
-
-	fremote, err := fs.NewFs(remoteName)
-	if err != nil {
-		log.Fatalf("Failed to make %q: %v", remoteName, err)
-	}
-	flocal, err := fs.NewFs(localName)
-	if err != nil {
-		log.Fatalf("Failed to make %q: %v", remoteName, err)
-	}
-
-	fs.CalculateModifyWindow(fremote, flocal)
-
-	TestMkdir(flocal, fremote)
-	TestCopy(flocal, fremote)
-	TestSync(flocal, fremote)
-	TestLs(flocal, fremote)
-	TestLsd(flocal, fremote)
-	TestCheck(flocal, fremote)
-	TestPurge(flocal, fremote)
-	//TestRmdir(flocal, fremote)
-
-	cleanTempDir()
-	log.Printf("Tests OK")
-}
--- a/rclonetest/version.go
+++ b/rclonetest/version.go
@@ -1,3 +0,0 @@
-package main
-
-const Version = "v0.98"
--- a/s3/s3.go
+++ b/s3/s3.go
@@ -227,7 +227,7 @@ func NewFs(name, root string) (fs.Fs, error) {
 // Return an FsObject from a path
 //
 // May return nil if an error occurred
-func (f *FsS3) NewFsObjectWithInfo(remote string, info *s3.Key) fs.Object {
+func (f *FsS3) newFsObjectWithInfo(remote string, info *s3.Key) fs.Object {
 	o := &FsObjectS3{
 		s3:     f,
 		remote: remote,
@@ -256,7 +256,7 @@ func (f *FsS3) NewFsObjectWithInfo(remote string, info *s3.Key) fs.Object {
 //
 // May return nil if an error occurred
 func (f *FsS3) NewFsObject(remote string) fs.Object {
-	return f.NewFsObjectWithInfo(remote, nil)
+	return f.newFsObjectWithInfo(remote, nil)
 }

 // list the objects into the function supplied
@@ -281,6 +281,9 @@ func (f *FsS3) list(directories bool, fn func(string, *s3.Key)) {
 					continue
 				}
 				remote := remote[rootLength:]
+				if strings.HasSuffix(remote, "/") {
+					remote = remote[:len(remote)-1]
+				}
 				fn(remote, &s3.Key{Key: remote})
 			}
 		} else {
@@ -309,7 +312,7 @@ func (f *FsS3) List() fs.ObjectsChan {
 		go func() {
 			defer close(out)
 			f.list(false, func(remote string, object *s3.Key) {
-				if fs := f.NewFsObjectWithInfo(remote, object); fs != nil {
+				if fs := f.newFsObjectWithInfo(remote, object); fs != nil {
 					out <- fs
 				}
 			})
@@ -418,13 +421,28 @@ func (o *FsObjectS3) Size() int64 {

 // readMetaData gets the metadata if it hasn't already been fetched
 //
+// if we get a 404 error then we retry a few times for eventual
+// consistency reasons
+//
 // it also sets the info
 func (o *FsObjectS3) readMetaData() (err error) {
 	if o.meta != nil {
 		return nil
 	}
+	var headers s3.Headers

-	headers, err := o.s3.b.Head(o.s3.root+o.remote, nil)
+	// Try reading the metadata a few times (with exponential
+	// backoff) to get around eventual consistency on 404 error
+	for tries := uint(0); tries < 10; tries++ {
+		headers, err = o.s3.b.Head(o.s3.root+o.remote, nil)
+		if s3Err, ok := err.(*s3.Error); ok {
+			if s3Err.StatusCode == http.StatusNotFound {
+				time.Sleep(5 * time.Millisecond << tries)
+				continue
+			}
+		}
+		break
+	}
 	if err != nil {
 		fs.Debug(o, "Failed to read info: %s", err)
 		return err
@@ -514,6 +532,12 @@ func (o *FsObjectS3) Update(in io.Reader, modTime time.Time, size int64) error {
 	}

 	_, err := o.s3.b.PutReaderHeaders(o.s3.root+o.remote, in, size, contentType, o.s3.perm, headers)
+	if err != nil {
+		return err
+	}
+	// Read the metadata from the newly created object
+	o.meta = nil // wipe old metadata
+	err = o.readMetaData()
 	return err
 }

--- a/s3/s3_test.go
+++ b/s3/s3_test.go
@@ -0,0 +1,53 @@
+// Test S3 filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package s3_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+	"github.com/ncw/rclone/s3"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*s3.FsObjectS3)(nil))
+	fstests.RemoteName = "TestS3:"
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/swift/swift.go
+++ b/swift/swift.go
@@ -44,6 +44,9 @@ func init() {
 				Help:  "Memset Memstore UK v2",
 				Value: "https://auth.storage.memset.com/v2.0",
 			}},
+		}, {
+			Name: "tenant",
+			Help: "Tenant name - optional",
 		},
 		// snet     = flag.Bool("swift-snet", false, "Use internal service network") // FIXME not implemented
 		},
@@ -107,9 +110,11 @@ func swiftConnection(name string) (*swift.Connection, error) {
 		return nil, errors.New("auth not found")
 	}
 	c := &swift.Connection{
-		UserName: userName,
-		ApiKey:   apiKey,
-		AuthUrl:  authUrl,
+		UserName:  userName,
+		ApiKey:    apiKey,
+		AuthUrl:   authUrl,
+		UserAgent: fs.UserAgent,
+		Tenant:    fs.ConfigFile.MustValue(name, "tenant"),
 	}
 	err := c.Authenticate()
 	if err != nil {
@@ -156,7 +161,7 @@ func NewFs(name, root string) (fs.Fs, error) {
 // Return an FsObject from a path
 //
 // May return nil if an error occurred
-func (f *FsSwift) NewFsObjectWithInfo(remote string, info *swift.Object) fs.Object {
+func (f *FsSwift) newFsObjectWithInfo(remote string, info *swift.Object) fs.Object {
 	fs := &FsObjectSwift{
 		swift:  f,
 		remote: remote,
@@ -178,7 +183,7 @@ func (f *FsSwift) NewFsObjectWithInfo(remote string, info *swift.Object) fs.Obje
 //
 // May return nil if an error occurred
 func (f *FsSwift) NewFsObject(remote string) fs.Object {
-	return f.NewFsObjectWithInfo(remote, nil)
+	return f.newFsObjectWithInfo(remote, nil)
 }

 // list the objects into the function supplied
@@ -200,8 +205,11 @@ func (f *FsSwift) list(directories bool, fn func(string, *swift.Object)) {
 			for i := range objects {
 				object := &objects[i]
 				// FIXME if there are no directories, swift gives back the files for some reason!
-				if directories && !strings.HasSuffix(object.Name, "/") {
-					continue
+				if directories {
+					if !strings.HasSuffix(object.Name, "/") {
+						continue
+					}
+					object.Name = object.Name[:len(object.Name)-1]
 				}
 				if !strings.HasPrefix(object.Name, f.root) {
 					fs.Log(f, "Odd name received %q", object.Name)
@@ -232,7 +240,7 @@ func (f *FsSwift) List() fs.ObjectsChan {
 		go func() {
 			defer close(out)
 			f.list(false, func(remote string, object *swift.Object) {
-				if fs := f.NewFsObjectWithInfo(remote, object); fs != nil {
+				if fs := f.newFsObjectWithInfo(remote, object); fs != nil {
 					out <- fs
 				}
 			})
@@ -408,6 +416,12 @@ func (o *FsObjectSwift) Update(in io.Reader, modTime time.Time, size int64) erro
 	m := swift.Metadata{}
 	m.SetModTime(modTime)
 	_, err := o.swift.c.ObjectPut(o.swift.container, o.swift.root+o.remote, in, true, "", "", m.ObjectHeaders())
+	if err != nil {
+		return err
+	}
+	// Read the metadata from the newly created object
+	o.meta = nil // wipe old metadata
+	err = o.readMetaData()
 	return err
 }

--- a/swift/swift_test.go
+++ b/swift/swift_test.go
@@ -0,0 +1,53 @@
+// Test Swift filesystem interface
+//
+// Automatically generated - DO NOT EDIT
+// Regenerate with: go run gen_tests.go or make gen_tests
+package swift_test
+
+import (
+	"testing"
+
+	"github.com/ncw/rclone/fs"
+	"github.com/ncw/rclone/fstest/fstests"
+	"github.com/ncw/rclone/swift"
+)
+
+func init() {
+	fstests.NilObject = fs.Object((*swift.FsObjectSwift)(nil))
+	fstests.RemoteName = "TestSwift:"
+}
+
+// Generic tests for the Fs
+func TestInit(t *testing.T)                  { fstests.TestInit(t) }
+func TestFsString(t *testing.T)              { fstests.TestFsString(t) }
+func TestFsRmdirEmpty(t *testing.T)          { fstests.TestFsRmdirEmpty(t) }
+func TestFsRmdirNotFound(t *testing.T)       { fstests.TestFsRmdirNotFound(t) }
+func TestFsMkdir(t *testing.T)               { fstests.TestFsMkdir(t) }
+func TestFsListEmpty(t *testing.T)           { fstests.TestFsListEmpty(t) }
+func TestFsListDirEmpty(t *testing.T)        { fstests.TestFsListDirEmpty(t) }
+func TestFsNewFsObjectNotFound(t *testing.T) { fstests.TestFsNewFsObjectNotFound(t) }
+func TestFsPutFile1(t *testing.T)            { fstests.TestFsPutFile1(t) }
+func TestFsPutFile2(t *testing.T)            { fstests.TestFsPutFile2(t) }
+func TestFsListDirFile2(t *testing.T)        { fstests.TestFsListDirFile2(t) }
+func TestFsListDirRoot(t *testing.T)         { fstests.TestFsListDirRoot(t) }
+func TestFsListRoot(t *testing.T)            { fstests.TestFsListRoot(t) }
+func TestFsListFile1(t *testing.T)           { fstests.TestFsListFile1(t) }
+func TestFsNewFsObject(t *testing.T)         { fstests.TestFsNewFsObject(t) }
+func TestFsListFile1and2(t *testing.T)       { fstests.TestFsListFile1and2(t) }
+func TestFsRmdirFull(t *testing.T)           { fstests.TestFsRmdirFull(t) }
+func TestFsPrecision(t *testing.T)           { fstests.TestFsPrecision(t) }
+func TestObjectString(t *testing.T)          { fstests.TestObjectString(t) }
+func TestObjectFs(t *testing.T)              { fstests.TestObjectFs(t) }
+func TestObjectRemote(t *testing.T)          { fstests.TestObjectRemote(t) }
+func TestObjectMd5sum(t *testing.T)          { fstests.TestObjectMd5sum(t) }
+func TestObjectModTime(t *testing.T)         { fstests.TestObjectModTime(t) }
+func TestObjectSetModTime(t *testing.T)      { fstests.TestObjectSetModTime(t) }
+func TestObjectSize(t *testing.T)            { fstests.TestObjectSize(t) }
+func TestObjectOpen(t *testing.T)            { fstests.TestObjectOpen(t) }
+func TestObjectUpdate(t *testing.T)          { fstests.TestObjectUpdate(t) }
+func TestObjectStorable(t *testing.T)        { fstests.TestObjectStorable(t) }
+func TestLimitedFs(t *testing.T)             { fstests.TestLimitedFs(t) }
+func TestLimitedFsNotFound(t *testing.T)     { fstests.TestLimitedFsNotFound(t) }
+func TestObjectRemove(t *testing.T)          { fstests.TestObjectRemove(t) }
+func TestObjectPurge(t *testing.T)           { fstests.TestObjectPurge(t) }
+func TestFinalise(t *testing.T)              { fstests.TestFinalise(t) }
--- a/version.go
+++ b/version.go
@@ -1,3 +0,0 @@
-package main
-
-const Version = "v0.98"
Author	SHA1	Message	Date
Nick Craig-Wood	165e89c266	Version v1.09	2015-02-07 22:44:23 +00:00
Nick Craig-Wood	b4e19cfd62	windows: make tests work properly	2015-02-07 22:32:51 +00:00
Nick Craig-Wood	20ad96f3cd	windows: Stop drive letters (eg C:) getting mixed up with remotes (eg drive:) This was done by stopping the user configuring single letter remotes and making sure we don't treat single letter remotes as a remote name, but as a drive letter.	2015-02-07 22:32:51 +00:00
Nick Craig-Wood	d64a37772f	local: Fix directory separators on Windows - fixes #24	2015-02-07 22:32:51 +00:00
Nick Craig-Wood	5fb6f94579	drive: fix rate limit exceeded errors - fixes #20 This is done by pacing the requests to drive and backing them off using an exponential increase. Put and Modify operations can now be retried also.	2015-02-07 22:32:51 +00:00
Nick Craig-Wood	20535348db	Update docs to remove obsolete bug - fixes #21	2015-02-07 22:32:51 +00:00
Nick Craig-Wood	3d83a265c5	Update notes	2015-02-05 22:44:02 +00:00
Nick Craig-Wood	18a8a61cc5	Release v1.08	2015-02-04 22:31:56 +00:00
Nick Craig-Wood	1758621a51	drive: fix subdirectory listing to not list entire drive - fixes #23 This was causing inexplicably slow transfers on subdirectories of drives with lots of files.	2015-02-04 22:22:03 +00:00
Nick Craig-Wood	5710247bf6	drive: Fix SetModTime	2015-01-04 23:19:59 +00:00
Nick Craig-Wood	78b03929b7	Fix ModTime test	2015-01-04 16:57:55 +00:00
Nick Craig-Wood	492362ec7d	Catch nil from List() in tests	2015-01-04 16:23:22 +00:00
Nick Craig-Wood	51b24a1dc6	dropbox: adapt code to recent library changes	2014-12-23 13:55:22 +00:00
Nick Craig-Wood	cfdb48c864	Version v1.07	2014-12-23 11:26:32 +00:00
Nick Craig-Wood	14567952b3	google cloud storage: Fix memory leak - fixes #17 This was the same problem as issue #5 (which affected google drive)	2014-12-23 11:03:34 +00:00
Nick Craig-Wood	2b052671e2	swift: Add docs for tentant	2014-12-12 20:38:35 +00:00
Nick Craig-Wood	439a126af6	Version v1.06	2014-12-12 20:13:03 +00:00
Nick Craig-Wood	0fb35f081a	Use new location of Google API package - fixes #16	2014-12-12 20:02:08 +00:00
Nick Craig-Wood	9ba25c7219	Test with go 1.4 too	2014-12-12 19:27:14 +00:00
Nick Craig-Wood	af9c447146	Fix "Couldn't find home directory" on OSX - fixes #15	2014-12-12 19:18:23 +00:00
Nick Craig-Wood	ee6b39aa6c	Add tenant parameter for swift - fixes #13	2014-12-12 15:26:08 +00:00
Nick Craig-Wood	839133c5e1	Version v1.05	2014-08-09 17:22:17 +01:00
Nick Craig-Wood	f4eb48e531	Fix test incantation	2014-08-09 17:18:17 +01:00
Nick Craig-Wood	18439cf2d7	Move rclonetest into go tests for fs module	2014-08-03 11:18:25 +01:00
Nick Craig-Wood	d3c16608e4	Test Listing the Root of each Fs	2014-07-31 23:20:39 +01:00
Nick Craig-Wood	3e27ff1b95	Add Root List test and fs.Limited tests for single files	2014-07-31 21:35:29 +01:00
Nick Craig-Wood	ff91698fb5	Skip tests if test remote not configured	2014-07-31 08:51:39 +01:00
Nick Craig-Wood	c389616657	all: make private functions / variables / constant which shouldn't be public	2014-07-29 17:50:07 +01:00
Nick Craig-Wood	442578ca25	drive: reset root directory on Rmdir and Purge	2014-07-29 17:32:06 +01:00
Nick Craig-Wood	0b51d6221a	s3: make reading metadata more reliable to work around eventual consistency problems	2014-07-29 17:32:06 +01:00
Nick Craig-Wood	2f9f9afac2	fs: Document that Purger returns error on empty directory, test and fix	2014-07-29 17:18:22 +01:00
Nick Craig-Wood	9711a5d647	google cloud storage: re-read metadata in SetModTime	2014-07-29 17:18:22 +01:00
Nick Craig-Wood	cc679aa714	google cloud storage: fix ListDir on subdirectory	2014-07-29 17:18:22 +01:00
Nick Craig-Wood	457ef2c190	Automatically generate the tests files for each Fs	2014-07-29 17:18:22 +01:00
Nick Craig-Wood	17ffb0855f	Fixes after running errcheck	2014-07-25 18:19:49 +01:00
Nick Craig-Wood	125fc8f1f0	s3: strip trailing / from ListDir()	2014-07-24 23:13:33 +01:00
Nick Craig-Wood	1660903aa2	local: fix unit tests * Change log.Printf into fs.Log * Re-read metadata on SetModtime	2014-07-24 23:13:33 +01:00
Nick Craig-Wood	b013c58537	swift: return directories without / in ListDir	2014-07-24 23:13:33 +01:00
Nick Craig-Wood	a5b0d88608	Make tests for each Fs Factor tests out of rclonetest	2014-07-24 23:13:32 +01:00
Nick Craig-Wood	02d50f8c6e	local: remove annoying debug message	2014-07-22 23:06:01 +01:00
Nick Craig-Wood	e09ef62d5b	core: Fix race detected by go race detector	2014-07-22 23:03:14 +01:00
Nick Craig-Wood	a75bc0703f	Version 1.04	2014-07-21 21:32:37 +01:00
Nick Craig-Wood	80ecea82e8	google cloud storage: Fix crash on Update error - fixes #9	2014-07-21 21:25:46 +01:00
Nick Craig-Wood	54cd46372a	Version 1.03	2014-07-20 11:28:50 +01:00
Nick Craig-Wood	282cba20a0	swift, s3, dropbox: fix metadata read on Update() This was causing changed files to be marked as corrupted on upload	2014-07-20 11:23:05 +01:00
Nick Craig-Wood	2479ce2c8e	dropbox: go1.1 compatibility	2014-07-19 15:48:40 +01:00
Nick Craig-Wood	9aa4b6bd9b	Version 1.02	2014-07-19 13:24:48 +01:00
Nick Craig-Wood	6c10024420	rclonetest: add --subdir flag for testing with a sub directory Also add a test script for testing all the remotes	2014-07-19 13:07:56 +01:00
Nick Craig-Wood	e559194fb2	fs: Verify sizes are the same after transfer in Copy()	2014-07-19 13:05:07 +01:00
Nick Craig-Wood	1c472348b6	s3: Read metadata after Update or Put	2014-07-19 13:05:07 +01:00
Nick Craig-Wood	5a8bce6353	swift: Read metadata after Update or Put	2014-07-19 13:05:06 +01:00
Nick Craig-Wood	f9b31591f9	drive: Flush directory cache on Purge	2014-07-19 13:05:06 +01:00
Nick Craig-Wood	1527e64ee7	local: Implement Purger interface	2014-07-19 13:05:01 +01:00
Nick Craig-Wood	f7652db4f1	local: Make sure info is never nil	2014-07-19 11:50:11 +01:00
Nick Craig-Wood	8b75fb14c5	local: calculate md5sum on Read or Update since we check it in Copy()	2014-07-19 11:06:25 +01:00
Nick Craig-Wood	07f9a1a9f0	Update docs for Dropbox and Google Cloud Storage	2014-07-18 10:10:08 +01:00
Nick Craig-Wood	7d8bac2711	google cloud storage: fix merge conflict Conflicts: rclone.go rclonetest/rclonetest.go	2014-07-16 12:21:01 +01:00
Nick Craig-Wood	cad9479a00	google cloud storage: Update metadata on Put since we get it back	2014-07-16 12:12:36 +01:00
Nick Craig-Wood	dfc8a375f6	dropbox: Switch to using RFC3339 for time metadata	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	7c9bdb4b7a	dropbox: make limited fs work (copy single file)	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	f8bb0d9cc8	dropbox: remove metadata when we remove files	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	b185e104ed	dropbox: Fix mkdir on already created directory	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	e57a4c7c0c	dropbox: open the datastore in the background	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	d2f187e1a1	dropbox: Use /delta to list objects - much quicker Also fix major performance problem - re-reading entry each time!	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	c9aca33030	dropbox: Fix concurrent access to Dropbox datastore and Lower case keys in datastore	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	2b0911531c	dropbox: basics of metadata in Dropbox datastore working	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	2149185fc2	dropbox: Initial support of full Fs interface Still missing metadata support (eg SetModTime)	2014-07-15 19:27:42 +01:00
Nick Craig-Wood	0159da9f37	dropbox: graphics for the Dropbox app (used in auth process)	2014-07-15 19:27:41 +01:00
Nick Craig-Wood	680283d69f	google cloud storage: fix download of files in sub directories	2014-07-15 19:27:31 +01:00
Nick Craig-Wood	c71f339e01	google cloud storage: implement ACLs and delete	2014-07-15 19:27:31 +01:00
Nick Craig-Wood	c91c96565f	google cloud storage: set the Content-Type from the file name	2014-07-15 19:27:31 +01:00
Nick Craig-Wood	b72fc69fbe	google cloud storage: Make operations on single files work	2014-07-15 19:27:30 +01:00
Nick Craig-Wood	a1732c21d8	google cloud storage: Initial support for full Fs interface	2014-07-15 19:27:30 +01:00
Nick Craig-Wood	b83441081c	drive: factor common authentication code into googleauth module In preparation for Google Cloud Storage support	2014-07-15 19:27:30 +01:00
Nick Craig-Wood	8a76568ea8	core: Verify MD5 sums after each transfer	2014-07-15 19:27:05 +01:00
Nick Craig-Wood	c4dc9d273a	rclonetest: check sub directory and downloads	2014-07-15 13:28:48 +01:00
Nick Craig-Wood	66cf2df780	drive: check errors in Open() better	2014-07-15 13:28:35 +01:00
Nick Craig-Wood	c1a245d1c8	Factor UserAgent to fs and move Version to fs	2014-07-13 19:19:58 +01:00
Nick Craig-Wood	e40b09fe61	drive: Fix comment	2014-07-13 10:54:35 +01:00
Nick Craig-Wood	eb2b4ea8aa	rclone: Don't purge if --dry-run set	2014-07-13 10:54:30 +01:00
Nick Craig-Wood	e055ed0489	rclone: change "ls" and add "lsl" and "md5sum" commands Changed "ls" command not to show modification time by default only size and path. That is because it is slow for nearly all the remotes as it requires extra metadata lookup. All remotes can look up files and sizes without extra operations. Added "lsl" which does what "ls" used to - namely show modification time, size and path. Added "md5sum" which produces the same output as the md5sum command - md5sums and paths that is.	2014-07-12 12:09:20 +01:00
Nick Craig-Wood	dd6d7cad3a	Notes about storage systems	2014-07-09 20:50:08 +01:00
Nick Craig-Wood	37b2274e10	Version 1.01	2014-07-04 21:15:27 +01:00
Nick Craig-Wood	91cfbd4146	drive: fix transfer of big files using up lots of memory - fixes #5 This was done by making a seekWrapper which wraps an io.Reader with a basic Seek for code.google.com/p/google-api-go-client/googleapi to detect the length. Without this the getReaderSize function reads the entire file into memory to find its length.	2014-07-04 17:17:21 +01:00
Nick Craig-Wood	d4817399ff	Fix release procedure	2014-07-03 22:01:25 +01:00
Nick Craig-Wood	48d259da68	Version 1.00	2014-07-03 21:56:54 +01:00
Nick Craig-Wood	f86fa6a062	Fix make tag	2014-07-03 21:43:14 +01:00
Nick Craig-Wood	93cb0a47e4	drive: fix whole second dates - fixes #4	2014-07-03 21:32:01 +01:00
Nick Craig-Wood	a12760c038	Travis build correction - fixes #2	2014-06-26 19:05:48 +01:00
Nick Craig-Wood	fdcd6a3a4c	Add travis build file	2014-06-26 18:23:54 +01:00
Nick Craig-Wood	cb7891f4ff	Fix retag	2014-06-26 17:57:32 +01:00
Nick Craig-Wood	8f2684fa70	Version 0.99	2014-06-26 17:49:26 +01:00
Nick Craig-Wood	7ebf48ef42	Fix --dry-run not working and add tests for it - fixes #3	2014-06-26 15:33:06 +01:00
Nick Craig-Wood	1d67b014cb	Make compatible with go 1.1 - fixes #1	2014-06-26 15:18:48 +01:00