Merge lp:~dobey/ubuntu/lucid/ubuntuone-storage-protocol/trunk into lp:ubuntu/lucid/ubuntuone-storage-protocol

[dobey]

[lp:~dobey/ubuntu/lucid/ubuntuone-storage-protocol/trunk]

11. By dobey on 2010-02-17

Fix broken e-mail address

=== modified file 'PKG-INFO'
--- PKG-INFO	2009-12-07 17:00:00 +0000
+++ PKG-INFO	2010-02-17 23:29:10 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: ubuntuone-storage-protocol
-Version: 1.1.0
+Version: 1.1.2
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: UNKNOWN

=== modified file 'debian/changelog'
--- debian/changelog	2009-12-07 17:00:00 +0000
+++ debian/changelog	2010-02-17 23:29:10 +0000
@@ -1,3 +1,9 @@
+ubuntuone-storage-protocol (1.1.2-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream release.
+
+ -- Rodney Dawes <[e-mail]>  Wed, 17 Feb 2010 18:23:53 -0500
+
 ubuntuone-storage-protocol (1.1.0-0ubuntu1) lucid; urgency=low
 
   * New upstream release

=== modified file 'setup.py'
--- setup.py	2009-12-07 17:00:00 +0000
+++ setup.py	2010-02-17 23:29:10 +0000
@@ -119,7 +119,7 @@
 
 
 setup(name='ubuntuone-storage-protocol',
-      version='1.1.0',
+      version='1.1.2',
       packages=['ubuntuone',
                 'ubuntuone.storageprotocol'],
      data_files=[('/etc/ssl/certs', 

=== added file 'tests/test_client.py'
--- tests/test_client.py	1970-01-01 00:00:00 +0000
+++ tests/test_client.py	2010-02-17 23:29:10 +0000
@@ -0,0 +1,467 @@
+# coding=utf-8
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright (C) 2009 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the protocol client."""
+
+import unittest
+import uuid
+
+from twisted.internet.defer import Deferred
+
+from ubuntuone.storageprotocol import protocol_pb2
+from ubuntuone.storageprotocol.client import (
+    StorageClient, CreateUDF, ListVolumes, DeleteVolume
+)
+from ubuntuone.storageprotocol import volumes
+
+PATH = u'~/Documents/pdfs/moño/'
+NAME = u'UDF-me'
+VOLUME = uuid.UUID('12345678-1234-1234-1234-123456789abc')
+NODE = uuid.UUID('FEDCBA98-7654-3211-2345-6789ABCDEF12')
+USER = u'Dude'
+
+class FakedError(Exception):
+    """Stub to replace Request.error."""
+
+
+def stub_function(*args, **kwargs):
+    """Stub to replace non-related functions."""
+    return None
+
+def faked_error(message):
+    """Stub to replace Request.error."""
+    raise FakedError
+
+def was_called(self, flag):
+    """Helper to assert a function was called."""
+    assert not getattr(self, flag)
+    def set_flag(*args, **kwargs):
+        """Record the calling was made."""
+        setattr(self, flag, True)
+    return set_flag
+
+def build_list_volumes():
+    """Build a LIST_VOLUMES message."""
+    message = protocol_pb2.Message()
+    message.type = protocol_pb2.Message.VOLUMES_INFO
+    return message
+
+def build_volume_created():
+    """Build VOLUME_CREATED message."""
+    message = protocol_pb2.Message()
+    message.type = protocol_pb2.Message.VOLUME_CREATED
+    return message
+
+def build_volume_deleted():
+    """Build VOLUME_DELETED message."""
+    message = protocol_pb2.Message()
+    message.type = protocol_pb2.Message.VOLUME_DELETED
+    return message
+
+def set_root_message(message):
+    """Set a simple Root message."""
+    message.type = protocol_pb2.Volumes.ROOT
+    message.root.node = str(NODE)
+
+def set_udf_message(message):
+    """Set a simple UDFs message."""
+    message.type = protocol_pb2.Volumes.UDF
+    message.udf.volume = str(VOLUME)
+    message.udf.node = str(NODE)
+    message.udf.suggested_path = PATH
+
+def set_share_message(message):
+    """Set a simple Share message."""
+    message.type = protocol_pb2.Volumes.SHARE
+    message.share.share_id = str(VOLUME)
+    message.share.direction = 0
+    message.share.subtree = str(NODE)
+    message.share.share_name = u'test'
+    message.share.other_username = USER
+    message.share.other_visible_name = USER
+    message.share.accepted = False
+    message.share.access_level = 0
+
+
+class DummyAttribute(object):
+    """Helper class to replace non-related classes."""
+
+    def __getattribute__(self, name):
+        """Attributes can be whatever we need."""
+        return stub_function
+
+
+class FakedProtocol(StorageClient):
+    """Fake StorageClient to avoid twisted."""
+
+    def __init__(self, *args, **kwargs):
+        """Override transports and keep track of messages."""
+        StorageClient.__init__(self, *args, **kwargs)
+        self.transport = DummyAttribute()
+        self.messages = []
+
+    def sendMessage(self, message):
+        """Keep track of messages."""
+        self.messages.append(message)
+
+
+class ClientTestCase(unittest.TestCase):
+    """Check that MultiQuery works using an iterator."""
+
+    def setUp(self):
+        """Initialize testing client."""
+        self.client = FakedProtocol()
+        self.called = False
+        self.volume = None
+
+    def tearDown(self):
+        """Clean up."""
+        self.client = None
+
+    # client to server
+    def test_create_udf(self):
+        """Test create_udf."""
+        original = CreateUDF.start
+        CreateUDF.start = was_called(self, 'called')
+
+        try:
+            result = self.client.create_udf(path=PATH, name=NAME)
+            self.assertTrue(self.called, 'CreateUDF.start() was called')
+            self.assertTrue(isinstance(result, Deferred))
+        finally:
+            CreateUDF.start = original
+
+    def test_list_volumes(self):
+        """Test list_volumes."""
+        original = ListVolumes.start
+        ListVolumes.start = was_called(self, 'called')
+
+        try:
+            result = self.client.list_volumes()
+            self.assertTrue(self.called, 'ListVolumes.start() was called')
+            self.assertTrue(isinstance(result, Deferred))
+        finally:
+            ListVolumes.start = original
+
+    def test_delete_volume(self):
+        """Test delete_volume."""
+        original = DeleteVolume.start
+        DeleteVolume.start = was_called(self, 'called')
+
+        try:
+            result = self.client.delete_volume(volume_id=VOLUME)
+            self.assertTrue(self.called, 'DeleteVolume.start() was called')
+            self.assertTrue(isinstance(result, Deferred))
+        finally:
+            DeleteVolume.start = original
+
+    def test_set_volume_deleted_callback(self):
+        """Test callback setting."""
+        a_callback = lambda x: None
+        self.client.set_volume_deleted_callback(a_callback)
+        # pylint: disable-msg= W0212
+        self.assertTrue(self.client._volume_deleted_callback is a_callback)
+
+    def test_callback_must_be_callable(self):
+        """Test set callback parameters."""
+        self.assertRaises(TypeError, self.client.set_volume_created_callback,
+                          'hello')
+
+        self.assertRaises(TypeError, self.client.set_volume_deleted_callback,
+                          'world')
+
+    def test_set_volume_created_callback(self):
+        """Test callback setting."""
+        a_callback = lambda y, z: None
+        self.client.set_volume_created_callback(a_callback)
+        # pylint: disable-msg= W0212
+        self.assertTrue(self.client._volume_created_callback is a_callback)
+
+    # server to client
+    def test_handle_volume_created(self):
+        """Test handle_VOLUME_CREATED."""
+        a_callback = was_called(self, 'called')
+        self.client.set_volume_created_callback(a_callback)
+
+        message = build_volume_created()
+        set_root_message(message.volume_created)
+        self.client.handle_VOLUME_CREATED(message)
+
+        self.assertTrue(self.called)
+
+    def test_handle_root_created_passes_a_root(self):
+        """Test handle_VOLUME_CREATED parameter passing."""
+        self.volume = None
+        a_callback = lambda vol: setattr(self, 'volume', vol)
+        self.client.set_volume_created_callback(a_callback)
+
+        message = build_volume_created()
+        set_root_message(message.volume_created)
+        root = volumes.RootVolume.from_msg(message.volume_created.root)
+
+        self.client.handle_VOLUME_CREATED(message)
+        self.assertEquals(root, self.volume)
+
+    def test_handle_udf_created_passes_a_udf(self):
+        """Test handle_VOLUME_CREATED parameter passing."""
+        self.volume = None
+        a_callback = lambda vol: setattr(self, 'volume', vol)
+        self.client.set_volume_created_callback(a_callback)
+
+        message = build_volume_created()
+        set_udf_message(message.volume_created)
+        udf = volumes.UDFVolume.from_msg(message.volume_created.udf)
+
+        self.client.handle_VOLUME_CREATED(message)
+        self.assertEquals(udf, self.volume)
+
+    def test_handle_share_created_passes_a_share(self):
+        """Test handle_VOLUME_CREATED parameter passing."""
+        self.volume = None
+        a_callback = lambda vol: setattr(self, 'volume', vol)
+        self.client.set_volume_created_callback(a_callback)
+
+        message = build_volume_created()
+        set_share_message(message.volume_created)
+        share = volumes.ShareVolume.from_msg(message.volume_created.share)
+
+        self.client.handle_VOLUME_CREATED(message)
+        self.assertEquals(share, self.volume)
+
+    def test_handle_volume_created_if_volume_is_buggy(self):
+        """Test handle_VOLUME_CREATED if the volume is buggy."""
+        message = build_volume_created()
+        message.volume_created.type = -1 # invalid type!
+        self.client.set_volume_created_callback(lambda vol: None)
+        self.assertRaises(TypeError, self.client.handle_VOLUME_CREATED,
+                          message)
+
+    def test_handle_volume_created_if_callback_is_none(self):
+        """Test handle_VOLUME_CREATED if callback is none."""
+        message = build_volume_created()
+        self.client.handle_VOLUME_CREATED(message)
+
+    def test_handle_volume_deleted(self):
+        """Test handle_VOLUME_DELETED."""
+        a_callback = was_called(self, 'called')
+        self.client.set_volume_deleted_callback(a_callback)
+
+        message = build_volume_deleted()
+        message.volume_deleted.volume = str(VOLUME)
+        self.client.handle_VOLUME_DELETED(message)
+
+        self.assertTrue(self.called)
+
+    def test_handle_volume_deleted_passes_the_id(self):
+        """Test handle_VOLUME_DELETED."""
+        self.volume = None
+        a_callback = lambda vol_id: setattr(self, 'volume', vol_id)
+        self.client.set_volume_deleted_callback(a_callback)
+
+        message = build_volume_deleted()
+        message.volume_deleted.volume = str(VOLUME)
+        self.client.handle_VOLUME_DELETED(message)
+
+        self.assertEquals(VOLUME, self.volume)
+
+    def test_handle_volume_deleted_if_none(self):
+        """Test handle_VOLUME_DELETED if callback is none."""
+        message = build_volume_deleted()
+        self.client.handle_VOLUME_DELETED(message)
+
+
+class CreateUDFTestCase(unittest.TestCase):
+    """Test cases for CreateUDF op."""
+
+    def setUp(self):
+        """Initialize testing protocol."""
+        self.protocol = FakedProtocol()
+        self.request = CreateUDF(self.protocol, path=PATH, name=NAME)
+        self.request.error = faked_error
+        self.done_called = False
+        self.request.done = was_called(self, 'done_called')
+
+    def tearDown(self):
+        """Clean up."""
+        self.protocol = None
+        self.request = None
+
+    def test_init(self):
+        """Test request creation."""
+        self.assertEquals(PATH, self.request.path)
+        self.assertEquals(NAME, self.request.name)
+        self.assertTrue(self.request.volume_id is None)
+        self.assertTrue(self.request.node_id is None)
+
+    def test_start(self):
+        """Test request start."""
+        self.request.start()
+
+        self.assertEquals(1, len(self.request.protocol.messages))
+        actual_msg, = self.request.protocol.messages
+        self.assertEquals(protocol_pb2.Message.CREATE_UDF, actual_msg.type)
+        self.assertEquals(self.request.path, actual_msg.create_udf.path)
+        self.assertEquals(self.request.name, actual_msg.create_udf.name)
+
+    def test_process_message_error(self):
+        """Test request processMessage on error."""
+        message = protocol_pb2.Message()
+        self.assertRaises(FakedError, self.request.processMessage, message)
+
+    def test_process_message_volume_created(self):
+        """Test request processMessage on sucess."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.VOLUME_CREATED
+        message.volume_created.type = protocol_pb2.Volumes.UDF
+        message.volume_created.udf.volume = str(VOLUME)
+        message.volume_created.udf.node = str(NODE)
+        self.request.processMessage(message)
+
+        self.assertEquals(str(VOLUME), self.request.volume_id, 'volume set')
+        self.assertEquals(str(NODE), self.request.node_id, 'node set')
+        self.assertTrue(self.done_called, 'done() was called')
+
+
+class ListVolumesTestCase(unittest.TestCase):
+    """Test cases for ListVolumes op."""
+
+    def setUp(self):
+        """Initialize testing protocol."""
+        self.protocol = FakedProtocol()
+        self.request = ListVolumes(self.protocol)
+        self.request.error = faked_error
+        self.done_called = False
+        self.request.done = was_called(self, 'done_called')
+
+    def tearDown(self):
+        """Clean up."""
+        self.protocol = None
+        self.request = None
+
+    def test_init(self):
+        """Test request creation."""
+        self.assertEquals([], self.request.volumes)
+
+    def test_start(self):
+        """Test request start."""
+        self.request.start()
+
+        self.assertEquals(1, len(self.request.protocol.messages))
+        actual_msg, = self.request.protocol.messages
+        self.assertEquals(protocol_pb2.Message.LIST_VOLUMES, actual_msg.type)
+
+    def test_process_message_error(self):
+        """Test request processMessage on error."""
+        message = protocol_pb2.Message()
+        self.assertRaises(FakedError, self.request.processMessage, message)
+
+    def test_process_message_error_when_incorrect_volume(self):
+        """Test error condition when incorrect volume type."""
+        message = build_list_volumes()
+        message.list_volumes.type = -1
+        self.assertRaises(FakedError, self.request.processMessage, message)
+
+    def test_process_message_volume_created(self):
+        """Test request processMessage on sucess."""
+        message = build_list_volumes()
+        set_udf_message(message.list_volumes)
+        udf = volumes.UDFVolume.from_msg(message.list_volumes.udf)
+        self.request.processMessage(message)
+
+        message = build_list_volumes()
+        set_share_message(message.list_volumes)
+        share = volumes.ShareVolume.from_msg(message.list_volumes.share)
+        self.request.processMessage(message)
+
+        message = build_list_volumes()
+        set_root_message(message.list_volumes)
+        root = volumes.RootVolume.from_msg(message.list_volumes.root)
+        self.request.processMessage(message)
+
+        self.assertEquals(3, len(self.request.volumes),
+                          '3 volumes stored')
+        self.assertEquals([udf, share, root], self.request.volumes,
+                          'volumes stored')
+
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.VOLUMES_END
+        self.request.processMessage(message)
+
+        self.assertTrue(self.done_called, 'done() was called')
+
+    def test_start_cleanups_volumes(self):
+        """Test start() is idempotent."""
+        self.request.start()
+
+        message = build_list_volumes()
+        set_udf_message(message.list_volumes)
+        self.request.processMessage(message)
+
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.VOLUMES_END
+        self.request.processMessage(message)
+
+        self.request.start()
+        self.assertEquals([], self.request.volumes)
+
+
+class DeleteVolumeTestCase(unittest.TestCase):
+    """Test cases for DeleteVolume op."""
+
+    def setUp(self):
+        """Initialize testing protocol."""
+        self.protocol = FakedProtocol()
+        self.request = DeleteVolume(self.protocol, volume_id=VOLUME)
+        self.request.error = faked_error
+        self.done_called = False
+        self.request.done = was_called(self, 'done_called')
+
+    def tearDown(self):
+        """Clean up."""
+        self.protocol = None
+        self.request = None
+
+    def test_init(self):
+        """Test request creation."""
+        self.assertEquals(str(VOLUME), self.request.volume_id)
+
+    def test_start(self):
+        """Test request start."""
+        self.request.start()
+
+        self.assertEquals(1, len(self.request.protocol.messages))
+        actual_msg, = self.request.protocol.messages
+        self.assertEquals(protocol_pb2.Message.DELETE_VOLUME, actual_msg.type)
+        self.assertEquals(self.request.volume_id,
+                          actual_msg.delete_volume.volume)
+
+    def test_process_message_error(self):
+        """Test request processMessage on error."""
+        message = protocol_pb2.Message()
+        self.assertRaises(FakedError, self.request.processMessage, message)
+
+    def test_process_message_ok(self):
+        """Test request processMessage on sucess."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.OK
+        self.request.processMessage(message)
+
+        self.assertTrue(self.done_called, 'done() was called')
+
+
+if __name__ == '__main__':
+    unittest.main()

=== modified file 'tests/test_dircontent.py'
--- tests/test_dircontent.py	2009-08-11 16:00:00 +0000
+++ tests/test_dircontent.py	2010-02-17 23:29:10 +0000
@@ -41,17 +41,21 @@
         self.assertRaises(InvalidFilename, normalize_filename, "..")
         self.assertRaises(InvalidFilename, validate_filename, "..")
 
+    def test_valid_characters(self):
+        """Tests that all weird but valid characters are accepted."""
+        for n in range(1, 32):
+            filename = u"xy" + unichr(n) + u"zzy"
+            normalize_filename(filename)
+            validate_filename(filename)
+        for c in [u':', u';', u'*', u'?', u'\\', u'\x7f']:
+            filename = u"xy" + c + u"zzy"
+            normalize_filename(filename)
+            validate_filename(filename)
+
     def test_excluded_character(self):
         """Tests that all excluded characters are banned."""
-        for n in range(0, 32):
-            name = u"xyz" + unicode(chr(n))
-            try:
-                self.assertRaises(InvalidFilename, normalize_filename, name)
-                self.assertRaises(InvalidFilename, validate_filename, name)
-            except AssertionError, e:
-                raise AssertionError(u"%s for %s" % (unicode(e), name))
-        for c in [u':', u';', u'*', u'?', u'\\', u'/', u'\x7f']:
-            name = u"xyz" + c
+        for c in [u'/', unichr(0)]:
+            name = u"xy" + c + u"zzy"
             try:
                 self.assertRaises(InvalidFilename, normalize_filename, name)
                 self.assertRaises(InvalidFilename, validate_filename, name)

=== modified file 'tests/test_throttling.py'
--- tests/test_throttling.py	2009-12-07 17:00:00 +0000
+++ tests/test_throttling.py	2010-02-17 23:29:10 +0000
@@ -20,7 +20,7 @@
 
 from __future__ import with_statement
 
-from twisted.internet import defer, reactor
+from twisted.internet import task
 from twisted.trial.unittest import TestCase as TwistedTestCase
 
 from ubuntuone.storageprotocol import client
@@ -48,168 +48,106 @@
         self.events.append("unthW")
 
 
-class TestProducingState(TwistedTestCase):
+class BaseThrottlingTestCase(TwistedTestCase):
+    """Base test case for ThrottlingStorageClientFactory."""
+
+    def setUp(self):
+        self.client = FakeClient()
+        self.factories = []
+        self.clock = task.Clock()
+        # use task.Clock instead of the reactor for the callLater
+        self.old_callLater = client.ThrottlingStorageClientFactory.callLater
+        client.ThrottlingStorageClientFactory.callLater = self.clock.callLater
+
+    def tearDown(self):
+        for f in self.factories:
+            f.unregisterProtocol(None)
+        client.ThrottlingStorageClientFactory.callLater = self.old_callLater
+
+    def create_factory(self, read_limit, write_limit):
+        """Create a ThrottlingStorageClientFactory with the specified args."""
+        tscf = client.ThrottlingStorageClientFactory(read_limit, write_limit)
+        tscf.client = self.client
+        self.factories.append(tscf)
+        return tscf
+
+
+class TestProducingState(BaseThrottlingTestCase):
     """Test for filename validation and normalization."""
 
     timeout = 5
 
     def setUp(self):
-        self.client = FakeClient()
-        self.tscf = client.ThrottlingStorageClientFactory(3, 3)
-        self.tscf.client = self.client
-
-    def tearDown(self):
-        self.tscf.unregisterProtocol(None)
+        BaseThrottlingTestCase.setUp(self)
+        self.tscf = self.create_factory(3, 3)
 
     def test_under_write_limit(self):
         """Don't pas the write limit, no event."""
-        d = defer.Deferred()
         self.tscf.registerWritten(2)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, [])
-            d.callback(True)
-
-        reactor.callLater(.1, check)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, [])
 
     def test_under_read_limit(self):
         """Don't pas the read limit, no event."""
-        d = defer.Deferred()
         self.tscf.registerRead(2)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, [])
-            d.callback(True)
-
-        reactor.callLater(.1, check)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, [])
 
     def test_above_write_throttles(self):
         """Above the write limit, throttles."""
