Merge lp:~mandel/ubuntuone-windows-installer/implement_ipc into lp:ubuntuone-windows-installer/beta

[Manuel de la Peña]

Implements the first part of the IPC. This branch contains the code that will communicate with python by requesting a TcpClient to a TcpClient factory which will be implemented in an other branch.

[John O'Brien (jdobrien)]

I'm sorry I still don't have my test environment setup to actually test this.

But I wanted to point out, due to a concern with the Ubuntu client, UDFs can only be created with the path starting with ~/. I think it's something the windows client is going to need to handle as it gets these back from the server.

This code looks good from a visual review.

PS. You may find it advantageous to keep branches smaller than 2k line diffs :)

review: Approve

[Rick McBride (rmcbride)]

Tests pass. Looks good.

I second jdo's comment regarding the diff limit. Makes branch approvals happen a lot faster :)

review: Approve

[Manuel de la Peña (mandel)]

I agree with the merge sizes, but most of the time is the bloody windows devel enviroment that keeps adding bloody xml everywhere....

=== modified file '.bzrignore'
--- .bzrignore	2010-08-02 17:57:48 +0000
+++ .bzrignore	2010-08-11 10:35:55 +0000
@@ -26,3 +26,4 @@
 src/UbuntuOneClient/obj
 src/UbuntuOneClient.Tests/bin
 src/UbuntuOneClient.Tests/obj
+*.ReSharper

=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs	2010-08-05 07:13:28 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs	2010-08-11 10:35:55 +0000
@@ -33,13 +33,6 @@
     public interface ISyncConfiguration
     {
         /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        [OperationContract(IsOneWay = true)]
-        void RegisterClient();
-
-        /// <summary>
         /// Returns the throttling limits that have been set up for the daemon.
         /// </summary>
         /// <returns>The upload and downloads limits that the daemon has.</returns>

=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs	2010-08-05 07:13:28 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -33,12 +33,6 @@
         SessionMode = SessionMode.Required)]
 	public interface ISyncDaemon
 	{
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        [OperationContract(IsOneWay = true)]
-        void RegisterClient();
 
 		/// <summary>
 		/// Allows to start the daemon by a client.
@@ -67,6 +61,13 @@
 		bool TryStop();
 
         /// <summary>
+        /// Returns the port number of the socket that the synd daemo is listening to for communication.
+        /// </summary>
+        /// <returns></returns>
+        [OperationContract]
+	    int GetListeningSocket();
+
+        /// <summary>
         /// Allows to query the service about the current status of the daemon.
         /// </summary>
         /// <returns>A data contract that contains the current status of the daemon.</returns>

=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs	2010-08-02 10:07:10 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs	2010-08-11 10:35:55 +0000
@@ -32,12 +32,6 @@
         SessionMode = SessionMode.Required)]
     public interface ISyncFileManager
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        [OperationContract(IsOneWay = true)]
-        void RegisterClient();
 
         /// <summary>
         /// Returns the metadata

=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs	2010-08-05 08:01:59 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs	2010-08-11 10:35:55 +0000
@@ -33,12 +33,6 @@
         SessionMode = SessionMode.Required)]
     public interface ISyncFolders
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        [OperationContract(IsOneWay = true)]
-        void RegisterClient();
 
         /// <summary>
         /// Creates a new udf for the given path.

=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs	2010-08-05 07:13:28 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs	2010-08-11 10:35:55 +0000
@@ -33,12 +33,6 @@
         SessionMode = SessionMode.Required)]
     public interface ISyncShares
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        [OperationContract(IsOneWay = true)]
-        void RegisterClient();
 
         /// <summary>
         /// Allows the client to query and get all the different shares that the user has.

=== modified file 'src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs'
--- src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs	2010-08-05 07:13:28 +0000
+++ src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj	2010-07-30 09:33:20 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj	2010-08-11 10:35:55 +0000
@@ -55,12 +55,17 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="Net\TcpClientCommunicatorFixture.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Protobuf\ConvertFixture.cs" />
     <Compile Include="Protobuf\SyncConfigurationMessageFactoryFixture.cs" />
     <Compile Include="Protobuf\SyncDaemonMessageFactoryFixture.cs" />
     <Compile Include="Protobuf\SyncFolderMessageFactoryFixture.cs" />
     <Compile Include="Protobuf\SyncShareMessageFactoryFixture.cs" />
+    <Compile Include="SyncConfigurationServiceFixture.cs" />
+    <Compile Include="SyncDaemonServiceFixture.cs" />
+    <Compile Include="SyncFoldersServiceFixture.cs" />
+    <Compile Include="SyncSharesServiceFixture.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Canonical.UbuntuOne.Common\Canonical.UbuntuOne.Common.csproj">
@@ -73,6 +78,10 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <Reference Include="log4net, Version=1.2.10.0, Culture=neutral, PublicKeyToken=1b44e1d426115821, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\log4net\log4net.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework, Version=2.5.5.10112, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Nunit\nunit.framework.dll</HintPath>
@@ -81,9 +90,16 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Protobuf-net\protobuf-net.dll</HintPath>
     </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\RhinoMocks\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include="Microsoft.Net.Framework.2.0">

=== added directory 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Net'
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Net/TcpClientCommunicatorFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Net/TcpClientCommunicatorFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Net/TcpClientCommunicatorFixture.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Net.Sockets;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Tests.Net
+{
+    [TestFixture]
+    public class TcpClientCommunicatorFixture
+    {
+        #region Variables
+
+        private ITcpClientFactory _clientFactory;
+        private ITcpClient _client;
+        private IProtobufSerializer _serializer;
+        private NetworkStream _stream;
+        private bool _wasCalled;
+        private MockRepository _mocks;
+        private ConfigurationMessage _message;
+        private TcpClientCommunicator<ConfigurationMessage> _communitcator;
+
+        #endregion
+
+        #region Setup & TearDown
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _clientFactory = _mocks.StrictMock<ITcpClientFactory>();
+            _client = _mocks.StrictMock<ITcpClient>();
+            _serializer = _mocks.StrictMock<IProtobufSerializer>();
+            _message = _mocks.Stub<ConfigurationMessage>();
+            _stream = _mocks.StrictMock<NetworkStream>();
+            _wasCalled = false;
+            _communitcator = new TcpClientCommunicator<ConfigurationMessage>
+            {
+                ProtobufSerializer = _serializer,
+                TcpClientFactory = _clientFactory
+            };
+        }
+
+        #endregion
+
+        #region Helpers
+
+        private string ConvertCallback(ConfigurationMessage message)
+        {
+            _wasCalled = true;
+            return "mandel";
+        }
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void SendMessageTest()
+        {
+            using(_mocks.Record())
+            {
+                Expect.Call(_clientFactory.GetClient())
+                    .Return(_client)
+                    .Repeat.Once();
+                Expect.Call(_client.GetStream())
+                    .Return(_stream)
+                    .Repeat.Once();
+                Expect.Call(() => _serializer.Serialize(_stream, _message))
+                    .Repeat.Once();
+                Expect.Call(() => _client.Close())
+                    .Repeat.Once();
+                Expect.Call(() => _stream.Close())
+                    .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                _communitcator.SendMessage(_message);
+            }
+        }
+
+        [Test]
+        public void SendReceiveMessage()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_clientFactory.GetClient())
+                    .Return(_client)
+                    .Repeat.Once();
+                Expect.Call(_client.GetStream())
+                    .Return(_stream)
+                    .Repeat.Once();
+                Expect.Call(() => _serializer.Serialize(_stream, _message))
+                    .Repeat.Once();
+                Expect.Call(_serializer.Deserialize<ConfigurationMessage>(_stream))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _client.Close())
+                    .Repeat.Once();
+                Expect.Call(() => _stream.Close())
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _communitcator.SendReceiveMessage<string>(_message, ConvertCallback);
+                Assert.IsTrue(_wasCalled, "The convert callback was not called.");
+            }
+        }
+
+        #endregion
+
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/ConvertFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/ConvertFixture.cs	2010-07-13 09:12:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/ConvertFixture.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncDaemonMessageFactoryFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncDaemonMessageFactoryFixture.cs	2010-07-13 09:12:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncDaemonMessageFactoryFixture.cs	2010-08-11 10:35:55 +0000
@@ -71,5 +71,37 @@
             var message = _factory.QueryUploads();
             Assert.AreEqual(SyncDaemonMessage.MessageType.QUERYUPLOADS, message.Type);
         }
