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();
}
