Merge lp:~facundo/magicicada-protocol/publicfiles into lp:magicicada-protocol

[Facundo Batista]

Protocol infrastructure to support public files change and listing.

Protocol infrastructure to support public files change and listing.

[Facundo Batista (facundo)]

Comments addressed

[lp:~facundo/magicicada-protocol/publicfiles]

170. By Facundo Batista on 2016-11-15

Import order.

[Natalia Bidart (nataliabidart)]

LGTM Thanks!

review: Approve

=== modified file 'tests/test_client.py'
--- tests/test_client.py	2016-09-19 02:00:32 +0000
+++ tests/test_client.py	2016-11-15 23:38:26 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
-#
-# Copyright (C) 2009-2015 Canonical Ltd.
+
+# Copyright 2009-2015 Canonical Ltd.
+# Copyright 2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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,
@@ -26,6 +27,7 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
+
 """Tests for the protocol client."""
 
 import StringIO
@@ -42,8 +44,20 @@
 
 from ubuntuone.storageprotocol import protocol_pb2, sharersp, delta, request
 from ubuntuone.storageprotocol.client import (
-    StorageClient, CreateUDF, ListVolumes, DeleteVolume, GetDelta, Unlink,
-    Authenticate, MakeFile, MakeDir, PutContent, Move, BytesMessageProducer,
+    Authenticate,
+    BytesMessageProducer,
+    ChangePublicAccess,
+    CreateUDF,
+    DeleteVolume,
+    GetDelta,
+    ListPublicFiles,
+    ListVolumes,
+    MakeDir,
+    MakeFile,
+    Move,
+    PutContent,
+    StorageClient,
+    Unlink,
 )
 
 from ubuntuone.storageprotocol import volumes
@@ -61,6 +75,7 @@
 NODE = uuid.UUID('FEDCBA98-7654-3211-2345-6789ABCDEF12')
 USER = u'Dude'
 GENERATION = 999
+PUBLIC_URL = "http://magicicada/someid"
 
 
 class FakedError(Exception):
@@ -308,7 +323,7 @@
         self.client.set_share_change_callback(a_callback)
         self.assertTrue(self.client._share_change_callback is a_callback)
         self.client.handle_NOTIFY_SHARE(proto_msg)
-        self.assertEquals(self.share_notif.share_id, share_resp.share_id)
+        self.assertEqual(self.share_notif.share_id, share_resp.share_id)
 
     def test_share_delete_callback(self):
         """Test share_delete callback usage."""
@@ -329,7 +344,7 @@
         self.client.set_share_delete_callback(a_callback)
         self.assertTrue(self.client._share_delete_callback is a_callback)
         self.client.handle_SHARE_DELETED(proto_msg)
-        self.assertEquals(self.deleted_share_id, share_id)
+        self.assertEqual(self.deleted_share_id, share_id)
 
     def test_share_answer_callback(self):
         """Test share_answer callback usage."""
@@ -351,8 +366,8 @@
         self.client.set_share_answer_callback(a_callback)
         self.assertTrue(self.client._share_answer_callback is a_callback)
         self.client.handle_SHARE_ACCEPTED(proto_msg)
-        self.assertEquals(self.answer[0], share_id)
-        self.assertEquals(self.answer[1], "Yes")
+        self.assertEqual(self.answer[0], share_id)
+        self.assertEqual(self.answer[1], "Yes")
 
     def test_handle_volume_new_generation_uuid(self):
         """Test handle_VOLUME_NEW_GENERATION with an uuid id."""
@@ -415,7 +430,7 @@
         root = volumes.RootVolume.from_msg(message.volume_created.root)
 
         self.client.handle_VOLUME_CREATED(message)
-        self.assertEquals(root, self.volume)
+        self.assertEqual(root, self.volume)
 
     def test_handle_udf_created_passes_a_udf(self):
         """Test handle_VOLUME_CREATED parameter passing."""