+
+        [TestCase("NodeId1", "ShareId1")]
+        [TestCase("NodeId2", "ShareId2")]
+        [TestCase("NodeId3", "ShareId3")]
+        public void ScheduleAsNextTest(string shareId, string nodeId)
+        {
+            var message = _factory.ScheduleAsNext(shareId, nodeId);
+            Assert.AreEqual(SyncDaemonMessage.MessageType.SCHEDULENEXT, message.Type);
+            Assert.AreEqual(nodeId, message.NextNodeId);
+            Assert.AreEqual(shareId, message.NextShareId);
+        }
+
+        [Test]
+        public void ConnectTest()
+        {
+            var message = _factory.Connect();
+            Assert.AreEqual(SyncDaemonMessage.MessageType.CONNECT, message.Type);
+        }
+
+        [Test]
+        public void DisconnectTest()
+        {
+            var message = _factory.Disconnect();
+            Assert.AreEqual(SyncDaemonMessage.MessageType.DISCONNECT, message.Type);
+        }
+
+        [Test]
+        public void QuitTest()
+        {
+            var message = _factory.Quit();
+            Assert.AreEqual(SyncDaemonMessage.MessageType.QUIT, message.Type);
+        }
     }
 }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncFolderMessageFactoryFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncFolderMessageFactoryFixture.cs	2010-07-13 09:12:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Protobuf/SyncFolderMessageFactoryFixture.cs	2010-08-11 10:35:55 +0000
@@ -119,7 +119,7 @@
         [Test]
         public void RefreshFolders()
         {
-            var message = _factory.RefreshFolders();
+            var message = _factory.RefreshVolumes();
             Assert.AreEqual(FolderMessage.MessageType.REFRESH, message.Type);
         }
 

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncConfigurationServiceFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncConfigurationServiceFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncConfigurationServiceFixture.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Tests
+{
+    [TestFixture]
+    public class SyncConfigurationServiceFixture
+    {
+        #region Variables
+
+        private ISyncConfigurationMessageFactory _messageFactory;
+        private ITcpClientCommunicator<ConfigurationMessage> _communicator;
+        private ConfigurationMessage _message;
+        private MockRepository _mocks;
+        private SyncConfigurationService _service;
+
+        #endregion
+
+        #region Setup
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _messageFactory = _mocks.StrictMock<ISyncConfigurationMessageFactory>();
+            _communicator = _mocks.StrictMock<ITcpClientCommunicator<ConfigurationMessage>>();
+            _message = _mocks.StrictMock<ConfigurationMessage>();
+            _service = new SyncConfigurationService
+            {
+                SyncConfigurationMessageFactory = _messageFactory,
+                TcpClientCommunicator = _communicator
+            };
+        }
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void GetThrottlingLimitsCorrectMessageTest()
+        {
+            _message.Type = ConfigurationMessage.MessageType.THROTTLING;
+            _message.Throttling = new ConfigurationMessage.ThrottlingLimitsMessage();
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryThrottling())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<ThrottlingData>(_message, Convert.ToThrottlingData))
+                    .Return(new ThrottlingData())
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetThrottlingLimits();
+            }
+        }
+
+        [TestCase(3, 4)]
+        [TestCase(34, 56)]
+        public void SetThrottlingLimitsCorrectMessageTest(int download, int upload)
+        {
+            var data = new ThrottlingData
+            {
+                Download = download,
+                Upload = upload
+            };
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.SetThrottlingLimits(data))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.SetThrottlingLimits(data);
+            }
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void EnableThrottlingLimitsCorrectMessageTest(bool isEnabled)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.EnableThrottling(isEnabled))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.EnableThrottlingLimits(isEnabled);
+            }
+        }
+
+        [Test]
+        public void IsEnabledThrottlingLimitsCorrectMessageTest()
+        {
+            _message.Type = ConfigurationMessage.MessageType.ENABLETHROTTLING;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryThrottling())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<bool>(_message, Convert.ToIsEnabledThrottling))
+                    .Return(true)
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.IsEnabledThrottlingLimits();
+            }
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void EnableUdfAutosubscribeCorrectMessageTest(bool isEnabled)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.EnablesAutosubscribe(isEnabled))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.EnableUdfAutosubscribe(isEnabled);
+            }
+        }
+
+        [Test]
+        public void IsEnabledUdfAutosubscribeCorrectMessageTest()
+        {
+            _message.Type = ConfigurationMessage.MessageType.ENABLEAUTOSUBSCRIBE;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryThrottling())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<bool>(_message, Convert.ToIsAutosubscribe))
+                    .Return(false)
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.IsEnabledUdfAutosubscribe();
+            }
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncDaemonServiceFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncDaemonServiceFixture.cs	2010-07-07 10:41:49 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncDaemonServiceFixture.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -17,7 +17,9 @@
  * 
  * Authors: Manuel de la Peña <[e-mail]>
  */
+using System.Collections.Generic;
 using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
 using log4net;
 using NUnit.Framework;
 using Rhino.Mocks;