-        d = defer.Deferred()
         self.tscf.registerWritten(4)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW"])
-            d.callback(True)
-
-        reactor.callLater(.1, check)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, ["thW"])
 
     def test_above_read_throttles(self):
         """Above the read limit, throttles."""
-        d = defer.Deferred()
         self.tscf.registerRead(4)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR"])
-            d.callback(True)
-
-        reactor.callLater(.1, check)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, ["thR"])
 
     def test_above_write_throttles_unthrottles(self):
         """Above the write limit, throttles and unthrottles after 1s."""
-        d = defer.Deferred()
         self.tscf.registerWritten(4)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW", "unthW"])
-            d.callback(True)
-
-        reactor.callLater(1.1, check)
-        return d
+        self.clock.advance(1.1)
+        self.assertEqual(self.client.events, ["thW", "unthW"])
 
     def test_above_read_throttles_unthrottles(self):
         """Above the read limit, throttles and unthrottles after 1s."""
-        d = defer.Deferred()
         self.tscf.registerRead(4)
-
-        def check():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR", "unthR"])
-            d.callback(True)
-
-        reactor.callLater(1.1, check)
-        return d
+        self.clock.advance(1.1)
+        self.assertEqual(self.client.events, ["thR", "unthR"])
 
     def test_very_above_write_throttles_unthrottles(self):
         """A lot above the write limit, throttles and unthrottles."""
-        d = defer.Deferred()
         self.tscf.registerWritten(8)
-
-        def check1():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW"])
-            reactor.callLater(1, check2)
-
-        def check2():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW", "unthW"])
-            d.callback(True)
-
-        reactor.callLater(1.1, check1)
-        return d
+        self.clock.advance(1.1)
+        self.assertEqual(self.client.events, ["thW"])
+        self.clock.advance(1)
+        self.assertEqual(self.client.events, ["thW", "unthW"])
 
     def test_very_above_read_throttles_unthrottles(self):
         """A lot above the read limit, throttles and unthrottles."""
-        d = defer.Deferred()
         self.tscf.registerRead(8)
-
-        def check1():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR"])
-            reactor.callLater(1, check2)
-
-        def check2():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR", "unthR"])
-            d.callback(True)
-
-        reactor.callLater(1.1, check1)
-        return d
+        self.clock.advance(1.1)
+        self.assertEqual(self.client.events, ["thR"])
+        self.clock.advance(1)
+        self.assertEqual(self.client.events, ["thR", "unthR"])
 
     def test_double_write(self):
         """Two writes on a row while throttling."""
-        d = defer.Deferred()
         self.tscf.registerWritten(4)
-
-        def check1():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW"])
-            self.tscf.registerWritten(1)
-            reactor.callLater(2, check2)
-
-        def check2():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thW", "unthW"])
-            d.callback(True)
-
-        reactor.callLater(.1, check1)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, ["thW"])
+        self.tscf.registerWritten(1)
+        self.clock.advance(2)
+        self.assertEqual(self.client.events, ["thW", "unthW"])
 
     def test_double_read(self):
         """Two read on a row while throttling."""
-        d = defer.Deferred()
         self.tscf.registerRead(4)
-
-        def check1():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR"])
-            self.tscf.registerWritten(1)
-            reactor.callLater(2, check2)
-
-        def check2():
-            """Check for the correct events."""
-            self.assertEqual(self.client.events, ["thR", "unthR"])
-            d.callback(True)
-
-        reactor.callLater(.1, check1)
-        return d
+        self.clock.advance(.1)
+        self.assertEqual(self.client.events, ["thR"])
+        self.tscf.registerWritten(1)
+        self.clock.advance(2)
+        self.assertEqual(self.client.events, ["thR", "unthR"])
 

=== added file 'tests/test_volumes.py'
--- tests/test_volumes.py	1970-01-01 00:00:00 +0000
+++ tests/test_volumes.py	2010-02-17 23:29:10 +0000
@@ -0,0 +1,164 @@
+# coding=utf-8
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright (C) 2009 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for volume data type."""
+
+import unittest
+import uuid
+
+from copy import copy
+
+from ubuntuone.storageprotocol import protocol_pb2, volumes
+
+PATH = u'~/Documents/pdfs/moño/'
+NAME = u'What a beatiful volume'
+VOLUME = uuid.UUID('12345678-1234-1234-1234-123456789abc')
+NODE = uuid.UUID('FEDCBA98-7654-3211-2345-6789ABCDEF12')
+USER = u'dude'
+
+class VolumeTestCase(unittest.TestCase):
+    """Check Volume data type."""
+
+    volume_class = volumes.Volume
+    kwargs = dict(volume_id=VOLUME, node_id=NODE)
+
+    def setUp(self):
+        """Initialize testing volume."""
+        self.volume = self.volume_class(**self.kwargs)
+
+    def tearDown(self):
+        """Clean up."""
+        self.volume = None
+
+    def assert_correct_attributes(self):
+        """Assert over attribute correctness."""
+        self.assertEquals(VOLUME, self.volume.volume_id)
+        self.assertEquals(NODE, self.volume.node_id)
+
+    def test_creation(self):
+        """Test creation."""
+        self.assert_correct_attributes()
+
+    def test_is_a_volume(self):
+        """Test class inheritance."""
+        self.assertTrue(isinstance(self.volume, volumes.Volume))
+
+
+    def test_from_params(self):
+        """Test creation using from_params."""
+        self.volume = self.volume_class.from_params(**self.kwargs)
+        self.assert_correct_attributes()
+
+    def test_from_msg(self):
+        """Test creation using from_msg."""
+        self.assertRaises(NotImplementedError, self.volume_class.from_msg, None)
+
+    def test_is_equal(self):
+        """Test object equality."""
+        other = copy(self.volume)
+        self.assertEquals(other, self.volume)
+
+        for attr, value in self.kwargs.iteritems():
+            setattr(other, attr, None)
+            self.assertNotEquals(other, self.volume,
+                                 'not equal when %s differ' % attr)
+            setattr(other, attr, value)
+
+        self.assertEquals(other, self.volume)
+
+
+class ShareTestCase(VolumeTestCase):
+    """Check Share data type."""
+
+    # pylint: disable-msg=W0212
+    to_me = volumes._direction_prot2nice[protocol_pb2.Shares.TO_ME]
+    only_view = volumes._access_prot2nice[protocol_pb2.Shares.VIEW]
+
+    volume_class = volumes.ShareVolume
+    kwargs = dict(volume_id=VOLUME, node_id=NODE,
+                  direction=to_me,
+                  share_name=NAME, other_username=USER,
+                  other_visible_name=USER, accepted=False,
+                  access_level=only_view)
+
+    def assert_correct_attributes(self):
+        """Assert over attribute correctness."""
+        super(ShareTestCase, self).assert_correct_attributes()
+        self.assertEquals(self.to_me, self.volume.direction)
+        self.assertEquals(NAME, self.volume.share_name)
+        self.assertEquals(USER, self.volume.other_username)
+        self.assertEquals(USER, self.volume.other_visible_name)
+        self.assertEquals(False, self.volume.accepted)
+        self.assertEquals(self.only_view, self.volume.access_level)
+
+    def test_from_msg(self):
+        """Test creation using from_msg."""
+        message = protocol_pb2.Shares()
+        # pylint: disable-msg=W0201
+        message.share_id = str(VOLUME)
+        message.subtree = str(NODE)
+        message.share_name = NAME
+        message.other_username = USER
+        message.other_visible_name = USER
+        self.volume = self.volume_class.from_msg(message)
+        self.assert_correct_attributes()
+
+
+class UDFTestCase(VolumeTestCase):
+    """Check UDF data type."""
+
+    volume_class = volumes.UDFVolume
+    kwargs = dict(volume_id=VOLUME, node_id=NODE, suggested_path=PATH)
+
+    def assert_correct_attributes(self):
+        """Assert over attribute correctness."""
+        super(UDFTestCase, self).assert_correct_attributes()
+        self.assertEquals(PATH, self.volume.suggested_path)
+
+    def test_from_msg(self):
+        """Test creation using from_msg."""
+        message = protocol_pb2.UDFs()
+        # pylint: disable-msg=W0201
+        message.volume = str(VOLUME)
+        message.node = str(NODE)
+        message.suggested_path = PATH
+        self.volume = self.volume_class.from_msg(message)
+        self.assert_correct_attributes()
+
+
+class RootTestCase(VolumeTestCase):
+    """Check Root data type."""
+
+    volume_class = volumes.RootVolume
+    kwargs = dict(node_id=NODE)
+
+    def assert_correct_attributes(self):
+        """Assert over attribute correctness."""
+        self.assertEquals(None, self.volume.volume_id)
+        self.assertEquals(NODE, self.volume.node_id)
+
+    def test_from_msg(self):
+        """Test creation using from_msg."""
+        message = protocol_pb2.Root()
+        # pylint: disable-msg=W0201
+        message.node = str(NODE)
+        self.volume = self.volume_class.from_msg(message)
+        self.assert_correct_attributes()
+
+
+if __name__ == '__main__':
+    unittest.main()

=== modified file 'ubuntuone/storageprotocol/client.py'
--- ubuntuone/storageprotocol/client.py	2009-12-07 17:00:00 +0000
+++ ubuntuone/storageprotocol/client.py	2010-02-17 23:29:10 +0000
@@ -1,6 +1,7 @@
 # ubuntuone.storageprotocol.client - the storage protocol client
 #
 # Author: Lucio Torre <[e-mail]>
+# Author: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2009 Canonical Ltd.
 #
@@ -15,28 +16,27 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""
-The storage protocol client.
-
-"""
-from twisted.internet.protocol import ClientFactory
-from twisted.internet import reactor, defer
-from twisted.python import log
-
+"""The storage protocol client."""
+
+import logging
 import uuid
