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

[Manuel de la Peña]

Provides the required code to allow the python code to send messages to the c# processes using the CallNamedPipe method from win32pipe

=== modified file 'build.number'
--- build.number	2010-10-12 10:18:45 +0000
+++ build.number	2010-10-12 10:18:45 +0000
@@ -1,1 +1,1 @@
-1.0.606.5623
 \ No newline at end of file
+1.0.611.8185
 \ No newline at end of file
 
=== modified file 'main.build'
--- main.build	2010-10-06 13:13:50 +0000
+++ main.build	2010-10-12 10:18:45 +0000
@@ -213,7 +213,7 @@
               managed="true"
               workingdir="src"
               program="python.exe"
-              commandline="setup.py py2exe" />
+              commandline="setup.py py2exe --packages=ubuntuone.storageprotocol" />
               
     </target>
     
 
=== modified file 'src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj'
--- src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	2010-10-05 09:49:29 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	2010-10-12 10:18:45 +0000
@@ -31,6 +31,10 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=3.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\JsonNet\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework, Version=2.5.5.10112, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Nunit\nunit.framework.dll</HintPath>
@@ -49,8 +53,13 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ColonSeparatedSSOCredentialsEncoderFixture.cs" />
+    <Compile Include="CredentialsDeniedEventArgsFixture.cs" />
+    <Compile Include="CredentialsErrorEventArgsFixture.cs" />
+    <Compile Include="CredentialsFoundEventArgsFixture.cs" />
+    <Compile Include="JsonCredentialsEncoderFixture.cs" />
     <Compile Include="JsonSSOCredentialsEncoderFixture.cs" />
     <Compile Include="KeyringFixture.cs" />
