public static ResponseConfiguration CreateStreamCompleted(HttpEntity entity, Message message)
        {
            Debug.Assert(message.GetType() == typeof(ClientMessage.CreateStreamCompleted));

            var completed = message as ClientMessage.CreateStreamCompleted;
            if (completed == null)
                return InternalServerEror(entity, message);

            switch (completed.ErrorCode)
            {
                case OperationErrorCode.Success:
                    return new ResponseConfiguration(HttpStatusCode.Created,
                                                     "Stream created",
                                                     null,
                                                     new KeyValuePair<string, string>("Location",
                                                                                      HostName.Combine(entity.UserHostName,
                                                                                                  "/streams/{0}",
                                                                                                  completed.EventStreamId)));
                case OperationErrorCode.PrepareTimeout:
                case OperationErrorCode.CommitTimeout:
                case OperationErrorCode.ForwardTimeout:
                    return new ResponseConfiguration(HttpStatusCode.InternalServerError, "Create timeout", null);
                case OperationErrorCode.WrongExpectedVersion:
                case OperationErrorCode.StreamDeleted:
                case OperationErrorCode.InvalidTransaction:
                    return new ResponseConfiguration(HttpStatusCode.BadRequest,
                                                     string.Format("Error code : {0}. Reason : {1}", completed.ErrorCode, completed.Error),
                                                     null);
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        public static string TextMessage(HttpEntity entity, Message message)
        {
            Debug.Assert(message.GetType() == typeof(HttpMessage.TextMessage));

            var textMessage = message as HttpMessage.TextMessage;
            return textMessage != null ? entity.ResponseCodec.To(textMessage) : string.Empty;
        }

            public static string ReadEventsBackwardsCompletedFeed(HttpEntity entity, Message message, int start, int count)
            {
                Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventsBackwardsCompleted));

                var completed = message as ClientMessage.ReadEventsBackwardsCompleted;
                if (completed != null)
                {
                    switch (completed.Result)
                    {
                        case RangeReadResult.Success:
                            var updateTime = completed.Events.Length != 0
                                                 ? completed.Events[0].TimeStamp
                                                 : DateTime.MinValue.ToUniversalTime();
                            return entity.ResponseCodec.To(Convert.ToFeed(completed.EventStreamId,
                                                                          start,
                                                                          count,
                                                                          updateTime,
                                                                          completed.Events,
                                                                          Convert.ToEntry,
                                                                          entity.ServerHttpEndPoint));
                        case RangeReadResult.NoStream:
                        case RangeReadResult.StreamDeleted:
                            return string.Empty;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                return string.Empty;
            }

        public static ResponseConfiguration ReadEventCompleted(HttpEntity entity, Message message)
        {
            Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted));

            var completed = message as ClientMessage.ReadEventCompleted;
            if (completed == null)
                return InternalServerEror(entity, message);

            switch (completed.Result)
            {
                case SingleReadResult.Success:
                    return new ResponseConfiguration(HttpStatusCode.OK, 
                                                     "OK",
                                                     entity.ResponseCodec.ContentType,
                                                     new KeyValuePair<string, string>(
                                                         "Cache-Control",
                                                         string.Format("max-age={0}", MaxPossibleAge)));
                case SingleReadResult.NotFound:
                case SingleReadResult.NoStream:
                    return NotFound(entity, completed);
                case SingleReadResult.StreamDeleted:
                    return Gone(entity, completed);
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

 public RandTestQueueItem(int logicalTime, int globalId, IPEndPoint endPoint, Message message, IPublisher bus)
 {
     LogicalTime = logicalTime;
     GlobalId = globalId;
     EndPoint = endPoint;
     Message = message;
     Bus = bus;
 }

 public HttpSend(
     HttpEntityManager httpEntityManager, ResponseConfiguration configuration, string data, Message message)
     : base(Guid.Empty, null, httpEntityManager)
 {
     Data = data;
     Configuration = configuration;
     Message = message;
 }

        public static string GetFreshStatsCompleted(HttpResponseFormatterArgs entity, Message message)
        {
            var completed = message as MonitoringMessage.GetFreshStatsCompleted;
            if (completed == null || !completed.Success)
                return String.Empty;

            return entity.ResponseCodec.To(completed.Stats);
        }

 public PollStream(string streamId, long lastCommitPosition, int? lastEventNumber, DateTime expireAt, Message originalRequest)
 {
     StreamId = streamId;
     LastCommitPosition = lastCommitPosition;
     LastEventNumber = lastEventNumber;
     ExpireAt = expireAt;
     OriginalRequest = originalRequest;
 }

        public static string ReadAllEventsForwardCompleted(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
        {
            var msg = message as ClientMessage.ReadAllEventsForwardCompleted;
            if (msg == null || msg.Result != ReadAllResult.Success)
                return String.Empty;

            return entity.ResponseCodec.To(Convert.ToAllEventsForwardFeed(msg, entity.RequestedUrl, embed)); 
        }

        public static string GetStreamEventsBackward(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed, bool headOfStream)
        {
            var msg = message as ClientMessage.ReadStreamEventsBackwardCompleted;
            if (msg == null || msg.Result != ReadStreamResult.Success)
                return String.Empty;

            return entity.ResponseCodec.To(Convert.ToStreamEventBackwardFeed(msg, entity.RequestedUrl, embed, headOfStream));
        }

 public SubscribeAwake(
     IEnvelope envelope, Guid correlationId, string streamId, TFPos @from, Message replyWithMessage)
 {
     StreamId = streamId;
     From = @from;
     ReplyWithMessage = replyWithMessage;
     Envelope = envelope;
     CorrelationId = correlationId;
 }

        public static string GetFreshStatsCompleted(HttpEntity entity, Message message)
        {
            Debug.Assert(message.GetType() == typeof(MonitoringMessage.GetFreshStatsCompleted));

            var completed = message as MonitoringMessage.GetFreshStatsCompleted;
            if (completed == null || !completed.Success)
                return string.Empty;

            return entity.ResponseCodec.To(completed.Stats);
        }

            public static string ListStreamsCompletedServiceDoc(HttpEntity entity, Message message)
            {
                Debug.Assert(message.GetType() == typeof(ClientMessage.ListStreamsCompleted));

                var streams = message as ClientMessage.ListStreamsCompleted;
                return streams != null
                           ? entity.ResponseCodec.To(Convert.ToServiceDocument(streams.Streams,
                                                                               new string[0],
                                                                               entity.ServerHttpEndPoint))
                           : string.Empty;
            }

        public static string EventEntry(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
        {
            var msg = message as ClientMessage.ReadEventCompleted;
            if (msg == null || msg.Result != ReadEventResult.Success || msg.Record.Event == null)
                return entity.ResponseCodec.To(new {});

            switch (entity.ResponseCodec.ContentType)
            {
                case ContentType.Atom:
                case ContentType.AtomJson:
                case ContentType.Html:
                    return entity.ResponseCodec.To(Convert.ToEntry(msg.Record, entity.RequestedUrl, embed, singleEntry: true));
                default:
                    return AutoEventConverter.SmartFormat(msg.Record, entity.ResponseCodec);
            }
        }

            public static string ReadEventCompletedEntry(HttpEntity entity, Message message)
            {
                Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted));

                var completed = message as ClientMessage.ReadEventCompleted;
                if (completed != null)
                {
                    switch (completed.Result)
                    {
                        case SingleReadResult.Success:
                            return entity.ResponseCodec.To(Convert.ToEntry(completed.Record, entity.ServerHttpEndPoint));
                        case SingleReadResult.NotFound:
                        case SingleReadResult.NoStream:
                        case SingleReadResult.StreamDeleted:
                            return string.Empty;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                return string.Empty;
            }

            public static string ReadEventCompletedEntry(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed)
            {
                Debug.Assert(message.GetType() == typeof(ClientMessage.ReadEventCompleted));

                var completed = message as ClientMessage.ReadEventCompleted;
                if (completed != null)
                {
                    switch (completed.Result)
                    {
                        case ReadEventResult.Success:
                            return entity.ResponseCodec.To(Convert.ToEntry(completed.Record, entity.UserHostName, embed));
                        case ReadEventResult.NotFound:
                        case ReadEventResult.NoStream:
                        case ReadEventResult.StreamDeleted:
                            return string.Empty;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                return string.Empty;
            }

            public static string ReadStreamEventsBackwardCompletedFeed(HttpResponseFormatterArgs entity, Message message, EmbedLevel embed, bool headOfStream)
            {
                Debug.Assert(message.GetType() == typeof(ClientMessage.ReadStreamEventsBackwardCompleted));

                var completed = message as ClientMessage.ReadStreamEventsBackwardCompleted;
                if (completed != null)
                {
                    switch (completed.Result)
                    {
                        case ReadStreamResult.Success:
                            return entity.ResponseCodec.To(Convert.ToReadStreamFeed(completed, entity.UserHostName, embed, headOfStream));
                        case ReadStreamResult.NoStream:
                        case ReadStreamResult.StreamDeleted:
                        case ReadStreamResult.NotModified:
                        case ReadStreamResult.Error:
                            return string.Empty;
                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                return string.Empty;
            }

 public void Handle(Message message)
 {
     Publish(message);
 }

 public static string WriteEventsCompleted(HttpEntity entity, Message message)
 {
     Debug.Assert(message.GetType() == typeof(ClientMessage.WriteEventsCompleted));
     return string.Empty;
 }

        public static string WriteEvents(ICodec codec, Message message)
        {
            Debug.Assert(message.GetType() == typeof (ClientMessage.WriteEvents));

            var writeEvents = message as ClientMessage.WriteEvents;
            if (writeEvents == null)
                return string.Empty;

            return codec.To(new ClientMessageDto.WriteEventText(writeEvents.CorrelationId,
                                                                writeEvents.ExpectedVersion,
                                                                writeEvents.Events.Select(e => new ClientMessageDto.EventText(e.EventId, 
                                                                                                                              e.EventType,
                                                                                                                              e.Data, 
                                                                                                                              e.Metadata)).ToArray()));
        }