@@ -431,7 +446,7 @@
         udf = volumes.UDFVolume.from_msg(message.volume_created.udf)
 
         self.client.handle_VOLUME_CREATED(message)
-        self.assertEquals(udf, self.volume)
+        self.assertEqual(udf, self.volume)
 
     def test_handle_share_created_passes_a_share(self):
         """Test handle_VOLUME_CREATED parameter passing."""
@@ -447,7 +462,7 @@
         share = volumes.ShareVolume.from_msg(message.volume_created.share)
 
         self.client.handle_VOLUME_CREATED(message)
-        self.assertEquals(share, self.volume)
+        self.assertEqual(share, self.volume)
 
     def test_handle_volume_created_if_callback_is_none(self):
         """Test handle_VOLUME_CREATED if callback is none."""
@@ -478,7 +493,7 @@
         message.volume_deleted.volume = str(VOLUME)
         self.client.handle_VOLUME_DELETED(message)
 
-        self.assertEquals(VOLUME, self.volume)
+        self.assertEqual(VOLUME, self.volume)
 
     def test_handle_volume_deleted_if_none(self):
         """Test handle_VOLUME_DELETED if callback is none."""
@@ -515,8 +530,8 @@
 
     def test_init(self):
         """Test request creation."""
-        self.assertEquals(PATH, self.request.path)
-        self.assertEquals(NAME, self.request.name)
+        self.assertEqual(PATH, self.request.path)
+        self.assertEqual(NAME, self.request.name)
         self.assertTrue(self.request.volume_id is None)
         self.assertTrue(self.request.node_id is None)
 
@@ -524,11 +539,11 @@
         """Test request start."""
         self.request.start()
 
-        self.assertEquals(1, len(self.request.protocol.messages))
+        self.assertEqual(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)
+        self.assertEqual(protocol_pb2.Message.CREATE_UDF, actual_msg.type)
+        self.assertEqual(self.request.path, actual_msg.create_udf.path)
+        self.assertEqual(self.request.name, actual_msg.create_udf.name)
 
     def test_process_message_error(self):
         """Test request processMessage on error."""
@@ -544,8 +559,8 @@
         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.assertEqual(str(VOLUME), self.request.volume_id, 'volume set')
+        self.assertEqual(str(NODE), self.request.node_id, 'node set')
         self.assertTrue(self.done_called, 'done() was called')
 
 
@@ -566,15 +581,15 @@
 
     def test_init(self):
         """Test request creation."""
-        self.assertEquals([], self.request.volumes)
+        self.assertEqual([], self.request.volumes)
 
     def test_start(self):
         """Test request start."""
         self.request.start()
 
-        self.assertEquals(1, len(self.request.protocol.messages))
+        self.assertEqual(1, len(self.request.protocol.messages))
         actual_msg, = self.request.protocol.messages
-        self.assertEquals(protocol_pb2.Message.LIST_VOLUMES, actual_msg.type)
+        self.assertEqual(protocol_pb2.Message.LIST_VOLUMES, actual_msg.type)
 
     def test_process_message_error(self):
         """Test request processMessage on error."""
@@ -598,10 +613,9 @@
         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')
+        self.assertEqual(3, len(self.request.volumes), '3 volumes stored')
+        self.assertEqual([udf, share, root], self.request.volumes,
+                         'volumes stored')
 
         message = protocol_pb2.Message()
         message.type = protocol_pb2.Message.VOLUMES_END
@@ -622,7 +636,7 @@
         self.request.processMessage(message)
 
         self.request.start()
-        self.assertEquals([], self.request.volumes)
+        self.assertEqual([], self.request.volumes)
 
 
 class DeleteVolumeTestCase(RequestTestCase):
@@ -642,17 +656,17 @@
 
     def test_init(self):
         """Test request creation."""
-        self.assertEquals(str(VOLUME), self.request.volume_id)
+        self.assertEqual(str(VOLUME), self.request.volume_id)
 
     def test_start(self):
         """Test request start."""
         self.request.start()
 