+    <Compile Include="LoginCredentialsEventArgsFixture.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SSOLoginProcessorFixture.cs" />
   </ItemGroup>
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/CredentialsDeniedEventArgsFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/CredentialsDeniedEventArgsFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/CredentialsDeniedEventArgsFixture.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of Ubuntu One on Windows.
+ * 
+ * Ubuntu One 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 Ubuntu One for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class CredentialsDeniedEventArgsFixture
+    {
+        #region Variables
+
+        private CredentialsDeniedEventArgs _args;
+
+        #endregion
+
+        #region Tests
+        
+        [Test]
+        public void EmptyConstructorTest()
+        {
+            _args = new CredentialsDeniedEventArgs();
+            Assert.AreEqual(string.Empty, _args.ApplicationName);
+        }
+
+        [TestCase("UbuntuOne")]
+        [TestCase("OtherApp")]
+        [TestCase("Tomboy")]
+        public void StringConstructorTest(string appName)
+        {
+            // create the credentials and make sure the correct data is used.
+            _args = new CredentialsDeniedEventArgs(appName);
+            Assert.AreEqual(appName, _args.ApplicationName);
+        }
+
+        #endregion
+
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/CredentialsErrorEventArgsFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/CredentialsErrorEventArgsFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/CredentialsErrorEventArgsFixture.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of Ubuntu One on Windows.
+ * 
+ * Ubuntu One 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 Ubuntu One for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+
+    [TestFixture]
+    public class CredentialsErrorEventArgsFixture
+    {
+
+        #region Variables
+
+        private CredentialsErrorEventArgs _args;
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void EmptyConstructorTest()
+        {
+            _args = new CredentialsErrorEventArgs();
+            Assert.AreEqual(string.Empty, _args.ApplicationName);
+            Assert.AreEqual(string.Empty, _args.DetailedErrorMessage);
+            Assert.AreEqual(string.Empty, _args.ErrorMessage);
+        }
+
+        [TestCase("UbuntuOne", "Error 08")]
+        [TestCase("Tomboy", "NullReferenceException")]
+        [TestCase("OtherApp", "StupidError")]
+        public void ApplicationErrorConstructorTest(string appName, string error)
+        {
+            _args = new CredentialsErrorEventArgs(appName, error);
+            Assert.AreEqual(appName, _args.ApplicationName);
+            Assert.AreEqual(error, _args.ErrorMessage);
+            Assert.AreEqual(string.Empty, _args.DetailedErrorMessage);
+        }
+
+        [TestCase("UbuntuOne", "Error 08", "You do not have the keyring rigths.")]
+        [TestCase("Tomboy", "NullReferenceException", "Stupid extension")]
+        [TestCase("OtherApp", "StupidError", "Learn to code")]
+        public void ApplicationErrorDetailConstructorTest(string appName, string error, string detail)
+        {
+            _args = new CredentialsErrorEventArgs(appName, error, detail);
+            Assert.AreEqual(appName, _args.ApplicationName);
+            Assert.AreEqual(error, _args.ErrorMessage);
+            Assert.AreEqual(detail, _args.DetailedErrorMessage);
+        }
+
+        #endregion
+
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/CredentialsFoundEventArgsFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/CredentialsFoundEventArgsFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/CredentialsFoundEventArgsFixture.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of Ubuntu One on Windows.
+ * 
+ * Ubuntu One 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 Ubuntu One for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class CredentialsFoundEventArgsFixture
+    {
+        #region Variables
+
+        private CredentialsFoundEventArgs _args;
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void EmptyConstructorTest()
+        {
+            _args = new CredentialsFoundEventArgs();
+            Assert.AreEqual(string.Empty, _args.ApplicationName);
+            Assert.IsEmpty((ICollection)_args.Credentials.Values);
+        }
+
+        [TestCase("UbuntuOne", "token", "tokenSecret", "consumerKey", "consumerSecret")]
+        [TestCase("Tomboy", "tomboyToken", "tomboyToeknSecret", "tomboyConsumerKey", "tomboyConsumerSecret")]
+        public void AppNameCredentialsConstructor(string appName, string token, string tokenSecret, 
+            string consumerKey, string consumerSecret )
+        {
+            // create the dict with the data
+            var credentials = new Dictionary<string, string>
+            {
+                {"Token", token},
+                {"TokenSecret", tokenSecret},
+                {"ConsumerKey", consumerKey},
+                {"ConsumerSecret", consumerSecret}
+            };
+            _args = new CredentialsFoundEventArgs(appName, credentials);
+            Assert.AreEqual(appName, _args.ApplicationName);
+            Assert.AreSame(credentials, _args.Credentials);
+        }
+
+        #endregion
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/JsonCredentialsEncoderFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/JsonCredentialsEncoderFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/JsonCredentialsEncoderFixture.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,100 @@
+/* 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 Newtonsoft.Json.Linq;
+using NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class JsonCredentialsEncoderFixture
+    {
+        #region Variables
+
+        private JsonSSOCredentialsEncoder _encoder;
+
+        #endregion
+
+        #region Setup & TearDown
+
+        [SetUp]
+        public void Setup()
+        {
+            _encoder = new JsonSSOCredentialsEncoder();    
+        }
+
+        #endregion
+
+        #region Tests
+
+        [TestCase("token", "tokenSecret", "consumerKey", "consumerSecret")]
+        [TestCase("asasferer", "ykvchdclsc", "sdahdlfa", "zcknvculdsnv")]
+        public void EncodeTest(string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            // pass the data to encode, later test that the required data is present
+            // and that the data is the same.
+            var encodedData = _encoder.Encode(token, tokenSecret, consumerKey, consumerSecret);
+            // use the Json.Net to read the result string and ensure we do have the data
+            var credentials = JObject.Parse(encodedData);
+            Assert.AreEqual(token, (string)credentials["token"]);
+            Assert.AreEqual(tokenSecret, (string)credentials["token_secret"]);
+            Assert.AreEqual(consumerKey, (string)credentials["consumer_key"]);
+            Assert.AreEqual(consumerSecret, (string)credentials["consumer_secret"]);
+        }
+
+        [TestCase("token", "tokenSecret", "consumerKey", "consumerSecret")]
+        [TestCase("asasferer", "ykvchdclsc", "sdahdlfa", "zcknvculdsnv")]
+        public void DecodeTest(string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            // create the encoded data, decode it an ensure is the same
+            string returnedToken;
+            string returnedTokenSecret;
+            string returnedConsumerKey;
+            string returnedConsumerSecret;
+
+            var encodedData = _encoder.Encode(token, tokenSecret, consumerKey, consumerSecret);
+            _encoder.Decode(encodedData, out returnedToken, out returnedTokenSecret, 
+                out  returnedConsumerKey, out returnedConsumerSecret);
+            Assert.AreEqual(token, returnedToken);
+            Assert.AreEqual(tokenSecret, returnedTokenSecret);
+            Assert.AreEqual(consumerKey, returnedConsumerKey);
+            Assert.AreEqual(consumerSecret, returnedConsumerSecret);
+        }
+
+        [TestCase(null, "tokenSecret", "consumerKey", "consumerSecret")]
+        [TestCase("token", null, "consumerKey", "consumerSecret")]
+        [TestCase("token", "tokenSecret", null, "consumerSecret")]
+        [TestCase("token", "tokenSecret", "consumerKey", null)]
+        [ExpectedException(typeof(SSOException))]
+        public void DecodeEmptyDataTest(string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            // encode the data, then try to decode an expect the exception
+            string returnedToken;
+            string returnedTokenSecret;
+            string returnedConsumerKey;
+            string returnedConsumerSecret;
+
+            var encodedData = _encoder.Encode(token, tokenSecret, consumerKey, consumerSecret);
+            _encoder.Decode(encodedData, out returnedToken, out returnedTokenSecret,
+                out  returnedConsumerKey, out returnedConsumerSecret);
+        }
+
+        #endregion
+
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/LoginCredentialsEventArgsFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/LoginCredentialsEventArgsFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/LoginCredentialsEventArgsFixture.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,52 @@
+/* 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 NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class LoginCredentialsEventArgsFixture
+    {
+        #region Variables
+
+        private LoginCredentialsEventArgs _args;
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void EmptyConstructorTest()
+        {
+            _args = new LoginCredentialsEventArgs();
+            Assert.AreEqual(string.Empty, _args.Username);
+            Assert.AreEqual(string.Empty, _args.Password);
+        }
+
+        [TestCase("username", "password")]
+        [TestCase("otherUsername", "otherPassword")]
+        public void UsernamePasswordConstructor(string username, string password)
+        {
+            _args = new LoginCredentialsEventArgs(username, password);
+            Assert.AreEqual(username, _args.Username);
+            Assert.AreEqual(password, _args.Password);
+        }
+        #endregion
+    }
+}
 
=== modified file 'src/Canonical.Ubuntu.SSO/SSOCredentialsProvider.cs'
--- src/Canonical.Ubuntu.SSO/SSOCredentialsProvider.cs	2010-10-05 15:20:36 +0000
+++ src/Canonical.Ubuntu.SSO/SSOCredentialsProvider.cs	2010-10-12 10:18:45 +0000
@@ -20,7 +20,6 @@
 using System;
 using System.Collections.Generic;
 using System.Windows;
-using Canonical.UbuntuOne.Common;
 using Canonical.UbuntuOne.Common.Aop;
 
 namespace Canonical.Ubuntu.SSO
@@ -150,6 +149,7 @@
         [DebugLogged]
         public void LoginOrRegisterToGetCredentials()
         {
+            throw new NotImplementedException();
         }
 
         #endregion
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-10-12 10:18:45 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj	2010-10-12 10:18:45 +0000
@@ -91,6 +91,15 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="IMessageProcessor.cs" />
+    <Compile Include="IPipeListener.cs" />
+    <Compile Include="IPipeStreamer.cs" />
+    <Compile Include="IPipeStreamerFactory.cs" />
+    <Compile Include="JsonMessageProcessor.cs" />
+    <Compile Include="JsonPipeStreamer.cs" />
+    <Compile Include="JsonPipeStreamerFactory.cs" />
+    <Compile Include="PipeListener.cs" />
+    <Compile Include="PipeListenerException.cs" />
     <Compile Include="SyncDaemonWindowsService.cs">
     </Compile>
     <Compile Include="CallerContext.cs" />
@@ -113,6 +122,10 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\log4net\log4net.dll</HintPath>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=3.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\JsonNet\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="Spring.Core, Version=1.3.0.20349, Culture=neutral, PublicKeyToken=65e474d141e25e07, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\Spring.Net\Spring.Core.dll</HintPath>
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/IMessageProcessor.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/IMessageProcessor.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/IMessageProcessor.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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 now how to process the messages comming from python.
+    /// </summary>
+    public interface IMessageProcessor
+    {
+        /// <summary>
+        /// Will process the message sent by the python code and will perform all the possibly required operations.
+        /// </summary>
+        /// <param name="message"></param>
+        void ProcessMessage(object message);
+    }
+}
 \ No newline at end of file
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,43 @@
+using System;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    internal interface IPipeListener
+    {
+        /// <summary>
+        /// Gets if the pipe listener is indeed listening to the pipe.
+        /// </summary>
+        bool IsListening { get; }
+
+        /// <summary>
+        /// Gets and sets the number of threads that will be used to listen to the 
+        /// pipe. Each thread will listeng to connections and will dispatch the 
+        /// messages when ever they are done.
+        /// </summary>
+        int NumberOfThreads { get; set; }
+
+        /// <summary>
+        /// Gets and sets the pipe stream factory that know how to generate the streamers used for the communication.
+        /// </summary>
+        IPipeStreamerFactory PipeStreamerFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the action that will be performed with the message of that 
+        /// is received by the pipe listener.
+        /// </summary>
+        IMessageProcessor MessageProcessor { get; set; }
+
+        /// <summary>
+        /// Starts listening to the different pipe messages and will perform the appropiate
+        /// action when a message is received.
+        /// </summary>
+        /// <param name="namedPipe">The name fof the pipe to listen.</param>
+        void StartListening(string namedPipe);
+
+        /// <summary>
+        /// Stops listening to the different pipe messages. All the thread that are listening already will 
+        /// be forced to stop.
+        /// </summary>
+        void StopListening();
+    }
+}
 \ No newline at end of file
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamer.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamer.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamer.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,52 @@
+/*
+ * 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 System.Text;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Interface that should be implemented by those objects that
+    /// know the protocol that is used to communicate with the python code.
+    /// </summary>
+    public interface IPipeStreamer
+    {
+        /// <summary>
+        /// Gets and sets the encoding used by the streamer.
+        /// </summary>
+        Encoding Encoding { get; set; }
+
+        /// <summary>
+        /// Reads the current contents that are present in the stream and returns an object that
+        /// represents them.
+        /// </summary>
+        /// <param name="stream">The stream from which the data is read.</param>
+        /// <returns>An object that represents the data in the stream.</returns>
+        object Read(Stream stream);
+
+        /// <summary>
+        /// Writes the given object to the stream so that the python code can read it.
+        /// </summary>
+        /// <param name="outData">The object to be serialized in the stream.</param>
+        /// <param name="stream">The stream to which the serialization will be written.</param>
+        /// <returns>The position in the stream after the write operation.</returns>
+        int Write(object outData, Stream stream);
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamerFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamerFactory.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/IPipeStreamerFactory.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,33 @@
+/*
+ * 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>
+    /// Factory that will generate the IPipeStream objects that understand the protocol used to communicate
+    /// between the different processes.
+    /// </summary>
+    public interface IPipeStreamerFactory
+    {
+        /// <summary>
+        /// Creates a new PipeStreamer that know the streamer to create that will
+        /// know the protocol used to communicate between processes.
+        /// </summary>
+        /// <returns>A pipe streamer that knoww how to the protocol works.</returns>
+        IPipeStreamer Create();
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,38 @@
+/*
+ * 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
+{
+    /// <summary>
+    /// Message processor that works with json messages from python.
+    /// </summary>
+    internal class JsonMessageProcessor : IMessageProcessor
+    {
+        /// <summary>
+        /// Will process the message sent by the python code and will perform all the possibly required operations.
+        /// </summary>
+        /// <param name="message"></param>
+        public void ProcessMessage(object message)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamer.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamer.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamer.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,91 @@
+/*
+ * 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.IO;
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// Pipe streamer that uses json to talk with the python code.
+    /// </summary>
+    internal class JsonPipeStreamer : IPipeStreamer
+    {
+        #region Implementation of IPipeStreamer
+
+        /// <summary>
+        /// Gets and sets the encoding used by the streamer.
+        /// </summary>
+        public Encoding Encoding
+        {
+            get { return new UTF8Encoding(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        /// Reads the current contents that are present in the stream and returns an object that
+        /// represents them.
+        /// </summary>
+        /// <param name="stream">The stream from which the data is read.</param>
+        /// <returns>An object that represents the data in the stream.</returns>
+        public object Read(Stream stream)
+        {
+            int len = 0;
+
+            len = stream.ReadByte() * 256;
+            len += stream.ReadByte();
+            byte[] inBuffer = new byte[len];
+            stream.Read(inBuffer, 0, len);
+            var json = Encoding.GetString(inBuffer);
+  
+            // we just need to read the string from the python code and parse it as a json string :D
+            var message = JObject.Parse(json);
+            return message;
+        }
+
+        /// <summary>
+        /// Writes the given object to the stream so that the python code can read it.
+        /// </summary>
+        /// <param name="outData">The object to be serialized in the stream.</param>
+        /// <param name="stream">The stream to which the serialization will be written.</param>
+        /// <returns>The position in the stream after the write operation.</returns>
+        public int Write(object outData, Stream stream)
+        {
+            // generate the json from the outData and write it ot the stream
+            var json = JsonConvert.SerializeObject(outData, Formatting.None);
+            byte[] outBuffer = Encoding.GetBytes(json);
+            int len = outBuffer.Length;
+            if (len > UInt16.MaxValue)
+            {
+                len = (int)UInt16.MaxValue;
+            }
+            stream.WriteByte((byte)(len / 256));
+            stream.WriteByte((byte)(len & 255));
+            stream.Write(outBuffer, 0, len);
+            stream.Flush();
+
+            return outBuffer.Length + 2;
+        }
+
+        #endregion
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,41 @@
+/*
+ * 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>
+    /// PipeStreamerFactory that creates streamers that use json for communication.
+    /// </summary>
+    internal class JsonPipeStreamerFactory : IPipeStreamerFactory
+    {
+        #region Implementation of IPipeStreamerFactory
+
+        /// <summary>
+        /// Creates a new PipeStreamer that know the streamer to create that will
+        /// know the protocol used to communicate between processes.
+        /// </summary>
+        /// <returns>A pipe streamer that knoww how to the protocol works.</returns>
+        public IPipeStreamer Create()
+        {
+            return new JsonPipeStreamer();
+        }
+
+        #endregion
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,244 @@
+/*
+ * 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.IO;
+using System.IO.Pipes;
+using System.Threading;
+using log4net;
+
+namespace Canonical.UbuntuOne.ProcessDispatcher
+{
+    /// <summary>
+    /// This oject represents a listener that will be waiting for messages
+    /// from the python code and will perform an operation for each messages
+    /// that has been recived. 
+    /// </summary>
+    internal class PipeListener : IPipeListener
+    {
+        #region Helper strcut
+
+        /// <summary>
+        /// Private structure used to pass the start of the listener to the 
+        /// different listening threads.
+        /// </summary>
+        private struct PipeListenerState
+        {
+            #region Variables
+
+            private readonly string _namedPipe;
+            private readonly Action<object> _callback;
+
+            #endregion
+
+            #region Properties
+
+            /// <summary>
+            /// Gets the named pipe to which the thread should listen.
+            /// </summary>
+            public string NamedPipe { get { return _namedPipe; } }
+
+            /// <summary>
+            /// Gets the callback that the listening pipe should execute.
+            /// </summary>
+            public Action<object> Callback { get { return _callback; } }
+
+            #endregion
+
+            public PipeListenerState(string namedPipe, Action<object> callback)
+            {
+                _namedPipe = namedPipe;
+                _callback = callback;
+            }
+        }
+
+        #endregion
+
+        #region Variables
+
+        private readonly object _loggerLock = new object();
+        private ILog _logger;
+        private bool _isListening;
+        private readonly object _isListeningLock = new object();
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets the logger to used with the object.
+        /// </summary>
+        internal ILog Logger
+        {
+            get
+            {
+                if (_logger == null)
+                {
+                    lock (_loggerLock)
+                    {
+                        _logger = LogManager.GetLogger(typeof(PipeListener));
+                    }
+                }
+                return _logger;
+            }
+            set
+            {
+                _logger = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets if the pipe listener is indeed listening to the pipe.
+        /// </summary>
+        public bool IsListening
+        {
+            get { return _isListening; }
+            private set
+            {
+                // we have to lock to ensure that the threads do not screw each
+                // other up, this makes a small step of the processing to be sync :(
+                lock (_isListeningLock)
+                {
+                    _isListening = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets and sets the number of threads that will be used to listen to the 
+        /// pipe. Each thread will listeng to connections and will dispatch the 
+        /// messages when ever they are done.
+        /// </summary>
+        public int NumberOfThreads { get; set; }
+
+        /// <summary>
+        /// Gets and sets the pipe stream factory that know how to generate the streamers used for the communication.
+        /// </summary>
+        public IPipeStreamerFactory PipeStreamerFactory { get; set; }
+
+        /// <summary>
+        /// Gets and sets the action that will be performed with the message of that 
+        /// is received by the pipe listener.
+        /// </summary>
+        public IMessageProcessor MessageProcessor { get; set; }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Helper method that is used in another thread that will be listening to the possible events from 
+        /// the pipe.
+        /// </summary>
+        private void Listen(object state)
+        {
+            var namedPipeState = (PipeListenerState)state;
+            
+            try
+            {
+                var threadNumber = Thread.CurrentThread.ManagedThreadId;
+                // starts the named pipe since in theory it should not be present, if there is 
+                // a pipe already present we have an issue.
+                using (var pipeServer = new NamedPipeServerStream(namedPipeState.NamedPipe, PipeDirection.InOut, NumberOfThreads,PipeTransmissionMode.Message,PipeOptions.Asynchronous))
+                {
+                    Logger.DebugFormat("Thread {0} listenitng to pipe {1}", threadNumber, namedPipeState.NamedPipe);
+                    // we wait until the python code connects to the pipe, we do not block the 
+                    // rest of the app because we are in another thread.
+                    pipeServer.WaitForConnection();
+
+                    Logger.DebugFormat("Got clien connection in tread {0}", threadNumber);
+                    try
+                    {
+                        // create a streamer that know the protocol
+                        var streamer = PipeStreamerFactory.Create();
+                        // Read the request from the client. 
+                        var message = streamer.Read(pipeServer);
+                        Logger.DebugFormat("Message received to thread {0} is {1}", threadNumber, message);
+
+                        // execute the action that has to occur with the message
+                        namedPipeState.Callback(message);
+                    }
+                    // Catch the IOException that is raised if the pipe is broken
+                    // or disconnected.
+                    catch (IOException e)
+                    {
+                        Logger.DebugFormat("Error in thread {0} when reading pipe {1}",threadNumber, e.Message);
+                        throw new PipeListenerException(
+                            string.Format("Error in thread {0} when reading pipe {1}", threadNumber, e.Message), e);
+                    }
+
+                }
+                // if we are still listening, we will create a new thread to be used for listening,
+                // otherwhise we will not and not lnger threads will be added. Ofcourse if the rest of the
+                // threads do no add more than one work, we will have no issues with the pipe server since it
+                // has been disposed
+                if (IsListening)
+                {
+                    ThreadPool.QueueUserWorkItem(Listen, namedPipeState.NamedPipe);
+                }
+            }
+            catch (PlatformNotSupportedException e)
+            {
+                // are we running on an OS that does not have pipes (Mono on some os)
+                throw new PipeListenerException(string.Format("Cannot listen to pipe {0}", namedPipeState.NamedPipe), e);
+            }
+            catch (IOException e)
+            {
+                // there are too many servers listening to this pipe.
+                throw new PipeListenerException(
+                    string.Format("There are too many servers listening to {0}", namedPipeState.NamedPipe), e);
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Starts listening to the different pipe messages and will perform the appropiate
+        /// action when a message is received.
+        /// </summary>
+        /// <param name="namedPipe">The name fof the pipe to listen.</param>
+        public void StartListening(string namedPipe)
+        {
+            if (NumberOfThreads < 0)
+            {
+                throw new PipeListenerException(
+                    "The number of threads to use to listen to the pipe must be at least one.");
+            }
+            // we will be using a thread pool that will allow to have the different threads listening to 
+            // the messages of the pipes. There could be issues if the devel provided far to many threads
+            // to listen to the pipe since the number of pipe servers is limited.
+            for (var currentThreaCount = 0; currentThreaCount < NumberOfThreads; currentThreaCount++)
+            {
+                // we add an new thread to listen
+                ThreadPool.QueueUserWorkItem(Listen, new PipeListenerState(namedPipe, MessageProcessor.ProcessMessage));
+            }
+
+        }
+
+        /// <summary>
+        /// Stops listening to the different pipe messages. All the thread that are listening already will 
+        /// be forced to stop.
+        /// </summary>
+        public void StopListening()
+        {
+            IsListening = false;
+        }
+
+    }
+}
 
=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/PipeListenerException.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/PipeListenerException.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/PipeListenerException.cs	2010-10-12 10:18:45 +0000
@@ -0,0 +1,62 @@
+/*
+ * 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
+{
+    /// <summary>
+    /// Base class exception thrown where there is an issue while listening to the pipe used
+    /// by python to send messages.
+    /// </summary>
+    public class PipeListenerException : Exception 
+    {
+
+        /// <summary>
+        /// Creates a new instance of the exception.
+        /// </summary>
+        public PipeListenerException()
+        {
+            
+        }
+
+        /// <summary>
+        /// Creates a new instance of the exception that will carry the given 
+        /// message.
+        /// </summary>
+        /// <param name="message">The message to be carrie by the exception.</param>
+        public PipeListenerException(string message)
+            : base(message)
+        {
+            
+        }
+
+        /// <summary>
+        /// Creates a new instance of the exception that will carry the given message and
+        /// inner exception.
+        /// </summary>
+        /// <param name="message">The message to be carried by the exception.</param>
+        /// <param name="inner">The inner exception that originated this exception.</param>
+        public PipeListenerException(string message, Exception inner)
+            : base(message, inner)
+        {
+            
+        }
+    }
+}
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Program.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/Program.cs	2010-10-12 10:18:45 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/Program.cs	2010-10-12 10:18:45 +0000
@@ -18,6 +18,7 @@
  * Authors: Manuel de la Peña <[e-mail]>
  */
 using System;
+using System.Security.Principal;
 using Canonical.UbuntuOne.Common.Container;
 using Canonical.UbuntuOne.Common.Utils;
 using log4net;
@@ -29,6 +30,8 @@
     {
         private static readonly ILog _logger = LogManager.GetLogger(typeof(Program));
         private static readonly ConfigurationLocator _configLocator = new ConfigurationLocator();
+        private static readonly string _listegingPipe =
+            "PythonMessages";
 
         /// <summary>
         /// This method starts the service.
@@ -71,6 +74,12 @@
                 var syncDaemonWindowsService = ObjectsContainer.GetImplementationOf<SyncDaemonWindowsService>();
                 // To run more than one service you have to add them here
                 syncDaemonWindowsService.Start();
+                // we need to start listening to the possible messages sent by the python code, we
+                // ensure that it is done to a ipe just for the user
+                var pipeListener = ObjectsContainer.GetImplementationOf<IPipeListener>();
+                var userPipe = _listegingPipe + WindowsIdentity.GetCurrent().Name;
+                _logger.InfoFormat("Listening on {0}", userPipe);
+                pipeListener.StartListening(userPipe);
                 while (true) ;
             });
 
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs'
--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs	2010-10-12 10:18:45 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs	2010-10-12 10:18:45 +0000
@@ -283,11 +283,17 @@
                     UseShellExecute = false,
                     RedirectStandardOutput = true,
                     RedirectStandardError = true,
-                    CreateNoWindow = true,
+                    CreateNoWindow = false,
                     WindowStyle = ProcessWindowStyle.Hidden
                 }
             };
             proc.Start();