@@ -27,31 +29,44 @@
     [TestFixture]
     public class SyncDaemonServiceFixture
     {
-        #region Setup
+        #region Variables
 
+        private ISyncDaemonMessageFactory _messageFactory;
+        private SyncDaemonMessage _message;
         private MockRepository _mocks;
-        private IAuthentication _auth;
-        private IProcessManagerFactory _managerFactory;
-        private IProcessManager _processManager;
         private SyncDaemonService _service;
+        private IAuthentication _authentication;
         private ILog _logger;
+        private IProcessManagerFactory _processManagerFactory;
+        private IProcessManager _processManager;
+        private ITcpClientCommunicator<SyncDaemonMessage> _communicator;
+
+        #endregion
+
+        #region Setup
 
         [SetUp]
         public void Setup()
         {
             _mocks = new MockRepository();
-            _auth = _mocks.DynamicMock<IAuthentication>();
-            _managerFactory = _mocks.DynamicMock<IProcessManagerFactory>();
-            _processManager = _mocks.DynamicMock<IProcessManager>();
+            _messageFactory = _mocks.StrictMock<ISyncDaemonMessageFactory>();
+            _message = _mocks.StrictMock<SyncDaemonMessage>();
             _logger = _mocks.DynamicMock<ILog>();
+            _authentication = _mocks.StrictMock<IAuthentication>();
+            _processManagerFactory = _mocks.StrictMock<IProcessManagerFactory>();
+            _processManager = _mocks.StrictMock<IProcessManager>();
+            _communicator = _mocks.StrictMock<ITcpClientCommunicator<SyncDaemonMessage>>();
             _service = new SyncDaemonService
             {
+                SyncDaemonMessageFactory = _messageFactory,
+                Authentication = _authentication,
                 Logger = _logger,
-                ProcessManagerFactory = _managerFactory,
-                Authentication = _auth
+                ProcessManagerFactory = _processManagerFactory,
+                TcpClientCommunicator =  _communicator
             };
         }
 
+
         #endregion
 
         #region Tests
@@ -67,21 +82,21 @@
             {
                 // expect to call the authentication class as well as
                 // the factory and the manager.
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
                 Expect.Call(() => _processManager.Start())
                     .Repeat.Once();
-                    
+
             }
             using (_mocks.Playback())
             {
@@ -100,15 +115,15 @@
             {
                 // expect to call the authentication class as well as
                 // the factory and the manager.
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
@@ -134,15 +149,15 @@
             {
                 // we try to run the process but we will throw an exception when
                 // trying to start the process
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
@@ -167,15 +182,15 @@
             {
                 // we try to run the process but we will throw an exception when
                 // trying to start the process
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
@@ -197,11 +212,11 @@
         {
             using (_mocks.Record())
             {
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(false)
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Repeat.Never();
 
                 Expect.Call(() => _processManager.Start())
@@ -219,21 +234,23 @@
         [Test]
         public void StopTest()
         {
-            using(_mocks.Record())
+            using (_mocks.Record())
             {
                 // set basic set up to be able to start and stop
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
+                Expect.Call(() => _processManager.Start())
+                    .Repeat.Once();
                 Expect.Call(() => _processManager.Stop())
                     .Repeat.Once();
             }
@@ -254,18 +271,21 @@
             using (_mocks.Record())
             {
                 // set basic set up to be able to start and stop
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
+                Expect.Call(() => _processManager.Start())
+                    .Repeat.Once();
+
                 Expect.Call(() => _processManager.Stop())
                     .Repeat.Once();
             }
@@ -286,11 +306,11 @@
         {
             using (_mocks.Record())
             {
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
             }
@@ -310,18 +330,21 @@
         {
             using (_mocks.Record())
             {
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
+                Expect.Call(() => _processManager.Start())
+                    .Repeat.Once();
+
                 Expect.Call(() => _processManager.Stop())
                     .Throw(new ProcessManagementException());
             }
@@ -342,18 +365,21 @@
 
             using (_mocks.Record())
             {
-                SetupResult.For(_auth.IsAuthenticated)
+                SetupResult.For(_authentication.IsAuthenticated)
                     .Return(true)
                     .Repeat.Once();
 
-                SetupResult.For(_auth.Username)
+                SetupResult.For(_authentication.Username)
                     .Return("mandel")
                     .Repeat.Once();
 
-                Expect.Call(_managerFactory.GetManager())
+                Expect.Call(_processManagerFactory.GetManager())
                     .Return(_processManager)
                     .Repeat.Once();
 
+                Expect.Call(() => _processManager.Start())
+                    .Repeat.Once();
+
                 Expect.Call(() => _processManager.Stop())
                     .Throw(new ProcessManagementException());
             }
@@ -365,7 +391,178 @@
             }
         }
 
+        [Test]
+        public void GetListeningSocketTest()
+        {
+            Assert.Ignore("To be implemented.");    
+        }
+
+        [Test]
+        public void GetCurrentStatusCorrectMessageTest()
+        {
+            _message.Type = SyncDaemonMessage.MessageType.STATUS;
+            _message.State = new SyncDaemonMessage.StateMessage();
+            _mocks.BackToRecord(_message);
+            using(_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryState())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<StateData>(_message, Convert.ToStateData))
+                    .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                _service.GetCurrentStatus();
+            }
+        }
+
+        [Test]
+        public void GetCurrentDownloadsCorrectMessageTest()
+        {
+            _message.Type = SyncDaemonMessage.MessageType.DOWNLOADS;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryDownloads())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<DownloadData>>(_message, Convert.ToCurrentDownloads))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetCurrentDownloads();
+            }
+        }
+
+        [Test]
+        public void GetWaitingContentCorrectMessageTest()
+        {
+            _message.Type = SyncDaemonMessage.MessageType.WAITING;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryWaiting())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<QueueItemData>>(_message, Convert.ToCurrentWaiting))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetWaitingContent();
+            }
+        }
+
+        [TestCase("ShareId", "NodeId")]
+        [TestCase("Share", "Node")]
+        public void ScheduleAsNextTest(string shareId, string nodeId)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.ScheduleAsNext(shareId, nodeId))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.ScheduleAsNext(shareId, nodeId);
+            }
+        }
+
+        [Test]
+        public void GetCurrentUploadsCorrectMessageTest()
+        {
+            _message.Type = SyncDaemonMessage.MessageType.UPLOADS;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryUploads())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<UploadData>>(_message, Convert.ToCurrentUploads))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetCurrentUploads();
+            }
+        }
+
+        [Test]
+        public void ConnectTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.Connect())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.Connect();
+            }
+        }
+
+        [Test]
+        public void DisconnectTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.Disconnect())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.Disconnect();
+            }
+        }
+
+        [Test]
+        public void GetRootDirectoryTest()
+        {
+            _message.Type = SyncDaemonMessage.MessageType.ROOT;
+            _mocks.BackToRecord(_message);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryRoot())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<string>(_message, Convert.ToRootDirectory))
+                    .Return("test")
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetRootDirectory();
+            }
+        }
+
+        [Test]
+        public void QuitTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.Quit())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.Quit();
+            }
+        }
+
         #endregion
