/// <summary>
        /// Sends a message to a remote server.
        /// </summary>
        /// <param name="action">The action to perform.</param>
        /// <param name="request">The request to send to the server.</param>
        /// <returns>The response from the server.</returns>
        public Response SendMessage(string action, ServerRequest request)
        {
            // Make sure there is a password
            if ((cryptoKey.Length == 0) || (cryptoIv.Length == 0)) InitialisePassword();

            // Generate the encrypted request
            var encryptedRequest = new EncryptedRequest();
            encryptedRequest.Action = action;
            var crypto = new RijndaelManaged();
            crypto.Key = cryptoKey;
            crypto.IV = cryptoIv;
            encryptedRequest.EncryptedData = EncryptMessage(crypto, request.ToString());

            // Send the request
            var response = innerConnection.SendMessage("ProcessSecureRequest", encryptedRequest);
            var encryptedResponse = response as EncryptedResponse;

            // Generate the actual response
            if ((response.Result == ResponseResult.Success) && (encryptedResponse != null))
            {
                var data = DecryptMessage(crypto, encryptedResponse.EncryptedData);
                response = XmlConversionUtil.ProcessResponse(data);
            }
            return response;
        }

 public void SendMessageSendsAndReceivesAMessage()
 {
     var action = "DoSomething";
     var request = new ServerRequest
     {
         ServerName = "TestServer"
     };
     var url = "http://somewhere/";
     var factory = new TestClientFactory((u, a, d) =>
     {
         Assert.AreEqual(url + "server/TestServer/RawXmlMessage.aspx", u.AbsoluteUri);
         Assert.AreEqual("POST", a);
         Assert.AreEqual(action, d["action"]);
         Assert.AreEqual(request.ToString(), d["message"]);
         var theResponse = new Response
         {
             RequestIdentifier = request.Identifier
         };
         return Encoding.UTF8.GetBytes(theResponse.ToString());
     });
     var connection = new HttpConnection(new Uri(url), factory);
     var response = connection.SendMessage(action, request);
     Assert.IsInstanceOf<Response>(response);
     Assert.AreEqual(request.Identifier, response.RequestIdentifier);
 }

 public void EqualsMatchesRequestWithTheSameIdentifier()
 {
     ServerRequest request1 = new ServerRequest();
     ServerRequest request2 = new ServerRequest();
     request1.Identifier = request2.Identifier;
     Assert.IsTrue(request1.Equals(request2));
 }

 public void SendMessageAsyncSendsMessage()
 {
     var action = "DoSomething";
     var request = new ServerRequest
     {
         ServerName = "TestServer"
     };
     var url = "http://somewhere/";
     var factory = new TestClientFactory((u, a, d) =>
     {
         Assert.AreEqual(url + "server/TestServer/RawXmlMessage.aspx", u.AbsoluteUri);
         Assert.AreEqual("POST", a);
         Assert.AreEqual(action, d["action"]);
         Assert.AreEqual(request.ToString(), d["message"]);
         var theResponse = new Response
         {
             RequestIdentifier = request.Identifier
         };
         return Encoding.UTF8.GetBytes(theResponse.ToString());
     });
     var connection = new HttpConnection(new Uri(url), factory);
     var completed = false;
     connection.SendMessageCompleted += (o, e) =>
     {
         completed = true;
         Assert.IsFalse(e.Cancelled);
         Assert.IsNull(e.Error);
     };
     connection.SendMessageAsync(action, request);
     Assert.IsTrue(completed);
 }

 public void ChannelCanBeSetAndRetrieved()
 {
     var channelInfo = new object();
     var message = new ServerRequest();
     message.ChannelInformation = channelInfo;
     Assert.AreSame(channelInfo, message.ChannelInformation);
 }

 /// <summary>
 /// Fires the <see cref="RequestSending"/> event.
 /// </summary>
 /// <param name="action">The action that is being sent.</param>
 /// <param name="request">The request that is being sent.</param>
 protected virtual void FireRequestSending(string action, ServerRequest request)
 {
     if (RequestSending != null)
     {
         RequestSending(this, new CommunicationsEventArgs(action, request));
     }
 }

 public void InitialiseNewRequestSetsTheDefaultValues()
 {
     DateTime now = DateTime.Now;
     ServerRequest request = new ServerRequest();
     Assert.IsFalse(string.IsNullOrEmpty(request.Identifier), "Identifier was not set");
     Assert.AreEqual(Environment.MachineName, request.SourceName, "Source name doesn't match the machine name");
     Assert.IsTrue((now <= request.Timestamp), "Timestamp was not set");
 }

 public void ConvertXmlToRequestConvertsRequest()
 {
     var request = new ServerRequest("123456-789");
     request.ServerName = "theServer";
     var xmlString = request.ToString();
     var convertedRequest = XmlConversionUtil.ConvertXmlToRequest(xmlString);
     Assert.AreEqual("123456-789", convertedRequest.SessionToken);
     Assert.AreEqual("theServer", convertedRequest.ServerName);
 }

 public void InitialiseResponseFromRequestSetsTheDefaultValues()
 {
     DateTime now = DateTime.Now;
     ServerRequest request = new ServerRequest();
     ListUsersResponse response = new ListUsersResponse(request);
     Assert.AreEqual(ResponseResult.Unknown, response.Result, "Result wasn't set to failure");
     Assert.AreEqual(request.Identifier, response.RequestIdentifier, "RequestIdentifier wasn't set to the identifier of the request");
     Assert.IsTrue((now <= response.Timestamp), "Timestamp was not set");
 }

 public void InitialiseRequestWithSessionSetsTheCorrectValues()
 {
     string sessionToken = "the session";
     DateTime now = DateTime.Now;
     ServerRequest request = new ServerRequest(sessionToken);
     Assert.IsFalse(string.IsNullOrEmpty(request.Identifier), "Identifier was not set");
     Assert.AreEqual(Environment.MachineName, request.SourceName, "Source name doesn't match the machine name");
     Assert.AreEqual(sessionToken, request.SessionToken, "SessionToken doesn't match the input token");
     Assert.IsTrue((now <= request.Timestamp), "Timestamp was not set");
 }

 public void ToStringSerialisesDefaultValues()
 {
     ServerRequest request = new ServerRequest();
     string actual = request.ToString();
     string expected = string.Format(System.Globalization.CultureInfo.CurrentCulture,"<serverMessage xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " +
         "timestamp=\"{2:yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz}\" identifier=\"{0}\" source=\"{1}\" />",
         request.Identifier,
         request.SourceName,
         request.Timestamp);
     Assert.AreEqual(expected, actual);
 }

        private void buildProject()
        {
            this._manager = new RemoteCruiseManagerFactory()
                .GetCruiseServerClient("tcp://localhost:21234/CruiseManager.rem");
            this._project = new ProjectRequest("Edd", this.Name);
            this._manager.ForceBuild(this._project);
            this._request = new ServerRequest(this._project.SessionToken);

            // Write current status
            this.progress(String.Empty);
            IsRunning = false;
            Console.Write("\n\n");
        }

        public void SendMessageEncryptsMessage()
        {
            var innerConnection = new TestConnection();
            var outerConnection = new EncryptingConnection(innerConnection);
            var request = new ServerRequest();
            var expectedResponse = new Response(request);
            var actionName = "DoSomething";
            string iv = null;
            string key = null;

            innerConnection.SendMessageAction = (a, r) =>
            {
                Response sendResponse = null;
                if (a == "RetrievePublicKey")
                {
                    sendResponse = this.GenerateKeyResponse(r);
                }
                else if (a == "InitialiseSecureConnection")
                {
                    Assert.IsInstanceOf<LoginRequest>(r);
                    sendResponse = this.GenerateConnectioResponse(r as LoginRequest, out iv, out key);
                }
                else if (a == "ProcessSecureRequest")
                {
                    Assert.IsInstanceOf<EncryptedRequest>(r);
                    var actualRequest = r as EncryptedRequest;
                    Assert.AreEqual(actionName, actualRequest.Action);

                    var crypto = new RijndaelManaged();
                    crypto.Key = Convert.FromBase64String(key);
                    crypto.IV = Convert.FromBase64String(iv);
                    var requestData = DecryptMessage(crypto, actualRequest.EncryptedData);
                    Assert.AreEqual(request.ToString(), requestData);

                    var encryptedResponse = new EncryptedResponse();
                    encryptedResponse.Result = ResponseResult.Success;
                    encryptedResponse.EncryptedData = EncryptMessage(crypto, expectedResponse.ToString());
                    sendResponse = encryptedResponse;
                }
                else
                {
                    Assert.Fail("Unknown action: " + a);
                }

                return sendResponse;
            };
            var response = outerConnection.SendMessage(actionName, request);
            Assert.IsNotNull(response);
            Assert.AreEqual(expectedResponse.RequestIdentifier, response.RequestIdentifier);
        }

 public void GetSetAllPropertiesWorks()
 {
     ServerRequest request = new ServerRequest();
     request.Identifier = "new id";
     Assert.AreEqual("new id", request.Identifier, "Identifier fails the get/set test");
     request.ServerName = "new server";
     Assert.AreEqual("new server", request.ServerName, "ServerName fails the get/set test");
     request.SessionToken = "new session";
     Assert.AreEqual("new session", request.SessionToken, "SessionToken fails the get/set test");
     request.SourceName = "new source";
     Assert.AreEqual("new source", request.SourceName, "SourceName fails the get/set test");
     DateTime now = DateTime.Now;
     request.Timestamp = now;
     Assert.AreEqual(now, request.Timestamp, "Timestamp fails the get/set test");
 }

 public Response SendMessage(string action, ServerRequest request)
 {
     Assert.AreEqual(this.action, action);
     Assert.AreEqual(this.message, request.GetType());
     if (!string.IsNullOrEmpty(projectName) && (request is ProjectRequest))
     {
         Assert.AreEqual(this.projectName, (request as ProjectRequest).ProjectName);
     }
     if (response == null)
     {
         Response result = new Response(request);
         result.Result = ResponseResult.Success;
         return result;
     }
     else
     {
         return response;
     }
 }

 /// <summary>
 /// Initialise a new instance of <see cref="Response"/> from a request.
 /// </summary>
 /// <param name="request">The request to use.</param>
 public Response(ServerRequest request)
     : this()
 {
     requestIdentifier = request.Identifier;
 }

 /// <summary>
 /// Lists the available servers that can be monitored.
 /// </summary>
 /// <param name="request">The request.</param>
 /// <returns>
 /// A list containing one server - local.
 /// </returns>
 /// <remarks>
 /// This message is not secured at all.
 /// </remarks>
 public DataListResponse ListServers(ServerRequest request)
 {
     return new DataListResponse
     {
         Data = new List<string>{
             "local"
         }
     };
 }

        /// <summary>
        /// Terminate a secure communications connection.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Response TerminateSecureConnection(ServerRequest request)
        {
            // Remove the connection details
            if (connections.ContainsKey(request.SourceName))
            {
                connections.Remove(request.SourceName);
            }

            // Generate a response
            var response = new Response(request);
            response.Result = ResponseResult.Success;
            return response;
        }

        /// <summary>
        /// Retrieve the public key for the server.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public DataResponse RetrievePublicKey(ServerRequest request)
        {
            var response = new DataResponse(request);

            // Either generate or retrieve the key for CruiseControl.NET Server
            var cp = new CspParameters();
            cp.KeyContainerName = "CruiseControl.NET Server";
            var provider = new RSACryptoServiceProvider(cp);

            // Return the public key
            response.Data = provider.ToXmlString(false);
            response.Result = ResponseResult.Success;

            return response;
        }

        /// <summary>
        /// Processes an encrypted request.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public Response ProcessSecureRequest(ServerRequest request)
        {
            // Validate the request
            var encryptedRequest = request as EncryptedRequest;
            if (encryptedRequest == null) throw new CruiseControlException("Incoming request is not an encrypted request");
            if (!connections.ContainsKey(request.SourceName)) throw new CruiseControlException("No secure connection for the source");
            var connection = connections[request.SourceName];

            // Decrypt the data
            var crypto = new RijndaelManaged();
            crypto.Key = connection.Key;
            crypto.IV = connection.IV;
            string data = DecryptMessage(crypto, encryptedRequest.EncryptedData);

            // Find the action and message type, extract the message and invoke the method
            var response = ExtractAndInvokeMessage(data, encryptedRequest.Action,
                new RemotingChannelSecurityInformation { IsEncrypted = true });

            // Encrypt the response
            var encryptedResponse = new EncryptedResponse(request);
            encryptedResponse.EncryptedData = response.ToString();
            encryptedResponse.EncryptedData = EncryptMessage(crypto, encryptedResponse.EncryptedData);
            encryptedResponse.Result = ResponseResult.Success;

            return encryptedResponse;
        }