+            // we wait, we are in a diff thread in a diff process this will not block the user UI
+            proc.WaitForExit();
+            var error = proc.StandardError.ReadToEnd();
+            Logger.InfoFormat("StandarOutput from u1sync is: {0}", proc.StandardOutput.ReadToEnd());
+            Logger.ErrorFormat("StandardError from u1sync is: {0}", proc.StandardError.ReadToEnd());
+            proc.Close();
         }
 
         /// <summary>
 
=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml'
--- src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml	2010-10-12 10:18:45 +0000
+++ src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml	2010-10-12 10:18:45 +0000
@@ -116,5 +116,24 @@
     <property name="SyncShares"
               ref="SyncSharesServiceHost" />
   </object>
+
+  <!-- ###################################################################################################### -->
+  <!-- The pipe listener that will be used to know what the python code wants to tell us                      -->
+  <!-- ###################################################################################################### -->
+
+  <object id="PipeStreamerFactory"
+          type="Canonical.UbuntuOne.ProcessDispatcher.JsonPipeStreamerFactory, Canonical.UbuntuOne.ProcessDispatcher"
+          autowire="autodetect"/>
+
+  <object id="MessageProcessor"
+          type="Canonical.UbuntuOne.ProcessDispatcher.JsonMessageProcessor, Canonical.UbuntuOne.ProcessDispatcher"
+          autowire="autodetect" />
   