+
 from functools import partial
 from itertools import chain
-import logging
 from oauth import oauth
-from ubuntuone.storageprotocol import protocol_pb2
-from ubuntuone.storageprotocol import request
-from ubuntuone.storageprotocol import sharersp
-
+
+from twisted.internet.protocol import ClientFactory
+from twisted.internet import reactor, defer
+from twisted.python import log
+
+from ubuntuone.storageprotocol import (
+    protocol_pb2, request, sharersp, volumes
+)
 
 log_debug = partial(log.msg, loglevel=logging.DEBUG)
 
 class StorageClient(request.RequestHandler):
-    """ A Basic Storage Protocol client."""
+    """A Basic Storage Protocol client."""
 
     # we are a client, we do odd requests
     REQUEST_ID_START = 1
@@ -46,28 +46,34 @@
         request.RequestHandler.__init__(self)
         self.root_id = None
         self.root_id_defers = []
+
         self._node_state_callback = None
         self._share_change_callback = None
         self._share_answer_callback = None
         self._free_space_callback = None
         self._account_info_callback = None
+        self._volume_created_callback = None
+        self._volume_deleted_callback = None
+
         self.line_mode = True
 
     def protocol_version(self):
-        """ask for the protocol version
+        """Ask for the protocol version
 
         will return a deferred that will get called with
-        the request object when completed
+        the request object when completed.
+
         """
         p = ProtocolVersion(self)
         p.start()
         return p.deferred
 
     def dataReceived(self, data):
-        """extends dataReceived.
-
-        this method first reads the protocol hello line then switches back to
-        len+data."""
+        """Extend dataReceived.
+
+        First reads the protocol hello line then switch back to len+data.
+
+        """
         if self.line_mode:
             # first read the hello line, then back to binary.
             try:
@@ -82,8 +88,9 @@
     def dummy_authenticate(self, credentials):
         """Authenticate to a server using the 'dummy auth' provider.
 
-        Returns a deferred that will get called with the request
+        Return a deferred that will get called with the request
         object when completed.
+
         """
         p = Authenticate(self, {'dummy_token': credentials})
         p.start()
@@ -97,8 +104,9 @@
         @param token: a previously acquired OAuth access token.
         @type consumer: `oauth.OAuthToken`
 
-        Returns a deferred that will get called with the request
+        Return a deferred that will get called with the request
         object when completed.
+
         """
         request = oauth.OAuthRequest.from_consumer_and_token(
             oauth_consumer=consumer,
@@ -116,9 +124,10 @@
         return p.deferred
 
     def handle_ROOT(self, message):
-        """handle incoming ROOT message
-
-        will notify if someone is waiting for this information
+        """Handle incoming ROOT message.
+
+        Will notify if someone is waiting for this information.
+
         """
         self.root_id = message.root.node
         if self.root_id_defers:
@@ -127,40 +136,66 @@
             self.root_id_defers = []
 
     def handle_NODE_STATE(self, message):
-        """handle incoming NODE_STATE"""
+        """Handle incoming NODE_STATE."""
         self.notify_node_state(message.node_state)
 
     def handle_NOTIFY_SHARE(self, message):
-        """handle incoming NOTIFY_SHARE"""
+        """Handle incoming NOTIFY_SHARE."""
         self.notify_share_change(message)
 
     def handle_SHARE_DELETED(self, message):
-        """handle incoming SHARE_DELETED"""
+        """Handle incoming SHARE_DELETED."""
         self.notify_share_change(message)
 
     def handle_SHARE_ACCEPTED(self, message):
-        """handle incoming SHARE_ACCEPTED"""
+        """Handle incoming SHARE_ACCEPTED."""
         self.notify_share_answer(message.share_accepted)
 
+    def handle_VOLUME_CREATED(self, message):
+        """Handle incoming VOLUME_CREATED"""
+        assert message.type == protocol_pb2.Message.VOLUME_CREATED
+        msg = message.volume_created
+        vol = None
+        if self._volume_created_callback is not None:
+            if msg.type == protocol_pb2.Volumes.ROOT:
+                vol = volumes.RootVolume.from_msg(msg.root)
+            elif msg.type == protocol_pb2.Volumes.SHARE:
+                vol = volumes.ShareVolume.from_msg(msg.share)
+            elif msg.type == protocol_pb2.Volumes.UDF:
+                vol = volumes.UDFVolume.from_msg(msg.udf)
+            else:
+                raise TypeError("Message.volume_created's type is not valid: %s" %
+                                message.volume_created.type)
+
+            self._volume_created_callback(vol)
+
+    def handle_VOLUME_DELETED(self, message):
+        """Handle incoming VOLUME_DELETED."""
+        assert message.type == protocol_pb2.Message.VOLUME_DELETED
+        if self._volume_deleted_callback is not None:
+            vol_id = uuid.UUID(message.volume_deleted.volume)
+            self._volume_deleted_callback(vol_id)
+
     def handle_BEGIN_CONTENT(self, message):
-        """Accepts and discards a misplaced BEGIN_CONTENT.
+        """Accept and discard a misplaced BEGIN_CONTENT.
 
         It can happen that while the server receives a PUT_CONTENT request
         and that it tells us to BEGIN_CONTENT, we cancelled the request,
         received the OK, and this side's request is gone, so receive this
         message here.
+
         """
 
     def handle_FREE_SPACE_INFO(self, message):
-        """handle unsolicited FREE_SPACE_INFO"""
+        """Handle unsolicited FREE_SPACE_INFO."""
         self.notify_free_space(message.free_space_info)
 
     def handle_ACCOUNT_INFO(self, message):
-        """handle unsolicited ACCOUNT_INFO"""
+        """Handle unsolicited ACCOUNT_INFO."""
         self.notify_account_info(message.account_info)
 
     def get_root(self):
-        """get the root id through a deferred"""
+        """Get the root id through a deferred."""
         if self.root_id is not None:
             return defer.succeed(self.root_id)
         else:
@@ -169,43 +204,44 @@
             return d
 
     def make_dir(self, share, parent, name):
-        """ create a directory named name on the node parent
-
-        the new node id will be on request.new_dir_id
+        """Create a directory named name on the node parent
+
+        the new node id will be on request.new_dir_id.
+
         """
         p = MakeDir(self, share, parent, name)
         p.start()
         return p.deferred
 
     def make_file(self, share, parent, name):
-        """ create a file named name on the node parent
-
-        the new node id will be on request.new_file_id
+        """Create a file named name on the node parent
+
+        the new node id will be on request.new_file_id.
+
         """
         p = MakeFile(self, share, parent, name)
         p.start()
         return p.deferred
 
     def move(self, share, node, new_parent, new_name):
-        """ move a node
-        """
+        """Move a node."""
         p = Move(self, share, node, new_parent, new_name)
         p.start()
         return p.deferred
 
     def unlink(self, share, node):
-        """ unlink a node
-        """
+        """Unlink a node."""
         p = Unlink(self, share, node)
         p.start()
         return p.deferred
 
     def get_content(self, share, node, hash, offset=0,
                     callback=None, node_attr_callback=None):
-        """ get the content of node with hash
+        """Get the content of node with hash
 
         the content will be on request.content
-        or callback will be called for every piece that arrives
+        or callback will be called for every piece that arrives.
+
         """
         req = self.get_content_request(share, node, hash, offset,
                                        callback, node_attr_callback)
@@ -213,10 +249,11 @@
 
     def get_content_request(self, share, node, hash, offset=0,
                             callback=None, node_attr_callback=None):
-        """ get the content of node with hash, returns the request
-
-        the content will be on request.content
-        or callback will be called for every piece that arrives
+        """Get the content of node with hash, return the request.
+
+        The content will be on request.content, or callback will be
+        called for every piece that arrives.
+
         """
         p = GetContent(self, share, node, hash, offset,
                                         callback, node_attr_callback)
@@ -225,33 +262,31 @@
 
     def put_content(self, share, node, previous_hash, hash,
                     crc32, size, deflated_size, fd):
-        """ put the content of fd into file node
-        """
+        """Put the content of fd into file node."""
         req = self.put_content_request(share, node, previous_hash,
                                        hash, crc32, size, deflated_size, fd)
         return req.deferred
 
     def put_content_request(self, share, node, previous_hash, hash,
                             crc32, size, deflated_size, fd):
-        """ put the content of fd into file node, return the request
-        """
+        """Put the content of fd into file node, return the request."""
         p = PutContent(self, share, node, previous_hash, hash, crc32, size,
                                                             deflated_size, fd)
         p.start()
         return p
 
     def query(self, items):
-        """ get the current hash for items if changed
-
-        items is a list of (node, hash) tuples
+        """Get the current hash for items if changed
+
+        items is a list of (node, hash) tuples.
+
         """
         r = MultiQuery(self, items)
         r.start()
         return r.deferred
 
     def get_free_space(self, share_id):
-        """Get quota information for the given share (or the user's own
-        space)."""
+        """Get quota info for the given share (or the user's own space)."""
         r = FreeSpaceInquiry(self, share_id)
         r.start()
         return r.deferred
@@ -263,9 +298,10 @@
         return r.deferred
 
     def set_node_state_callback(self, callback):
-        """define the function to be called when a node_state message arrives
-
-        the function will be called with the message as argument
+        """Define the function to be called when a node_state message arrives
+
+        The function will be called with the message as argument.
+
         """
         self._node_state_callback = callback
 
@@ -281,8 +317,9 @@
                                       node_state.hash)
 
     def set_free_space_callback(self, callback):
-        """Sets the quota notification callback, which will be called
-        with the share id and free bytes.
+        """Set the quota notification callback.
+
+        It will be called with the share id and free bytes.
 
         """
         self._free_space_callback = callback
@@ -299,8 +336,10 @@
                                       free_space_info.free_bytes)
 
     def set_account_info_callback(self, callback):
-        """Sets the account info notification callback; the callback
-        will be passed a raw AccountInfo structure when it is called."""
+        """Set the account info notification callback; the callback
+        will be passed a raw AccountInfo structure when it is called.
+
+        """
         self._account_info_callback = callback
 
     def notify_account_info(self, account_info):
@@ -309,9 +348,7 @@
             self._account_info_callback(account_info)
 
     def set_share_change_callback(self, callback):
-        """Define the function to be called when something changed regarding
-        a share.
-        """
+        """Set the callback when something changed regarding a share."""
         self._share_change_callback = callback
 
     def notify_share_change(self, msg):
@@ -319,6 +356,7 @@
         notify info.
 
         @param msg: - a (raw) NotifyShare message
+
         """
         if not self._share_change_callback:
             return
@@ -340,6 +378,7 @@
         """Call the current share answer callback, if any, with the info.
 
         @param msg: - a (raw) ShareAccepted message
+
         """
         if self._share_answer_callback:
             if msg.answer == protocol_pb2.ShareAccepted.YES:
@@ -350,8 +389,22 @@
                 raise ValueError("Not supported ShareAccepted answer")
             self._share_answer_callback(uuid.UUID(msg.share_id), answer)
 
+    def set_volume_created_callback(self, callback):
+        """Set the callback for volume creation notification."""
+        if callable(callback):
+            self._volume_created_callback = callback
+        else:
+            raise TypeError('callback for volume_created must be callable')
+
+    def set_volume_deleted_callback(self, callback):
+        """Set the callback for volume deletion notification."""
+        if callable(callback):
+            self._volume_deleted_callback = callback
+        else:
+            raise TypeError('callback for volume_deleted must be callable')
+
     def create_share(self, node, share_to, name, access_level):
-        """Creates a share to other user.
+        """Create a share to other user.
 
         node: which node to share.
         share_to: the id of the receiving user.
@@ -360,25 +413,28 @@
 
         There's no need to indicate where the node lives, as it only can be
         in own root (there's no re-sharing).
+
         """
         r = CreateShare(self, node, share_to, name, access_level)
         r.start()
         return r.deferred
 
     def delete_share(self, share_id):
-        """Deletes a share we have offered.
+        """Delete a share we have offered.
 
         @param share_id: the id of the share to delete
+
         """
         r = DeleteShare(self, share_id)
         r.start()
         return r.deferred
 
     def accept_share(self, share_id, answer):
-        """Accepts (or not) a share from other user.
+        """Accept (or not) a share from other user.
 
         share_id: the share id
         answer: if it was accepted ("Yes") or not ("No")
+
         """
         r = AcceptShare(self, share_id, answer)
         r.start()
@@ -389,16 +445,52 @@
 
         This includes the shares the user created, and those that were
         shared to her.
+
         """
         p = ListShares(self)
         p.start()
         return p.deferred
 
+    def create_udf(self, path, name):
+        """Create a User Defined Folder.
+
+        @param path: the path in disk to the UDF.
+        @param name: the name of the UDF.
+
+        """
+        p = CreateUDF(self, path, name)
+        p.start()
+        return p.deferred
+
+    def list_volumes(self):
+        """List all the volumes the user has.
+
+        This includes the volumes:
+            - all the user's UDFs.
+            - all the shares the user has accepted.
+            - the root-root volume.
+
+        """
+        p = ListVolumes(self)
+        p.start()
+        return p.deferred
+
+    def delete_volume(self, volume_id):
+        """Delete 'volume' on the server, removing the associated tree.
+
+        @param volume: the id of the volume to delete.
+
+        """
+        p = DeleteVolume(self, volume_id)
+        p.start()
+        return p.deferred
+
     def query_caps(self, caps):
         """Query the server to discover its capabilitis.
 
         The server should answer if it supports or not all the given
         caps.
+
         """
         r = QuerySetCaps(self, caps)
         r.start()
@@ -412,14 +504,15 @@
 
 
 class GetContent(request.Request):
-    """A Request to get the content of a node id
+    """A Request to get the content of a node id.
 
     @ivar data: the content of the node (available upon success)
+
     """
 
     def __init__(self, protocol, share, node_id, hash,
                  offset=0, callback=None, node_attr_callback=None):
-        """ request the content of node with hash
+        """Request the content of node with hash.
 
         @param protocol: the request handler
         @param share: the share node or root
@@ -439,7 +532,7 @@
         self.parts = []
 
     def _start(self):
-        "send GET_CONTENT"
+        """Send GET_CONTENT."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.GET_CONTENT
         message.get_content.node = str(self.node_id)
@@ -449,8 +542,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """process messages
-        """
+        """Process messages."""
         # pylint: disable-msg=W0201
         if message.type == protocol_pb2.Message.NODE_ATTR:
             if self.node_attr_callback is not None:
@@ -486,20 +578,22 @@
             self.error(request.StorageProtocolProtocolError(message))
 
     def _cancel(self):
-        """Cancels the current download."""
+        """Cancel the current download."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.CANCEL_REQUEST
         self.sendMessage(message)
 
+
 class ListShares(request.Request):
     """List all the shares the user is involved.
 
     This includes the shares the user created, and those that were
     shared to her.
+
     """
 
     def _start(self):
-        '''Sends the LIST_SHARES message to the server.'''
+        """Send the LIST_SHARES message to the server."""
         # pylint: disable-msg=W0201
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.LIST_SHARES
@@ -507,7 +601,7 @@
         self.shares = []
 
     def processMessage(self, message):
-        '''Process the answer from the server.'''
+        """Process the answer from the server."""
         if message.type == protocol_pb2.Message.SHARES_INFO:
             share = sharersp.ShareResponse.load_from_msg(message.shares)
             self.shares.append(share)
@@ -516,8 +610,9 @@
         else:
             self.error(request.StorageRequestError(self, message))
 
+
 class CreateShare(request.Request):
-    """Creates a share."""
+    """Create a share."""
 
     # these are the valid access levels and their translation to the
     # protocol message
@@ -527,7 +622,7 @@
     }
 
     def __init__(self, protocol, node_id, share_to, name, access_level):