-
     }
 }

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncFoldersServiceFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncFoldersServiceFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncFoldersServiceFixture.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Collections.Generic;
+using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Tests
+{
+    [TestFixture]
+    public class SyncFoldersServiceFixture
+    {
+        #region Variables
+
+        private ISyncFolderMessageFactory _messageFactory;
+        private FolderMessage _message;
+        private MockRepository _mocks;
+        private SyncFoldersService _service;
+        private ITcpClientCommunicator<FolderMessage> _communicator;
+
+        #endregion
+
+        #region Setup & Tear downs
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _messageFactory = _mocks.StrictMock<ISyncFolderMessageFactory>();
+            _message = _mocks.StrictMock<FolderMessage>();
+            _communicator = _mocks.StrictMock<ITcpClientCommunicator<FolderMessage>>();
+            _service = new SyncFoldersService
+            {
+                SyncFolderMessageFactory = _messageFactory,
+                TcpClientCommunicator = _communicator
+            };
+        }
+
+        #endregion
+
+        #region Tests
+
+        [TestCase("path1")]
+        [TestCase("path to new location")]
+        public void CreateFolderUdfTest(string path)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.CreateFolder(path))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.CreateFolderUdf(path);
+            }
+        }
+
+        [TestCase("path1")]
+        [TestCase("path to old location")]
+        public void DeleteFolderUdfTest(string path)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.DeleteFolder(path))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.DeleteFolderUdf(path);
+            }
+        }
+
+        [Test]
+        public void GetFoldersCorrectMessageTest()
+        {
+            var data = new FolderMessage.UdfDataMessage
+            {
+                Node = new FolderMessage.NodeMessage()
+            };
+            _message = new FolderMessage(new List<FolderMessage.UdfDataMessage>())
+            {
+                Type = FolderMessage.MessageType.FOLDERS
+            };
+            _message.Udfs.Add(data);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryFolders())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<UdfData>>(_message, Convert.ToAllFolders))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetFolders();
+            }
+        }
+
+        [TestCase("firstId")]
+        [TestCase("secondId")]
+        public void SubscribeTest(string folderId)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.Subscribe(folderId))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.Subscribe(folderId);
+            }
+        }
+
+        [TestCase("firstId")]
+        [TestCase("secondId")]
+        public void UnsubscribeTest(string folderId)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.Unsubscribe(folderId))
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage((_message)))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.Unsubscribe(folderId);
+            }
+        }
+
+        [TestCase("FirstPath")]
+        [TestCase("secondPath")]
+        public void GetInfoCorrectMessageTest(string path)
+        {
+            var data = new FolderMessage.UdfDataMessage
+            {
+                Node = new FolderMessage.NodeMessage()
+            };
+            _message = new FolderMessage(new List<FolderMessage.UdfDataMessage>())
+            {
+                Type = FolderMessage.MessageType.INFO
+            };
+            _message.Udfs.Add(data);
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryInfo(path))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<UdfData>(_message, Convert.ToUdfData))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetInfo(path);
+            }
+        }
+
+        [Test]
+        public void RefreshVolumes()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.RefreshVolumes())
+                    .Return(_message);
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.RefreshVolumes();
+            }
+        }
+
+        #endregion
+    }
+}

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncSharesServiceFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncSharesServiceFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/SyncSharesServiceFixture.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Collections.Generic;
+using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Tests
+{
+    [TestFixture]
+    public class SyncSharesServiceFixture
+    {
+        #region Variables
+
+        private ISyncShareMessageFactory _messageFactory;
+        private ShareMessage _message;
+        private MockRepository _mocks;
+        private SyncSharesService _service;
+        private ITcpClientCommunicator<ShareMessage> _communicator;
+
+        #endregion
+
+        #region Setup & Tear down
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _messageFactory = _mocks.StrictMock<ISyncShareMessageFactory>();
+            _message = _mocks.StrictMock<ShareMessage>();
+            _communicator = _mocks.StrictMock<ITcpClientCommunicator<ShareMessage>>();
+            _service = new SyncSharesService
+            {
+                SyncShareMessageFactory = _messageFactory,
+                TcpClientCommunicator = _communicator
+            };
+        }
+
+        #endregion
+
+        #region Tests
+ 
+        [Test]
+        public void GetSharesTest()
+        {
+            using(_mocks.Record())
+            {
+                Expect.Call(_messageFactory.QueryShares())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<ShareData>>(_message, Convert.ToGetShares))
+                    .Return(new List<ShareData>())
+                    .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                _service.GetShares();
+            }
+        }
+
+        [TestCase("ShareId")]
+        public void AcceptShare(string shareId)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.AcceptShare(shareId))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.AcceptShare(shareId);
+            }
+        }
+
+        [TestCase("ShareID")]
+        public void RejectShare(string shareId)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.RejectShare(shareId))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.RejectShare(shareId);
+            }
+        }
+
+        [TestCase("Path", "Username", "Name", AccessLevel.MODIFY)]
+        public void CreateShare(string path, string username, string name, AccessLevel accessLevel)
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.CreateShare(path, username, name, accessLevel))
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.CreateShare(path, username, name, accessLevel);
+            }
+        }
+
+        [Test]
+        public void UpdateShares()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.UpdateShares())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(() => _communicator.SendMessage(_message))
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.UpdateShares();
+            }
+        }
+
+        [Test]
+        public void GetShared()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_messageFactory.GetShared())
+                    .Return(_message)
+                    .Repeat.Once();
+                Expect.Call(_communicator.SendReceiveMessage<IList<ShareData>>(_message, Convert.ToGetShared))
+                    .Return(new List<ShareData>())
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _service.GetShared();
+            }
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-08-03 15:34:47 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-08-11 10:35:55 +0000
@@ -71,11 +71,17 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="Net\ITcpClient.cs" />
+    <Compile Include="Net\ITcpClientCommunicator.cs" />
+    <Compile Include="Net\ITcpClientFactory.cs" />
+    <Compile Include="Net\TcpClientCommunicator.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="ProjectInstaller.cs">
       <SubType>Component</SubType>
     </Compile>
     <Compile Include="Protobuf\FolderMessageExtensions.cs" />
+    <Compile Include="Protobuf\IProtobufSerializer.cs" />
+    <Compile Include="Protobuf\ProtobufSerializer.cs" />
     <Compile Include="Protobuf\ShareMessageExtensions.cs" />
     <Compile Include="SyncConfigurationService.cs" />
     <Compile Include="SyncDaemonService.cs" />