-        self.assertEquals(1, len(self.request.protocol.messages))
+        self.assertEqual(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)
+        self.assertEqual(protocol_pb2.Message.DELETE_VOLUME, actual_msg.type)
+        self.assertEqual(self.request.volume_id,
+                         actual_msg.delete_volume.volume)
 
     def test_process_message_error(self):
         """Test request processMessage on error."""
@@ -685,17 +699,17 @@
 
     def test_init(self):
         """Test request creation."""
-        self.assertEquals(str(SHARE), self.request.share_id)
+        self.assertEqual(str(SHARE), self.request.share_id)
 
     def test_start(self):
         """Test request start."""
         self.request.start()
 
-        self.assertEquals(1, len(self.request.protocol.messages))
+        self.assertEqual(1, len(self.request.protocol.messages))
         actual_msg, = self.request.protocol.messages
-        self.assertEquals(protocol_pb2.Message.GET_DELTA, actual_msg.type)
-        self.assertEquals(self.request.share_id,
-                          actual_msg.get_delta.share)
+        self.assertEqual(protocol_pb2.Message.GET_DELTA, actual_msg.type)
+        self.assertEqual(self.request.share_id,
+                         actual_msg.get_delta.share)
 
     def test_process_message_error(self):
         """Test request processMessage on error."""
@@ -712,11 +726,11 @@
         self.request.processMessage(message)
 
         self.assertTrue(self.done_called, 'done() was called')
-        self.assertEquals(self.request.end_generation,
-                          message.delta_end.generation)
-        self.assertEquals(self.request.full, message.delta_end.full)
-        self.assertEquals(self.request.free_bytes,
-                          message.delta_end.free_bytes)
+        self.assertEqual(self.request.end_generation,
+                         message.delta_end.generation)
+        self.assertEqual(self.request.full, message.delta_end.full)
+        self.assertEqual(self.request.free_bytes,
+                         message.delta_end.free_bytes)
 
     def test_process_message_content(self):
         """Test request processMessage for content."""
@@ -748,11 +762,11 @@
         self.request.done = was_called(self, 'done_called')
         self.request.start()
 
-        self.assertEquals(1, len(self.request.protocol.messages))
+        self.assertEqual(1, len(self.request.protocol.messages))
         actual_msg, = self.request.protocol.messages
-        self.assertEquals(protocol_pb2.Message.GET_DELTA, actual_msg.type)
-        self.assertEquals(self.request.share_id,
-                          actual_msg.get_delta.share)
+        self.assertEqual(protocol_pb2.Message.GET_DELTA, actual_msg.type)
+        self.assertEqual(self.request.share_id,
+                         actual_msg.get_delta.share)
 
 
 class TestAuth(RequestTestCase):
@@ -958,5 +972,124 @@
         return d
 
 
