private static void AddNegotiatedHeaders(Negotiator negotiator, Response response)
{
foreach (var header in negotiator.NegotiationContext.Headers)
{
response.Headers[header.Key] = header.Value;
}
}
public FetchRequestHandler(TQuery query, Func <TQuery, Task <Maybe <PagedResult <TResult> > > > fetchCollection,
Negotiator negotiator, Url url, IMapper autoMapper = null)
{
_query = query;
_fetchCollection = fetchCollection;
_negotiator = negotiator;
_url = url;
_autoMapper = autoMapper;
}
/// <summary>
/// Add a collection of cookies to the response.
/// </summary>
/// <param name="negotiator">The <see cref="Negotiator"/> instance.</param>
/// <param name="cookies">The <see cref="INancyCookie"/> instances that should be added.</param>
/// <returns>The modified <see cref="Negotiator"/> instance.</returns>
public static Negotiator WithCookies(this Negotiator negotiator, IEnumerable <INancyCookie> cookies)
{
foreach (var cookie in cookies)
{
negotiator.WithCookie(cookie);
}
return(negotiator);
}
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception)
{
HttpServiceError httpServiceError = HttpServiceErrorUtilities.ExtractFromException(exception, HttpServiceErrorDefinition.GeneralError);
Negotiator negotiator = new Negotiator(context)
.WithHttpServiceError(httpServiceError);
return(responseNegotiator.NegotiateResponse(negotiator, context));
}
/// <summary>
/// Adds headers to the response using anonymous types
/// </summary>
/// <param name="negotiator">Negotiator object</param>
/// <param name="headers">
/// Array of headers - each header should be a Tuple with two string elements
/// for header name and header value
/// </param>
/// <returns>Modified negotiator</returns>
public static Negotiator WithHeaders(this Negotiator negotiator, params Tuple <string, string>[] headers)
{
foreach (var keyValuePair in headers)
{
negotiator.NegotiationContext.Headers[keyValuePair.Item1] = keyValuePair.Item2;
}
return(negotiator);
}
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
context.NegotiationContext = new NegotiationContext();
Negotiator negotiator = new Negotiator(context)
.WithHttpServiceError(HttpServiceErrorDefinition.InternalServerError);
context.Response = responseNegotiator.NegotiateResponse(negotiator, context);
}
public static Negotiator WithEtag(this Negotiator negotiator, string etag)
{
if (etag != null)
{
negotiator.WithHeader("ETag", etag);
}
return(negotiator);
}
public static Negotiator AsResponseType(this Negotiator self, string type)
{
return(type == ResponseType.JSON
? self.AsJSON()
: (type == ResponseType.XML
? self.AsXML()
: self
));
}
/// <summary>
/// Create the Nancy Response
/// </summary>
/// <param name="nancyContext">Nancy Context</param>
/// <param name="statusCode">Http Response Status Code</param>
/// <param name="outputDataModel">Output Data Model</param>
/// <returns></returns>
protected Response CreateResponse(NancyContext nancyContext, HttpStatusCode statusCode, object outputDataModel)
{
nancyContext.NegotiationContext = new NegotiationContext();
var negotiator = new Negotiator(nancyContext)
.WithStatusCode(statusCode)
.WithModel(outputDataModel);
return(_responseNegotiator.NegotiateResponse(negotiator, nancyContext));
}
public void GivenOnlyFollowRpmDemandItWinsTheNegotiation()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyFollowRpmDemand);
var program = negotiator.Negotiate();
Assert.True(program is RpmBasedShiftingProgram);
}
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
context.NegotiationContext = new NegotiationContext();
Negotiator negotiator = new Negotiator(context)
.WithStatusCode(HttpServiceErrorDefinition.NotFoundError.HttpStatusCode)
.WithModel(HttpServiceErrorDefinition.NotFoundError.ServiceErrorModel);
context.Response = responseNegotiator.NegotiateResponse(negotiator, context);
}
private static Response CreateNegotiatedResponse(NancyContext context, IResponseNegotiator responseNegotiator, Exception exception)
{
var (httpStatusCode, details) = HttpServiceErrorUtilities.ExtractFromException(exception);
Negotiator negotiator = new Negotiator(context)
.WithStatusCode(httpStatusCode)
.WithModel(details);
return responseNegotiator.NegotiateResponse(negotiator, context);
}
public void GivenOnlyYieldDemandItWinsTheNegotiation()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyYieldDemand);
var program = negotiator.Negotiate();
Assert.True(program is YieldingShiftingProgram);
}
public HttpResponseMessage GetSupportedClassifiers()
{
var result = classifiers
.Select(c => c.Name)
.OrderByDescending(classifier => classifier == "Exception Type and Stack Trace")
.ToArray();
return(Negotiator.FromModel(Request, result)
.WithTotalCount(result.Length));
}
public void EngineBreakingDemandAltersAffectsTheProgramWhenInRpm()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyFollowRpmDemand);
negotiator.Issue(new EngineBrakingDemand());
var program = negotiator.Negotiate();
Assert.True(program is EngineBrakingShiftingProgram);
}
private static Response CreateNegociatedResponse(NancyContext context, Exception exception, IResponseNegotiator responseNegotiator)
{
var httpServiceError = HttpServiceErrorUtilities
.ExtractFromException(exception, HttpServiceErrorDefinition.GeneralError);
var negociator = new Negotiator(context)
.WithStatusCode(httpServiceError.HttpStatusCode)
.WithModel(httpServiceError.ServiceErrorModel);
return(responseNegotiator.NegotiateResponse(negociator, context));
}
public static Negotiator WithModelAppendedRestfulUrls(this Negotiator negotiator, IEnumerable <Message> messages, Request request)
{
string baseUrl = request.Url.SiteBase + request.Url.BasePath;
foreach (var message in messages)
{
message.Url = baseUrl + "/messages/" + message.Id;
}
return(negotiator.WithModel(messages));
}
public void Handle(HttpStatusCode statusCode, NancyContext context)
{
LogException(context);
context.NegotiationContext = new NegotiationContext();
Negotiator negotiator = new Negotiator(context)
.WithStatusCode(HttpServiceErrorDefinition.InternalServerError.HttpStatusCode)
.WithModel(HttpServiceErrorDefinition.InternalServerError.ServiceErrorModel);
context.Response = _responseNegotiator.NegotiateResponse(negotiator, context);
}
public void TargetGearDemandWinsOverFollowRpmDemand()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyTargetGearDemand);
negotiator.Issue(_dummyFollowRpmDemand);
var program = negotiator.Negotiate();
Assert.True(program is GearTargetingShiftingProgram);
}
public static Negotiator WithEtagAndLastModified(this Negotiator negotiator, Etag etag, DateTime responseLastModified)
{
var currentEtag = etag?.ToString();
if (currentEtag != null)
{
negotiator.WithHeader("ETag", currentEtag);
}
return(negotiator
.WithHeader("Last-Modified", responseLastModified.ToString("R")));
}
public void NegotiatedTargetGearProgramReflectsTheDemand()
{
var negotiator = new Negotiator();
negotiator.Issue(new TargetGearDemand(new Gear(2)));
var program = negotiator.Negotiate();
Assert.AreEqual(SuggestedAction.Upshift, program.GetSuggestedActionFor(new Gear(1), new Rpm(1000)));
Assert.AreEqual(SuggestedAction.Retain, program.GetSuggestedActionFor(new Gear(2), new Rpm(1000)));
Assert.AreEqual(SuggestedAction.Downshift, program.GetSuggestedActionFor(new Gear(3), new Rpm(1000)));
}
public void YieldDemandWinsOverAllOtherDemands()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyYieldDemand);
negotiator.Issue(_dummyTargetGearDemand);
negotiator.Issue(_dummyFollowRpmDemand);
var program = negotiator.Negotiate();
Assert.True(program is YieldingShiftingProgram);
}
public void RevokingEngineBrakingProgramMakesNegotiatorReturnRpmBackAgain()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyFollowRpmDemand);
negotiator.Issue(new EngineBrakingDemand());
negotiator.RevokeEngineBrakingDemand();
var program = negotiator.Negotiate();
Assert.True(program is RpmBasedShiftingProgram);
}
public void RevokingTargetGearDemandMakesItGoBackToFollowRpmDemand()
{
var negotiator = new Negotiator();
negotiator.Issue(_dummyTargetGearDemand);
negotiator.Issue(_dummyFollowRpmDemand);
negotiator.RevokeTargetGearDemand();
var program = negotiator.Negotiate();
Assert.True(program is RpmBasedShiftingProgram);
}
public async Task <HttpResponseMessage> GetRetryHistory()
{
using (var session = store.OpenAsyncSession())
{
var retryHistory = await session.LoadAsync <RetryHistory>(RetryHistory.MakeId()).ConfigureAwait(false)
?? RetryHistory.CreateNew();
return(Negotiator
.FromModel(Request, retryHistory)
.WithDeterministicEtag(retryHistory.GetHistoryOperationsUniqueIdentifier()));
}
}
private void OnConnectionArrived(ConnectionArrived data)
{
if (Settings.Filter?.Accept(data.Remote) != false)
{
Negotiator.Handle(data.Connection, new HandshakeNegotiatorPassiveInstance(Localhost, Hash, HandshakeOptions.Extended));
}
else
{
Notifications.Enqueue(new PeerRejectedNotification(data.Remote));
data.Connection.Terminate();
}
}
public static Negotiator WithDeterministicEtag(this Negotiator negotiator, string data)
{
if (string.IsNullOrEmpty(data))
{
return(negotiator);
}
var guid = DeterministicGuid.MakeId(data);
return(negotiator
.WithHeader("ETag", guid.ToString()));
}
/// <summary>
/// Extends the content negotiation to render a page in a longer set of results
/// </summary>
/// <typeparam name="T">The type of item to be returned in the page</typeparam>
/// <param name="negotiator">The content negotiator object</param>
/// <param name="items">The full set of items from which the page is to be selected</param>
/// <param name="skip">Offset into the list for the start of the page</param>
/// <param name="take">The number of items to include on the page</param>
/// <param name="defaultPageSize">The default page size, used for generating the extents of the previous and next pages</param>
/// <param name="resourceUri">The base URI that generates the list of items</param>
/// <returns>The updated negotiator</returns>
/// <remarks>
/// <para>The negotiator will be configured with a return value for text/html and for application/json.</para>
/// <para>For text/html the response model will be an instance of <see cref="PagedResultModel{T}"/>, with the link URIs included in the model,
/// the response view name will be set to Paged{NameOfItemModel} with the word "Model" stripped from the end.</para>
/// <para>For application/json, the response model will simply be a <see cref="List{T}"/>.</para>
/// <para>In either case the HTTP Links header will be populated with first, prev and next links as appropriate. No
/// first or prev link is generated if the request is for the first page. No next link is generated if the page includes
/// the final item in the list.</para>
/// </remarks>
public static Negotiator WithPagedList <T>(this Negotiator negotiator, dynamic requestObject, IEnumerable <T> items, int skip, int take, int defaultPageSize, string resourceUri)
{
var links = new List <string>();
var queryParamsSeparator = resourceUri.Contains("?") ? "&" : "?";
var fullList = items.ToList();
var returnList = fullList.Count > take?fullList.Take(take).ToList() : fullList;
var negotiate = negotiator.WithModel(returnList);
string first = null, prev = null, next = null;
if (skip > 0)
{
first = resourceUri;
var prevPage = skip - defaultPageSize;
prev = prevPage <= 0 ? resourceUri : String.Format("{0}{1}skip={2}", resourceUri, queryParamsSeparator, prevPage);
}
if (fullList.Count > take)
{
next = String.Format("{0}{1}skip={2}", resourceUri, queryParamsSeparator, skip + take);
}
if (first != null)
{
links.Add(MakeLink(first, "first"));
}
if (prev != null)
{
links.Add(MakeLink(prev, "prev"));
}
if (next != null)
{
links.Add(MakeLink(next, "next"));
}
if (links.Count > 0)
{
return(negotiate.WithModel(returnList).WithHeader("Link", String.Join(",", links)));
}
var pagedView = "Paged" + typeof(T).Name;
if (pagedView.EndsWith("Model"))
{
pagedView = pagedView.Substring(0, pagedView.Length - 5);
}
return(negotiate.WithMediaRangeModel(new MediaRange("text/html"),
new PagedResultModel <T>(first, prev, next, returnList, requestObject))
.WithView(pagedView)
.WithMediaRangeModel("application/json", returnList));
}
public CommandRequestHandler(ICommandDispatcher dispatcher, T command,
IResponseFormatter responseFormatter,
IValidatorResolver validatorResolver,
Negotiator negotiator,
Messages.Commands.Request request)
{
_dispatcher = dispatcher;
_command = command;
_command.Request = request;
_responseFormatter = responseFormatter;
_validatorResolver = validatorResolver;
_negotiator = negotiator;
}
public CommandRequestHandler(ICommandDispatcher dispatcher, T command, IResponseFormatter responseFormatter,
Negotiator negotiator, Url url)
{
_dispatcher = dispatcher;
_command = command;
_command.Request = new Common.Commands.Request
{
Origin = url.Path.Remove(0, 1),
CreatedAt = DateTime.UtcNow
};
_responseFormatter = responseFormatter;
_negotiator = negotiator;
}
public CommandRequestHandler(ICommandDispatcher dispatcher, T command,
IResponseFormatter responseFormatter,
IValidatorResolver validatorResolver,
Negotiator negotiator,
Url url, string culture)
{
_dispatcher = dispatcher;
_command = command;
_command.Request = Messages.Commands.Request.Create <T>(Guid.NewGuid(), url.Path, culture);
_responseFormatter = responseFormatter;
_validatorResolver = validatorResolver;
_negotiator = negotiator;
}
private Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>[] GetCompatibleHeaders(NancyContext context, Negotiator negotiator)
{
List<Tuple<string, decimal>> acceptHeaders;
if (negotiator.NegotiationContext.PermissableMediaRanges.Any(mr => mr.IsWildcard))
{
acceptHeaders = context.Request.Headers
.Accept.Where(header => header.Item2 > 0m)
.ToList();
}
else
{
acceptHeaders = negotiator.NegotiationContext
.PermissableMediaRanges
.Where(header => context.Request.Headers.Accept.Any(mr => header.Matches(mr.Item1) && mr.Item2 > 0m))
.Select(header => new Tuple<string, decimal>(header, 1.0m))
.ToList();
}
return (from header in acceptHeaders
let compatibleProcessors = (IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>)GetCompatibleProcessorsByHeader(header.Item1, negotiator.NegotiationContext.GetModelForMediaRange(header.Item1), context)
where compatibleProcessors != null
select new Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>(
header.Item1,
compatibleProcessors
)).ToArray();
}
private static Response NegotiateResponse(IEnumerable<Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>> compatibleHeaders, object model, Negotiator negotiator, NancyContext context)
{
foreach (var compatibleHeader in compatibleHeaders)
{
var prioritizedProcessors = compatibleHeader.Item2
.OrderByDescending(x => x.Item2.ModelResult)
.ThenByDescending(x => x.Item2.RequestedContentTypeResult);
foreach (var prioritizedProcessor in prioritizedProcessors)
{
var processorType = prioritizedProcessor.Item1.GetType();
context.WriteTraceLog(sb => sb.AppendFormat("[DefaultRouteInvoker] Invoking processor: {0}\n", processorType));
var response =
SafeInvokeResponseProcessor(prioritizedProcessor.Item1, compatibleHeader.Item1, negotiator.NegotiationContext.GetModelForMediaRange(compatibleHeader.Item1), context);
if (response != null)
{
return response;
}
}
}
return null;
}
private static Negotiator GetNegotiator(object routeResult, NancyContext context)
{
var negotiator = routeResult as Negotiator;
if (negotiator == null)
{
context.WriteTraceLog(sb => sb.AppendFormat("[DefaultRouteInvoker] Wrapping result of type {0} in negotiator\n", routeResult.GetType()));
negotiator = new Negotiator(context);
negotiator.WithModel(routeResult);
}
return negotiator;
}
private void Reader()
{
using(Negotiator neg=new Negotiator(this.stream))
{
byte[] buffer = new byte[this.socket.ReceiveBufferSize];
while (!this.abort)
{
int bytes = 0;
lock (this.stream)
{
if (this.socket.Available > 0)
{
bytes = this.stream.Read(buffer, 0, buffer.Length);
}
}
if (bytes > 0)
{
bytes = neg.Negotiate(buffer, bytes);
if (bytes > 0)
{
this.RaiseDataReceived(this.Encoding.GetString(buffer, 0, bytes));
}
}
else
{
System.Threading.Thread.Sleep(10);
}
}
}
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="PeerNet.DataConnection"/> class.
/// </summary>
/// <param name="peer">Peer to connect to.</param>
/// <param name="provider">This Peer.</param>
/// <param name="dataConnectionOptions">an instance of the DataConnectionOptions class.</param>
public DataConnection (Peer peer, Peer provider, DataConnectionOptions dataConnectionOptions)
{
Type = "data";
this.Peer = peer;
this.Provider = provider;
this.Id = "dc_" + Util.token;
this.DataConnectionOptions = dataConnectionOptions;
negotiator = Negotiator.GetNegotiator ();
NegotiatorOptions negotiatorOptions = new NegotiatorOptions ();
negotiatorOptions.Originator = true;
negotiator.StartConnection (this, negotiatorOptions, provider.context);
}
