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())); }
public static string DeleteStreamCompleted(HttpEntity entity, Message message) { Debug.Assert(message.GetType() == typeof(ClientMessage.DeleteStreamCompleted)); return string.Empty; }
public void Publish(Message message) { _bus.Publish(message); }
public static ResponseConfiguration GetFreshStatsCompleted(HttpResponseConfiguratorArgs entity, Message message) { var completed = message as MonitoringMessage.GetFreshStatsCompleted; if (completed == null) return InternalServerError(); var cacheSeconds = (int)MonitoringService.MemoizePeriod.TotalSeconds; return completed.Success ? Ok(entity.ResponseCodec.ContentType, Helper.UTF8NoBom, null, cacheSeconds, isCachePublic: true) : NotFound(); }
public TcpSend(TcpConnectionManager connectionManager, Message message) { ConnectionManager = connectionManager; Message = message; }
public void Publish(Message message) { //Ensure.NotNull(message, "message"); _queue.Enqueue(message); if (Interlocked.CompareExchange(ref _isRunning, 1, 0) == 0) ThreadPool.QueueUserWorkItem(ReadFromQueue); }
public static ResponseConfiguration DeleteStreamCompleted(HttpResponseConfiguratorArgs entity, Message message) { var msg = message as ClientMessage.DeleteStreamCompleted; if (msg != null) { switch (msg.Result) { case OperationResult.Success: return new ResponseConfiguration(HttpStatusCode.NoContent, "Stream deleted", "text/plain", Helper.UTF8NoBom); case OperationResult.PrepareTimeout: case OperationResult.CommitTimeout: case OperationResult.ForwardTimeout: return InternalServerError("Delete timeout"); case OperationResult.WrongExpectedVersion: return BadRequest("Wrong expected EventNumber"); case OperationResult.StreamDeleted: return Gone("Stream deleted"); case OperationResult.InvalidTransaction: return InternalServerError("Invalid transaction"); case OperationResult.AccessDenied: return Unauthorized(); default: throw new ArgumentOutOfRangeException(); } } var notHandled = message as ClientMessage.NotHandled; if (notHandled != null) return HandleNotHandled(entity.RequestedUrl, notHandled); return InternalServerError(); }
public TcpForwardMessage(Message message) { Ensure.NotNull(message, "message"); Message = message; }
public static ResponseConfiguration ReadAllEventsForwardCompleted(HttpResponseConfiguratorArgs entity, Message message, bool headOfTf) { var msg = message as ClientMessage.ReadAllEventsForwardCompleted; if (msg != null) { switch (msg.Result) { case ReadAllResult.Success: var codec = entity.ResponseCodec; if (!headOfTf && msg.Events.Length == msg.MaxCount) return Ok(codec.ContentType, codec.Encoding, null, MaxPossibleAge, msg.IsCachePublic); var etag = GetPositionETag(msg.TfLastCommitPosition, codec.ContentType); var cacheSeconds = GetCacheSeconds(msg.StreamMetadata); return Ok(codec.ContentType, codec.Encoding, etag, cacheSeconds, msg.IsCachePublic); case ReadAllResult.NotModified: return NotModified(); case ReadAllResult.Error: return InternalServerError(msg.Error); case ReadAllResult.AccessDenied: return Unauthorized(); default: throw new ArgumentOutOfRangeException(); } } var notHandled = message as ClientMessage.NotHandled; if (notHandled != null) return HandleNotHandled(entity.RequestedUrl, notHandled); return InternalServerError(); }
public void Publish(Message message) { Ensure.NotNull(message, "message"); _publisher.Publish(message); }
public static ResponseConfiguration WriteEventsCompleted(HttpResponseConfiguratorArgs entity, Message message, string eventStreamId) { var msg = message as ClientMessage.WriteEventsCompleted; if (msg != null) { switch (msg.Result) { case OperationResult.Success: var location = HostName.Combine(entity.RequestedUrl, "/streams/{0}/{1}", Uri.EscapeDataString(eventStreamId), msg.FirstEventNumber); return new ResponseConfiguration(HttpStatusCode.Created, "Created", "text/plain", Helper.UTF8NoBom, new KeyValuePair<string, string>("Location", location)); case OperationResult.PrepareTimeout: case OperationResult.CommitTimeout: case OperationResult.ForwardTimeout: return InternalServerError("Write timeout"); case OperationResult.WrongExpectedVersion: return BadRequest("Wrong expected EventNumber"); case OperationResult.StreamDeleted: return Gone("Stream deleted"); case OperationResult.InvalidTransaction: return InternalServerError("Invalid transaction"); case OperationResult.AccessDenied: return Unauthorized(); default: throw new ArgumentOutOfRangeException(); } } var notHandled = message as ClientMessage.NotHandled; if (notHandled != null) return HandleNotHandled(entity.RequestedUrl, notHandled); return InternalServerError(); }