public void SendMessage(WireSendingMessage message, IEndpoint endpoint)
        {
            TransportPipe pipe;
            var customEndpoint = (CustomTcpEndpoint) endpoint;
            if (!_endpointToPipe.TryGetValue(customEndpoint, out pipe))
            {
                pipe = new TcpTransportPipeMultiThread(3000000,
                                                           HighWaterMarkBehavior.Block,
                                                           customEndpoint.EndPoint,
                                                           _transport);
                _endpointToPipe.Add(customEndpoint, pipe);
            }
            var wait = default(SpinWait);
            var sent = false;
            bool first = true;
            var buffer = _serializer.Serialize(message.MessageData);
            do
            {
                sent = pipe.Send(new ArraySegment<byte>(buffer, 0, buffer.Length), true);
                if (!first)
                    wait.SpinOnce();
                else
                    first = false;
            } while (!sent && wait.Count < 1000);

            if (!sent) //peer is disconnected (or underwater from too many message), raise some event?
            {
                Console.WriteLine("AAAAG");
                _logger.Info(string.Format("disconnect of endpoint {0}", customEndpoint.EndPoint));
                EndpointDisconnected(endpoint);
                pipe.Dispose();
                _endpointToPipe.Remove(customEndpoint);
            }
        }

		public override void ProcessMessage(IEndpoint endpoint, byte[] data)
		{
			List<byte> package = new List<byte>();
			if (_client == null)
			{
				_client = new TcpClient();
				_client.Connect(_options.Endpoint);

				if (_options.SohDelimiters.Length > 0)
				{
					package.AddRange(_options.SohDelimiters);
				}
			}

			//TODO: If options mandate delimters, write STX and ETX here
			if (_options.StxDelimiters.Length > 0)
			{
				package.AddRange(_options.StxDelimiters);
			}

			package.AddRange(data);

			if (_options.EtxDelimiters.Length > 0)
			{
				package.AddRange(_options.EtxDelimiters);
			}

			Write(package.ToArray());

			if (!_options.KeepConnectionOpen)
			{
				CloseConnection();
			}
		}

 public void SetUp()
 {
     endpoint = A.Fake<IEndpoint>();
     applicationEndpoints = new List<IEndpoint> { endpoint };
     findNextRequestChainPart = A.Fake<IFindNextRequestChainPart>();
     requestGraph = new RequestGraph(applicationEndpoints, findNextRequestChainPart);
 }

        public IClient Create(IEndpoint endpoint, IClientPool ownerPool)
        {
            TSocket socket = null;
            TTransport transport = null;
            if (endpoint.Timeout == 0)
            {
                socket = new TSocket(endpoint.Address, endpoint.Port);
            }
            else
            {
                socket = new TSocket(endpoint.Address, endpoint.Port, endpoint.Timeout);
            }
            TcpClient tcpClient = socket.TcpClient;

            if (this.isBufferSizeSet)
            {
                transport = new TBufferedTransport(socket, this.bufferSize);
            }
            else
            {
                transport = new TBufferedTransport(socket);
            }

            TProtocol protocol = new TBinaryProtocol(transport);
            CassandraClient cassandraClient = new CassandraClient(protocol);
            IClient client = new DefaultClient() {
                CassandraClient = cassandraClient,
                Endpoint = endpoint,
                OwnerPool = ownerPool,
                TcpClient = tcpClient,
                Created = DateTime.Now
            };

            return client;
        }

 public override void Bind(IEndpoint endpoint)
 {
     // TODO: ClearOldHeaders
     Open();
     safeChannel.Channel.QueueBind(endpoint.Name, name, endpoint.RoutingKey, endpoint.RoutingHeaders);
     Close();
 }

        public IClient Create(IEndpoint endpoint, IClientPool ownerPool)
        {
            TSocket socket = null;
            if (endpoint.Timeout == 0)
            {
                socket = new TSocket(endpoint.Address, endpoint.Port);
            }
            else
            {
                socket = new TSocket(endpoint.Address, endpoint.Port, endpoint.Timeout);
            }
            TcpClient tcpClient = socket.TcpClient;
            TProtocol protocol = new TBinaryProtocol(socket);
            CassandraClient cassandraClient = new CassandraClient(protocol);
            IClient client = new DefaultClient()
            {
                CassandraClient = cassandraClient,
                Endpoint = endpoint,
                OwnerPool = ownerPool,
                TcpClient = tcpClient,
                Created = DateTime.Now
            };

            return client;
        }

 public string DispatchAction(IEndpoint endpoint)
 {
     switch (endpoint.ActionName)
     {
         case "RegisterUser":
             return this.ProcessRegisterUserCommand(endpoint.Parameters);
         case "LoginUser":
             return this.ProcessLoginUserCommand(endpoint.Parameters);
         case "LogoutUser":
             return this.ProcessLogoutUserCommand();
         case "CreateIssue":
             return this.ProcessCreateIssueCommand(endpoint.Parameters);
         case "RemoveIssue":
             return this.ProcessRemoveIssueCommand(endpoint.Parameters);
         case "AddComment":
             return this.ProcessAddCommentCommand(endpoint.Parameters);
         case "MyIssues":
             return this.ProcessMyIssuesCommand();
         case "MyComments":
             return this.ProcessMyCommentsCommand();
         case "Search":
             return this.ProcessSearchCommand(endpoint.Parameters);
         default:
             return string.Format(Messages.IvalidActionWithName, endpoint.ActionName);
     }
 }

        public ViewEngineResult FindView(IEndpoint endpoint)
        {
            var templates = filterViewsCollection.FindTemplates(endpoint, FindAllTemplates()).ToList();

            if (templates.Count < 1) return null;

            if (templates.Count > 1)
                throw new UWebSparkException(
                    string.Format(
                        "More then one template was found for endpoint '{0}.{1}'.\nThe following templates were found: {2}",
                        endpoint.HandlerType.Name, endpoint.Method.Name,
                        string.Join(", ", templates.Select(x => x.Name))));

            var template = templates.Single();

            var descriptor = descriptorBuilder.BuildDescriptor(template, true, null, null);

            var sparkViewEntry = engine.CreateEntry(descriptor);

            var view = sparkViewEntry.CreateInstance() as UWebSparkView;

            if (view != null) view.ResolveDependencies = resolveDependencies;

            return new ViewEngineResult(view);
        }

        private static object[] MapParameters(IEndpoint executionEndpoint, MethodInfo action)
        {
            var methodParams = action.GetParameters();

            var result = new object[methodParams.Length];

            int pos = 0;
            foreach (var param in methodParams)
            {
                object value = null;
                if (param.ParameterType == typeof(DateTime))
                {
                    value = DateTime.ParseExact(
                        executionEndpoint.Parameters[param.Name],
                        Constants.DateFormat,
                        CultureInfo.InvariantCulture);
                }
                else
                {
                    value = Convert.ChangeType(
                        executionEndpoint.Parameters[param.Name],
                        param.ParameterType);
                }

                result[pos++] = value;
            }

            return result;
        }

 public ServiceHeartbeatMonitor(IEndpoint publisherEndpoint, IEndpoint subscriberEndpoint, MessageFormatType expectedMessageFormat)
     : this(publisherEndpoint, 
             subscriberEndpoint, 
             new SubscriptionsMsmqChannel(subscriberEndpoint, expectedMessageFormat), 
             new ServiceHeartbeatMsmqChannel(subscriberEndpoint, expectedMessageFormat))
 {
 }

 public string DispatchAction(IEndpoint endpoint)
 {
     switch (endpoint.ActionName)
     {
         case "RegisterUser":
             return this.tracker.RegisterUser(
                 endpoint.Parameters["username"],
                 endpoint.Parameters["password"],
                 endpoint.Parameters["confirmPassword"]);
         case "LoginUser":
             return this.tracker.LoginUser(endpoint.Parameters["username"], endpoint.Parameters["password"]);
         case "CreateIssue":
             return this.tracker.CreateIssue(
                 endpoint.Parameters["title"],
                 endpoint.Parameters["description"],
                 (IssuePriority)Enum.Parse(typeof(IssuePriority), endpoint.Parameters["priority"], true),
                 endpoint.Parameters["tags"].Split('|'));
         case "RemoveIssue":
             return this.tracker.RemoveIssue(int.Parse(endpoint.Parameters["id"]));
         case "LogoutUser":
             return this.tracker.LogoutUser();
         case "AddComment":
             return this.tracker.AddComment(int.Parse(endpoint.Parameters["id"]), endpoint.Parameters["text"]);
         case "MyIssues":
             return this.tracker.GetMyIssues();
         case "MyComments":
             return this.tracker.GetMyComments();
         case "Search":
             return this.tracker.SearchForIssues(endpoint.Parameters["tags"].Split('|'));
         default:
             return string.Format("Invalid action: {0}", endpoint.ActionName);
     }
 }

 /// <summary>
 /// Adds a named endpoint to the collection
 /// </summary>
 /// <param name="endpointName">The name of the endpoint</param>
 /// <param name="endpoint">The endpoint</param>
 /// <exception cref="ArgumentNullException">Thrown if <paramref name="endpointName"/>
 /// or <paramref name="endpoint"/> are <c>null</c></exception>
 /// <exception cref="EndpointAlreadyExistsException">Thrown if there is already an
 /// endpoint with the specified <paramref name="endpointName"/></exception>
 public void Add(EndpointName endpointName, IEndpoint endpoint)
 {
     if (endpointName == null) throw new ArgumentNullException("endpointName");
     if (endpoint == null) throw new ArgumentNullException("endpoint");
     if (_endpoints.ContainsKey(endpointName)) throw new EndpointAlreadyExistsException(endpointName);
     _endpoints[endpointName] = endpoint;
 }

        public RedirectResult GetUrlToRedirectTo(object result, IEndpoint endpoint)
        {
            var redirectable = (IRedirectable) result;
            var redirectResult = redirectable.RedirectTo();

            return new RedirectResult(redirectResult.GetUrl(urlBuilder), redirectable.Permanent);
        }

 public CompletionAcknowledgementMessage(Guid messageId, string messageType, bool processingSuccessful, IEndpoint endpoint)
 {
     MessageId = messageId;
     ProcessingSuccessful = processingSuccessful;
     Endpoint = endpoint;
     MessageType = messageType;
 }

 public ShadowMessageCommand(MessageWireData message, PeerId primaryRecipient, bool primaryWasOnline, IEndpoint targetEndpoint)
 {
     Message = message;
     PrimaryRecipient = primaryRecipient;
     PrimaryWasOnline = primaryWasOnline;
     TargetEndpoint = targetEndpoint;
 }

        public IMessageTopology Build(IEndpoint endpoint)
        {
            var topology = new MessageTopology();
            topology.PublishExchange = topology.DefineExchange(endpoint.Name, ExchangeType.Topic);

            return topology;
        }

        private static object[] MapParameters(IEndpoint executionEndpoint, MethodInfo action)
        {
            var parameters = action
                             .GetParameters()
                             .Select<ParameterInfo, object>(p =>
            {
                if (p.ParameterType == typeof(int))
                {
                    return int.Parse(executionEndpoint.Parameters[p.Name]);
                }
                else if (p.ParameterType == typeof(DateTime))
                {
                    return DateTime.ParseExact(executionEndpoint.Parameters[p.Name], Constants.DateFormat, CultureInfo.InvariantCulture);
                } 
                else if (p.ParameterType == typeof(decimal))
                {
                    return decimal.Parse(executionEndpoint.Parameters[p.Name]);
                }
                else
                {
                    return executionEndpoint.Parameters[p.Name];
                }
            })
                             .ToArray();

            return parameters;
        }

 public AuthenticateEndpoint(IEndpoint endpoint, IAuthenticationRuleCollection authenticationRuleCollection, IAuthentication authentication, 
     IOutputWriter outputWriter)
 {
     this.endpoint = endpoint;
     this.authenticationRuleCollection = authenticationRuleCollection;
     this.authentication = authentication;
     this.outputWriter = outputWriter;
 }

 public MessageSubscription(Type messageType, PeerId peer, IEndpoint endpoint, ISubscriptionFilter subscriptionFilter, ReliabilityLevel reliabilityLevel)
 {
     MessageType = messageType;
     Peer = peer;
     Endpoint = endpoint;
     SubscriptionFilter = (subscriptionFilter);
     ReliabilityLevel = reliabilityLevel;
 }

 public void Save(IEndpoint endpoint)
 {
     var key = endpoint.Name.ToLower();
     if (Endpoints.ContainsKey(key))
         Endpoints[key] = endpoint;
     else
         Endpoints.Add(key, endpoint);
 }