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

[Manuel de la Peña]

Provides the technique used to communicate the different windows client the firing of events from the python code.

[Stuart Colville (muffinresearch)]

tests pass, looks good.

review: Approve

[Rick McBride (rmcbride)]

Looks good, however 'NAnt.exe tests' hangs after

'Executng Canonical.UbuntuOne.ProcessDispatcher.Tests' and the exec block after it. (Note that Executing is misspelled in the echo string).

At that point nunit-console.exe spikes at 50% processor utilization and about 30,048K. The first time I tried this I left it running like this for two hours and it never came back.

Once the script is broken w/ CTRL-C, nunit-console.exe has to be killed at the task manager before anything further can be run in this context.

review: Needs Fixing

[lp:~mandel/ubuntuone-windows-installer/implement_dotnet_ipc_events]

47. By Manuel de la Peña on 2010-08-18

Modify the tests to beignored until RhinoMocks has multithreading support.

48. By Manuel de la Peña on 2010-08-18

Fix echo typo.

[Manuel de la Peña (mandel)]

Rick,

This issue is again due to RhinoMocks not having support with multithreading (major PITA in this area of the code).

As we did with the other test that had this same issue I have added an ignore message. Right now I do not have the time to look at RhinoMocks to add the support or to use a completely diff lib in the project for mocking (I doubt there is any better than Rhino and open sourced).

[Rick McBride (rmcbride)]

Works now with that test disabled.

review: Approve

=== modified file 'main.build'
--- main.build	2010-08-10 10:04:31 +0000
+++ main.build	2010-08-18 09:45:53 +0000
@@ -176,7 +176,7 @@
               program="nunit-console.exe"
               commandline="Canonical.UbuntuOne.Common.Tests.dll /xml=../../../../test-results/Canonical.UbuntuOne.Common.Tests-Result.xml" /> 
 	
-		<echo>Executng Canonical.UbuntuOne.ProcessDispatcher.Tests</echo>
+		<echo>Executing Canonical.UbuntuOne.ProcessDispatcher.Tests</echo>
 		<exec basedir="tools/NUnit"
               managed="true"
               workingdir="src/Canonical.UbuntuOne.ProcessDispatcher.Tests/bin/${enviroment}"
 
=== modified file 'src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj'
--- src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj	2010-08-04 14:36:09 +0000
+++ src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj	2010-08-18 09:45:53 +0000
@@ -58,6 +58,7 @@
     <Compile Include="Container\SpringContainer.cs" />
     <Compile Include="Container\UnsatisfiedDependencyException.cs" />
     <Compile Include="IAuthentication.cs" />
+    <Compile Include="OperationContracts\IEventNotifier.cs" />
     <Compile Include="Utils\ApplicationWrapper.cs" />
     <Compile Include="Utils\Explorer.cs" />
     <Compile Include="Utils\ExplorerException.cs" />
 