=== added directory 'src/Canonical.UbuntuOne.ProcessDispatcher/Net'
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClient.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClient.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClient.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Net.Sockets;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Net
+{
+    /// <summary>
+    /// Interface to be implemented by a TcpClient that allows to communicate with the 
+    /// python code.
+    /// </summary>
+    internal interface ITcpClient
+    {
+        /// <summary>
+        /// Returns the stream that is used by the tcp client to communicate with
+        /// the python code.
+        /// </summary>
+        /// <returns>A stream that can send data to the python process.</returns>
+        NetworkStream GetStream();
+
+        /// <summary>
+        /// Closes the TcpClient release the different used resources.
+        /// </summary>
+        void Close();
+    }
+}

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientCommunicator.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientCommunicator.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientCommunicator.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Net
+{
+    /// <summary>
+    /// Interface to be implemented by a class that allows to send an receive
+    /// protobuf messages using sockets and a tcp client.
+    /// </summary>
+    internal interface ITcpClientCommunicator<TMessage>
+    {
+        /// <summary>
+        /// Sends a message to the python code but does not expecte and answer
+        /// back.
+        /// </summary>
+        /// <param name="message">The message to be sent to the python code.</param>
+        void SendMessage(TMessage message);
+
+        /// <summary>
+        /// Sends a message to the python code and expects and answer back.
+        /// </summary>
+        /// <typeparam name="TResult">The type of object that is expected to be in the return from the 
+        /// python code.</typeparam>
+        /// <param name="message">The message to be sent to the python code.</param>
+        /// <param name="conversion">A function that can convert the message type from the python code to 
+        /// the expected result type.</param>
+        /// <returns>The resposne that the python returned once the message has been processed.</returns>
+        TResult SendReceiveMessage<TResult>(TMessage message, Func<TMessage, TResult> conversion);
+    }
+}

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientFactory.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Net/ITcpClientFactory.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Net.Sockets;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Net
+{
+    /// <summary>
+    /// Interface to be implemented by a factory that will return TcpClients that are configured ready
+    /// to communicate with the python code.
+    /// </summary>
+    internal interface ITcpClientFactory
+    {
+        /// <summary>
+        /// Returns a client that allows to communicate with the python code.
+        /// </summary>
+        /// <returns>A TcpClient configured to talk with the python code through sockets.</returns>
+        ITcpClient GetClient();
+    }
+}

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Net/TcpClientCommunicator.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Net/TcpClientCommunicator.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Net/TcpClientCommunicator.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Net
+{
+    /// <summary>
+    /// Implementation of ITcpClientCommunicator that allows to send and receive
+    /// messages from the python code.
+    /// </summary>
+    internal class TcpClientCommunicator<TMessage> : ITcpClientCommunicator<TMessage>
+    {
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the factory that is used to crete a tcp client that will communicate with 
+        /// the python code.
+        /// </summary>
+        internal ITcpClientFactory TcpClientFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the serializer that is used to serialize the protobuf messages that 
+        /// are used to communicate with the python code.
+        /// </summary>
+        internal IProtobufSerializer ProtobufSerializer { get; set; }
+
+        #endregion
+
+        #region Implementation of ITcpClientCommunicator<TMessage>
+
+        /// <summary>
+        /// Sends a message to the python code but does not expecte and answer
+        /// back.
+        /// </summary>
+        /// <param name="message">The message to be sent to the python code.</param>
+        public void SendMessage(TMessage message)
+        {
+            // get the tcp client that will be used to communicate with python
+            var client = TcpClientFactory.GetClient();
+            var stream = client.GetStream();
+            ProtobufSerializer.Serialize(stream, message);
+            stream.Close();
+            client.Close();
+        }
+
+        /// <summary>
+        /// Sends a message to the python code and expects and answer back.
+        /// </summary>
+        /// <typeparam name="TResult">The type of object that is expected to be in the return from the 
+        /// python code.</typeparam>
+        /// <param name="message">The message to be sent to the python code.</param>
+        /// <param name="conversion">A function that can convert the message type from the python code to 
+        /// the expected result type.</param>
+        /// <returns>The resposne that the python returned once the message has been processed.</returns>
+        public TResult SendReceiveMessage<TResult>(TMessage message, Func<TMessage, TResult> conversion)
+        {
+            // get the tcp client that will be used to communicate with python
+            var client = TcpClientFactory.GetClient();
+            var stream = client.GetStream();
+            ProtobufSerializer.Serialize(stream, message);
+            var response = ProtobufSerializer.Deserialize<TMessage>(stream);
+            var result = conversion(response);
+            // close resources
+            stream.Close();
+            client.Close();
+            return result;
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Properties/AssemblyInfo.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Properties/AssemblyInfo.cs	2010-07-30 09:33:20 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Properties/AssemblyInfo.cs	2010-08-11 10:35:55 +0000
@@ -23,3 +23,4 @@
 // If you need to expose a type to COM, use [ComVisible(true)] on that type.
 [assembly: ComVisible(false)]
 [assembly: InternalsVisibleTo("Canonical.UbuntuOne.ProcessDispatcher.Tests")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/Convert.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/Convert.cs	2010-07-13 10:45:23 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/Convert.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -255,6 +255,7 @@
         {
             ValidateArgs.Begin()
                 .IsNotNull(udfProto)
+                .IsNotNull(udfProto.Node)
                 .Check();
             return new UdfData
             {

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/IProtobufSerializer.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/IProtobufSerializer.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/IProtobufSerializer.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.IO;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Interface to be implemented by a serializer that can serialize and deserialize the protobuf
+    /// messages that are used in the application for IPC.
+    /// </summary>
+    interface IProtobufSerializer
+    {
+        /// <summary>
+        /// Method that serializes a given message to the provided destination stream.
+        /// </summary>
+        /// <typeparam name="TMessage">A message type to serialize.</typeparam>
+        /// <param name="destinationStream">The destination stream that will contain the serialized version of the message.</param>
+        /// <param name="message">The message that will be serialize to its binary format.</param>
+        void Serialize<TMessage>(Stream destinationStream, TMessage message);
+
+        /// <summary>
+        /// Method that deserializes an object from the given source stream.
+        /// </summary>
+        /// <typeparam name="TMessage">The type of the message that should be deserialized.</typeparam>
+        /// <param name="sourceStream">The source stream that contains the binary representation of the message.</param>
+        TMessage Deserialize<TMessage>(Stream sourceStream);
+
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncDaemonMessageFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncDaemonMessageFactory.cs	2010-07-07 17:06:36 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncDaemonMessageFactory.cs	2010-08-11 10:35:55 +0000
@@ -56,5 +56,32 @@
         /// </summary>
         /// <returns>A message that queries the current uploads in the daemon.</returns>
         SyncDaemonMessage QueryUploads();
+
+        /// <summary>
+        /// Creates a new message that can be used to place an specific share id with a node id as the 
+        /// next node to be processed.
+        /// </summary>
+        /// <param name="shareId">The id of the share.</param>
+        /// <param name="nodeId">The node id.</param>
+        /// <returns>A message that can be used to schedule the nex share to be processed.</returns>
+        SyncDaemonMessage ScheduleAsNext(string shareId, string nodeId);
+
+        /// <summary>
+        /// Creates a message that will tell the daemon to connect to the UbuntuOne server.
+        /// </summary>
+        /// <returns>A message that will tell the python code to connect to the Ubuntu One server.</returns>
+        SyncDaemonMessage Connect();
+
+        /// <summary>
+        /// Creates a message that will tell the daemon to disconnect from the UbuntuOne server.
+        /// </summary>
+        /// <returns>A message that will tell the python code to disconnect from the UbuntuOne server. </returns>
+        SyncDaemonMessage Disconnect();
+
+        /// <summary>
+        /// Creates a new message that will tell the daemon to quit.
+        /// </summary>
+        /// <returns>A message that will tell the python code to quit the sync daemon.</returns>
+        SyncDaemonMessage Quit();
     }
 }
\ No newline at end of file

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncFolderMessageFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncFolderMessageFactory.cs	2010-07-13 09:12:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ISyncFolderMessageFactory.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -66,6 +66,6 @@
         /// Creates a message that tells the daemon to refresh the folders.
         /// </summary>
         /// <returns>A message that tells the daemon to refresh the folders.</returns>
-        FolderMessage RefreshFolders();
+        FolderMessage RefreshVolumes();
     }
 }
\ No newline at end of file

=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ProtobufSerializer.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ProtobufSerializer.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/ProtobufSerializer.cs	2010-08-11 10:35:55 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.IO;
+using ProtoBuf;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Convenience class that wraps the static Serializer class that is used to serialize and 
+    /// deserialize protobuf messages.
+    /// </summary>
+    internal class ProtobufSerializer : IProtobufSerializer
+    {
+        #region Implementation of IProtobufSerializer
+
+        /// <summary>
+        /// Method that serializes a given message to the provided destination stream.
+        /// </summary>
+        /// <typeparam name="TMessage">A message type to serialize.</typeparam>
+        /// <param name="destinationStream">The destination stream that will contain the serialized version of the message.</param>
+        /// <param name="message">The message that will be serialize to its binary format.</param>
+        public void Serialize<TMessage>(Stream destinationStream, TMessage message)
+        {
+            Serializer.Serialize(destinationStream, message);
+        }
+
+        /// <summary>
+        /// Method that deserializes an object from the given source stream.
+        /// </summary>
+        /// <typeparam name="TMessage">The type of the message that should be deserialized.</typeparam>
+        /// <param name="sourceStream">The source stream that contains the binary representation of the message.</param>
+        public TMessage Deserialize<TMessage>(Stream sourceStream)
+        {
+            return Serializer.Deserialize<TMessage>(sourceStream);
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncDaemonMessageFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncDaemonMessageFactory.cs	2010-07-13 09:12:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncDaemonMessageFactory.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -19,32 +19,96 @@
  */
 namespace Canonical.UbuntuOne.ProcessDispatcher
 {
+    /// <summary>
+    /// Implementation of the ISyncDaemonMessageFactory that generates the message to be sent to python.
+    /// </summary>
     internal class SyncDaemonMessageFactory : ISyncDaemonMessageFactory
     {
-
+        /// <summary>
+        /// Creates a message that can be used to query the root of used by the sync daemon.
+        /// </summary>
+        /// <returns>A message that can be used to query the root of the daemon.</returns>
         public SyncDaemonMessage QueryRoot()
         {
             return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.QUERYROOT };
         }
 
+        /// <summary>
+        /// Creates a message that can be used to query the state of the sync daemon.
+        /// </summary>
+        /// <returns>A message that can be used to query the sync daemon about its state.</returns>
         public SyncDaemonMessage QueryState()
         {
             return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.QUERYSTATUS };
         }
 
+        /// <summary>
+        /// Creates a message that can be used to query the downloads that are currently in process 
+        /// in the sycn daemon.
+        /// </summary>
+        /// <returns>A message that can be used to query the sync daemon about the current downloads.</returns>
         public SyncDaemonMessage QueryDownloads()
         {
             return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.QUERYDOWNLOADS };
         }
 
+        /// <summary>
+        /// Creates a message that can be used to query the sync daemon about the items that are in the 
+        /// queue to be processed.
+        /// </summary>
+        /// <returns>A message to query the queue of the daemon.</returns>
         public SyncDaemonMessage QueryWaiting()
         {
             return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.QUERYWAITING };
         }
 
+        /// <summary>
+        /// Creates a message that can be used to query the sync daemon about the items that are currently
+        /// being uploaded.
+        /// </summary>
+        /// <returns>A message that queries the current uploads in the daemon.</returns>
         public SyncDaemonMessage QueryUploads()
         {
             return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.QUERYUPLOADS };
         }
+
+        /// <summary>
+        /// Creates a new message that can be used to place an specific share id with a node id as the 
+        /// next node to be processed.
+        /// </summary>
+        /// <param name="shareId">The id of the share.</param>
+        /// <param name="nodeId">The node id.</param>
+        /// <returns>A message that can be used to schedule the nex share to be processed.</returns>
+        public SyncDaemonMessage ScheduleAsNext(string shareId, string nodeId)
+        {
+            return new SyncDaemonMessage {NextShareId = shareId, NextNodeId = nodeId, Type = SyncDaemonMessage.MessageType.SCHEDULENEXT};
+        }
+
+        /// <summary>
+        /// Creates a message that will tell the daemon to connect to the UbuntuOne server.
+        /// </summary>
+        /// <returns>A message that will tell the python code to connect to the UbuntuOne server.</returns>
+        public SyncDaemonMessage Connect()
+        {
+            return new SyncDaemonMessage {Type = SyncDaemonMessage.MessageType.CONNECT};
+        }
+
+        /// <summary>
+        /// Creates a message that will tell the daemon to disconnect from the UbuntuOne server.
+        /// </summary>
+        /// <returns>A message that will tell the python code to disconnect from the UbuntuOne server. </returns>
+        public SyncDaemonMessage Disconnect()
+        {
+            return new SyncDaemonMessage { Type = SyncDaemonMessage.MessageType.DISCONNECT};
+        }
+
+        /// <summary>
+        /// Creates a new message that will tell the daemon to quit.
+        /// </summary>
+        /// <returns>A message that will tell the python code to quit the sync daemon.</returns>
+        public SyncDaemonMessage Quit()
+        {
+            return new SyncDaemonMessage{Type = SyncDaemonMessage.MessageType.QUIT};
+        }
     }
 }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncFolderMessageFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncFolderMessageFactory.cs	2010-08-09 16:40:28 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Protobuf/SyncFolderMessageFactory.cs	2010-08-11 10:35:55 +0000