+  <object id="PipeListener"
+          type="Canonical.UbuntuOne.ProcessDispatcher.PipeListener, Canonical.UbuntuOne.ProcessDispatcher"
+          autowire="autodetect">
+    <property name="NumberOfThreads"
+              value="5"/>
+  </object>
+
 </objects>
 \ No newline at end of file
 
=== modified file 'src/Version.cs'
--- src/Version.cs	2010-10-12 10:18:45 +0000
+++ src/Version.cs	2010-10-12 10:18:45 +0000
@@ -10,6 +10,6 @@
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-[assembly: AssemblyVersionAttribute("1.0.606.5623")]
-[assembly: AssemblyFileVersionAttribute("1.0.606.5623")]
+[assembly: AssemblyVersionAttribute("1.0.611.8185")]
+[assembly: AssemblyFileVersionAttribute("1.0.611.8185")]
 
 
=== modified file 'src/u1sync/main.py'
--- src/u1sync/main.py	2010-09-27 17:33:52 +0000
+++ src/u1sync/main.py	2010-10-12 10:18:45 +0000
@@ -43,7 +43,7 @@
 from u1sync.merge import (
     SyncMerge, ClobberServerMerge, ClobberLocalMerge, merge_trees)
 from u1sync.sync import download_tree, upload_tree