-        """Creates a share.
+        """Create a share.
 
         @param node_id: which node will be root to share.
         @param share_to: the id of the receiving user.
@@ -543,7 +638,7 @@
         self.share_id = None
 
     def _start(self):
-        '''Sends the CREATE_SHARE message to the server.'''
+        """Send the CREATE_SHARE message to the server."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.CREATE_SHARE
         message.create_share.node = self.node
@@ -562,7 +657,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        '''Process the answer from the server.'''
+        """Process the answer from the server."""
         if message.type == protocol_pb2.Message.SHARE_CREATED:
             self.share_id = message.share_created.share_id
             self.done()
@@ -574,7 +669,7 @@
 
 
 class AcceptShare(request.Request):
-    """Acceptss a share (or not)."""
+    """Accept a share (or not)."""
 
     # these are the valid answers and their translation to the
     # protocol message
@@ -584,17 +679,18 @@
     }
 
     def __init__(self, protocol, share_id, answer):
-        """Accepts (or not) a share from other user.
+        """Accept (or not) a share from other user.
 
         @param share_id: the share id
         @param answer: if it was accepted ("Yes") or not ("No")
+
         """
         request.Request.__init__(self, protocol)
         self.share_id = share_id
         self.answer = answer
 
     def _start(self):
-        '''Sends the SHARE_ACCEPTED message to the server.'''
+        """Send the SHARE_ACCEPTED message to the server."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.SHARE_ACCEPTED
         message.share_accepted.share_id = str(self.share_id)
@@ -610,7 +706,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        '''Process the answer from the server.'''
+        """Process the answer from the server."""
         if message.type == protocol_pb2.Message.OK:
             self.done()
         else:
@@ -618,18 +714,19 @@
 
 
 class DeleteShare(request.Request):
-    """Deletes a share."""
+    """Delete a share."""
 
     def __init__(self, protocol, share_id):
-        """Deletes a share we had offered to someone else.
+        """Delete a share we had offered to someone else.
 
         @param share_id: the share id
+
         """
         request.Request.__init__(self, protocol)
         self.share_id = share_id
 
     def _start(self):
-        """Sends the DELETE_SHARE message to the server."""
+        """Send the DELETE_SHARE message to the server."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.DELETE_SHARE
         message.delete_share.share_id = str(self.share_id)
@@ -644,13 +741,117 @@
             self.error(request.StorageRequestError(self, message))
 
 
+class CreateUDF(request.Request):
+    """Create a UDF."""
+
+    def __init__(self, protocol, path, name):
+        """Create a UDF.
+
+        @param path: which node will be root to be UDF.
+        @param name: the name of the UDF
+
+        """
+        request.Request.__init__(self, protocol)
+        self.path = path
+        self.name = name
+        self.volume_id = None
+        self.node_id = None
+
+    def _start(self):
+        """Send the CREATE_UDF message to the server."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.CREATE_UDF
+        message.create_udf.path = self.path
+        message.create_udf.name = self.name
+        self.sendMessage(message)
+
+    def processMessage(self, message):
+        """Process the answer from the server."""
+        if (message.type == protocol_pb2.Message.VOLUME_CREATED and
+            message.volume_created.type == protocol_pb2.Volumes.UDF):
+            self.volume_id = message.volume_created.udf.volume
+            self.node_id = message.volume_created.udf.node
+            self.done()
+        else:
+            self.error(request.StorageRequestError(self, message))
+
+
+class ListVolumes(request.Request):
+    """List all the volumes the user has.
+
+    Including:
+        - the UDFs the user created.
+        - the shares the user has accepted.
+        - the user's root-root.
+
+    """
+
+    def __init__(self, protocol):
+        """List volumes."""
+        request.Request.__init__(self, protocol)
+        self.volumes = []
+
+    def _start(self):
+        """Send the LIST_VOLUMES message to the server."""
+        self.volumes = []
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.LIST_VOLUMES
+        self.sendMessage(message)
+
+    def processMessage(self, message):
+        """Process the answer from the server."""
+        if message.type == protocol_pb2.Message.VOLUMES_INFO:
+            if message.list_volumes.type == protocol_pb2.Volumes.SHARE:
+                vol = volumes.ShareVolume.from_msg(message.list_volumes.share)
+                self.volumes.append(vol)
+            elif message.list_volumes.type == protocol_pb2.Volumes.UDF:
+                vol = volumes.UDFVolume.from_msg(message.list_volumes.udf)
+                self.volumes.append(vol)
+            elif message.list_volumes.type == protocol_pb2.Volumes.ROOT:
+                vol = volumes.RootVolume.from_msg(message.list_volumes.root)
+                self.volumes.append(vol)
+            else:
+                self.error(request.StorageRequestError(self, message))
+        elif message.type == protocol_pb2.Message.VOLUMES_END:
+            self.done()
+        else:
+            self.error(request.StorageRequestError(self, message))
+
+
+class DeleteVolume(request.Request):
+    """Delete a volume."""
+
+    def __init__(self, protocol, volume_id):
+        """Delete a volume.
+
+        @param volume_id: the volume id
+
+        """
+        request.Request.__init__(self, protocol)
+        self.volume_id = str(volume_id)
+
+    def _start(self):
+        """Send the DELETE_VOLUME message to the server."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.DELETE_VOLUME
+        message.delete_volume.volume = self.volume_id
+
+        self.sendMessage(message)
+
+    def processMessage(self, message):
+        """Process the answer from the server."""
+        if message.type == protocol_pb2.Message.OK:
+            self.done()
+        else:
+            self.error(request.StorageRequestError(self, message))
+
+
 class Unlink(request.Request):
-    """ unlink a node
-    """
+    """Unlink a node."""
     # pylint: disable-msg=C0111
 
     def __init__(self, protocol, share, node_id):
-        """ request that node_id be unlinked
+        """Request that node_id be unlinked
 
         @param protocol: the request handler
         @param share: the share node or root
@@ -677,10 +878,10 @@
 
 
 class Move(request.Request):
-    """ move a node
-    """
+    """Move a node."""
+
     def __init__(self, protocol, share, node_id, new_parent_id, new_name):
-        """create the move request
+        """Create the move request
 
         @param protocol: the request handler
         @param share: the share node or root
@@ -697,7 +898,7 @@
         self.new_name = new_name
 
     def _start(self):
-        """send MOVE"""
+        """Send MOVE."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.MOVE
         message.move.share = self.share
@@ -708,7 +909,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """process messages"""
+        """Process messages."""
         if message.type == protocol_pb2.Message.OK:
             self.done()
         else:
@@ -718,16 +919,19 @@
             self.error(request.StorageRequestError(self, message))
 
 class MultiQuery(object):
-    """Creates a Request-like object that encapsulates many Query requests
-
-    we may need to split this request into many Query rests if the list of items
-    to query is to big to fit in one message
+    """Create a Request-like object that encapsulates many Query requests
+
+    We may need to split this request into many Query rests if the list of
+    items to query is to big to fit in one message.
+
     """
+
     def __init__(self, protocol, items):
-        """ create a multiquery
+        """Create a multiquery.
 
         @param protocol: the request handler
         @param items: a list of (node, hash) tuples
+
         """
         items = iter(items)
         defers = []
@@ -745,27 +949,28 @@
         self.deferred = defer.DeferredList(defers, consumeErrors=True)
 
     def start(self):
-        """start the queries"""
+        """Start the queries."""
         for q in self.queries:
             q.start()
 
 class Query(request.Request):
-    """query about the hash of a node_id
+    """Query about the hash of a node_id.
 
     @ivar remains: the items that could not fit in the query
     @ivar response: the node state messages that were received
+
     """
 
     def __init__(self, protocol, items):
-        """ generates a query message to send to the server
+        """Generate a query message to send to the server.
 
-        puts as much items as it can inside the message
-        whats left is left in self.remainder
+        Put as much items as it can inside the message whats left is
+        left in self.remainder.
 
         @param protocol: the request handler
         @param items: a list of (node, hash, share) tuples
+
         """
-
         request.Request.__init__(self, protocol)
         self.query_message = qm = protocol_pb2.Message()
         qm.id = 0 # just to have something in the field when calculating size
@@ -775,7 +980,7 @@
         items_that_fit = []
 
         def add_items(msg, *args):
-            """add items to query"""
+            """Add items to query."""
             for share, node, hash in args:
                 qi = msg.query.add()
                 qi.share = share
@@ -794,11 +999,11 @@
             add_items(qm, *items_that_fit)
 
     def _start(self):
-        """send QUERY"""
+        """Send QUERY."""
         self.sendMessage(self.query_message)
 
     def processMessage(self, message):
-        """handle messages"""
+        """Handle messages."""
         if message.type == protocol_pb2.Message.NODE_STATE:
             self.response.append(message.node_state)
             self.protocol.notify_node_state(message.node_state)
@@ -838,8 +1043,9 @@
     def go(self):
         """While producing, generates data.
 
-        Reads a little from the file, generates a BYTES message, and pass the
-        control to the reactor.  If no more data, it finishes with EOF.
+        Read a little from the file, generates a BYTES message, and pass the
+        control to the reactor.  If no more data, finish with EOF.
+
         """
         if not self.producing or self.request.cancelled or self.finished:
             return
@@ -864,11 +1070,12 @@
 
 
 class PutContent(request.Request):
-    """PUT content request"""
+    """Put content request."""
+
     def __init__(self, protocol, share, node_id,
                  previous_hash, hash, crc32, size,
                  deflated_size, fd):
-        """ put content into a node
+        """Put content into a node.
 
         @param protocol: the request handler
         @param share: the share node or root
@@ -891,7 +1098,7 @@
         self.fd = fd
 
     def _start(self):
-        """send PUT_CONTENT"""
+        """Send PUT_CONTENT."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.PUT_CONTENT
         message.put_content.share = self.share
@@ -904,7 +1111,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """handle messages"""
+        """Handle messages."""
         if message.type == protocol_pb2.Message.BEGIN_CONTENT:
             message_producer = BytesMessageProducer(
                 self, self.fd, message.begin_content.offset)
@@ -917,7 +1124,7 @@
             self.error(request.StorageRequestError(self, message))
 
     def _cancel(self):
-        """Cancels the current upload."""
+        """Cancel the current upload."""
         if self.producer is not None:
             self.producer.stopProducing()
         message = protocol_pb2.Message()
@@ -926,10 +1133,10 @@
 
 
 class MakeObject(request.Request):
-    """ Handles the creation of new objects
+    """Handle the creation of new objects.
 
-    on completion it will have the attribute 'new_id' with the
-    node id of the created object
+    On completion it will have the attribute 'new_id' with the
+    node id of the created object.
 
     @cvar create_message: must be overridden with the correct creation message
         to send
@@ -939,10 +1146,11 @@
     @ivar new_id: the id of the node that was created (available upon success)
     @ivar new_parent_id: the parent id the node now exists under
     @ivar new_name: the name the node now exists under
+
     """
 
     def __init__(self, protocol, share, parent_id, name):
-        """ create a node
+        """Create a node.
 
         @param protocol: the request handler
         @param share: the share node or root
@@ -956,7 +1164,7 @@
         self.name = name
 
     def _start(self):
-        """send $MAKE message"""
+        """Send MAKE message."""
         message = protocol_pb2.Message()
         message.type = self.create_message
 
@@ -966,7 +1174,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """handle messages"""
+        """Handle messages."""
         # pylint: disable-msg=W0201
         if message.type == self.create_response:
             self.new_id = message.new.node