=== added file 'src/Canonical.UbuntuOne.Common/OperationContracts/IEventNotifier.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/IEventNotifier.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/IEventNotifier.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,59 @@
+/*
+ * 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.ServiceModel;
+
+namespace Canonical.UbuntuOne.Common.OperationContracts
+{
+    /// <summary>
+    /// Interface to be implemented by those objects that will allow to 
+    /// </summary>
+    [ServiceContract( CallbackContract = typeof(ISyncDaemonClient),
+        SessionMode = SessionMode.Required)]
+    public interface IEventNotifier
+    {
+        /// <summary>
+        /// Method that allows to register a client that will be reciving notitications 
+        /// from than point until it unregisters
+        /// </summary>
+        [OperationContract(IsOneWay = true)]
+        void RegisterClient();
+
+        /// <summary>
+        /// Method that allows to unregister a client from receiving notification.
+        /// </summary>
+        [OperationContract(IsOneWay = true)]
+        void UnregisterClient();
+
+        /// <summary>
+        /// Method that tells the notifier to start listening for other events using a separate thread.
+        /// </summary>
+        void StartListening();
+
+        /// <summary>
+        /// Method that tells the notifier to stop listning for events.
+        /// </summary>
+        void StopListening();
+
+        /// <summary>
+        /// Gets if the notifier is listening.
+        /// </summary>
+        bool IsListening { get; }
+    }
+}
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs	2010-08-10 08:50:26 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncConfiguration.cs	2010-08-18 09:45:53 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -25,11 +25,7 @@
     /// Interface to be implemented by those object that allows to interact with the 
     /// different setting of the sync daemon.
     /// </summary>
-    [ServiceContract(
-        Name = "SyncConfiguration",
-        Namespace = "http://one.ubuntu.com/syncconfiguration",
-        CallbackContract = typeof(ISyncDaemonClient),
-        SessionMode = SessionMode.Required)]
+    [ServiceContract]
     public interface ISyncConfiguration
     {
         /// <summary>
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs	2010-08-10 08:50:26 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemon.cs	2010-08-18 09:45:53 +0000
@@ -26,11 +26,7 @@
 	/// The implementators of this interface should allow the callng clients to perform a number of applications on 
 	/// the sync daemon from windows. This will allow users to interact with the daemon through .Net.
 	/// </summary>
-    [ServiceContract(
-        Name = "SyncDaemon",
-        Namespace = "http://one.ubuntu.com/syncdaemon",
-        CallbackContract = typeof(ISyncDaemonClient),
-        SessionMode = SessionMode.Required)]
+    [ServiceContract]
 	public interface ISyncDaemon
 	{
 
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemonClient.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemonClient.cs	2010-08-05 07:13:28 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncDaemonClient.cs	2010-08-18 09:45:53 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -25,7 +25,7 @@
     /// Interface to be implementedby a sync daemon client that wants to interact with the 
     /// daemon that manages the Ubuntu One storage in a machine.
     /// </summary>
-    [ServiceContract(Namespace = "http://one.ubuntu.com/client")]
+    [ServiceContract]
     public interface ISyncDaemonClient
     {
         /// <summary>
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs	2010-08-10 08:50:26 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFileManager.cs	2010-08-18 09:45:53 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -25,11 +25,7 @@
     /// <summary>
     /// Service that provides method to interact with the FileManager used by the sync daemon.
     /// </summary>
-    [ServiceContract(
-        Name = "SyncFileManager",
-        Namespace = "http://one.ubuntu.com/syncfilemanager",
-        CallbackContract = typeof(ISyncDaemonClient),
-        SessionMode = SessionMode.Required)]
+    [ServiceContract]
     public interface ISyncFileManager
     {
 
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs	2010-08-10 08:50:26 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncFolders.cs	2010-08-18 09:45:53 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -26,11 +26,7 @@
     /// Interface to be implemented by those objects that allow to interact with the data related to 
     /// the sync folders by the Ubuntu One sync daemon.
     /// </summary>
-    [ServiceContract(
-        Name = "SyncFolders",
-        Namespace = "http://one.ubuntu.com/syncfolders",
-        CallbackContract = typeof(ISyncDaemonClient),
-        SessionMode = SessionMode.Required)]
+    [ServiceContract]
     public interface ISyncFolders
     {
 
 
=== modified file 'src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs'
--- src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs	2010-08-10 08:50:26 +0000
+++ src/Canonical.UbuntuOne.Common/OperationContracts/ISyncShares.cs	2010-08-18 09:45:53 +0000
@@ -1,4 +1,4 @@
-/**
+/*
  * Copyright 2010 Canonical Ltd.
  * 
  * This file is part of UbuntuOne on Windows.
@@ -26,11 +26,7 @@
     /// Contract to be implemented by a object that allows to interact with the different shares
     /// that a user has in the Ubuntu One storage infrastructure.
     /// </summary>
-    [ServiceContract(
-        Name = "SyncShares",
-        Namespace = "http://one.ubuntu.com/shares",
-        CallbackContract = typeof(ISyncDaemonClient),
-        SessionMode = SessionMode.Required)]
+    [ServiceContract]
     public interface ISyncShares
     {
 
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj	2010-08-12 07:59:15 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/Canonical.UbuntuOne.ProcessDispatcher.Tests.csproj	2010-08-18 09:45:53 +0000
@@ -55,6 +55,7 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="EventNotifierFixture.cs" />
     <Compile Include="Net\PortManagerFixture.cs" />
     <Compile Include="Net\TcpClientCommunicatorFixture.cs" />
     <Compile Include="Net\TcpClientFactoryFixture.cs" />
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher.Tests/EventNotifierFixture.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher.Tests/EventNotifierFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher.Tests/EventNotifierFixture.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,239 @@
+/*
+ * 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.Net.Sockets;
+using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher.Tests
+{
+    [TestFixture]
+    public class EventNotifierFixture
+    {
+        #region Vars
+
+        private MockRepository _mocks;
+        private IEventDispatcher _eventDispatcher;
+        private ISyncDaemonClient _notifyIconClient;
+        private ICallerContext<ISyncDaemonClient> _callerContext;
+        private IPortManager _portManager;
+        private IProtobufSerializer _serilizer;
+        private TcpClient _client;
+        private EventNotifier _notifier;
+        private int _freePort;
+
+        #endregion
+
+        #region Setup
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _eventDispatcher = _mocks.DynamicMock<IEventDispatcher>();
+            _notifyIconClient = _mocks.StrictMock<ISyncDaemonClient>();
+            _mocks.StrictMock<ISyncDaemonClient>();
+            _callerContext = _mocks.StrictMock<ICallerContext<ISyncDaemonClient>>();
+            _portManager = _mocks.StrictMock<IPortManager>();
+            _serilizer = _mocks.DynamicMock<IProtobufSerializer>();
+            _freePort = 50128;
+            _notifier = new EventNotifier
+            {
+                CallerContext = _callerContext,
+                EventDispatcher = _eventDispatcher,
+                PortManager = _portManager,
+                ProtobufSerializer = _serilizer
+            };
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _notifier.KillListeningThread();
+        }
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void RegisterClientTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_callerContext.GetCaller())
+                    .Return(_notifyIconClient)
+                    .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                _notifier.RegisterClient();
+            }
+        }
+
+        [Test]
+        public void UnregisterClientRegisteredTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_callerContext.GetCaller())
+                    .Return(_notifyIconClient)
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _notifier.UnregisterClient();
+            }
+        }
+
+        [Test]
+        public void UnregisterClientNotRegisteredTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(_callerContext.GetCaller())
+                    .Return(_notifyIconClient)
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                _notifier.UnregisterClient();
+            }
+        }
+
+        [Test]
+        public void StartListeningTest()
+        {
+            try
+            {
+                Assert.Ignore("This test is not reliable until RhinoMocks has multithread support.");
+                //using (_mocks.Record())
+                //{
+                //    Expect.Call(_portManager.GetDotNetClientPort())
+                //        .Return(_freePort)
+                //        .Repeat.Any();
+                //}
+                //using (_mocks.Playback())
+                //{
+                //    _notifier.StartListening();
+                //    // create a client that will connect to the port
+                //    while (!_notifier.IsListening)
+                //    {
+                //        // wait doing nothing :(
+                //    }
+                //    _client = new TcpClient("localhost", _freePort);
+                //    // write data in the buffer to tell the the event notifier
+                //    var stream = _client.GetStream();
+                //    var data = System.Text.Encoding.ASCII.GetBytes("Test");
+                //    stream.Write(data, 0, data.Length);
+                //    stream.Flush();
+                //    stream.Close();
+                //}
+            }
+            catch (SocketException)
+            {
+                Assert.Inconclusive(
+                    "The test could not be performed due to a socket exception. You firewall is probably blocking connections to {0}", 
+                    _freePort);
+            }
+        }
+
+        [Test]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void StartListeningAlreadyListeningTest()
+        {
+            try
+            {
+                using (_mocks.Record())
+                {
+                    Expect.Call(_portManager.GetDotNetClientPort())
+                        .Return(_freePort)
+                        .Repeat.Once();
+                }
+                using (_mocks.Playback())
+                {
+                    _notifier.StartListening();
+                    _notifier.StartListening();
+                }
+            }
+            catch (SocketException)
+            {
+                Assert.Inconclusive(
+                    "The test could not be performed due to a socket exception. You firewall is probably blocking connections to {0}",
+                    _freePort);
+            }
+        }
+
+        [Test]
+        public void StopListeningTest()
+        {
+            try
+            {
+                using (_mocks.Record())
+                {
+                    Expect.Call(_portManager.GetDotNetClientPort())
+                        .Return(_freePort)
+                        .Repeat.Any();
+                }
+                using (_mocks.Playback())
+                {
+                    _notifier.StartListening();
+                    _notifier.StopListening();
+                }
+            }
+            catch (SocketException)
+            {
+                Assert.Inconclusive(
+                    "The test could not be performed due to a socket exception. You firewall is probably blocking connections to {0}",
+                    _freePort);
+            }
+        }
+
+        [Test]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void StopListeningExceptionTest()
+        {
+            try
+            {
+                using (_mocks.Record())
+                {
+                    Expect.Call(_portManager.GetDotNetClientPort())
+                        .Return(_freePort)
+                        .Repeat.Once();
+                }
+                using (_mocks.Playback())
+                {
+                    _notifier.StopListening();
+                }
+            }
+            catch(SocketException)
+            {
+                Assert.Inconclusive(
+                    "The test could not be performed due to a socket exception. You firewall is probably blocking connections to {0}",
+                    _freePort);
+            }
+        }
+
+        #endregion
+
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/CallerContext.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/CallerContext.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/CallerContext.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,43 @@
+/*
+ * 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.ServiceModel;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Implementation of the ICallerContext that realies in WCF the retrive the caller of a
+    /// WCF Operation contract.
+    /// </summary>
+    internal class CallerContext<TCaller> : ICallerContext<TCaller>
+    {
+        #region Implementation of ICallerContext<TCaller>
+
+        /// <summary>
+        /// Returns the object that has called the method,
+        /// </summary>
+        /// <returns>The object that performed the call.</returns>
+        public TCaller GetCaller()
+        {
+            return OperationContext.Current.GetCallbackChannel<TCaller>();
+        }
+
+        #endregion
+    }
+}
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-08-12 07:59:15 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-08-18 09:45:53 +0000
@@ -71,6 +71,10 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="CallerContext.cs" />
+    <Compile Include="EventNotifier.cs" />
+    <Compile Include="ICallerContext.cs" />
+    <Compile Include="IEventDispatcher.cs" />
     <Compile Include="Net\IPortFinder.cs" />
     <Compile Include="Net\IPortManager.cs" />
     <Compile Include="Net\ITcpClient.cs" />
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/EventNotifier.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/EventNotifier.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/EventNotifier.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,357 @@
+/*
+ * 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 System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Canonical.UbuntuOne.Common;
+using Canonical.UbuntuOne.Common.OperationContracts;
+using Canonical.UbuntuOne.ProcessDispatcher.Net;
+using log4net;
+using PortManagerImpl = Canonical.UbuntuOne.ProcessDispatcher.Net.PortManager;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Implementation of the IEventNotifier that receives messages from the python code through sockets and 
+    /// broadcasts those messages to the .net clients that have registered to receive them.
+    /// </summary>
+    internal class EventNotifier : IEventNotifier
+    {
+        #region Helper class
+
+        /// <summary>
+        /// This class is used to allows to keep the state of the async reading operation of the 
+        /// socket.
+        /// </summary>
+        private class StateObject
+        {
+            /// <summary>
+            /// The socket we are working with.
+            /// </summary>
+            public Socket WorkSocket;
+
+            /// <summary>
+            /// The size of the buffer that will be used to read.
+            /// </summary>
+            public const int BufferSize = 1024;
+
+            /// <summary>
+            /// The buffer wich will be used to place the read information.
+            /// </summary>
+            public readonly byte[] Buffer = new byte[BufferSize];
+
+            /// <summary>
+            /// Stream that is used to concatenated the data that has been processed
+            /// so far.
+            /// </summary>
+            public readonly MemoryStream ResultBuilder = new MemoryStream();
+        }
+
+        #endregion
+
+        #region Vars
+
+        private IPortManager _portManager;
+        private ILog _logger;
+        private readonly object _loggerLock = new object();
+        private readonly object _clientsLock = new object();
+        private readonly object _portManagerLock = new object();
+        private readonly object _isListeningLock = new object();
+        private static readonly ManualResetEvent _allDone = new ManualResetEvent(false);
+        private static readonly HashSet<ISyncDaemonClient> _registeredClients = new HashSet<ISyncDaemonClient>();
+        private bool _hasToListen;
+        private bool _isListening;
+        private Thread _listeningThread;
+
+        #endregion
+
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the protobuf serializer that is used to deserialize the messages comming from python.
+        /// </summary>
+        internal IProtobufSerializer ProtobufSerializer { get; set; }
+
+        /// <summary>
+        /// Gets and sets the event dispatcher that is used to notify the different clients about
+        /// an event.
+        /// </summary>
+        internal IEventDispatcher EventDispatcher { get; set; }
+
+        /// <summary>
+        /// Gets and sets the object that is used to retrieve the information of the object
+        /// that performs the different WCF calls.
+        /// </summary>
+        internal ICallerContext<ISyncDaemonClient> CallerContext { get; set; }
+
+        /// <summary>
+        /// Gets and sets the logger that is used to log the different activities.
+        /// </summary>
+        internal ILog Logger
+        {
+            get
+            {
+                if(_logger == null)
+                {
+                    lock (_loggerLock)
+                    {
+                        _logger = LogManager.GetLogger(typeof (EventNotifier));
+                    }
+                }
+                return _logger;
+            }
+            set { _logger = value; }
+        }
+        /// <summary>
+        /// Gets and sets the port manager that is used to ensure that the ports are correctly used
+        /// for the application per user.
+        /// </summary>
+        internal IPortManager PortManager
+        {
+            get
+            {
+                if(_portManager == null)
+                {
+                    lock (_portManagerLock)
+                    {
+                        _portManager = PortManagerImpl.Instance;
+                    }
+                }
+                return _portManager;
+            }
+            set { _portManager = value; }
+        }
+
+        #endregion
+
+        #region HelperMethods
+
+        /// <summary>
+        /// This method listens to the port that has been set for this service to be listening for 
+        /// </summary>
+        private void Listen()
+        {
+
+            var localEndPoint = new IPEndPoint(IPAddress.Any, PortManager.GetDotNetClientPort());
+            var listener = new Socket(localEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+            try
+            {
+                listener.Bind(localEndPoint);
+                listener.Listen(1000);
+                lock (_isListeningLock)
+                {
+                    _isListening = true;
+                }
+                while (_hasToListen)
+                {
+                    _allDone.Reset();
+
+                    Logger.Info("Waiting for a connection...");
+                    listener.BeginAccept(
+                        new AsyncCallback(AcceptCallback),
+                        listener);
+
+                    _allDone.WaitOne();
+                }
+            }
+            catch (Exception e)
+            {
+                var message = string.Format("An exception was thrown when listening to port {0}",
+                    PortManager.GetDotNetClientPort());
+                Logger.Error(message, e);
+            }
+        }
+
+        /// <summary>
+        /// Callback that will be used to accept connections in an async manner. The method 
+        /// will be ran in a separate thread and will take care of dispathinch the work to other threads.
+        /// </summary>
+        /// <param name="asyncResult">The async result that will be passed to the call back with the 
+        /// connect information.</param>
+        private void AcceptCallback(IAsyncResult asyncResult)
+        {
+            var listener = (Socket)asyncResult.AsyncState;
+            var handler = listener.EndAccept(asyncResult);
+            // Signal the main thread to continue.
+            _allDone.Set();
+
+            // Create the state object.
+            var state = new StateObject
+            {
+                WorkSocket = handler
+            };
+            handler.BeginReceive(state.Buffer, 0, StateObject.BufferSize, 0,
+                new AsyncCallback(ReadCallback), state);
+        }
+
+        /// <summary>
+        /// Callback that will be used after a read operation has been performed once the data from 
+        /// the python client has arrived.
+        /// </summary>
+        /// <param name="ar">The async result that will be passed to the callback with the read information
+        /// that has been collected so far.</param>
+        private void ReadCallback(IAsyncResult ar)
+        {
+            var state = (StateObject)ar.AsyncState;
+            var handler = state.WorkSocket;
+
+            // Read data from the client socket.
+            var read = handler.EndReceive(ar);
+
+            // Data was read from the client socket.
+            if (read > 0)
+            {
+                // create a binary writer that will be used to append the data to the stream.
+                var writer = new BinaryWriter(state.ResultBuilder);
+                writer.Write(state.Buffer, 0, read);
+                writer.Flush();
+                // start another callback to see if we have more info to read.
+                handler.BeginReceive(state.Buffer, 0, StateObject.BufferSize, 0,
+                    new AsyncCallback(ReadCallback), state);
+            }
+            else
+            {
+                if (state.ResultBuilder.Length > 1)
+                {
+                    // All the data has been read from the client;
+                    // display it on the console.
+                    var workThread = new Thread(ProcessMessage);
+                    workThread.Start(state.ResultBuilder);
+
+                }
+                handler.Close();
+            }
+        }
+
+        /// <summary>
+        /// Method that will be executed in a thread that will process the message comming from python and
+        /// will notify the different clients.
+        /// </summary>
+        /// <param name="o">An object that should be castable to a MemoryStream that contains the data of the
+        /// protobuf message.</param>
+        private void ProcessMessage(object o)
+        {
+            // cast the object to the data that we actually have, 
+            var data = (MemoryStream) o;
+            var protobufMessage = ProtobufSerializer.Deserialize<SyncDaemonClientMessage>(data);
+            EventDispatcher.Dispatch(protobufMessage, _registeredClients);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Helper method that can be used internally to kill the listening thread to allow the event listener to stop. This
+        /// method is very useful when running tests to be sure that not too many threads are kept alive.
+        /// </summary>
+        internal void KillListeningThread()
+        {
+            if (_listeningThread != null)
+            {
+                _hasToListen = false;
+                _listeningThread.Abort();
+            }
+        }
+
+        #region Implementation of IEventNotifier
+
+        /// <summary>
+        /// Method that allows to register a client that will be reciving notitications 
+        /// from than point until it unregisters
+        /// </summary>
+        public void RegisterClient()
+        {
+            lock (_clientsLock)
+            {
+                // we get the client that will be used for the callbacks
+                var client = CallerContext.GetCaller();
+                if(!_registeredClients.Contains(client))
+                {
+                    _registeredClients.Add(client);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Method that allows to unregister a client from receiving notification.
+        /// </summary>
+        public void UnregisterClient()
+        {
+            lock (_clientsLock)
+            {
+                var client = CallerContext.GetCaller();
+                if(_registeredClients.Contains(client))
+                {
+                    _registeredClients.Remove(client);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Method that tells the notifier to start listening for other events using a separate thread.
+        /// </summary>
+        public void StartListening()
+        {
+            if (!_hasToListen)
+            {
+                _hasToListen = true;
+                // Once created, start listening to the port used by python to talk with us
+                _listeningThread = new Thread(Listen) {Name = "EventNotifierSocketServer"};
+                _listeningThread.Start();
+            }
+            else
+            {
+                throw new InvalidOperationException("EventNotifier cannot start listning because it already is.");
+            }
+        }
+
+        /// <summary>
+        /// Method that tells the notifier to stop listning for events.
+        /// </summary>
+        public void StopListening()
+        {
+            if (_hasToListen)
+            {
+                _hasToListen = false;
+                lock (_isListeningLock)
+                {
+                    _isListening = false;
+                }
+                _listeningThread.Join();
+            }
+            else
+            {
+                throw  new InvalidOperationException("Cannot stop listening because EventNotifier never started to listen.");
+            }
+        }
+
+        /// <summary>
+        /// Gets if the notifier is listening.
+        /// </summary>
+        public bool IsListening
+        {
+            get { return _isListening; }
+        }
+
+        #endregion
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/ICallerContext.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/ICallerContext.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/ICallerContext.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,34 @@
+/*
+ * 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]>
+ */
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Interface to be implemented by those objects that can retrieve information regarding the
+    /// context of a method call.
+    /// </summary>
+    internal interface ICallerContext<TCaller>
+    {
+        /// <summary>
+        /// Returns the object that has called the method,
+        /// </summary>
+        /// <returns>The object that performed the call.</returns>
+        TCaller GetCaller();
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/IEventDispatcher.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/IEventDispatcher.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/IEventDispatcher.cs	2010-08-18 09:45:53 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Interface to be implemented by an object that knows how to dispatch events froma protobuf message
+    /// to a collection of ISyncDaemonClients.
+    /// </summary>
+    internal interface IEventDispatcher
+    {
+        /// <summary>
+        /// Method that ensures that an event that is given in a particular protobuf message
+        /// is notified to all the different clients.
+        /// </summary>
+        /// <param name="clientMessage">The client message that was sent by the python code.</param>
+        /// <param name="clients">An enumerable that contains all those clients that have to be notified about the 
+        /// particular event.</param>
+        void Dispatch(SyncDaemonClientMessage clientMessage, IEnumerable<ISyncDaemonClient> clients);
+    }
+}