@@ -82,7 +82,7 @@
             };
         }
 
-        public FolderMessage RefreshFolders()
+        public FolderMessage RefreshVolumes()
         {
             return new FolderMessage { Type = FolderMessage.MessageType.REFRESH };
         }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncConfigurationService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncConfigurationService.cs	2010-08-02 10:07:10 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncConfigurationService.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -17,22 +17,32 @@
  * 
  * Authors: Manuel de la Peña <[e-mail]>
  */
-using System;
 using Canonical.UbuntuOne.Common;
 using Canonical.UbuntuOne.Common.Aop;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
 
 namespace Canonical.UbuntuOne.ProcessDispatcher
 {
-    class SyncConfigurationService : ISyncConfiguration
+    /// <summary>
+    /// Implementation of the ISyncConfiguration contract that fowards the required operations to the 
+    /// python code which will perform the appropiate operations.
+    /// </summary>
+    internal class SyncConfigurationService : ISyncConfiguration
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        public void RegisterClient()
-        {
-            throw new NotImplementedException();
-        }
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the message factory that can be used to generate the appropiate messages to 
+        /// communicate with the python process that manages the configuration.
+        /// </summary>
+        internal ISyncConfigurationMessageFactory SyncConfigurationMessageFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the communicator that is used to send and receive messages to the socket.
+        /// </summary>
+        internal ITcpClientCommunicator<ConfigurationMessage> TcpClientCommunicator { get; set; }
+
+        #endregion
 
         /// <summary>
         /// Returns the throttling limits that have been set up for the daemon.
@@ -41,7 +51,9 @@
         [DebugLogged]
         public ThrottlingData GetThrottlingLimits()
         {
-            throw new NotImplementedException();
+            // create a message that will be used to query the thorttling limits to the python process
+            var message = SyncConfigurationMessageFactory.QueryThrottling();
+            return TcpClientCommunicator.SendReceiveMessage<ThrottlingData>(message, Convert.ToThrottlingData);
         }
 
         /// <summary>
@@ -51,7 +63,8 @@
         [DebugLogged]
         public void SetThrottlingLimits(ThrottlingData limits)
         {
-            throw new NotImplementedException();
+            var message = SyncConfigurationMessageFactory.SetThrottlingLimits(limits);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -61,7 +74,8 @@
         [DebugLogged]
         public void EnableThrottlingLimits(bool isEnabled)
         {
-            throw new NotImplementedException();
+            var message = SyncConfigurationMessageFactory.EnableThrottling(isEnabled);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -71,7 +85,8 @@
         [DebugLogged]
         public bool IsEnabledThrottlingLimits()
         {
-            throw new NotImplementedException();
+            var message = SyncConfigurationMessageFactory.QueryThrottling();
+            return TcpClientCommunicator.SendReceiveMessage<bool>(message, Convert.ToIsEnabledThrottling);
         }
 
         /// <summary>
@@ -81,7 +96,8 @@
         [DebugLogged]
         public void EnableUdfAutosubscribe(bool isEnable)
         {
-            throw new NotImplementedException();
+            var message = SyncConfigurationMessageFactory.EnablesAutosubscribe(isEnable);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -91,7 +107,8 @@
         [DebugLogged]
         public bool IsEnabledUdfAutosubscribe()
         {
-            throw new NotImplementedException();
+            var message = SyncConfigurationMessageFactory.QueryThrottling();
+            return TcpClientCommunicator.SendReceiveMessage<bool>(message, Convert.ToIsAutosubscribe);
         }
     }
 }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs	2010-08-05 08:15:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs	2010-08-11 10:35:55 +0000
@@ -1,25 +1,28 @@
-// Copyright 2010 Canonical Ltd.
-// 
-// This file is part of UbuntuOne on Windows.
-// 
-// UbuntuOne on Windows is free software: you can redistribute it and/or modify		
-// it under the terms of the GNU Lesser General Public License version 		
-// as published by the Free Software Foundation.		
-//		
-// Ubuntu One on Windows is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
-// GNU Lesser General Public License for more details.	
-//
-// You should have received a copy of the GNU Lesser General Public License	
-// along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
-// 
-// Authors: Manuel de la Peña <[e-mail]>
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
 using System;
 using System.Collections.Generic;
 using Canonical.UbuntuOne.Common;
 using Canonical.UbuntuOne.Common.Aop;
 using Canonical.UbuntuOne.Common.Validation;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
 using log4net;
 
 namespace Canonical.UbuntuOne.ProcessDispatcher
@@ -73,6 +76,17 @@
         /// </summary>
         internal IAuthentication Authentication { get; set; }
 
+        /// <summary>
+        /// Allows to get and set the factory that is used to generate the different messages that are sent
+        /// to the python code.
+        /// </summary>
+        internal ISyncDaemonMessageFactory SyncDaemonMessageFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the communicator that is used to send and receive messages to the socket.
+        /// </summary>
+        internal ITcpClientCommunicator<SyncDaemonMessage> TcpClientCommunicator { get; set; }
+
         #endregion
 
         public SyncDaemonService()
@@ -193,10 +207,10 @@
         }
 
         /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
+        /// Returns the port number of the socket that the synd daemo is listening to for communication.
         /// </summary>
-        public void RegisterClient()
+        /// <returns></returns>
+        public int GetListeningSocket()
         {
             throw new NotImplementedException();
         }
@@ -208,7 +222,8 @@
         [DebugLogged]
         public StateData GetCurrentStatus()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.QueryState();
+            return TcpClientCommunicator.SendReceiveMessage<StateData>(message, Convert.ToStateData);
         }
 
         /// <summary>