-if __name__ == '__main__':
-    unittest.main()
+class ChangePublicAccessTestCase(RequestTestCase):
+    """Test cases for ChangePublicAccess op."""
+
+    request_class = ChangePublicAccess
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize testing protocol."""
+        yield super(ChangePublicAccessTestCase, self).setUp()
+        self.protocol = FakedProtocol()
+        self.request = self.request_class(
+            self.protocol, share_id=SHARE, node_id=NODE, is_public=True)
+        self.request.error = faked_error
+        self.done_called = False
+        self.request.done = was_called(self, 'done_called')
+
+    def test_init(self):
+        """Test request creation."""
+        self.assertEqual(self.request.share_id, str(SHARE))
+        self.assertEqual(self.request.node_id, str(NODE))
+        self.assertTrue(self.request.is_public)
+
+    def test_start(self):
+        """Test request start."""
+        self.request.start()
+
+        self.assertEqual(1, len(self.request.protocol.messages))
+        actual_msg, = self.request.protocol.messages
+        self.assertEqual(actual_msg.type,
+                         protocol_pb2.Message.CHANGE_PUBLIC_ACCESS)
+        self.assertEqual(actual_msg.change_public_access.share,
+                         self.request.share_id)
+        self.assertEqual(actual_msg.change_public_access.node,
+                         self.request.node_id)
+        self.assertTrue(actual_msg.change_public_access.is_public)
+
+    def test_process_message_error(self):
+        """Test request processMessage on error."""
+        message = protocol_pb2.Message()
+        self.assertRaises(FakedError, self.request.processMessage, message)
+        self.assertIsNone(self.request.public_url)
+
+    def test_process_message_ok(self):
+        """Test request processMessage on sucess."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.OK
+        message.public_url = PUBLIC_URL
+        self.request.processMessage(message)
+
+        self.assertTrue(self.done_called, 'done() was called')
+        self.assertIsNotNone(self.request.public_url)
+
+
+class ListPublicFilesTestCase(RequestTestCase):
+    """Test cases for ListPublicFiles op."""
+
+    request_class = ListPublicFiles
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize testing protocol."""
+        yield super(ListPublicFilesTestCase, self).setUp()
+        self.protocol = FakedProtocol()
+        self.request = self.request_class(self.protocol)
+        self.request.error = faked_error
+        self.done_called = False
+        self.request.done = was_called(self, 'done_called')
+
+    def test_start(self):
+        """Test request start."""
+        self.request.start()
+
+        self.assertEqual(1, len(self.request.protocol.messages))
+        actual_msg, = self.request.protocol.messages
+        self.assertEqual(actual_msg.type,
+                         protocol_pb2.Message.LIST_PUBLIC_FILES)
+
+    def test_process_message_error(self):
+        """Test request processMessage on error."""
+        message = protocol_pb2.Message()
+        self.assertRaises(FakedError, self.request.processMessage, message)
+        self.assertEqual(self.request.public_files, [])
+
+    def test_process_message_ok(self):
+        """Test request processMessage on sucess."""
+        # send two nodes
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.PUBLIC_FILE_INFO
+        message.public_file_info.share = 'share_id'
+        message.public_file_info.node = 'node_id_1'
+        message.public_file_info.is_public = True
+        message.public_file_info.public_url = "test url 123"
+        self.request.processMessage(message)
+
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.PUBLIC_FILE_INFO
+        message.public_file_info.share = 'share_id'
+        message.public_file_info.node = 'node_id_2'
+        message.public_file_info.is_public = True
+        message.public_file_info.public_url = "test url 456"
+        self.request.processMessage(message)
+
+        # finish
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.PUBLIC_FILE_INFO_END
+        self.request.processMessage(message)
+
+        # check
+        self.assertTrue(self.done_called, 'done() was called')
+        node1, node2 = self.request.public_files
+        print("NNNNNNNNNNNNO 1", node1)
+
+        self.assertEqual(node1.share_id, 'share_id')
+        self.assertEqual(node1.node_id, 'node_id_1')
+        self.assertEqual(node1.is_public, True)
+        self.assertEqual(node1.public_url, 'test url 123')
+
+        self.assertEqual(node2.share_id, 'share_id')
+        self.assertEqual(node2.node_id, 'node_id_2')
+        self.assertEqual(node2.is_public, True)
+        self.assertEqual(node2.public_url, 'test url 456')
 
=== added file 'tests/test_public_file_info.py'
--- tests/test_public_file_info.py	1970-01-01 00:00:00 +0000
+++ tests/test_public_file_info.py	2016-11-15 23:38:26 +0000
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Tests for generation node data type."""
+
+import unittest
+
+from ubuntuone.storageprotocol import protocol_pb2, public_file_info, request
+
+SHARE = "share_id"
+NODE = "node_id"
+PUBLIC_URL = "test public url"
+
+
+def get_message():
+    """Returns a PUBLIC_FILE_INFO message with sample data in the fields."""
+    message = protocol_pb2.Message()
+    message.type = protocol_pb2.Message.PUBLIC_FILE_INFO
+    message.public_file_info.share = str(SHARE)
+    message.public_file_info.node = str(NODE)
+    message.public_file_info.is_public = True
+    message.public_file_info.public_url = PUBLIC_URL
+    return message
+
+
+class DeltaTestCase(unittest.TestCase):
+    """Check Delta data type."""
+
+    def test_correct_attributes(self):
+        """Assert over attribute correctness."""
+        m = public_file_info.PublicFileInfo.from_message(get_message())
+        self.assertEqual(m.share_id, SHARE)
+        self.assertEqual(m.node_id, NODE)
+        self.assertEqual(m.is_public, True)
+        self.assertEqual(m.public_url, PUBLIC_URL)
+
+    def test_is_equal(self):
+        """Test object equality."""
+        m = public_file_info.PublicFileInfo.from_message(get_message())
+        m2 = public_file_info.PublicFileInfo.from_message(get_message())
+        self.assertEqual(m, m2)
+
+    def test_root_share_id(self):
+        """Test that DeltaInfo.from_message works with request.ROOT."""
+        msg = get_message()
+        msg.public_file_info.share = request.ROOT
+        m = public_file_info.PublicFileInfo.from_message(msg)
+        self.assertEqual(m.share_id, request.ROOT)
 