@@ -977,36 +1185,39 @@
             self.error(request.StorageRequestError(self, message))
 
 class MakeDir(MakeObject):
-    """Extends MakeObject to make directories"""
+    """Extend MakeObject to make directories."""
+
     create_message = protocol_pb2.Message.MAKE_DIR
     create_response = protocol_pb2.Message.NEW_DIR
 
 
 class MakeFile(MakeObject):
-    """Extends MakeObject to make files"""
+    """Extend MakeObject to make files."""
+
     create_message = protocol_pb2.Message.MAKE_FILE
     create_response = protocol_pb2.Message.NEW_FILE
 
 
 class ProtocolVersion(request.Request):
-    """ Handles the protocol version query
+    """Handle the protocol version query.
 
     when completed will contain the servers protocol version
     on `other_protocol_version`
 
     @ivar other_protocol_version: the other peer's protocol version (available
         upon success)
+
     """
 
     def _start(self):
-        """send PROTOCOL_VERSION"""
+        """Send PROTOCOL_VERSION."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.PROTOCOL_VERSION
         message.protocol.version = self.protocol.PROTOCOL_VERSION
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """handle messages"""
+        """Handle messages."""
         # pylint: disable-msg=W0201
         if message.type == protocol_pb2.Message.PROTOCOL_VERSION:
             self.other_protocol_version = message.protocol.version
@@ -1015,20 +1226,20 @@
             self.error(request.StorageRequestError(self, message))
 
 class Authenticate(request.Request):
-    """ Request to authenticate the user
-    """
+    """Request to authenticate the user."""
 
     def __init__(self, protocol, auth_parameters):
-        """create an authentication request
+        """Create an authentication request.
 
         @param protocol: the request handler
         @param auth_parameters: a dictionary of authentication parameters.
+
         """
         request.Request.__init__(self, protocol)
         self.auth_parameters = auth_parameters
 
     def _start(self):
-        """send AUTH_REQUEST"""
+        """Send AUTH_REQUEST."""
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.AUTH_REQUEST
         for key, value in self.auth_parameters.items():
@@ -1038,7 +1249,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """handle messages"""
+        """Handle messages."""
         if message.type == protocol_pb2.Message.AUTH_AUTHENTICATED:
             self.done()
         elif message.type == protocol_pb2.Message.ERROR:
@@ -1050,13 +1261,14 @@
 
 
 class QuerySetCaps(request.Request):
-    """Queries or Sets the server to use capabilities."""
+    """Query or Set the server to use capabilities."""
 
     def __init__(self, protocol, caps, set_mode=False):
-        """Generates a query_caps or set_caps message to send to the server.
+        """Generate a query_caps or set_caps message to send to the server.
 
         @param protocol: the request handler
         @param caps: a list of capabilities to ask for or to set
+
         """
         request.Request.__init__(self, protocol)
         self.caps = caps
@@ -1067,7 +1279,7 @@
         self.set_mode = set_mode
 
     def _start(self):
-        """Send QUERY_CAPS or SET_CAPS"""
+        """Send QUERY_CAPS or SET_CAPS."""
         message = protocol_pb2.Message()
         if self.set_mode:
             message.type = protocol_pb2.Message.SET_CAPS
@@ -1083,7 +1295,7 @@
         self.sendMessage(message)
 
     def processMessage(self, message):
-        """Handle the message"""
+        """Handle the message."""
         if message.type == protocol_pb2.Message.ACCEPT_CAPS:
             self.accepted = message.accept_caps.accepted
             self.redirect_hostname = message.accept_caps.redirect_hostname
@@ -1098,12 +1310,12 @@
     """Query available space."""
 
     def __init__(self, protocol, share_id):
-        '''Initializes the request.'''
+        """Initialize the request."""
         request.Request.__init__(self, protocol)
         self.share_id = share_id
 
     def _start(self):
-        '''Sends the FREE_SPACE_INQUIRY message to the server.'''
+        """Send the FREE_SPACE_INQUIRY message to the server."""
         # pylint: disable-msg=W0201
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.FREE_SPACE_INQUIRY
@@ -1112,7 +1324,7 @@
         self.free_bytes = None
 
     def processMessage(self, message):
-        '''Process the answer from the server.'''
+        """Process the answer from the server."""
         if message.type == protocol_pb2.Message.FREE_SPACE_INFO:
             self.free_bytes = message.free_space_info.free_bytes
             self.done()
@@ -1124,7 +1336,7 @@
     """Query account information."""
 
     def _start(self):
-        '''Sends the FREE_SPACE_INQUIRY message to the server.'''
+        """Send the FREE_SPACE_INQUIRY message to the server."""
         # pylint: disable-msg=W0201
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.ACCOUNT_INQUIRY
@@ -1132,7 +1344,7 @@
         self.purchased_bytes = None
 
     def processMessage(self, message):
-        '''Process the answer from the server.'''
+        """Process the answer from the server."""
         if message.type == protocol_pb2.Message.ACCOUNT_INFO:
             self.purchased_bytes = message.account_info.purchased_bytes
             self.done()
@@ -1141,19 +1353,18 @@
 
 
 class ThrottlingStorageClient(StorageClient):
-    """
-    This is the throttling version of the StorageClient protocol.
-    """
+    """The throttling version of the StorageClient protocol."""
+
     factory = None
 
     def connectionMade(self):
-        """Handle connection Made."""
+        """Handle connectionMade."""
         if self.factory.client is None:
             self.factory.client = self
         StorageClient.connectionMade(self)
 
     def connectionLost(self, reason=None):
-        """Handle connection lost."""
+        """Handle connectionLost."""
         if self.factory.client is self:
             self.factory.unregisterProtocol(self)
         StorageClient.connectionLost(self, reason=reason)
@@ -1194,20 +1405,19 @@
 
 
 class StorageClientFactory(ClientFactory):
-    """StorageClient factory"""
+    """StorageClient factory."""
     # pylint: disable-msg=W0232
     protocol = StorageClient
 
 
 class ThrottlingStorageClientFactory(StorageClientFactory):
-    """
-    This is the throttling version of StorageClientFactory.
-    """
+    """The throttling version of StorageClientFactory."""
 
     protocol = ThrottlingStorageClient
+    client = None
 
     def __init__(self, read_limit=None, write_limit=None):
-        """creates the instance"""
+        """Create the instance."""
         self.readLimit = read_limit # max bytes we should read per second
         self.writeLimit = write_limit # max bytes we should write per second
         self.readThisSecond = 0
@@ -1219,14 +1429,13 @@
         self.stopped = True
 
     def callLater(self, period, func, *args, **kwargs):
-        """
-        Wrapper around L{reactor.callLater} for test purpose.
-        """
+        """Wrapper around L{reactor.callLater} for test purpose."""
         return reactor.callLater(period, func, *args, **kwargs)
 
     def maybeCallLater(self, id, period, func):
-        """do a callLater only if we don't have a DelayedCall with the
+        """Do a callLater only if we don't have a DelayedCall with the
         specified id already running.
+
         """
         delayed_call = getattr(self, id)
         # check if we already have a DelayedCall running
@@ -1236,21 +1445,17 @@
         return delayed_call
 
     def registerWritten(self, length):
-        """
-        Called by protocol to tell us more bytes were written.
-        """
+        """Called by protocol to tell us more bytes were written."""
         self.writtenThisSecond += length
         self.checkWriteBandwidth()
 
     def registerRead(self, length):
-        """
-        Called by protocol to tell us more bytes were read.
-        """
+        """Called by protocol to tell us more bytes were read."""
         self.readThisSecond += length
         self.checkReadBandwidth()
 
     def checkReadBandwidth(self):
-        """Checks if we've passed bandwidth limits."""
+        """Check if we've passed bandwidth limits."""
         if self.readLimit is not None and \
            self.readThisSecond > self.readLimit and \
            self.unthrottleReadsID is None:
@@ -1262,7 +1467,7 @@
                                                          self.unthrottleReads)
 
     def checkWriteBandwidth(self):
-        """Checks if we've passed bandwidth limits."""
+        """Check if we've passed bandwidth limits."""
         if self.writeLimit is not None and \
            self.writtenThisSecond > self.writeLimit and \
            self.unthrottleWritesID is None:
@@ -1275,14 +1480,14 @@
                                                       self.unthrottleWrites)
 
     def _resetReadThisSecond(self):
-        """reset the counter named with 'name' every 1 second"""
+        """Reset the counter named with 'name' every 1 second."""
         # check the bandwidth limits
         self.readThisSecond = 0
         self.resetReadThisSecondID = self.callLater(1,
                                                    self._resetReadThisSecond)
 
     def _resetWrittenThisSecond (self):
-        """reset the counter named with 'name' every 1 second"""
+        """Reset the counter named with 'name' every 1 second."""
         self.writtenThisSecond = 0
         self.resetWriteThisSecondID = self.callLater(1,
                                                 self._resetWrittenThisSecond)
@@ -1310,7 +1515,7 @@
             self.client.unthrottleWrites()
 
     def buildProtocol(self, addr):
-        """build the protocol and start the counters reset loops"""
+        """Build the protocol and start the counters reset loops."""
         if self.readLimit is not None:
             self._resetReadThisSecond()
         if self.writeLimit is not None:
@@ -1319,7 +1524,7 @@
         return StorageClientFactory.buildProtocol(self, addr)
 
     def unregisterProtocol(self, protocol):
-        """Stop all DelayedCall we have around"""
+        """Stop all DelayedCall we have around."""
         for delayed in [self.unthrottleReadsID, self.resetReadThisSecondID,
                         self.unthrottleWritesID, self.resetWriteThisSecondID]:
             self._cancel_delayed_call(delayed)

=== modified file 'ubuntuone/storageprotocol/dircontent.proto'
--- ubuntuone/storageprotocol/dircontent.proto	2009-06-30 12:00:00 +0000
+++ ubuntuone/storageprotocol/dircontent.proto	2010-02-17 23:29:10 +0000
@@ -17,6 +17,9 @@
 */
 package ubuntuone.storageprotocol;
 