@@ -218,7 +233,8 @@
         [DebugLogged]
         public IList<DownloadData> GetCurrentDownloads()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.QueryDownloads();
+            return TcpClientCommunicator.SendReceiveMessage<IList<DownloadData>>(message, Convert.ToCurrentDownloads);
         }
 
         /// <summary>
@@ -228,7 +244,8 @@
         [DebugLogged]
         public IList<QueueItemData> GetWaitingContent()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.QueryWaiting();
+            return TcpClientCommunicator.SendReceiveMessage<IList<QueueItemData>>(message, Convert.ToCurrentWaiting);
         }
 
         /// <summary>
@@ -240,7 +257,8 @@
         [DebugLogged]
         public void ScheduleAsNext(string shareId, string nodeId)
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.ScheduleAsNext(shareId, nodeId);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -250,7 +268,8 @@
         [DebugLogged]
         public IList<UploadData> GetCurrentUploads()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.QueryUploads();
+            return TcpClientCommunicator.SendReceiveMessage<IList<UploadData>>(message, Convert.ToCurrentUploads);
         }
 
         /// <summary>
@@ -260,7 +279,8 @@
         [DebugLogged]
         public void Connect()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.Connect();
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -269,7 +289,8 @@
         [DebugLogged]
         public void Disconnect()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.Disconnect();
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -279,17 +300,19 @@
         [DebugLogged]
         public string GetRootDirectory()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.QueryRoot();
+            return TcpClientCommunicator.SendReceiveMessage<string>(message, Convert.ToRootDirectory);
         }
 
         /// <summary>