=== modified file 'ubuntuone/storageprotocol/client.py'
--- ubuntuone/storageprotocol/client.py	2016-10-11 19:01:04 +0000
+++ ubuntuone/storageprotocol/client.py	2016-11-15 23:38:26 +0000
@@ -1,12 +1,5 @@
-# ubuntuone.storageprotocol.client - the storage protocol client
-#
-# Author: Lucio Torre <[e-mail]>
-# Author: Natalia B. Bidart <[e-mail]>
-# Author: Guillermo Gonzalez <[e-mail]>
-# Author: Facundo Batista <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-#
 # Copyright 2009-2015 Canonical Ltd.
+# Copyright 2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # 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,
@@ -32,6 +25,7 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
+
 """The storage protocol client."""
 
 import logging
@@ -47,6 +41,7 @@
 from ubuntuone.storageprotocol import (
     delta,
     protocol_pb2,
+    public_file_info,
     request,
     sharersp,
     volumes,
@@ -538,6 +533,18 @@
         p.start()
         return p.deferred
 
+    def change_public_access(self, share_id, node_id, is_public):
+        """Change the public access of a file."""
+        p = ChangePublicAccess(self, share_id, node_id, is_public)
+        p.start()
+        return p.deferred
+
+    def list_public_files(self):
+        """List the public files."""
+        p = ListPublicFiles(self)
+        p.start()
+        return p.deferred
+
     def delete_volume(self, volume_id):
         """Delete 'volume' on the server, removing the associated tree.
 
@@ -961,6 +968,62 @@
             self._default_process_message(message)
 
 
+class ChangePublicAccess(request.Request):
+    """Change the public access of a file."""
+
+    __slots__ = ('share_id', 'node_id', 'is_public', 'public_url')
+
+    def __init__(self, protocol, share_id, node_id, is_public):
+        request.Request.__init__(self, protocol)
+        self.public_url = None
+
+        self.share_id = str(share_id)
+        self.node_id = str(node_id)
+        self.is_public = is_public
+
+    def _start(self):
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.CHANGE_PUBLIC_ACCESS
+        message.change_public_access.share = self.share_id
+        message.change_public_access.node = self.node_id
+        message.change_public_access.is_public = self.is_public
+        self.sendMessage(message)
+
+    def processMessage(self, message):
+        if message.type == protocol_pb2.Message.OK:
+            self.public_url = message.public_url
+            self.done()
+        else:
+            self._default_process_message(message)
+
+
+class ListPublicFiles(request.Request):
+    """List all the public files for an user."""
+
+    __slots__ = ('public_files',)
+
+    def __init__(self, protocol):
+        """List volumes."""
+        request.Request.__init__(self, protocol)
+        self.public_files = []
+
+    def _start(self):
+        """Send the LIST_PUBLIC_FILES message to the server."""
+        message = protocol_pb2.Message()
+        message.type = protocol_pb2.Message.LIST_PUBLIC_FILES
+        self.sendMessage(message)
+
+    def processMessage(self, message):
+        """Process the answer from the server."""
+        if message.type == protocol_pb2.Message.PUBLIC_FILE_INFO:
+            info = public_file_info.PublicFileInfo.from_message(message)
+            self.public_files.append(info)
+        elif message.type == protocol_pb2.Message.PUBLIC_FILE_INFO_END:
+            self.done()
+        else:
+            self._default_process_message(message)
+
+
 class Move(request.Request):
     """Move a node.
 
 
=== modified file 'ubuntuone/storageprotocol/protocol.proto'
--- ubuntuone/storageprotocol/protocol.proto	2012-03-29 20:28:09 +0000
+++ ubuntuone/storageprotocol/protocol.proto	2016-11-15 23:38:26 +0000
@@ -1,7 +1,6 @@
 /*
- ubuntuone.storageprotocol.protocol_pb2 - storage protocol
-
  Copyright 2009-2012 Canonical Ltd.
+ Copyright 2016 Chicharreros (https://launchpad.net/~chicharreros)
 
  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,
@@ -97,6 +96,11 @@
         GET_DELTA = 51;          // ask for a delta
         DELTA_INFO = 52;         // a row of the delta
         DELTA_END = 53;          // marks the end of a delta
+
+        CHANGE_PUBLIC_ACCESS = 55;  // change the public access of a file
+        PUBLIC_FILE_INFO = 56;  // information for a public file
+        PUBLIC_FILE_INFO_END = 57;  // marks the end of a bunch of public file infos
+        LIST_PUBLIC_FILES = 58;  // get the list of public files for the user
     }
 
     required MessageType type = 2; // The type of the message contained
@@ -159,6 +163,11 @@
     optional GetDelta get_delta = 38;
     optional DeltaInfo delta_info = 39;
     optional DeltaEnd delta_end = 40;
+
+    // public files
+    optional ChangePublicAccess change_public_access = 45;
+    optional bytes public_url = 46;
+    optional PublicFileInfo public_file_info = 47;
 }
 
 message Error {
@@ -481,6 +490,19 @@
     optional uint64 free_bytes = 3; // this will be just a hint if full == False
 }
 
+message ChangePublicAccess {
+    optional bytes share = 1;
+    optional bytes node = 2;
+    optional bool is_public = 3;
+}
+
+message PublicFileInfo {
+    optional bytes share = 1;
+    optional bytes node = 2;
+    optional bool is_public = 3;
+    optional bytes public_url = 4;
+}
+
 /*
 == changes ==
 
 
=== added file 'ubuntuone/storageprotocol/public_file_info.py'
--- ubuntuone/storageprotocol/public_file_info.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/storageprotocol/public_file_info.py	2016-11-15 23:38:26 +0000
@@ -0,0 +1,55 @@
+# Copyright 2016 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# 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/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Wrapper class for public file information."""
+
+
+class PublicFileInfo(object):
+    """Hold the public file object information."""
+
+    def __init__(self, share_id, node_id, is_public, public_url):
+        self.share_id = share_id
+        self.node_id = node_id
+        self.is_public = is_public
+        self.public_url = public_url
+
+    @classmethod
+    def from_message(cls, message):
+        """Creates the object using the information from a message."""
+        info = message.public_file_info
+        result = cls(
+            share_id=info.share,
+            node_id=info.node,
+            is_public=info.is_public,
+            public_url=info.public_url)
+        return result
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+
+        return self.__dict__ == other.__dict__