-from u1sync.utils import safe_mkdir
+from u1sync.utils import safe_mkdir, send_bus_error
 from u1sync import metadata
 from u1sync.constants import METADATA_DIR_NAME
 from u1sync.ubuntuone_optparse import UbuntuOneOptionsParser
@@ -332,21 +332,29 @@
     try:
         do_main(argv, UbuntuOneOptionsParser())
     except AuthenticationError, e:
+        sed_bus_error("Authentication failed: %s" % e, e)
         print "Authentication failed: %s" % e
     except ConnectionError, e:
+        sed_bus_error("Connection failed: %s" % e, e)
         print "Connection failed: %s" % e
-    except DirectoryNotInitializedError:
+    except DirectoryNotInitializedError, e:
+        sed_bus_error("Directory not initialized", e)
         print "Directory not initialized; " \
             "use --init [DIRECTORY] to initialize it."
-    except DirectoryAlreadyInitializedError:
+    except DirectoryAlreadyInitializedError, e:
+        sed_bus_error("Directory not initialized", e)
         print "Directory already initialized."
-    except NoSuchShareError:
+    except NoSuchShareError, e:
+        sed_bus_error("No matching share found.", e)
         print "No matching share found."
-    except ReadOnlyShareError:
+    except ReadOnlyShareError, e:
+        sed_bus_error("The selected action isn't possible on a read-only share.", e)
         print "The selected action isn't possible on a read-only share."