-        /// Allows client to tell the sync daemon to quit. Discomment allows the daemon toquee the event
+        /// Allows client to tell the sync daemon to quit. Discomment allows the daemon to quee the event
         /// for the next time it connects, quit completelly closes the service and stops listening the IO changes.
         /// </summary>
         [DebugLogged]
         public void Quit()
         {
-            throw new NotImplementedException();
+            var message = SyncDaemonMessageFactory.Quit();
+            TcpClientCommunicator.SendMessage(message);
         }
     }
 }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncFileManagerService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncFileManagerService.cs	2010-08-09 16:40:28 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncFileManagerService.cs	2010-08-11 10:35:55 +0000
@@ -24,16 +24,11 @@
 
 namespace Canonical.UbuntuOne.ProcessDispatcher
 {
-    class SyncFileManagerService : ISyncFileManager
+    /// <summary>
+    /// Class that implements the ISyncFileManager bny fowarding the request to the python code.
+    /// </summary>
+    internal class SyncFileManagerService : ISyncFileManager
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        public void RegisterClient()
-        {
-            throw new NotImplementedException();
-        }
 
         [DebugLogged]
         public IDictionary<string, string> GetMetadata(string path)

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncFoldersService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncFoldersService.cs	2010-08-02 10:07:10 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncFoldersService.cs	2010-08-11 10:35:55 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -17,22 +17,31 @@
  * 
  * Authors: Manuel de la Peña <[e-mail]>
  */
-using System;
 using System.Collections.Generic;
 using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
 
 namespace Canonical.UbuntuOne.ProcessDispatcher
 {
-    class SyncFoldersService : ISyncFolders
+    /// <summary>
+    /// Implementation of the ISyncFolders that fowards the request to the python code.
+    /// </summary>
+    internal class SyncFoldersService : ISyncFolders
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        public void RegisterClient()
-        {
-            throw new NotImplementedException();
-        }
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the factory that is used to generate the messages used to communicate with the
+        /// python process.
+        /// </summary>
+        internal ISyncFolderMessageFactory SyncFolderMessageFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the communicator that is used to send and receive messages to the socket.
+        /// </summary>
+        internal ITcpClientCommunicator<FolderMessage> TcpClientCommunicator { get; set; }
+
+        #endregion
 
         /// <summary>
         /// Creates a new udf for the given path.
@@ -40,7 +49,8 @@
         /// <param name="path">The path to which the Udf will be created.</param>
         public void CreateFolderUdf(string path)
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.CreateFolder(path);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -49,7 +59,8 @@
         /// <param name="path">The path whose Udf we will remove.</param>
         public void DeleteFolderUdf(string path)
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.DeleteFolder(path);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -58,7 +69,8 @@
         /// <returns>A list with all the udfs.</returns>
         public IList<UdfData> GetFolders()
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.QueryFolders();
+            return TcpClientCommunicator.SendReceiveMessage<IList<UdfData>>(message, Convert.ToAllFolders);
         }
 
         /// <summary>
@@ -67,7 +79,8 @@
         /// <param name="folderId">The id of the folder to subscribe to.</param>
         public void Subscribe(string folderId)
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.Subscribe(folderId);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -76,7 +89,8 @@
         /// <param name="folderId">The id of the folder to unsubscribe from.</param>
         public void Unsubscribe(string folderId)
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.Unsubscribe(folderId);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -86,7 +100,8 @@
         /// <returns>The udf data of the given path.</returns>
         public UdfData GetInfo(string path)
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.QueryInfo(path);
+            return TcpClientCommunicator.SendReceiveMessage<UdfData>(message, Convert.ToUdfData);
         }
 
         /// <summary>
@@ -94,7 +109,8 @@
         /// </summary>
         public void RefreshVolumes()
         {
-            throw new NotImplementedException();
+            var message = SyncFolderMessageFactory.RefreshVolumes();
+            TcpClientCommunicator.SendMessage(message);
         }
     }
 }

=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncSharesService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncSharesService.cs	2010-08-05 08:15:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncSharesService.cs	2010-08-11 10:35:55 +0000
@@ -1,37 +1,49 @@
-// Copyright 2010 Canonical Ltd.
-// 
-// This file is part of UbuntuOne on Windows.
-// 
-// UbuntuOne on Windows is free software: you can redistribute it and/or modify		
-// it under the terms of the GNU Lesser General Public License version 		
-// as published by the Free Software Foundation.		
-//		
-// Ubuntu One on Windows is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
-// GNU Lesser General Public License for more details.	
-//
-// You should have received a copy of the GNU Lesser General Public License	
-// along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
-// 
-// Authors: Manuel de la Peña <[e-mail]>
-using System;
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
 using System.Collections.Generic;
 using Canonical.UbuntuOne.Common;
 using Canonical.UbuntuOne.Common.Aop;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
 
 namespace Canonical.UbuntuOne.ProcessDispatcher
 {
-    class SyncSharesService : ISyncShares
+    /// <summary>
+    /// Implementation of the ISyncShares interface that will foward the request operations to the 
+    /// python code.
+    /// </summary>
+    internal class SyncSharesService : ISyncShares
     {
-        /// <summary>
-        /// Provides a way that the client can use to register itself to be notified about events 
-        /// through callbacks. The client should implemented the ISyncDaemonClient interface.
-        /// </summary>
-        public void RegisterClient()
-        {
-            throw new NotImplementedException();
-        }
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the factory that is used to create the protobuf messages used 
+        /// to communicate with the python code.
+        /// </summary>
+        internal ISyncShareMessageFactory SyncShareMessageFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the communicator that is used to send and receive messages to the socket.
+        /// </summary>
+        internal ITcpClientCommunicator<ShareMessage> TcpClientCommunicator { get; set; }
+
+        #endregion
 
         /// <summary>
         /// Allows the client to query and get all the different shares that the user has.
@@ -40,7 +52,9 @@
         [DebugLogged]
         public IList<ShareData> GetShares()
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.QueryShares();
+            return TcpClientCommunicator.SendReceiveMessage<IList<ShareData>>(message, Convert.ToGetShares);
+
         }
 
         /// <summary>
@@ -51,7 +65,8 @@
         [DebugLogged]
         public void AcceptShare(string shareId)
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.AcceptShare(shareId);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -62,7 +77,8 @@
         [DebugLogged]
         public void RejectShare(string shareId)
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.RejectShare(shareId);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -76,7 +92,8 @@
         [DebugLogged]
         public void CreateShare(string path, string username, string name, AccessLevel accessLevel)
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.CreateShare(path, username, name, accessLevel);
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -85,7 +102,8 @@
         [DebugLogged]
         public void UpdateShares()
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.UpdateShares();
+            TcpClientCommunicator.SendMessage(message);
         }
 
         /// <summary>
@@ -95,7 +113,8 @@
         [DebugLogged]
         public IList<ShareData> GetShared()
         {
-            throw new NotImplementedException();
+            var message = SyncShareMessageFactory.GetShared();
+            return TcpClientCommunicator.SendReceiveMessage<IList<ShareData>>(message, Convert.ToGetShared);
         }
     }
 }