+option java_package = "com.ubuntuone.storageprotocol";
+option java_outer_classname = "DirectoryContentProtocol";
+
 enum NodeType {
     DIRECTORY = 0;
     FILE = 1;

=== modified file 'ubuntuone/storageprotocol/dircontent.py'
--- ubuntuone/storageprotocol/dircontent.py	2009-08-11 16:00:00 +0000
+++ ubuntuone/storageprotocol/dircontent.py	2010-02-17 23:29:10 +0000
@@ -27,7 +27,7 @@
     DirectoryContent, DIRECTORY, FILE, SYMLINK
 
 ILLEGAL_FILENAMES = [u".", u".."]
-ILLEGAL_FILENAME_CHARS_RE_SOURCE = r'[\000-\037:;*?\\/\177]'
+ILLEGAL_FILENAME_CHARS_RE_SOURCE = r'[\000/]'
 ILLEGAL_FILENAME_CHARS_RE = re.compile(ILLEGAL_FILENAME_CHARS_RE_SOURCE)
 
 class InvalidFilename(Exception):

=== added file 'ubuntuone/storageprotocol/dircontent_pb2.py'
--- ubuntuone/storageprotocol/dircontent_pb2.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/storageprotocol/dircontent_pb2.py	2010-02-17 23:29:10 +0000
@@ -0,0 +1,105 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+from google.protobuf import descriptor
+from google.protobuf import message
+from google.protobuf import reflection
+from google.protobuf import service
+from google.protobuf import service_reflection
+from google.protobuf import descriptor_pb2
+_NODETYPE = descriptor.EnumDescriptor(
+  name='NodeType',
+  full_name='ubuntuone.storageprotocol.NodeType',
+  filename='NodeType',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='DIRECTORY', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='FILE', index=1, number=1,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SYMLINK', index=2, number=2,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+
+DIRECTORY = 0
+FILE = 1
+SYMLINK = 2
+
+
+
+_DIRECTORYENTRY = descriptor.Descriptor(
+  name='DirectoryEntry',
+  full_name='ubuntuone.storageprotocol.DirectoryEntry',
+  filename='ubuntuone/storageprotocol/dircontent.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.DirectoryEntry.name', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.DirectoryEntry.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node_type', full_name='ubuntuone.storageprotocol.DirectoryEntry.node_type', index=2,
+      number=3, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_DIRECTORYCONTENT = descriptor.Descriptor(
+  name='DirectoryContent',
+  full_name='ubuntuone.storageprotocol.DirectoryContent',
+  filename='ubuntuone/storageprotocol/dircontent.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='entries', full_name='ubuntuone.storageprotocol.DirectoryContent.entries', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_DIRECTORYENTRY.fields_by_name['node_type'].enum_type = _NODETYPE
+_DIRECTORYCONTENT.fields_by_name['entries'].message_type = _DIRECTORYENTRY
+
+class DirectoryEntry(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _DIRECTORYENTRY
+
+class DirectoryContent(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _DIRECTORYCONTENT
+

=== modified file 'ubuntuone/storageprotocol/protocol.proto'
--- ubuntuone/storageprotocol/protocol.proto	2009-08-26 12:00:00 +0000
+++ ubuntuone/storageprotocol/protocol.proto	2010-02-17 23:29:10 +0000
@@ -17,9 +17,12 @@
 */
 package ubuntuone.storageprotocol;
 
+option java_package = "com.ubuntuone.storageprotocol";
+option java_outer_classname = "StorageProtocol";
+
 message Message {
     required int32 id = 1; // A session-unique number identifying the
-                         // request that started this exchange
+                           // request that started this exchange
 
     enum MessageType {
         NOOP = 0;
@@ -35,8 +38,8 @@
         ROOT = 10;
         MAKE_DIR = 11;
         MAKE_FILE = 12;
-        NEW_DIR = 13;  // answer to MAKE_DIR
-        NEW_FILE = 14;  // answer to MAKE_FILE
+        NEW_DIR = 13;           // answer to MAKE_DIR
+        NEW_FILE = 14;          // answer to MAKE_FILE
         QUERY = 15;
         NODE_STATE = 16;
         QUERY_END = 17;
@@ -47,24 +50,34 @@
         EOF = 22;
         MOVE = 23;
         UNLINK = 24;
-        CREATE_SHARE = 25;
-        LIST_SHARES = 26;
-        SHARES_INFO = 27;  // answer to LIST_SHARES, one message per share
-        SHARES_END = 28;  // no more SHARES_INFO
-        NOTIFY_SHARE = 29;
-        SHARE_ACCEPTED = 30;
-        SHARE_DELETED = 31;
+
+        CREATE_SHARE = 25;      // enable the sharing for a given node
+        LIST_SHARES = 26;       // list all the shares
+        SHARES_INFO = 27;       // answer to LIST_SHARES, one message per share
+        SHARES_END = 28;        // no more SHARES_INFO
+        NOTIFY_SHARE = 29;      // notifies the presence of a new share
+        SHARE_ACCEPTED = 30;    // notifies whether a share was accepted or not
+        SHARE_DELETED = 31;     // answer to DELETE_SHARE (the share was disabled)
+        SHARE_CREATED = 34;     // answer to CREATE_SHARE, returns share id
+        DELETE_SHARE = 36;      // disable the sharing for a given node
+
+        CREATE_UDF = 44;        // register a new UDF against the server
+        LIST_VOLUMES = 45;      // list all volumes (UDFs plus accepted shares)
+        VOLUMES_INFO = 46;      // answer to LIST_VOLUMES, one message per volume
+        VOLUMES_END = 47;       // no more VOLUMES_INFO
+        VOLUME_DELETED = 48;    // answer to DELETE_VOLUME (the volume was deleted)
+        VOLUME_CREATED = 49;    // answer to CREATE_UDF or a share was accepted
+        DELETE_VOLUME = 50;     // removes the UDF and its files from the server
+
         CANCEL_REQUEST = 32;
         NODE_ATTR = 33;
-        SHARE_CREATED = 34;
         CANCELLED = 35;
-        DELETE_SHARE = 36;
-        QUERY_CAPS = 37;  // client2server, no commitment
-        SET_CAPS = 38;    // client2server, commitment from the server
-        ACCEPT_CAPS = 39; // server2client, the answer for previous two
-        FREE_SPACE_INFO = 40; // answer to FREE_SPACE_INQUIRY
+        QUERY_CAPS = 37;        // client2server, no commitment
+        SET_CAPS = 38;          // client2server, commitment from the server
+        ACCEPT_CAPS = 39;       // server2client, the answer for previous two
+        FREE_SPACE_INFO = 40;   // answer to FREE_SPACE_INQUIRY
         FREE_SPACE_INQUIRY = 41;
-        ACCOUNT_INFO = 42; // answer to ACCOUNT_INQUIRY
+        ACCOUNT_INFO = 42;      // answer to ACCOUNT_INQUIRY
         ACCOUNT_INQUIRY = 43;
     }
 
@@ -91,7 +104,7 @@
     optional CancelRequest cancel_request = 17;
     optional NodeAttr node_attr = 18;
 
-    // share management
+    // share, UDf and volume management
     optional CreateShare create_share = 19;
     optional Shares shares = 20;
     optional NotifyShare notify_share = 21;
@@ -100,6 +113,12 @@
     optional ShareCreated share_created = 24;
     optional DeleteShare delete_share = 25;
 
+    optional CreateUDF create_udf = 33;
+    optional Volumes list_volumes = 34;
+    optional VolumeDeleted volume_deleted = 35;
+    optional Volumes volume_created = 36;
+    optional DeleteVolume delete_volume = 37;
+
     // caps
     repeated QueryCaps query_caps = 26;
     repeated SetCaps set_caps = 27;
@@ -149,7 +168,7 @@
 }
 
 message Make {
-    optional bytes share = 1;
+    optional bytes share = 1; // share is actually a volume id
     optional bytes parent_node = 2;
     optional string name = 3;
 }
@@ -303,6 +322,47 @@
     optional string share_id = 1;
 }
 
+message CreateUDF {
+    // path and name should be encoded with utf8
+    optional string path = 1;
+    optional string name = 2;
+}
+
+message UDFs {
+    optional bytes volume = 1;
+    optional bytes node = 2;
+    // suggested path should be encoded with utf8
+    optional string suggested_path = 3;
+}
+
+message VolumeDeleted {
+    optional bytes volume = 1;
+}
+
+message DeleteVolume {
+    optional bytes volume = 1;
+}
+
+message Volumes {
+
+    enum VolumeType {
+        ROOT = 1;
+        SHARE = 2;
+        UDF = 3;
+    }
+
+    optional VolumeType type = 1;
+
+    // specific for a Root
+    optional Root root = 3;
+
+    // specific for a UDF
+    optional UDFs udf = 4;
+
+    // specific for share with direction "to me" and already accepted
+    optional Shares share = 5;
+}
+
 message QueryCaps {
     optional string capability = 1;
 }

=== added file 'ubuntuone/storageprotocol/protocol_pb2.py'
--- ubuntuone/storageprotocol/protocol_pb2.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/storageprotocol/protocol_pb2.py	2010-02-17 23:29:10 +0000
@@ -0,0 +1,2018 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+from google.protobuf import descriptor
+from google.protobuf import message
+from google.protobuf import reflection
+from google.protobuf import service
+from google.protobuf import service_reflection
+from google.protobuf import descriptor_pb2
+
+
+_MESSAGE_MESSAGETYPE = descriptor.EnumDescriptor(
+  name='MessageType',
+  full_name='ubuntuone.storageprotocol.Message.MessageType',
+  filename='MessageType',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='NOOP', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ERROR', index=1, number=1,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='OK', index=2, number=2,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='PING', index=3, number=3,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='PONG', index=4, number=4,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='PROTOCOL_VERSION', index=5, number=5,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTH_REQUEST', index=6, number=6,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTH_REQUEST_TOKEN', index=7, number=7,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTH_REQUEST_TOKEN_READY', index=8, number=8,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTH_AUTHENTICATED', index=9, number=9,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ROOT', index=10, number=10,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MAKE_DIR', index=11, number=11,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MAKE_FILE', index=12, number=12,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NEW_DIR', index=13, number=13,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NEW_FILE', index=14, number=14,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='QUERY', index=15, number=15,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NODE_STATE', index=16, number=16,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='QUERY_END', index=17, number=17,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='GET_CONTENT', index=18, number=18,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='PUT_CONTENT', index=19, number=19,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='BEGIN_CONTENT', index=20, number=20,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='BYTES', index=21, number=21,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='EOF', index=22, number=22,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MOVE', index=23, number=23,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='UNLINK', index=24, number=24,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='CREATE_SHARE', index=25, number=25,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='LIST_SHARES', index=26, number=26,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARES_INFO', index=27, number=27,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARES_END', index=28, number=28,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NOTIFY_SHARE', index=29, number=29,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARE_ACCEPTED', index=30, number=30,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARE_DELETED', index=31, number=31,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARE_CREATED', index=32, number=34,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='DELETE_SHARE', index=33, number=36,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='CREATE_UDF', index=34, number=44,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='LIST_VOLUMES', index=35, number=45,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='VOLUMES_INFO', index=36, number=46,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='VOLUMES_END', index=37, number=47,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='VOLUME_DELETED', index=38, number=48,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='VOLUME_CREATED', index=39, number=49,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='DELETE_VOLUME', index=40, number=50,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='CANCEL_REQUEST', index=41, number=32,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NODE_ATTR', index=42, number=33,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='CANCELLED', index=43, number=35,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='QUERY_CAPS', index=44, number=37,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SET_CAPS', index=45, number=38,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ACCEPT_CAPS', index=46, number=39,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='FREE_SPACE_INFO', index=47, number=40,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='FREE_SPACE_INQUIRY', index=48, number=41,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ACCOUNT_INFO', index=49, number=42,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ACCOUNT_INQUIRY', index=50, number=43,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_ERROR_ERRORTYPE = descriptor.EnumDescriptor(
+  name='ErrorType',
+  full_name='ubuntuone.storageprotocol.Error.ErrorType',
+  filename='ErrorType',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='UNSUPPORTED_VERSION', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTHENTICATION_FAILED', index=1, number=1,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='INTERNAL_ERROR', index=2, number=2,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='AUTHENTICATION_REQUIRED', index=3, number=3,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NO_PERMISSION', index=4, number=4,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='ALREADY_EXISTS', index=5, number=5,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='DOES_NOT_EXIST', index=6, number=6,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NOT_A_DIRECTORY', index=7, number=7,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NOT_EMPTY', index=8, number=8,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NOT_AVAILABLE', index=9, number=9,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='UPLOAD_IN_PROGRESS', index=10, number=10,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='UPLOAD_CORRUPT', index=11, number=11,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='UPLOAD_CANCELED', index=12, number=12,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='CONFLICT', index=13, number=13,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='TRY_AGAIN', index=14, number=14,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='PROTOCOL_ERROR', index=15, number=15,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='QUOTA_EXCEEDED', index=16, number=16,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='INVALID_FILENAME', index=17, number=17,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_CREATESHARE_ACCESSLEVEL = descriptor.EnumDescriptor(
+  name='AccessLevel',
+  full_name='ubuntuone.storageprotocol.CreateShare.AccessLevel',
+  filename='AccessLevel',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='VIEW', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MODIFY', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_SHARES_DIRECTION = descriptor.EnumDescriptor(
+  name='Direction',
+  full_name='ubuntuone.storageprotocol.Shares.Direction',
+  filename='Direction',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='TO_ME', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='FROM_ME', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_SHARES_ACCESSLEVEL = descriptor.EnumDescriptor(
+  name='AccessLevel',
+  full_name='ubuntuone.storageprotocol.Shares.AccessLevel',
+  filename='AccessLevel',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='VIEW', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MODIFY', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_NOTIFYSHARE_ACCESSLEVEL = descriptor.EnumDescriptor(
+  name='AccessLevel',
+  full_name='ubuntuone.storageprotocol.NotifyShare.AccessLevel',
+  filename='AccessLevel',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='VIEW', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='MODIFY', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_SHAREACCEPTED_ANSWER = descriptor.EnumDescriptor(
+  name='Answer',
+  full_name='ubuntuone.storageprotocol.ShareAccepted.Answer',
+  filename='Answer',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='YES', index=0, number=0,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='NO', index=1, number=1,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+_VOLUMES_VOLUMETYPE = descriptor.EnumDescriptor(
+  name='VolumeType',
+  full_name='ubuntuone.storageprotocol.Volumes.VolumeType',
+  filename='VolumeType',
+  values=[
+    descriptor.EnumValueDescriptor(
+      name='ROOT', index=0, number=1,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='SHARE', index=1, number=2,
+      options=None,
+      type=None),
+    descriptor.EnumValueDescriptor(
+      name='UDF', index=2, number=3,
+      options=None,
+      type=None),
+  ],
+  options=None,
+)
+
+
+_MESSAGE = descriptor.Descriptor(
+  name='Message',
+  full_name='ubuntuone.storageprotocol.Message',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='id', full_name='ubuntuone.storageprotocol.Message.id', index=0,
+      number=1, type=5, cpp_type=1, label=2,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='type', full_name='ubuntuone.storageprotocol.Message.type', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='error', full_name='ubuntuone.storageprotocol.Message.error', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='protocol', full_name='ubuntuone.storageprotocol.Message.protocol', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='auth_parameters', full_name='ubuntuone.storageprotocol.Message.auth_parameters', index=4,
+      number=5, type=11, cpp_type=10, label=3,
+      default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='root', full_name='ubuntuone.storageprotocol.Message.root', index=5,
+      number=6, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='query', full_name='ubuntuone.storageprotocol.Message.query', index=6,
+      number=7, type=11, cpp_type=10, label=3,
+      default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node_state', full_name='ubuntuone.storageprotocol.Message.node_state', index=7,
+      number=8, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='make', full_name='ubuntuone.storageprotocol.Message.make', index=8,
+      number=9, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='new', full_name='ubuntuone.storageprotocol.Message.new', index=9,
+      number=10, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='move', full_name='ubuntuone.storageprotocol.Message.move', index=10,
+      number=11, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='get_content', full_name='ubuntuone.storageprotocol.Message.get_content', index=11,
+      number=12, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='put_content', full_name='ubuntuone.storageprotocol.Message.put_content', index=12,
+      number=13, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='upload_in_progress', full_name='ubuntuone.storageprotocol.Message.upload_in_progress', index=13,
+      number=14, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='bytes', full_name='ubuntuone.storageprotocol.Message.bytes', index=14,
+      number=15, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='unlink', full_name='ubuntuone.storageprotocol.Message.unlink', index=15,
+      number=16, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='cancel_request', full_name='ubuntuone.storageprotocol.Message.cancel_request', index=16,
+      number=17, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node_attr', full_name='ubuntuone.storageprotocol.Message.node_attr', index=17,
+      number=18, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='create_share', full_name='ubuntuone.storageprotocol.Message.create_share', index=18,
+      number=19, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='shares', full_name='ubuntuone.storageprotocol.Message.shares', index=19,
+      number=20, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='notify_share', full_name='ubuntuone.storageprotocol.Message.notify_share', index=20,
+      number=21, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_accepted', full_name='ubuntuone.storageprotocol.Message.share_accepted', index=21,
+      number=22, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_deleted', full_name='ubuntuone.storageprotocol.Message.share_deleted', index=22,
+      number=23, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_created', full_name='ubuntuone.storageprotocol.Message.share_created', index=23,
+      number=24, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='delete_share', full_name='ubuntuone.storageprotocol.Message.delete_share', index=24,
+      number=25, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='create_udf', full_name='ubuntuone.storageprotocol.Message.create_udf', index=25,
+      number=33, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='list_volumes', full_name='ubuntuone.storageprotocol.Message.list_volumes', index=26,
+      number=34, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='volume_deleted', full_name='ubuntuone.storageprotocol.Message.volume_deleted', index=27,
+      number=35, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='volume_created', full_name='ubuntuone.storageprotocol.Message.volume_created', index=28,
+      number=36, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='delete_volume', full_name='ubuntuone.storageprotocol.Message.delete_volume', index=29,
+      number=37, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='query_caps', full_name='ubuntuone.storageprotocol.Message.query_caps', index=30,
+      number=26, type=11, cpp_type=10, label=3,
+      default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='set_caps', full_name='ubuntuone.storageprotocol.Message.set_caps', index=31,
+      number=27, type=11, cpp_type=10, label=3,
+      default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='accept_caps', full_name='ubuntuone.storageprotocol.Message.accept_caps', index=32,
+      number=28, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='free_space_info', full_name='ubuntuone.storageprotocol.Message.free_space_info', index=33,
+      number=29, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='free_space_inquiry', full_name='ubuntuone.storageprotocol.Message.free_space_inquiry', index=34,
+      number=30, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='account_info', full_name='ubuntuone.storageprotocol.Message.account_info', index=35,
+      number=31, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='begin_content', full_name='ubuntuone.storageprotocol.Message.begin_content', index=36,
+      number=32, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _MESSAGE_MESSAGETYPE,
+  ],
+  options=None)
+
+
+_ERROR = descriptor.Descriptor(
+  name='Error',
+  full_name='ubuntuone.storageprotocol.Error',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='type', full_name='ubuntuone.storageprotocol.Error.type', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='comment', full_name='ubuntuone.storageprotocol.Error.comment', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _ERROR_ERRORTYPE,
+  ],
+  options=None)
+
+
+_PROTOCOL = descriptor.Descriptor(
+  name='Protocol',
+  full_name='ubuntuone.storageprotocol.Protocol',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='version', full_name='ubuntuone.storageprotocol.Protocol.version', index=0,
+      number=1, type=5, cpp_type=1, label=2,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_AUTHPARAMETER = descriptor.Descriptor(
+  name='AuthParameter',
+  full_name='ubuntuone.storageprotocol.AuthParameter',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.AuthParameter.name', index=0,
+      number=1, type=9, cpp_type=9, label=2,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='value', full_name='ubuntuone.storageprotocol.AuthParameter.value', index=1,
+      number=2, type=9, cpp_type=9, label=2,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_MAKE = descriptor.Descriptor(
+  name='Make',
+  full_name='ubuntuone.storageprotocol.Make',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.Make.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='parent_node', full_name='ubuntuone.storageprotocol.Make.parent_node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.Make.name', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_NEW = descriptor.Descriptor(
+  name='New',
+  full_name='ubuntuone.storageprotocol.New',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.New.node', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='parent_node', full_name='ubuntuone.storageprotocol.New.parent_node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.New.name', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_ROOT = descriptor.Descriptor(
+  name='Root',
+  full_name='ubuntuone.storageprotocol.Root',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.Root.node', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_QUERY = descriptor.Descriptor(
+  name='Query',
+  full_name='ubuntuone.storageprotocol.Query',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.Query.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.Query.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='hash', full_name='ubuntuone.storageprotocol.Query.hash', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_NODESTATE = descriptor.Descriptor(
+  name='NodeState',
+  full_name='ubuntuone.storageprotocol.NodeState',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.NodeState.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.NodeState.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='hash', full_name='ubuntuone.storageprotocol.NodeState.hash', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_GETCONTENT = descriptor.Descriptor(
+  name='GetContent',
+  full_name='ubuntuone.storageprotocol.GetContent',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.GetContent.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.GetContent.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='hash', full_name='ubuntuone.storageprotocol.GetContent.hash', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='offset', full_name='ubuntuone.storageprotocol.GetContent.offset', index=3,
+      number=4, type=3, cpp_type=2, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_CANCELREQUEST = descriptor.Descriptor(
+  name='CancelRequest',
+  full_name='ubuntuone.storageprotocol.CancelRequest',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_NODEATTR = descriptor.Descriptor(
+  name='NodeAttr',
+  full_name='ubuntuone.storageprotocol.NodeAttr',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='deflated_size', full_name='ubuntuone.storageprotocol.NodeAttr.deflated_size', index=0,
+      number=1, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='size', full_name='ubuntuone.storageprotocol.NodeAttr.size', index=1,
+      number=2, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='hash', full_name='ubuntuone.storageprotocol.NodeAttr.hash', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='crc32', full_name='ubuntuone.storageprotocol.NodeAttr.crc32', index=3,
+      number=4, type=13, cpp_type=3, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_BYTES = descriptor.Descriptor(
+  name='Bytes',
+  full_name='ubuntuone.storageprotocol.Bytes',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='bytes', full_name='ubuntuone.storageprotocol.Bytes.bytes', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_PUTCONTENT = descriptor.Descriptor(
+  name='PutContent',
+  full_name='ubuntuone.storageprotocol.PutContent',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.PutContent.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.PutContent.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='previous_hash', full_name='ubuntuone.storageprotocol.PutContent.previous_hash', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='hash', full_name='ubuntuone.storageprotocol.PutContent.hash', index=3,
+      number=4, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='crc32', full_name='ubuntuone.storageprotocol.PutContent.crc32', index=4,
+      number=5, type=13, cpp_type=3, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='size', full_name='ubuntuone.storageprotocol.PutContent.size', index=5,
+      number=6, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='deflated_size', full_name='ubuntuone.storageprotocol.PutContent.deflated_size', index=6,
+      number=7, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_BEGINCONTENT = descriptor.Descriptor(
+  name='BeginContent',
+  full_name='ubuntuone.storageprotocol.BeginContent',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='offset', full_name='ubuntuone.storageprotocol.BeginContent.offset', index=0,
+      number=2, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_UPLOADINPROGRESS = descriptor.Descriptor(
+  name='UploadInProgress',
+  full_name='ubuntuone.storageprotocol.UploadInProgress',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='upload', full_name='ubuntuone.storageprotocol.UploadInProgress.upload', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='timestamp', full_name='ubuntuone.storageprotocol.UploadInProgress.timestamp', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_MOVE = descriptor.Descriptor(
+  name='Move',
+  full_name='ubuntuone.storageprotocol.Move',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.Move.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.Move.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='new_parent_node', full_name='ubuntuone.storageprotocol.Move.new_parent_node', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='new_name', full_name='ubuntuone.storageprotocol.Move.new_name', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_UNLINK = descriptor.Descriptor(
+  name='Unlink',
+  full_name='ubuntuone.storageprotocol.Unlink',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.Unlink.share', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.Unlink.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_CREATESHARE = descriptor.Descriptor(
+  name='CreateShare',
+  full_name='ubuntuone.storageprotocol.CreateShare',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.CreateShare.node', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_to', full_name='ubuntuone.storageprotocol.CreateShare.share_to', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.CreateShare.name', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='access_level', full_name='ubuntuone.storageprotocol.CreateShare.access_level', index=3,
+      number=4, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _CREATESHARE_ACCESSLEVEL,
+  ],
+  options=None)
+
+
+_SHARES = descriptor.Descriptor(
+  name='Shares',
+  full_name='ubuntuone.storageprotocol.Shares',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.Shares.share_id', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='direction', full_name='ubuntuone.storageprotocol.Shares.direction', index=1,
+      number=2, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='subtree', full_name='ubuntuone.storageprotocol.Shares.subtree', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_name', full_name='ubuntuone.storageprotocol.Shares.share_name', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='other_username', full_name='ubuntuone.storageprotocol.Shares.other_username', index=4,
+      number=5, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='other_visible_name', full_name='ubuntuone.storageprotocol.Shares.other_visible_name', index=5,
+      number=6, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='accepted', full_name='ubuntuone.storageprotocol.Shares.accepted', index=6,
+      number=7, type=8, cpp_type=7, label=1,
+      default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='access_level', full_name='ubuntuone.storageprotocol.Shares.access_level', index=7,
+      number=8, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _SHARES_DIRECTION,
+    _SHARES_ACCESSLEVEL,
+  ],
+  options=None)
+
+
+_NOTIFYSHARE = descriptor.Descriptor(
+  name='NotifyShare',
+  full_name='ubuntuone.storageprotocol.NotifyShare',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.NotifyShare.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='subtree', full_name='ubuntuone.storageprotocol.NotifyShare.subtree', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share_name', full_name='ubuntuone.storageprotocol.NotifyShare.share_name', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='from_username', full_name='ubuntuone.storageprotocol.NotifyShare.from_username', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='from_visible_name', full_name='ubuntuone.storageprotocol.NotifyShare.from_visible_name', index=4,
+      number=5, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='access_level', full_name='ubuntuone.storageprotocol.NotifyShare.access_level', index=5,
+      number=6, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _NOTIFYSHARE_ACCESSLEVEL,
+  ],
+  options=None)
+
+
+_SHAREACCEPTED = descriptor.Descriptor(
+  name='ShareAccepted',
+  full_name='ubuntuone.storageprotocol.ShareAccepted',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.ShareAccepted.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='answer', full_name='ubuntuone.storageprotocol.ShareAccepted.answer', index=1,
+      number=2, type=14, cpp_type=8, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _SHAREACCEPTED_ANSWER,
+  ],
+  options=None)
+
+
+_SHAREDELETED = descriptor.Descriptor(
+  name='ShareDeleted',
+  full_name='ubuntuone.storageprotocol.ShareDeleted',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.ShareDeleted.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_SHARECREATED = descriptor.Descriptor(
+  name='ShareCreated',
+  full_name='ubuntuone.storageprotocol.ShareCreated',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.ShareCreated.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_DELETESHARE = descriptor.Descriptor(
+  name='DeleteShare',
+  full_name='ubuntuone.storageprotocol.DeleteShare',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.DeleteShare.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_CREATEUDF = descriptor.Descriptor(
+  name='CreateUDF',
+  full_name='ubuntuone.storageprotocol.CreateUDF',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='path', full_name='ubuntuone.storageprotocol.CreateUDF.path', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='name', full_name='ubuntuone.storageprotocol.CreateUDF.name', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_UDFS = descriptor.Descriptor(
+  name='UDFs',
+  full_name='ubuntuone.storageprotocol.UDFs',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='volume', full_name='ubuntuone.storageprotocol.UDFs.volume', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='node', full_name='ubuntuone.storageprotocol.UDFs.node', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='suggested_path', full_name='ubuntuone.storageprotocol.UDFs.suggested_path', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_VOLUMEDELETED = descriptor.Descriptor(
+  name='VolumeDeleted',
+  full_name='ubuntuone.storageprotocol.VolumeDeleted',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='volume', full_name='ubuntuone.storageprotocol.VolumeDeleted.volume', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_DELETEVOLUME = descriptor.Descriptor(
+  name='DeleteVolume',
+  full_name='ubuntuone.storageprotocol.DeleteVolume',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='volume', full_name='ubuntuone.storageprotocol.DeleteVolume.volume', index=0,
+      number=1, type=12, cpp_type=9, label=1,
+      default_value="",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_VOLUMES = descriptor.Descriptor(
+  name='Volumes',
+  full_name='ubuntuone.storageprotocol.Volumes',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='type', full_name='ubuntuone.storageprotocol.Volumes.type', index=0,
+      number=1, type=14, cpp_type=8, label=1,
+      default_value=1,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='root', full_name='ubuntuone.storageprotocol.Volumes.root', index=1,
+      number=3, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='udf', full_name='ubuntuone.storageprotocol.Volumes.udf', index=2,
+      number=4, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='share', full_name='ubuntuone.storageprotocol.Volumes.share', index=3,
+      number=5, type=11, cpp_type=10, label=1,
+      default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+    _VOLUMES_VOLUMETYPE,
+  ],
+  options=None)
+
+
+_QUERYCAPS = descriptor.Descriptor(
+  name='QueryCaps',
+  full_name='ubuntuone.storageprotocol.QueryCaps',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='capability', full_name='ubuntuone.storageprotocol.QueryCaps.capability', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_SETCAPS = descriptor.Descriptor(
+  name='SetCaps',
+  full_name='ubuntuone.storageprotocol.SetCaps',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='capability', full_name='ubuntuone.storageprotocol.SetCaps.capability', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_ACCEPTCAPS = descriptor.Descriptor(
+  name='AcceptCaps',
+  full_name='ubuntuone.storageprotocol.AcceptCaps',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='accepted', full_name='ubuntuone.storageprotocol.AcceptCaps.accepted', index=0,
+      number=1, type=8, cpp_type=7, label=1,
+      default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='redirect_hostname', full_name='ubuntuone.storageprotocol.AcceptCaps.redirect_hostname', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='redirect_port', full_name='ubuntuone.storageprotocol.AcceptCaps.redirect_port', index=2,
+      number=3, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='redirect_srvrecord', full_name='ubuntuone.storageprotocol.AcceptCaps.redirect_srvrecord', index=3,
+      number=4, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_FREESPACEINFO = descriptor.Descriptor(
+  name='FreeSpaceInfo',
+  full_name='ubuntuone.storageprotocol.FreeSpaceInfo',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.FreeSpaceInfo.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    descriptor.FieldDescriptor(
+      name='free_bytes', full_name='ubuntuone.storageprotocol.FreeSpaceInfo.free_bytes', index=1,
+      number=2, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_FREESPACEINQUIRY = descriptor.Descriptor(
+  name='FreeSpaceInquiry',
+  full_name='ubuntuone.storageprotocol.FreeSpaceInquiry',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='share_id', full_name='ubuntuone.storageprotocol.FreeSpaceInquiry.share_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      default_value=unicode("", "utf-8"),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_ACCOUNTINFO = descriptor.Descriptor(
+  name='AccountInfo',
+  full_name='ubuntuone.storageprotocol.AccountInfo',
+  filename='ubuntuone/storageprotocol/protocol.proto',
+  containing_type=None,
+  fields=[
+    descriptor.FieldDescriptor(
+      name='purchased_bytes', full_name='ubuntuone.storageprotocol.AccountInfo.purchased_bytes', index=0,
+      number=1, type=4, cpp_type=4, label=1,
+      default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],  # TODO(robinson): Implement.
+  enum_types=[
+  ],
+  options=None)
+
+
+_MESSAGE.fields_by_name['type'].enum_type = _MESSAGE_MESSAGETYPE
+_MESSAGE.fields_by_name['error'].message_type = _ERROR
+_MESSAGE.fields_by_name['protocol'].message_type = _PROTOCOL
+_MESSAGE.fields_by_name['auth_parameters'].message_type = _AUTHPARAMETER
+_MESSAGE.fields_by_name['root'].message_type = _ROOT
+_MESSAGE.fields_by_name['query'].message_type = _QUERY
+_MESSAGE.fields_by_name['node_state'].message_type = _NODESTATE
+_MESSAGE.fields_by_name['make'].message_type = _MAKE
+_MESSAGE.fields_by_name['new'].message_type = _NEW
+_MESSAGE.fields_by_name['move'].message_type = _MOVE
+_MESSAGE.fields_by_name['get_content'].message_type = _GETCONTENT
+_MESSAGE.fields_by_name['put_content'].message_type = _PUTCONTENT
+_MESSAGE.fields_by_name['upload_in_progress'].message_type = _UPLOADINPROGRESS
+_MESSAGE.fields_by_name['bytes'].message_type = _BYTES
+_MESSAGE.fields_by_name['unlink'].message_type = _UNLINK
+_MESSAGE.fields_by_name['cancel_request'].message_type = _CANCELREQUEST
+_MESSAGE.fields_by_name['node_attr'].message_type = _NODEATTR
+_MESSAGE.fields_by_name['create_share'].message_type = _CREATESHARE
+_MESSAGE.fields_by_name['shares'].message_type = _SHARES
+_MESSAGE.fields_by_name['notify_share'].message_type = _NOTIFYSHARE
+_MESSAGE.fields_by_name['share_accepted'].message_type = _SHAREACCEPTED
+_MESSAGE.fields_by_name['share_deleted'].message_type = _SHAREDELETED
+_MESSAGE.fields_by_name['share_created'].message_type = _SHARECREATED
+_MESSAGE.fields_by_name['delete_share'].message_type = _DELETESHARE
+_MESSAGE.fields_by_name['create_udf'].message_type = _CREATEUDF
+_MESSAGE.fields_by_name['list_volumes'].message_type = _VOLUMES
+_MESSAGE.fields_by_name['volume_deleted'].message_type = _VOLUMEDELETED
+_MESSAGE.fields_by_name['volume_created'].message_type = _VOLUMES
+_MESSAGE.fields_by_name['delete_volume'].message_type = _DELETEVOLUME
+_MESSAGE.fields_by_name['query_caps'].message_type = _QUERYCAPS
+_MESSAGE.fields_by_name['set_caps'].message_type = _SETCAPS
+_MESSAGE.fields_by_name['accept_caps'].message_type = _ACCEPTCAPS
+_MESSAGE.fields_by_name['free_space_info'].message_type = _FREESPACEINFO
+_MESSAGE.fields_by_name['free_space_inquiry'].message_type = _FREESPACEINQUIRY
+_MESSAGE.fields_by_name['account_info'].message_type = _ACCOUNTINFO
+_MESSAGE.fields_by_name['begin_content'].message_type = _BEGINCONTENT
+_ERROR.fields_by_name['type'].enum_type = _ERROR_ERRORTYPE
+_CREATESHARE.fields_by_name['access_level'].enum_type = _CREATESHARE_ACCESSLEVEL
+_SHARES.fields_by_name['direction'].enum_type = _SHARES_DIRECTION
+_SHARES.fields_by_name['access_level'].enum_type = _SHARES_ACCESSLEVEL
+_NOTIFYSHARE.fields_by_name['access_level'].enum_type = _NOTIFYSHARE_ACCESSLEVEL
+_SHAREACCEPTED.fields_by_name['answer'].enum_type = _SHAREACCEPTED_ANSWER
+_VOLUMES.fields_by_name['type'].enum_type = _VOLUMES_VOLUMETYPE
+_VOLUMES.fields_by_name['root'].message_type = _ROOT
+_VOLUMES.fields_by_name['udf'].message_type = _UDFS
+_VOLUMES.fields_by_name['share'].message_type = _SHARES
+
+class Message(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _MESSAGE
+
+class Error(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _ERROR
+
+class Protocol(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _PROTOCOL
+
+class AuthParameter(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _AUTHPARAMETER
+
+class Make(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _MAKE
+
+class New(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _NEW
+
+class Root(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _ROOT
+
+class Query(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _QUERY
+
+class NodeState(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _NODESTATE
+
+class GetContent(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _GETCONTENT
+
+class CancelRequest(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _CANCELREQUEST
+
+class NodeAttr(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _NODEATTR
+
+class Bytes(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _BYTES
+
+class PutContent(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _PUTCONTENT
+
+class BeginContent(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _BEGINCONTENT
+
+class UploadInProgress(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _UPLOADINPROGRESS
+
+class Move(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _MOVE
+
+class Unlink(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _UNLINK
+
+class CreateShare(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _CREATESHARE
+
+class Shares(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _SHARES
+
+class NotifyShare(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _NOTIFYSHARE
+
+class ShareAccepted(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _SHAREACCEPTED
+
+class ShareDeleted(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _SHAREDELETED
+
+class ShareCreated(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _SHARECREATED
+
+class DeleteShare(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _DELETESHARE
+
+class CreateUDF(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _CREATEUDF
+
+class UDFs(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _UDFS
+
+class VolumeDeleted(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _VOLUMEDELETED
+
+class DeleteVolume(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _DELETEVOLUME
+
+class Volumes(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _VOLUMES
+
+class QueryCaps(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _QUERYCAPS
+
+class SetCaps(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _SETCAPS
+
+class AcceptCaps(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _ACCEPTCAPS
+
+class FreeSpaceInfo(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _FREESPACEINFO
+
+class FreeSpaceInquiry(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _FREESPACEINQUIRY
+
+class AccountInfo(message.Message):
+  __metaclass__ = reflection.GeneratedProtocolMessageType
+  DESCRIPTOR = _ACCOUNTINFO
+

=== modified file 'ubuntuone/storageprotocol/request.py'
--- ubuntuone/storageprotocol/request.py	2009-08-26 12:00:00 +0000
+++ ubuntuone/storageprotocol/request.py	2010-02-17 23:29:10 +0000
@@ -56,17 +56,18 @@
 class StorageProtocolError(Exception):
     """base class for all client/server exceptions."""
 
+
 class StorageProtocolErrorSizeTooBig(StorageProtocolError):
     """the size we received was too big."""
 
+
 class StorageProtocolProtocolError(StorageProtocolError):
     """A protocol error on the storage protocol."""
 
 
 class StorageRequestError(StorageProtocolError):
-    """an exception that keeps the request that generated it around
+    """an exception that keeps the request that generated it around."""
 
-    """
     def __init__(self, request, message):
         """create a StorageRequestError.
 

=== modified file 'ubuntuone/storageprotocol/sharersp.py'
--- ubuntuone/storageprotocol/sharersp.py	2009-06-30 12:00:00 +0000
+++ ubuntuone/storageprotocol/sharersp.py	2010-02-17 23:29:10 +0000
@@ -5,42 +5,31 @@
 #
 # Copyright 2009 Canonical Ltd.
 #
-# This program is free software: you can redistribute it and/or modify it 
+# This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3,
 # as published by the Free Software Foundation.
 #
-# This program is distributed in the hope that it will be useful, but 
-# WITHOUT ANY WARRANTY; without even the implied warranties of 
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 # PURPOSE.  See the GNU Affero General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""provides a handy class to use Shares
-"""
+"""A handy class to use Shares."""
 
 import uuid
-from ubuntuone.storageprotocol import protocol_pb2
-
-_direction_prot2nice = {
-    protocol_pb2.Shares.FROM_ME: "from_me",
-    protocol_pb2.Shares.TO_ME:   "to_me",
-}
-_direction_nice2prot = dict((y, x) for x, y in _direction_prot2nice.items())
-
-_access_prot2nice = {
-    protocol_pb2.Shares.VIEW: "View",
-    protocol_pb2.Shares.MODIFY: "Modify",
-}
-_access_nice2prot = dict((y, x) for x, y in _access_prot2nice.items())
+
+from ubuntuone.storageprotocol import volumes
+# pylint: disable-msg=W0212
 
 class ShareResponse(object):
-    '''This is a handy object to support all the fields of a share listing.'''
+    """This is a handy object to support all the fields of a share listing."""
 
     @classmethod
     def from_params(cls, id, direction, subtree, share_name, other_username,
                                    other_visible_name, accepted, access_level):
-        '''Creates the object from given parameters.'''
+        """Creates the object from given parameters."""
         # pylint: disable-msg=W0201
         o = cls()
         o.id = id
@@ -55,28 +44,29 @@
 
     @classmethod
     def load_from_msg(cls, msg):
-        '''Creates the object loading the information from a message.'''
+        """Creates the object loading the information from a message."""
+        # pylint: disable-msg=W0201
         o = cls()
         o.id = uuid.UUID(msg.share_id)
-        o.direction = _direction_prot2nice[msg.direction]
+        o.direction = volumes._direction_prot2nice[msg.direction]
         o.subtree = msg.subtree
         o.name = msg.share_name
         o.other_username = msg.other_username
         o.other_visible_name = msg.other_visible_name
         o.accepted = msg.accepted
-        o.access_level = _access_prot2nice[msg.access_level]
+        o.access_level = volumes._access_prot2nice[msg.access_level]
         return o
 
     def dump_to_msg(self, msg):
-        '''Dumps the object information to a given message.'''
+        """Dumps the object information to a given message."""
         msg.share_id = str(self.id)
-        msg.direction = _direction_nice2prot[self.direction]
+        msg.direction = volumes._direction_nice2prot[self.direction]
         msg.subtree = str(self.subtree)
         msg.share_name = self.name
         msg.other_username = self.other_username
         msg.other_visible_name = self.other_visible_name
         msg.accepted = self.accepted
-        msg.access_level = _access_nice2prot[self.access_level]
+        msg.access_level = volumes._access_nice2prot[self.access_level]
 
     def __str__(self):
         t = "Share %r [%s] (other: %s, access: %s, accepted: %s, id: %s)" % (
@@ -85,12 +75,12 @@
         return t
 
 class NotifyShareHolder(object):
-    '''This is a handy object to support all the fields of a share notify.'''
+    """This is a handy object to support all the fields of a share notify."""
 
     @classmethod
     def from_params(cls, share_id, subtree, share_name, from_username,
-                                            from_visible_name, access_level):
-        '''Creates the object from given parameters.'''
+                    from_visible_name, access_level):
+        """Creates the object from given parameters."""
         # pylint: disable-msg=W0201
         o = cls()
         o.share_id = share_id
@@ -103,24 +93,24 @@
 
     @classmethod
     def load_from_msg(cls, msg):
-        '''Creates the object loading the information from a message.'''
+        """Creates the object loading the information from a message."""
         o = cls()
         o.share_id = uuid.UUID(msg.share_id)
         o.subtree = msg.subtree
         o.share_name = msg.share_name.decode("utf8")
         o.from_username = msg.from_username.decode("utf8")
         o.from_visible_name = msg.from_visible_name.decode("utf8")
-        o.access_level = _access_prot2nice[msg.access_level]
+        o.access_level = volumes._access_prot2nice[msg.access_level]
         return o
 
     def dump_to_msg(self, msg):
-        '''Dumps the object information to a given message.'''
+        """Dumps the object information to a given message."""
         msg.share_id = str(self.share_id)
         msg.subtree = str(self.subtree)
         msg.share_name = self.share_name.encode("utf8")
         msg.from_username = self.from_username.encode("utf8")
         msg.from_visible_name = self.from_visible_name.encode("utf8")
-        msg.access_level = _access_nice2prot[self.access_level]
+        msg.access_level = volumes._access_nice2prot[self.access_level]
 
     def __str__(self):
         t = "Share Notification %r (from: %s, access: %s, id: %s)" % (

=== added file 'ubuntuone/storageprotocol/volumes.py'
--- ubuntuone/storageprotocol/volumes.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/storageprotocol/volumes.py	2010-02-17 23:29:10 +0000
@@ -0,0 +1,141 @@
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 2009 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""The volumes abstraction."""
+
+import uuid
+
+from ubuntuone.storageprotocol import protocol_pb2
+
+_direction_prot2nice = {
+    protocol_pb2.Shares.FROM_ME: "from_me",
+    protocol_pb2.Shares.TO_ME:   "to_me",
+}
+_direction_nice2prot = dict((y, x) for x, y in _direction_prot2nice.items())
+
+_access_prot2nice = {
+    protocol_pb2.Shares.VIEW: "View",
+    protocol_pb2.Shares.MODIFY: "Modify",
+}
+_access_nice2prot = dict((y, x) for x, y in _access_prot2nice.items())
+
+
+class Volume(object):
+    """A generic volume."""
+
+    def __init__(self, volume_id, node_id):
+        """Create the volume."""
+        self.volume_id = volume_id
+        self.node_id = node_id
+
+    @classmethod
+    def from_params(cls, **kwargs):
+        """Creates the object from given parameters."""
+        result = cls(**kwargs)
+        return result
+
+    @classmethod
+    def from_msg(cls, msg):
+        """Creates the object using the information from a message."""
+        raise NotImplementedError
+
+    def __eq__(self, other):
+        result = (self.volume_id == other.volume_id and
+                  self.node_id == other.node_id)
+        return result
+
+class ShareVolume(Volume):
+    """A volume representing an accepted Share."""
+
+    def __init__(self, volume_id, node_id, direction, share_name,
+                 other_username, other_visible_name, accepted, access_level):
+        """Create the share."""
+        super(ShareVolume, self).__init__(volume_id, node_id)
+        self.direction = direction
+        self.share_name = share_name
+        self.other_username = other_username
+        self.other_visible_name = other_visible_name
+        self.accepted = accepted
+        self.access_level = access_level
+
+    @classmethod
+    def from_msg(cls, msg):
+        """Creates the object using the information from a message."""
+        kwargs = dict(
+            volume_id=uuid.UUID(msg.share_id),
+            node_id=uuid.UUID(msg.subtree),
+            direction = _direction_prot2nice[msg.direction],
+            share_name=msg.share_name,
+            other_username=msg.other_username,
+            other_visible_name=msg.other_visible_name,
+            accepted=msg.accepted,
+            access_level=_access_prot2nice[msg.access_level]
+        )
+        result = cls(**kwargs)
+        return result
+
+    def __eq__(self, other):
+        result = (super(ShareVolume, self).__eq__(other) and
+                  self.direction == other.direction and
+                  self.share_name == other.share_name and
+                  self.other_username == other.other_username and
+                  self.other_visible_name == other.other_visible_name and
+                  self.accepted == other.accepted and
+                  self.access_level == other.access_level)
+        return result
+
+
+class UDFVolume(Volume):
+    """A volume representing a User Defined Folder."""
+
+    def __init__(self, volume_id, node_id, suggested_path):
+        """Create the UDF."""
+        super(UDFVolume, self).__init__(volume_id, node_id)
+        self.suggested_path = suggested_path
+
+    @classmethod
+    def from_msg(cls, msg):
+        """Creates the object using the information from a message."""
+        kwargs = dict(
+            volume_id=uuid.UUID(msg.volume),
+            node_id=uuid.UUID(msg.node),
+            suggested_path=msg.suggested_path
+        )
+        result = cls(**kwargs)
+        return result
+
+    def __eq__(self, other):
+        result = (super(UDFVolume, self).__eq__(other) and
+                  self.suggested_path == other.suggested_path)
+        return result
+
+
+class RootVolume(Volume):
+    """A volume representing a Root-root."""
+
+    def __init__(self, node_id):
+        """Create the volume."""
+        super(RootVolume, self).__init__(volume_id=None, node_id=node_id)
+
+    @classmethod
+    def from_msg(cls, msg):
+        """Creates the object using the information from a message."""
+        kwargs = dict(node_id=uuid.UUID(msg.node))
+        result = cls(**kwargs)
+        return result
+
+    def __eq__(self, other):
+        return self.node_id == other.node_id
+