-    except (ForcedShutdown, KeyboardInterrupt):
+    except (ForcedShutdown, KeyboardInterrupt), e:
+        sed_bus_error("Interrupted!", e)
         print "Interrupted!"
     except TreesDiffer, e:
+        sed_bus_error("Trees differ.", e)
         if not e.quiet:
             print "Trees differ."
     else:
 
=== modified file 'src/u1sync/utils.py'
--- src/u1sync/utils.py	2010-08-27 14:43:32 +0000
+++ src/u1sync/utils.py	2010-10-12 10:18:45 +0000
@@ -19,7 +19,11 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Miscellaneous utility functions."""
 
+import json
 import os
+import getpass
+
+import win32pipe
 from errno import EEXIST, ENOENT
 from u1sync.constants import (
     METADATA_DIR_NAME, SPECIAL_FILE_RE)
@@ -48,3 +52,36 @@
     except OSError, e:
         if e.errno != ENOENT:
             raise
+
+def get_user():
+    """Return the name of the current user."""
+    return r'{0}\{1}'.format(os.getenv('COMPUTERNAME'), getpass.getuser())
+    
+def create_error_message(error_message, exception):
+    """Create a new error message"""
+    # hack, I really dislike this, later using protobuf we 
+    # can state the type of error, right now, this should do the work.
+    message = {'type':'error', 
+               'message':error_message, 
+               'expcetion':type(exception.__class__.__name__)}
+    return message
+    
+def send_bus_message(message):
+    """Sends a message to a pipe listen by an other lang."""
+    pipe_name = r'\\.\pipe\PythonMessages{0}'.format(get_user())
+    # calulate json representation of the message 
+    data_json = json.dumps(message)
+    length = str(len(data_json)/256)
+    length += str(len(data_json)&256)
+    data_json = length + data_json
+    # call the pipe with the message
+    try:
+        data = win32pipe.CallNamedPipe(pipe_name, 
+            data_json, len(data_json), 0 )
+    except Exception:
+        print "Error: C# client is not listening!!"
+    
+def send_bus_error(error_message, exception):
+    message = create_error_message(error_message, exception)
+    send_bus_message(message)
+    
 \ No newline at end of file