void GivenAMatching(string baseUri, string template, string candidate)
{
ThenTheMatch = new UriTemplate(template).Match(baseUri.ToUri(), candidate.ToUri());
}
private void OnPostPrepare(HttpEntityManager manager, UriTemplateMatch match)
{
OnPost(manager, (ElectionMessageDto.PrepareDto dto) => new ElectionMessage.Prepare(dto));
}
private void OnProjectionsPostContinuous(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsPost(http, match, ProjectionMode.Continuous, match.BoundVariables["name"]);
}
private static ProjectionManagementMessage.RunAs GetRunAs(HttpEntityManager http, UriTemplateMatch match)
{
return(new ProjectionManagementMessage.RunAs(http.User));
}
private void OnProjectionsGetOneTime(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsGet(http, match, ProjectionMode.OneTime);
}
private void OnProjectionsPostTransient(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsPost(http, match, ProjectionMode.Transient, match.BoundVariables["name"]);
}
private void OnProjectionsGetPersistent(HttpEntity http, UriTemplateMatch match)
{
ProjectionsGet(http, match, ProjectionMode.Persistent);
}
private void OnProjectionsGetAny(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsGet(http, match, null);
}
/// <summary>
/// Deserialize the request
/// </summary>
public void DeserializeRequest(Message request, object[] parameters)
{
try
{
#if DEBUG
RemoteEndpointMessageProperty endpoint = (RemoteEndpointMessageProperty)request.Properties[RemoteEndpointMessageProperty.Name];
this.m_traceSource.TraceEvent(TraceEventType.Information, 0, "Received request from: {0}:{1}", endpoint.Address, endpoint.Port);
#endif
HttpRequestMessageProperty httpRequest = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
string contentType = httpRequest.Headers[HttpRequestHeader.ContentType];
UriTemplateMatch templateMatch = (UriTemplateMatch)request.Properties.SingleOrDefault(o => o.Value is UriTemplateMatch).Value;
// Not found
if (templateMatch == null)
{
throw new WebFaultException(HttpStatusCode.NotFound);
}
for (int pNumber = 0; pNumber < parameters.Length; pNumber++)
{
var parm = this.m_operationDescription.Messages[0].Body.Parts[pNumber];
// Simple parameter
if (templateMatch.BoundVariables.AllKeys.Any(o => o.ToLower() == parm.Name.ToLower()))
{
var rawData = templateMatch.BoundVariables[parm.Name];
parameters[pNumber] = Convert.ChangeType(rawData, parm.Type);
}
// Use XML Serializer
else if (contentType?.StartsWith("application/xml") == true)
{
var messageFormatProperty = (WebBodyFormatMessageProperty)request.Properties[WebBodyFormatMessageProperty.Name];
XmlDictionaryReader rawReader = request.GetReaderAtBodyContents();
switch (messageFormatProperty.Format)
{
case WebContentFormat.Raw:
{
rawReader.ReadStartElement("Binary");
byte[] rawBody = rawReader.ReadContentAsBase64();
using (MemoryStream ms = new MemoryStream(rawBody))
{
using (XmlReader bodyReader = XmlReader.Create(ms))
{
while (bodyReader.NodeType != XmlNodeType.Element)
{
bodyReader.Read();
}
Type eType = s_knownTypes.FirstOrDefault(o => o.GetCustomAttribute <XmlRootAttribute>()?.ElementName == bodyReader.LocalName &&
o.GetCustomAttribute <XmlRootAttribute>()?.Namespace == bodyReader.NamespaceURI);
XmlSerializer xsz = s_serializers[eType];
parameters[pNumber] = xsz.Deserialize(bodyReader);
}
}
}
break;
case WebContentFormat.Xml:
{
rawReader.MoveToStartElement();
using (rawReader)
{
Type eType = s_knownTypes.FirstOrDefault(o => o.GetCustomAttribute <XmlRootAttribute>()?.ElementName == rawReader.LocalName && o.GetCustomAttribute <XmlRootAttribute>()?.Namespace == rawReader.NamespaceURI);
this.m_traceSource.TraceEvent(TraceEventType.Information, 0, "Contract: {0}", typeof(TContract).Name);
this.m_traceSource.TraceEvent(TraceEventType.Information, 0, "Attempting to deserialize type: {0}", eType?.Name);
XmlSerializer xsz = s_serializers[eType];
parameters[pNumber] = xsz.Deserialize(rawReader);
}
}
break;
}
}
// Use JSON Serializer
else if (contentType?.StartsWith("application/json") == true)
{
// Read the binary contents form the WCF pipeline
XmlDictionaryReader bodyReader = request.GetReaderAtBodyContents();
bodyReader.ReadStartElement("Binary");
byte[] rawBody = bodyReader.ReadContentAsBase64();
// Now read the JSON data
MemoryStream ms = new MemoryStream(rawBody);
StreamReader sr = new StreamReader(ms);
JsonSerializer jsz = new JsonSerializer()
{
Binder = new ModelSerializationBinder(),
TypeNameAssemblyFormat = 0,
TypeNameHandling = TypeNameHandling.All
};
jsz.Converters.Add(new StringEnumConverter());
var dserType = parm.Type;
parameters[pNumber] = jsz.Deserialize(sr, dserType);
}
else if (contentType == "application/octet-stream")
{
XmlDictionaryReader rawReader = request.GetReaderAtBodyContents();
rawReader.ReadStartElement("Binary");
byte[] rawBody = rawReader.ReadContentAsBase64();
MemoryStream ms = new MemoryStream(rawBody);
parameters[pNumber] = ms;
}
else if (contentType != null)// TODO: Binaries
{
throw new InvalidOperationException("Invalid request format");
}
}
}
catch (Exception e)
{
this.m_traceSource.TraceEvent(TraceEventType.Error, e.HResult, e.ToString());
throw;
}
}
private void OnProjectionsGetAdHoc(HttpEntity http, UriTemplateMatch match)
{
ProjectionsGet(http, match, ProjectionMode.AdHoc);
}
public Stream RunDEAnalysis(Stream request)
{
bool ok = true;
string errorMessage = null;
DEAContext context = null;
string jsonRequest = null;
string jsonResponse = null;
const string fn = "RunDEAnalysis";
LOG.DebugFormat("{0} - started", fn);
UriTemplateMatch utm = WebOperationContext.Current.IncomingRequest.UriTemplateMatch;
LOG.Debug(utm.RequestUri.OriginalString);
try
{
using (StreamReader reader = new StreamReader(request))
{
jsonRequest = reader.ReadToEnd();
}
LOG.DebugFormat("Request: {0}", jsonRequest);
context = DEAContext.CreateFromJsonString(jsonRequest, out errorMessage);
ok = (context != null);
if (ok)
{
ok = context.RunDEA(out errorMessage);
if (ok && context.ConstraintsSet)
{
ok = context.ApplyCostConstraintsToProjectSelection(out errorMessage);
}
if (ok)
{
jsonResponse = context.ToJsonString(out errorMessage);
ok = (jsonResponse != null);
}
}
}
catch (Exception ex)
{
ok = false;
errorMessage = ex.Message;
}
DEAResponse response = new DEAResponse();
response.OK = ok;
response.errorMessage = errorMessage;
response.context = context;
jsonResponse = JsonConvert.SerializeObject(response, Formatting.Indented);
LOG.DebugFormat("Response: {0}", jsonResponse);
Stream ms = new MemoryStream(ASCIIEncoding.Default.GetBytes(s: jsonResponse));
LOG.DebugFormat("{0} - ended", fn);
return(ms);
}
public bool Parse(Socket socket, out RouteMatch?match, out RouteHandler route)
{
positionInTmp = 0;
Pipeline = false;
var methodEnd = ReadUntil(socket, Space, 0);
if (methodEnd == -1)
{
match = null;
route = null;
if (!socket.Connected)
{
offsetInOutput = 0;
return(false);
}
else if (positionInTmp == 0)
{
if (offsetInOutput != 0)
{
socket.Send(OutputTemp, offsetInOutput, SocketFlags.None);
offsetInOutput = 0;
socket.Close();
return(false);
}
else
{
return(ReturnError(socket, 408));
}
}
else
{
return(ReturnError(socket, 505));
}
}
HttpMethod = ReadMethod(methodEnd, InputTemp);
var rowEnd = ReadUntil(socket, LF, methodEnd + 1);
if (rowEnd == -1 || rowEnd < 12)
{
match = null;
route = null;
return(ReturnError(socket, 505));
}
RequestHeadersLength = 0;
ResponseHeadersLength = 0;
HttpProtocolVersion = ReadProtocol(rowEnd - 2);
if (HttpProtocolVersion == null)
{
match = null;
route = null;
ReturnError(socket, 505, "Only HTTP/1.1 and HTTP/1.0 supported (partially)", false);
return(false);
}
match = ReadUrl(rowEnd, out route);
if (route == null)
{
var unknownRoute = "Unknown route " + RawUrl + " on method " + HttpMethod;
ReturnError(socket, 404, unknownRoute, false);
return(false);
}
ResponseStatus = HttpStatusCode.OK;
ResponseLength = null;
ResponseContentType = null;
TemplateMatch = null;
ResponseIsJson = false;
ContentTypeResponseIndex = -1;
do
{
var start = rowEnd + 1;
rowEnd = ReadUntil(socket, CR, start);
if (rowEnd == start)
{
break;
}
else if (rowEnd == -1)
{
return(ReturnError(socket, 414));
}
else
{
int i = start;
for (; i < rowEnd; i++)
{
if (InputTemp[i] == ':')
{
break;
}
}
if (i == rowEnd)
{
return(ReturnError(socket, 414));
}
var nameBuf = TmpCharBuf;
for (int x = start; x < i; x++)
{
nameBuf[x - start] = Lower[InputTemp[x]];
}
var name = KeyCache.Get(nameBuf, i - start);
if (InputTemp[i + 1] == 32)
{
i++;
}
for (int x = i + 1; x < rowEnd; x++)
{
nameBuf[x - i - 1] = (char)InputTemp[x];
}
var value = ValueCache.Get(nameBuf, rowEnd - i - 1);
if (RequestHeadersLength == RequestHeaders.Length)
{
var newHeaders = new HeaderPair[RequestHeaders.Length * 2];
Array.Copy(RequestHeaders, newHeaders, RequestHeaders.Length);
RequestHeaders = newHeaders;
}
RequestHeaders[RequestHeadersLength++] = new HeaderPair(name, value);
}
rowEnd++;
} while (positionInTmp <= InputTemp.Length);
rowEnd += 2;
if (HttpMethod == "POST" || HttpMethod == "PUT")
{
int len = 0;
var ct = GetRequestHeader("content-length");
if (ct != null)
{
if (!int.TryParse(ct, out len))
{
return(ReturnError(socket, 411));
}
if (len > Limit)
{
return(ReturnError(socket, 413));
}
}
else
{
return(ReturnError(socket, 411));
}
InputStream.Reset();
var size = totalBytes - rowEnd;
InputStream.Write(InputTemp, rowEnd, size);
len -= size;
var oldTimeout = socket.ReceiveTimeout;
socket.ReceiveTimeout = 10000;
while (len > 0)
{
size = socket.Receive(InputTemp, Math.Min(len, InputTemp.Length), SocketFlags.None);
if (size < 1)
{
return(ReturnError(socket, 408));
}
InputStream.Write(InputTemp, 0, size);
len -= size;
}
socket.ReceiveTimeout = oldTimeout;
InputStream.Position = 0;
rowEnd = totalBytes;
totalBytes = 0;
}
else
{
Pipeline = rowEnd < totalBytes;
if (Pipeline)
{
Buffer.BlockCopy(InputTemp, rowEnd, InputTemp, 0, totalBytes - rowEnd);
totalBytes -= rowEnd;
}
else
{
totalBytes = 0;
}
}
return(true);
}
private ServerResponse DispatchRequest(Uri resourcePath, string httpMethod, string requestBody)
{
HttpStatusCode codeToReturn = HttpStatusCode.OK;
Response commandResponse = new Response();
Dictionary <string, string> locatorParameters = new Dictionary <string, string>();
UriTemplateTable templateTable = this.FindDispatcherTable(httpMethod);
UriTemplateMatch match = templateTable.MatchSingle(resourcePath);
if (resourcePath.AbsolutePath.ToUpperInvariant().Contains(ShutdownUrlFragment))
{
this.serverLogger.Log("Executing: [Shutdown] at URL: " + resourcePath.AbsolutePath);
}
else if (match == null)
{
codeToReturn = HttpStatusCode.NotFound;
commandResponse.Value = "No command associated with " + resourcePath.AbsolutePath;
}
else
{
string relativeUrl = match.RequestUri.AbsoluteUri.Substring(match.RequestUri.AbsoluteUri.IndexOf(this.listenerPath, StringComparison.OrdinalIgnoreCase) + this.listenerPath.Length - 1);
SessionId sessionIdValue = null;
string commandName = (string)match.Data;
foreach (string key in match.BoundVariables.Keys)
{
string value = match.BoundVariables[key];
locatorParameters.Add(key, value);
}
Command commandToExecute = new Command(commandName, requestBody);
object resultValue = null;
WebDriverResult resultCode = WebDriverResult.Success;
try
{
CommandHandler handler = this.handlerFactory.CreateHandler(commandToExecute.Name, locatorParameters, commandToExecute.Parameters);
sessionIdValue = handler.SessionId;
this.serverLogger.Log("Executing: " + handler.ToString() + " at URL: " + relativeUrl);
resultValue = handler.Execute();
codeToReturn = handler.StatusCode;
}
catch (CommandNotImplementedException ex)
{
codeToReturn = HttpStatusCode.NotImplemented;
resultValue = ex.Message + " (" + commandName + ")";
}
catch (InvalidCommandException ex)
{
codeToReturn = HttpStatusCode.MethodNotAllowed;
resultValue = ex.Message;
}
catch (ResourceNotFoundException ex)
{
codeToReturn = HttpStatusCode.NotFound;
resultValue = ex.Message + " (" + resourcePath.AbsolutePath + ")";
}
catch (InvalidParameterException ex)
{
codeToReturn = HttpStatusCode.BadRequest;
resultValue = ex.Message;
}
catch (NoSuchWindowException ex)
{
resultCode = WebDriverResult.NoSuchWindow;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (NoSuchElementException ex)
{
resultCode = WebDriverResult.NoSuchElement;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (NoSuchFrameException ex)
{
resultCode = WebDriverResult.NoSuchFrame;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (StaleElementReferenceException ex)
{
resultCode = WebDriverResult.ObsoleteElement;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (ElementNotVisibleException ex)
{
resultCode = WebDriverResult.ElementNotDisplayed;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (InvalidElementStateException ex)
{
resultCode = WebDriverResult.InvalidElementState;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (NotImplementedException ex)
{
resultCode = WebDriverResult.InvalidElementState;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (XPathLookupException ex)
{
resultCode = WebDriverResult.XPathLookupError;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (WebDriverTimeoutException ex)
{
resultCode = WebDriverResult.Timeout;
resultValue = CreateErrorResponse(commandName, ex);
}
catch (UnhandledAlertException ex)
{
resultCode = WebDriverResult.UnexpectedAlertOpen;
// This is ridiculously ugly. To be refactored.
ErrorResponse err = CreateErrorResponse(commandName, ex);
Dictionary <string, object> resp = new Dictionary <string, object>();
resp["class"] = err.ClassName;
resp["message"] = err.Message;
resp["screen"] = err.Screenshot;
resp["stackTrace"] = err.StackTrace;
Dictionary <string, object> alert = new Dictionary <string, object>();
alert["text"] = ex.Alert.Text;
resp["alert"] = alert;
resultValue = resp;
}
catch (Exception ex)
{
resultCode = WebDriverResult.UnhandledError;
resultValue = CreateErrorResponse(commandName, ex);
}
commandResponse = new Response(sessionIdValue);
commandResponse.Status = resultCode;
commandResponse.Value = resultValue;
this.serverLogger.Log("Done: " + relativeUrl);
}
return(new ServerResponse(commandResponse, codeToReturn));
}
private void OnPostMasterIsResigningOk(HttpEntityManager manager, UriTemplateMatch match)
{
OnPost(manager, (ElectionMessageDto.MasterIsResigningOkDto dto) => new ElectionMessage.MasterIsResigningOk(dto));
}
private void OnProjectionsPostAdHoc(HttpEntity http, UriTemplateMatch match)
{
ProjectionsPost(http, match, ProjectionMode.AdHoc, match.BoundVariables["name"]);
}
public void setup()
{
_urlTemplate = new UriTemplate("/a/b?c={C}");
_match = _urlTemplate.Match(new Uri("http://localhost"), new Uri("http://localhost/a/b"));
}
private void OnProjectionsPostPersistent(HttpEntity http, UriTemplateMatch match)
{
ProjectionsPost(http, match, ProjectionMode.Persistent, match.BoundVariables["name"]);
}
private void OnProjectionsGetTransient(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsGet(http, match, ProjectionMode.Transient);
}
private void OnProjectionStatusGet(HttpEntity http, UriTemplateMatch match)
{
http.Manager.Reply(
HttpStatusCode.NotImplemented, "Not Implemented",
e => Log.ErrorException(e, "Error while closing http connection (http service core)"));
}
private void OnProjectionsGetContinuous(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsGet(http, match, ProjectionMode.Continuous);
}
/// <inheritdoc/>
public Task <QueuedMessageList> ListMessagesAsync(QueueName queueName, QueuedMessageListId marker, int?limit, bool echo, bool includeClaimed, CancellationToken cancellationToken)
{
if (queueName == null)
{
throw new ArgumentNullException("queueName");
}
if (limit <= 0)
{
throw new ArgumentOutOfRangeException("limit");
}
UriTemplate template = new UriTemplate("/queues/{queue_name}/messages?marker={marker}&limit={limit}&echo={echo}&include_claimed={include_claimed}");
var parameters =
new Dictionary <string, string>()
{
{ "queue_name", queueName.Value },
{ "echo", echo.ToString() },
{ "include_claimed", includeClaimed.ToString() }
};
if (marker != null)
{
parameters["marker"] = marker.Value;
}
if (limit != null)
{
parameters["limit"] = limit.ToString();
}
Func <Task <Tuple <IdentityToken, Uri> >, HttpWebRequest> prepareRequest =
PrepareRequestAsyncFunc(HttpMethod.GET, template, parameters);
Func <Task <HttpWebRequest>, Task <ListCloudQueueMessagesResponse> > requestResource =
GetResponseAsyncFunc <ListCloudQueueMessagesResponse>(cancellationToken);
Func <Task <ListCloudQueueMessagesResponse>, QueuedMessageList> resultSelector =
task =>
{
ReadOnlyCollection <QueuedMessage> messages = null;
if (task.Result != null)
{
messages = task.Result.Messages;
}
QueuedMessageListId nextMarker = null;
if (task.Result != null && task.Result.Links != null)
{
Link nextLink = task.Result.Links.FirstOrDefault(i => string.Equals(i.Rel, "next", StringComparison.OrdinalIgnoreCase));
if (nextLink != null)
{
Uri baseUri = new Uri("https://example.com");
Uri absoluteUri;
if (nextLink.Href.StartsWith("/v1"))
{
absoluteUri = new Uri(baseUri, nextLink.Href.Substring("/v1".Length));
}
else
{
absoluteUri = new Uri(baseUri, nextLink.Href);
}
UriTemplateMatch match = template.Match(baseUri, absoluteUri);
if (!string.IsNullOrEmpty(match.BoundVariables["marker"]))
{
nextMarker = new QueuedMessageListId(match.BoundVariables["marker"]);
}
}
}
if (messages == null || messages.Count == 0)
{
// use the same marker again
messages = messages ?? new ReadOnlyCollection <QueuedMessage>(new QueuedMessage[0]);
nextMarker = marker;
}
Func <CancellationToken, Task <ReadOnlyCollectionPage <QueuedMessage> > > getNextPageAsync = null;
if (nextMarker != null || messages.Count == 0)
{
getNextPageAsync =
nextCancellationToken => ListMessagesAsync(queueName, nextMarker, limit, echo, includeClaimed, nextCancellationToken)
.Select(t => (ReadOnlyCollectionPage <QueuedMessage>)t.Result);
}
return(new QueuedMessageList(messages, getNextPageAsync, nextMarker));
};
return(AuthenticateServiceAsync(cancellationToken)
.Select(prepareRequest)
.Then(requestResource)
.Select(resultSelector));
}
private void OnProjectionsPostOneTime(HttpEntityManager http, UriTemplateMatch match)
{
ProjectionsPost(http, match, ProjectionMode.OneTime, match.BoundVariables["name"]);
}
private void OnPostGossip(HttpEntityManager entity, UriTemplateMatch match)
{
entity.ReadTextRequestAsync(OnPostGossipRequestRead, e => Log.Debug("Error while reading request (gossip): {0}", e.Message));
}
private static string MakeUrl(UriTemplateMatch match, string localPath)
{
return(new Uri(match.BaseUri, localPath).AbsoluteUri);
}
private void PostSubscription(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var groupname = match.BoundVariables["subscription"];
var stream = match.BoundVariables["stream"];
var envelope = new SendToHttpEnvelope(
_networkSendQueue, http,
(args, message) => http.ResponseCodec.To(message),
(args, message) =>
{
int code;
var m = message as ClientMessage.UpdatePersistentSubscriptionCompleted;
if (m == null)
{
throw new Exception("unexpected message " + message);
}
switch (m.Result)
{
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.Success:
code = HttpStatusCode.OK;
//TODO competing return uri to subscription
break;
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.DoesNotExist:
code = HttpStatusCode.NotFound;
break;
case ClientMessage.UpdatePersistentSubscriptionCompleted.UpdatePersistentSubscriptionResult.AccessDenied:
code = HttpStatusCode.Unauthorized;
break;
default:
code = HttpStatusCode.InternalServerError;
break;
}
return(new ResponseConfiguration(code, http.ResponseCodec.ContentType,
http.ResponseCodec.Encoding, new KeyValuePair <string, string>("location", MakeUrl(http, "/subscriptions/" + stream + "/" + groupname))));
});
http.ReadTextRequestAsync(
(o, s) =>
{
var data = http.RequestCodec.From <SubscriptionConfigData>(s);
var config = ParseConfig(data);
if (!ValidateConfig(config, http))
{
return;
}
var message = new ClientMessage.UpdatePersistentSubscription(Guid.NewGuid(),
Guid.NewGuid(),
envelope,
stream,
groupname,
config.ResolveLinktos,
config.StartFrom,
config.MessageTimeoutMilliseconds,
config.ExtraStatistics,
config.MaxRetryCount,
config.BufferSize,
config.LiveBufferSize,
config.ReadBatchSize,
config.CheckPointAfterMilliseconds,
config.MinCheckPointCount,
config.MaxCheckPointCount,
config.MaxSubscriberCount,
CalculateNamedConsumerStrategyForOldClients(data),
http.User,
"",
"");
Publish(message);
}, x => Log.DebugException(x, "Reply Text Content Failed."));
}
private void OnStaticContent(HttpEntityManager http, UriTemplateMatch match)
{
var contentLocalPath = match.BoundVariables["remaining_path"];
ReplyWithContent(http, contentLocalPath);
}
private static ClientMessages.NakAction GetNackAction(HttpEntityManager manager, UriTemplateMatch match, NakAction nakAction = NakAction.Unknown)
{
var rawValue = match.BoundVariables["action"] ?? string.Empty;
switch (rawValue.ToLowerInvariant())
{
case "park": return(ClientMessages.NakAction.Park);
case "retry": return(ClientMessages.NakAction.Retry);
case "skip": return(ClientMessages.NakAction.Skip);
case "stop": return(ClientMessages.NakAction.Stop);
default: return(ClientMessages.NakAction.Unknown);
}
}
private void OnPostViewChangeProof(HttpEntityManager manager, UriTemplateMatch match)
{
OnPost(manager, (ElectionMessageDto.ViewChangeProofDto dto) => new ElectionMessage.ViewChangeProof(dto));
}
private void GetNextNMessages(HttpEntityManager http, UriTemplateMatch match)
{
if (_httpForwarder.ForwardRequest(http))
{
return;
}
var groupname = match.BoundVariables["subscription"];
var stream = match.BoundVariables["stream"];
var cnt = match.BoundVariables["count"];
var embed = GetEmbedLevel(http, match);
int count = DefaultNumberOfMessagesToGet;
if (!cnt.IsEmptyString() && (!int.TryParse(cnt, out count) || count > 100 || count < 1))
{
SendBadRequest(http, string.Format("Message count must be an integer between 1 and 100 'count' ='{0}'", count));
return;
}
var envelope = new SendToHttpEnvelope(
_networkSendQueue, http,
(args, message) => Format.ReadNextNPersistentMessagesCompleted(http, message as ClientMessage.ReadNextNPersistentMessagesCompleted, stream, groupname, count, embed),
(args, message) =>
{
int code;
var m = message as ClientMessage.ReadNextNPersistentMessagesCompleted;
if (m == null)
{
throw new Exception("unexpected message " + message);
}
switch (m.Result)
{
case
ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.Success:
code = HttpStatusCode.OK;
break;
case
ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.DoesNotExist:
code = HttpStatusCode.NotFound;
break;
case
ClientMessage.ReadNextNPersistentMessagesCompleted.ReadNextNPersistentMessagesResult.AccessDenied:
code = HttpStatusCode.Unauthorized;
break;
default:
code = HttpStatusCode.InternalServerError;
break;
}
return(new ResponseConfiguration(code, http.ResponseCodec.ContentType,
http.ResponseCodec.Encoding));
});
var cmd = new ClientMessage.ReadNextNPersistentMessages(
Guid.NewGuid(),
Guid.NewGuid(),
envelope,
stream,
groupname,
count,
http.User);
Publish(cmd);
}
void GivenAMatching(string baseUri, string template, string candidate)
{
ThenTheMatch = new UriTemplate(template).Match(baseUri.ToUri(), candidate.ToUri());
}
private void OnPostAccept(HttpEntityManager manager, UriTemplateMatch match)
{
OnPost(manager, (ElectionMessageDto.AcceptDto dto) => new ElectionMessage.Accept(dto));
}
