public dynamic Post(GameLeaveRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.IsInactive)
{
if (request.ActorNr > 0)
{
WebApiApplication.DataAccess.GameInsert(appId, request.UserId, request.GameId, request.ActorNr);
}
}
else
{
WebApiApplication.DataAccess.GameDelete(appId, request.UserId, request.GameId);
}
var okResponse = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(okResponse));
return okResponse;
}
public dynamic Post(GameLeaveRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
var response = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public dynamic Post(GamePropertiesRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.State != null)
{
var state = (string)JsonConvert.SerializeObject(request.State);
WebApiApplication.DataAccess.StateSet(appId, request.GameId, state);
var properties = request.Properties;
object actorNrNext = null;
if (properties != null)
{
properties.TryGetValue("turn", out actorNrNext);
}
var userNextInTurn = string.Empty;
foreach (var actor in request.State.ActorList)
{
if (actorNrNext != null)
{
if (actor.ActorNr == actorNrNext)
{
userNextInTurn = (string)actor.UserId;
}
}
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
if (!string.IsNullOrEmpty(userNextInTurn))
{
var notificationContent = new Dictionary<string, string>
{
{ "en", "{USERNAME} finished. It's your turn." },
{ "de", "{USERNAME} hat seinen Zug gemacht. Du bist dran." },
};
pushWoosh.RequestPushNotification(notificationContent, request.Username, "UID2", userNextInTurn, appId);
}
}
var response = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
public dynamic Post(GameCloseRequest request, string appId)
{
if (log.IsDebugEnabled) log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse { Message = message };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
if (request.State == null)
{
if (request.ActorCount > 0)
{
var errorResponse = new ErrorResponse { Message = "Missing State." };
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(errorResponse));
return errorResponse;
}
WebApiApplication.DataAccess.StateDelete(appId, request.GameId);
var okResponse = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(okResponse));
return okResponse;
}
foreach (var actor in request.State.ActorList)
{
//var listProperties = new ListProperties() { ActorNr = (int)actor.ActorNr, Properties = request.State.CustomProperties };
//WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (string)JsonConvert.SerializeObject(listProperties));
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
//deprecated
if (request.State2 != null)
{
foreach (var actor in request.State2.ActorList)
{
WebApiApplication.DataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
}
var state = (string)JsonConvert.SerializeObject(request.State);
WebApiApplication.DataAccess.StateSet(appId, request.GameId, state);
var response = new OkResponse();
if (log.IsDebugEnabled) log.Debug(JsonConvert.SerializeObject(response));
return response;
}
/// <summary>
/// Before request is made to server respond with the specified HTML string to client
/// and ignore the request.
/// </summary>
/// <param name="html">HTML content to sent.</param>
/// <param name="headers">HTTP response headers.</param>
/// <param name="closeServerConnection">Close the server connection used by request if any?</param>
public void Ok(string html, Dictionary <string, HttpHeader> headers = null,
bool closeServerConnection = false)
{
var response = new OkResponse();
if (headers != null)
{
response.Headers.AddHeaders(headers);
}
response.HttpVersion = WebSession.Request.HttpVersion;
response.Body = response.Encoding.GetBytes(html ?? string.Empty);
Respond(response, closeServerConnection);
}
public dynamic Post(GameEventRequest request, string appId)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("{0} - {1}", Request.RequestUri, request == null ? "null" : JsonConvert.SerializeObject(request));
}
var okResponse = new OkResponse();
if (log.IsDebugEnabled)
{
log.Debug(JsonConvert.SerializeObject(okResponse));
}
return(okResponse);
}
/// <summary>
/// Before request is made to server
/// Respond with the specified byte[] to client
/// and ignore the request
/// </summary>
/// <param name="result"></param>
/// <param name="headers"></param>
public async Task Ok(byte[] result, Dictionary <string, HttpHeader> headers)
{
var response = new OkResponse();
if (headers != null && headers.Count > 0)
{
response.ResponseHeaders = headers;
}
response.HttpVersion = WebSession.Request.HttpVersion;
response.ResponseBody = result;
await Respond(response);
WebSession.Request.CancelRequest = true;
}
public IResponse Execute(List <ICommand> commandList)
{
IResponse response = new OkResponse("");
foreach (var command in commandList)
{
var successfulResponseList = _commandToResponseFactory.CreateResponseList(command.Command);
response = _commandProcessor.Process(command);
if (!successfulResponseList.Contains(response.ResponseCode))
{
return(response);
}
}
return(response);
}
public IActionResult Index([FromBody] GamePropertiesRequest request, [FromHeader] string appId)
{
if (!IsValid(request, out string message))
{
var errorResponse = new ErrorResponse {
Message = message
};
_logger.LogError($"{Request.GetUri()} - {JsonConvert.SerializeObject(errorResponse)}");
return(BadRequest(errorResponse));
}
if (request.State != null)
{
var state = (string)JsonConvert.SerializeObject(request.State);
_dataAccess.StateSet(appId, request.GameId, state);
var properties = request.Properties;
object actorNrNext = null;
properties?.TryGetValue("turn", out actorNrNext);
var userNextInTurn = string.Empty;
foreach (var actor in request.State.ActorList)
{
if (actorNrNext != null)
{
if (actor.ActorNr == actorNrNext)
{
userNextInTurn = (string)actor.UserId;
}
}
_dataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
if (!string.IsNullOrEmpty(userNextInTurn))
{
var notificationContent = new Dictionary <string, string>
{
{ "en", "{USERNAME} finished. It's your turn." },
{ "de", "{USERNAME} hat seinen Zug gemacht. Du bist dran." },
};
_notification.SendMessage(notificationContent, request.Username, "UID2", userNextInTurn, appId);
}
}
var response = new OkResponse();
_logger.LogInformation($"{Request.GetUri()} - {JsonConvert.SerializeObject(response)}");
return(Ok(response));
}
public async Task Invoke(HttpContext httpContext)
{
object result = null;
var errMessage = string.Empty;
var httpStatusCode = HttpStatusCode.OK;
var buildRequest = grpcRequestBuilder.BuildRequest(httpContext);
if (buildRequest.IsError)
{
errMessage = "bad request";
httpStatusCode = HttpStatusCode.BadRequest;
Logger.LogWarning(errMessage);
}
else
{
try
{
var channel = grpcPool.GetChannel(new ServiceEndpoint(httpContext.Items.DownstreamRequest().Host, httpContext.Items.DownstreamRequest().Port));
var client = new MethodDescriptorClient(channel);
result = await client.InvokeAsync(buildRequest.Data.GrpcMethod, buildRequest.Data.Headers, buildRequest.Data.RequestMessage);
}
catch (RpcException ex)
{
httpStatusCode = HttpStatusCode.InternalServerError;
errMessage = $"rpc exception.";
Logger.LogError($"{ex.StatusCode}--{ex.Message}", ex);
}
catch (Exception ex)
{
httpStatusCode = HttpStatusCode.ServiceUnavailable;
errMessage = $"error in request grpc service.";
Logger.LogError($"{errMessage}--{httpContext.Items.DownstreamRequest().ToUri()}", ex);
}
}
OkResponse <GrpcHttpContent> httpResponse;
if (string.IsNullOrEmpty(errMessage))
{
httpResponse = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(result));
}
else
{
httpResponse = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(errMessage));
}
httpContext.Response.ContentType = "application/json";
httpContext.Items.UpsertDownstreamResponse(new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers, "OcelotGrpcHttpMiddleware"));
// httpContext.DownstreamResponse = new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers, "OcelotGrpcHttpMiddleware");
}
public void should_return_claims_to_things()
{
var userInput = new Dictionary <string, string>()
{
{ "CustomerId", "Claims[CustomerId] > value" }
};
var claimsToThing = new OkResponse <ClaimToThing>(new ClaimToThing("CustomerId", "CustomerId", "", 0));
this.Given(x => x.GivenTheFollowingDictionary(userInput))
.And(x => x.GivenTheConfigHeaderExtractorReturns(claimsToThing))
.When(x => x.WhenIGetTheThings())
.Then(x => x.ThenTheConfigParserIsCalledCorrectly())
.And(x => x.ThenClaimsToThingsAreReturned())
.BDDfy();
}
public async Task <OkResponse <CourseDto> > CreateAsync(CourseCreateDto dto)
{
if (dto == null || string.IsNullOrEmpty(dto.Name))
{
return(OkResponse <CourseDto> .Error(HttpStatusCode.BadRequest, "Model is not valid!"));
}
var newCourse = _mapper.Map <Course>(dto);
newCourse.CreatedTime = DateTime.Now;
await _courseCollection.InsertOneAsync(newCourse);
var mapDto = _mapper.Map <CourseDto>(newCourse);
return(OkResponse <CourseDto> .Success(HttpStatusCode.OK, mapDto));
}
public Response <DownstreamRoute> Get(string upstreamUrlPath, string upstreamQueryString, string upstreamHttpMethod, IInternalConfiguration configuration, string upstreamHost)
{
var serviceName = GetServiceName(upstreamUrlPath);
var downstreamPath = GetDownstreamPath(upstreamUrlPath);
if (HasQueryString(downstreamPath))
{
downstreamPath = RemoveQueryString(downstreamPath);
}
var downstreamPathForKeys = $"/{serviceName}{downstreamPath}";
var loadBalancerKey = CreateLoadBalancerKey(downstreamPathForKeys, upstreamHttpMethod, configuration.LoadBalancerOptions);
if (_cache.TryGetValue(loadBalancerKey, out var downstreamRoute))
{
return(downstreamRoute);
}
var qosOptions = _qoSOptionsCreator.Create(configuration.QoSOptions, downstreamPathForKeys, new [] { upstreamHttpMethod });
var downstreamReRoute = new DownstreamReRouteBuilder()
.WithServiceName(serviceName)
.WithLoadBalancerKey(loadBalancerKey)
.WithDownstreamPathTemplate(downstreamPath)
.WithUseServiceDiscovery(true)
.WithHttpHandlerOptions(configuration.HttpHandlerOptions)
.WithQosOptions(qosOptions)
.WithDownstreamScheme(configuration.DownstreamScheme)
.WithLoadBalancerOptions(configuration.LoadBalancerOptions)
.Build();
var reRoute = new ReRouteBuilder()
.WithDownstreamReRoute(downstreamReRoute)
.WithUpstreamHttpMethod(new List <string>()
{
upstreamHttpMethod
})
.Build();
downstreamRoute = new OkResponse <DownstreamRoute>(new DownstreamRoute(new List <PlaceholderNameAndValue>(), reRoute));
_cache.AddOrUpdate(loadBalancerKey, downstreamRoute, (x, y) => downstreamRoute);
return(downstreamRoute);
}
TResponse TryDeserialize <TResponse>(string responseJson) where TResponse : class, IKernelResponse
{
JObject responseObject = (JObject)JsonConvert.DeserializeObject(responseJson, new JsonSerializerSettings
{
DateParseHandling = DateParseHandling.None
}) !;
if (responseObject.ContainsKey("error"))
{
ErrorResponse errorResponse = responseObject.ToObject <ErrorResponse>() !;
throw new JsiiException(errorResponse, null);
}
if (typeof(TResponse).IsAssignableFrom(typeof(HelloResponse)))
{
return(responseObject.ToObject <TResponse>() !);
}
if (responseObject.ContainsKey("callback"))
{
CallbackResponse callbackResponse = responseObject.ToObject <CallbackResponse>() !;
Callback callback = callbackResponse.Callback;
object?result = callback.InvokeCallback(_referenceMap, _frameworkToJsiiConverter, out string?error);
return(Send <SynchronousCompleteRequest, TResponse>(new SynchronousCompleteRequest
(
new CompleteRequest(callback.CallbackId, error, result)
)));
}
if (responseObject.ContainsKey("pending"))
{
// TODO: What does this mean?
throw new NotImplementedException();
}
if (responseObject.ContainsKey("ok"))
{
OkResponse <TResponse> okResponse = responseObject.ToObject <OkResponse <TResponse> >() !;
return(okResponse.Ok);
}
throw new ArgumentException("Unrecognized response format", nameof(responseJson));
}
public void BasicEventDispatcherTest()
{
const int port = 8732;
//Setup test's ZMQ
Utils.CreateZmq(ZSocketType.REP, port, true, out ZContext context, out ZSocket socket);
//Create the event dispatcher
EventDispatcher <EngineActionEvent, EngineActionResponse> eventDispatcher = null;
_ = Task.Run(() =>
{
eventDispatcher = new EventDispatcher <EngineActionEvent, EngineActionResponse>(new TimeSpan(0, 0, 0, 4), port);
eventDispatcher.DispatchEventsThread().RunSynchronously();
});
SpinWait.SpinUntil(() => eventDispatcher != null);
//Send the event
bool gotResponse = false;
eventDispatcher.QueueEvent(new PingEvent(), responseEventDispatcher =>
{
//We got a response
gotResponse = true;
Assert.IsNotNull(responseEventDispatcher);
Assert.That(responseEventDispatcher.GetType(), Is.EqualTo(typeof(OkResponse)));
});
//Get a event from the dispatcher
byte[] requestData = socket.Receive();
EngineActionEvent actionEvent = EventsSerializer.DeserializeEvent <EngineActionEvent>(requestData);
Assert.IsNotNull(actionEvent);
Assert.That(actionEvent.GetType(), Is.EqualTo(typeof(PingEvent)));
//Respond
EngineActionResponse response = new OkResponse();
byte[] responseData = EventsSerializer.SerializeEvent <EngineActionResponse>(response);
socket.Send(responseData);
SpinWait.SpinUntil(() => gotResponse);
eventDispatcher.Dispose();
socket.Dispose();
context.Dispose();
}
public IActionResult Index([FromBody] GameCloseRequest request, string appId)
{
if (!IsValid(request, out string message))
{
var errorResponse = new ErrorResponse {
Message = message
};
_logger.LogError($"{Request.GetUri()} - {JsonConvert.SerializeObject(errorResponse)}");
return(Ok(errorResponse));
}
appId = appId.ToLowerInvariant();
if (request.State == null)
{
if (request.ActorCount > 0)
{
var errorResponse = new ErrorResponse {
Message = "Missing State."
};
_logger.LogError($"{Request.GetUri()} - {JsonConvert.SerializeObject(errorResponse)}");
return(Ok(errorResponse));
}
_dataAccess.StateDelete(appId, request.GameId);
var okResponse = new OkResponse();
_logger.LogInformation($"{Request.GetUri()} - {JsonConvert.SerializeObject(okResponse)}");
return(Ok(okResponse));
}
foreach (var actor in request.State.ActorList)
{
//var listProperties = new ListProperties() { ActorNr = (int)actor.ActorNr, Properties = request.State.CustomProperties };
_dataAccess.GameInsert(appId, (string)actor.UserId, request.GameId, (int)actor.ActorNr);
}
var state = JsonConvert.SerializeObject(request.State);
_dataAccess.StateSet(appId, request.GameId, state);
var response = new OkResponse();
_logger.LogInformation($"{Request.GetUri()} - {JsonConvert.SerializeObject(response)}");
return(Ok(response));
}
public async Task <OkResponse <CategoryDto> > GetByIdAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(OkResponse <CategoryDto> .Error(HttpStatusCode.BadRequest, "Id cannot be empty!"));
}
var category = await _categoryCollection.Find(x => x.Id == id).FirstOrDefaultAsync();
if (category == null)
{
return(OkResponse <CategoryDto> .Error(HttpStatusCode.NotFound, "Category not found!"));
}
var mapDto = _mapper.Map <CategoryDto>(category);
return(OkResponse <CategoryDto> .Success(HttpStatusCode.OK, mapDto));
}
private void GivenNotPassingSecurityVerification()
{
for (int i = 0; i < _securityPolicyList.Count; i++)
{
Mock <ISecurityPolicy> item = _securityPolicyList[i];
if (i == 0)
{
Error error = new UnauthenticatedError($"Not passing security verification");
Response response = new ErrorResponse(error);
item.Setup(x => x.Security(_downstreamContext)).Returns(Task.FromResult(response));
}
else
{
Response response = new OkResponse();
item.Setup(x => x.Security(_downstreamContext)).Returns(Task.FromResult(response));
}
}
}
public async Task <OkResponse <object> > DeleteAsync(string id)
{
if (string.IsNullOrEmpty(id))
{
return(OkResponse <object> .Error(HttpStatusCode.BadRequest, "Id cannot be empty!"));
}
var result = await _courseCollection.DeleteOneAsync(x => x.Id == id);
if (result.DeletedCount > 0)
{
return(OkResponse <object> .Success(HttpStatusCode.NoContent));
}
else
{
return(OkResponse <object> .Error(HttpStatusCode.NotFound, "Course is not found."));
}
}
public async Task <OkResponse <CategoryDto> > UpdateAsync(CategoryUpdateDto dto)
{
if (dto == null || string.IsNullOrEmpty(dto.Id) || string.IsNullOrEmpty(dto.Name))
{
return(OkResponse <CategoryDto> .Error(HttpStatusCode.BadRequest, "Model is not valid!"));
}
var updateCategory = _mapper.Map <Category>(dto);
var result = await _categoryCollection.FindOneAndReplaceAsync(x => x.Id == updateCategory.Id, updateCategory);
if (result == null)
{
return(OkResponse <CategoryDto> .Error(HttpStatusCode.NotFound, "Category is not found."));
}
var mapDto = _mapper.Map <CategoryDto>(result);
return(OkResponse <CategoryDto> .Success(HttpStatusCode.OK, mapDto));
}
public dynamic Post(GameLeaveRequest request, string appId)
{
appId = appId.ToLowerInvariant();
string message;
if (!IsValid(request, out message))
{
var errorResponse = new ErrorResponse {
Message = message
};
if (log.IsDebugEnabled)
{
log.Debug(JsonConvert.SerializeObject(errorResponse));
}
return(errorResponse);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("{0} - {1}", Request.RequestUri, JsonConvert.SerializeObject(request));
}
if (request.IsInactive)
{
if (request.ActorNr > 0)
{
WebApiApplication.DataAccess.GameInsert(appId, request.UserId, request.GameId, request.ActorNr);
}
}
else
{
WebApiApplication.DataAccess.GameDelete(appId, request.UserId, request.GameId);
}
var okResponse = new OkResponse();
if (log.IsDebugEnabled)
{
log.Debug(JsonConvert.SerializeObject(okResponse));
}
return(okResponse);
}
public async Task Invoke(DownstreamContext context)
{
var httpStatusCode = HttpStatusCode.OK;
var buildRequest = await _dotNettyRequestBuilder.BuildRequest(context);
string resultMessage;
if (buildRequest.IsError)
{
resultMessage = "bad request";
httpStatusCode = HttpStatusCode.BadRequest;
Logger.LogDebug(resultMessage);
}
else
{
try
{
var endpoint = new IPEndPoint(IPAddress.Parse(context.DownstreamRequest.Host), context.DownstreamRequest.Port);
var serviceId = context.DownstreamRequest.AbsolutePath.TrimStart('/');
var result = await _serviceProxyProvider.InvokeAsync <object>(buildRequest.Data, serviceId, endpoint);
resultMessage = JsonConvert.SerializeObject(result);
}
catch (RpcException ex)
{
httpStatusCode = HttpStatusCode.InternalServerError;
resultMessage = $"rpc exception.";
Logger.LogError("apigateway dotnetty client error", ex);
}
catch (Exception ex)
{
httpStatusCode = HttpStatusCode.ServiceUnavailable;
resultMessage = $"error in request netty service.";
Logger.LogError($"{resultMessage}--{context.DownstreamRequest.ToUri()}", ex);
}
}
OkResponse <DotNettyHttpContent> httpResponse = new OkResponse <DotNettyHttpContent>(new DotNettyHttpContent(resultMessage));
//context.HttpContext.Response.ContentType = "application/json";
context.DownstreamResponse = new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers, string.Empty);
}
public async Task Invoke(DownstreamContext context)
{
string resultMessage = string.Empty;
var httpStatusCode = HttpStatusCode.OK;
var buildRequest = grpcRequestBuilder.BuildRequest(context);
if (buildRequest.IsError)
{
resultMessage = "bad request";
httpStatusCode = HttpStatusCode.BadRequest;
Logger.LogDebug(resultMessage);
//SetPipelineError(context, buildRequest.Errors);
}
else
{
try
{
//缓存连接应该使用服务发现或执行健康检查，不如会等太久
var channel = grpcChannelFactory.GetGrpcChannel(context.DownstreamRequest.Host, context.DownstreamRequest.Port);
var client = new GrpcClient(channel);
resultMessage = await client.InvokeMethodAsync(buildRequest.Data.GrpcMethod, buildRequest.Data.RequestMessage);
}
catch (RpcException ex)
{
httpStatusCode = HttpStatusCode.InternalServerError;
resultMessage = $"rpc exception.";
Logger.LogError($"{ex.StatusCode}--{ex.Message}", ex);
}
catch (Exception ex)
{
httpStatusCode = HttpStatusCode.ServiceUnavailable;
resultMessage = $"error in request grpc service.";
//SetPipelineError(context, new UnknownError(error));
Logger.LogError($"{resultMessage}--{context.DownstreamRequest.ToUri()}", ex);
}
}
OkResponse <GrpcHttpContent> httpResponse = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(resultMessage));
context.HttpContext.Response.ContentType = "application/json";
context.DownstreamResponse = new DownstreamResponse(httpResponse.Data, httpStatusCode, httpResponse.Data.Headers);
}
public async Task <Response <ServiceHostAndPort> > Lease(HttpContext httpContext)
{
var services = await _services();
if (_failings is null)
{
_failings = new Dictionary <int, Service>();
await PollAsync(null);
t = new Timer(Poll);
t.Change(10000, 10000);
_last = -1;
}
lock (_lock)
{
if (_failings.Count == services.Count)
{
Console.WriteLine("Critical: No available api nodes");
return(new ErrorResponse <ServiceHostAndPort>(new ErrorInvokingLoadBalancerCreator(new Exception("No available API Nodes."))));
}
_last++;
if (_last >= services.Count)
{
_last = 0;
}
while (_failings.ContainsKey(_last))
{
_last++;
if (_last >= services.Count)
{
_last = 0;
}
}
//Console.WriteLine(this.route.LoadBalancerKey + " " + _last);
var next = services[_last];
var response = new OkResponse <ServiceHostAndPort>(next.HostAndPort);
return(response);
}
}
private static dynamic GameCreate(GameCreateRequest request, string appId)
{
dynamic response;
if (WebApiApplication.DataAccess.StateExists(appId, request.GameId))
{
response = new ErrorResponse { Message = "Game already exists." };
return response;
}
if (request.CreateOptions == null)
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, string.Empty);
}
else
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, (string)JsonConvert.SerializeObject(request.CreateOptions));
}
response = new OkResponse();
return response;
}
private static SwaggerServiceDiscoveryProvider CreateProvider(Service service = null)
{
IServiceDiscoveryProviderFactory serviceDiscovery = Substitute.For <IServiceDiscoveryProviderFactory>();
IServiceProviderConfigurationCreator configurationCreator = Substitute.For <IServiceProviderConfigurationCreator>();
IOptionsMonitor <FileConfiguration> options = Substitute.For <IOptionsMonitor <FileConfiguration> >();
options.CurrentValue.Returns(new FileConfiguration());
IServiceDiscoveryProvider serviceProvider = Substitute.For <IServiceDiscoveryProvider>();
serviceProvider.Get().Returns(new List <Service>()
{
service
});
var response = new OkResponse <IServiceDiscoveryProvider>(serviceProvider);
serviceDiscovery.Get(Arg.Any <ServiceProviderConfiguration>(), Arg.Any <DownstreamReRoute>()).Returns(response);
var provider = new SwaggerServiceDiscoveryProvider(serviceDiscovery, configurationCreator, options);
return(provider);
}
public override int GetHashCode()
{
int hash = 1;
if (status_ != null)
{
hash ^= Status.GetHashCode();
}
if (httpResponseCase_ == HttpResponseOneofCase.DeniedResponse)
{
hash ^= DeniedResponse.GetHashCode();
}
if (httpResponseCase_ == HttpResponseOneofCase.OkResponse)
{
hash ^= OkResponse.GetHashCode();
}
hash ^= (int)httpResponseCase_;
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public async Task <OkResponse <List <CourseDto> > > GetAllAsync(string userId = null)
{
var courses = await _courseCollection.Find(x => string.IsNullOrEmpty(userId) || x.UserId == userId).ToListAsync();
if (!courses.Any())
{
courses = new List <Course>();
}
else
{
var categoryIds = courses.Select(x => x.CategoryId).ToList();
var categories = await _categoryCollection.Find(x => categoryIds.Contains(x.Id)).ToListAsync();
if (categoryIds.Any())
{
courses.ForEach(item => item.Category = categories.FirstOrDefault(x => x.Id == item.CategoryId));
}
}
var mapDtos = _mapper.Map <List <CourseDto> >(courses);
return(OkResponse <List <CourseDto> > .Success(HttpStatusCode.OK, mapDtos));
}
public async Task <TResponse> ExecuteAsync(ServiceRequest request, Func <Task> action)
{
Guard.ThrowIfNull(request, nameof(request));
Guard.ThrowIfNull(action, nameof(action));
ServiceResponse response;
_logger.Information(request.CorrelationId, $"{action.Method.Name} => Started");
var timer = new Stopwatch();
try
{
timer.Start();
await action();
timer.Stop();
_logger.Verbose(request.CorrelationId, $"{action.Method.Name} => Execution time: {timer.ElapsedMilliseconds}.");
response = new OkResponse(request.CorrelationId);
}
catch (Exception ex)
{
_logger.Error(request.CorrelationId, ex, $"{action.Method.Name} => Failed.");
response = new FailedResponse(request.CorrelationId, ex, action.Method.Name);
}
finally
{
_logger.Information(request.CorrelationId, $"{action.Method.Name} => Finished.");
}
var convertedResponse = _converter(response);
return(convertedResponse);
}
public static dynamic GameLoad(GameCreateRequest request, string appId)
{
dynamic response;
string stateJson = string.Empty;
stateJson = WebApiApplication.DataAccess.StateGet(appId, request.GameId);
if (!string.IsNullOrEmpty(stateJson))
{
response = new GameLoadResponse {
State = JsonConvert.DeserializeObject(stateJson)
};
return(response);
}
//TBD - check how deleteIfEmpty works with createifnot exists
if (stateJson == string.Empty)
{
WebApiApplication.DataAccess.StateDelete(appId, request.GameId);
if (log.IsDebugEnabled)
{
log.DebugFormat("Deleted empty state, app id {0}, gameId {1}", appId, request.GameId);
}
}
if (request.CreateIfNotExists)
{
response = new OkResponse();
return(response);
}
response = new ErrorResponse {
Message = "GameId not Found."
};
return(response);
}
private static dynamic GameCreate(GameCreateRequest request, string appId)
{
dynamic response;
if (WebApiApplication.DataAccess.StateExists(appId, request.GameId))
{
response = new ErrorResponse {
Message = "Game already exists."
};
return(response);
}
if (request.CreateOptions == null)
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, string.Empty);
}
else
{
WebApiApplication.DataAccess.StateSet(appId, request.GameId, (string)JsonConvert.SerializeObject(request.CreateOptions));
}
response = new OkResponse();
return(response);
}
public static async Task HandleGrpcRequestAsync(this DownstreamContext context, Func <Task> next, IEnumerable <Interceptor> interceptors = null, SslCredentials secureCredentials = null)
{
// ignore if the request is not a gRPC content type
if (!context.HttpContext.Request.Headers.Any(h => h.Key.ToLowerInvariant() == "content-type" && h.Value == "application/grpc"))
{
await next.Invoke();
}
else
{
var methodPath = context.DownstreamReRoute.DownstreamPathTemplate.Value;
var grpcAssemblyResolver = context.HttpContext.RequestServices.GetService <GrpcAssemblyResolver>();
var methodDescriptor = grpcAssemblyResolver.FindMethodDescriptor(methodPath.Split('/').Last().ToUpperInvariant());
if (methodDescriptor == null)
{
await next.Invoke();
}
else
{
var logger = context.HttpContext.RequestServices.GetService <IOcelotLoggerFactory>().CreateLogger <GrpcAssemblyResolver>();
var upstreamHeaders = new Dictionary <string, string>
{
{ "x-grpc-route-data", JsonConvert.SerializeObject(context.TemplatePlaceholderNameAndValues.Select(x => new { x.Name, x.Value })) },
{ "x-grpc-body-data", await context.DownstreamRequest.Content.ReadAsStringAsync() }
};
logger.LogInformation($"Upstream request method is {context.HttpContext.Request.Method}");
logger.LogInformation($"Upstream header data for x-grpc-route-data is {upstreamHeaders["x-grpc-route-data"]}");
logger.LogInformation($"Upstream header data for x-grpc-body-data is {upstreamHeaders["x-grpc-body-data"]}");
var requestObject = context.HttpContext.ParseRequestData(upstreamHeaders);
var requestJsonData = JsonConvert.SerializeObject(requestObject);
logger.LogInformation($"Request object data is {requestJsonData}");
var loadBalancerFactory = context.HttpContext.RequestServices.GetService <ILoadBalancerFactory>();
var loadBalancerResponse = await loadBalancerFactory.Get(context.DownstreamReRoute, context.Configuration.ServiceProviderConfiguration);
var serviceHostPort = await loadBalancerResponse.Data.Lease(context);
var downstreamHost = $"{serviceHostPort.Data.DownstreamHost}:{serviceHostPort.Data.DownstreamPort}";
logger.LogInformation($"Downstream IP Address is {downstreamHost}");
var channel = new Channel(downstreamHost, secureCredentials ?? ChannelCredentials.Insecure);
MethodDescriptorCaller client;
if (interceptors != null && interceptors.Any())
{
CallInvoker callInvoker = null;
foreach (var interceptor in interceptors)
{
callInvoker = channel.Intercept(interceptor);
}
client = new MethodDescriptorCaller(callInvoker);
}
else
{
client = new MethodDescriptorCaller(channel);
}
var concreteObject = JsonConvert.DeserializeObject(requestJsonData, methodDescriptor.InputType.ClrType);
var result = await client.InvokeAsync(methodDescriptor, context.HttpContext.GetRequestHeaders(), concreteObject);
logger.LogDebug($"gRPC response called with {JsonConvert.SerializeObject(result)}");
var jsonSerializer = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var response = new OkResponse <GrpcHttpContent>(new GrpcHttpContent(JsonConvert.SerializeObject(result, jsonSerializer)));
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = response.Data
};
context.HttpContext.Response.ContentType = "application/json";
context.DownstreamResponse = new DownstreamResponse(httpResponseMessage);
}
}
}
private IResponse HandleRequest(Request request)
{
IResponse response = null;
if (request is LoginRequest)
{
Console.WriteLine(value: "Login request ...");
LoginRequest logReq = (LoginRequest)request;
UserDTO udto = logReq.User;
User user = DTOUtils.GetFromDTO(usdto: udto);
try
{
lock (server)
{
server.Login(user: user, client: this);
}
return(new OkResponse());
}
catch (ControllerException e)
{
_connected = false;
return(new ErrorResponse(message: e.Message));
}
}
if (request is LogoutRequest)
{
Console.WriteLine(value: "Logout request");
LogoutRequest logReq = (LogoutRequest)request;
UserDTO udto = logReq.User;
User user = DTOUtils.GetFromDTO(usdto: udto);
try
{
lock (server)
{
server.Logout(user: user, client: this);
}
//_connected = false;
return(new OkResponse());
}
catch (ControllerException e)
{
_connected = false;
return(new ErrorResponse(message: e.Message));
}
}
if (request is GetAllRequest)
{
Console.WriteLine(value: "GetAllRequest");
GetAllRequest getAllRequest = (GetAllRequest)request;
try
{
List <Match> list = null;
lock (server)
{
list = server.GetAllMatches();
}
// _connected = false;
response = new GetAllReponse(list: list);
}
catch (Exception e)
{
_connected = false;
response = new ErrorResponse(message: e.Message);
}
}
if (request is GetAllFilteredAndSortedRequest)
{
Console.WriteLine(value: "GetAllFilteredAndSortedRequest");
GetAllFilteredAndSortedRequest getAllRequest = (GetAllFilteredAndSortedRequest)request;
try
{
List <Match> list = null;
lock (server)
{
list = server.GetFilteredAndSortedMatches();
}
// _connected = false;
response = new GetAllFilteredAndSortedResponse(list: list);
}
catch (Exception e)
{
_connected = false;
response = new ErrorResponse(message: e.Message);
}
}
if (request is SellTicketsRequest)
{
Console.WriteLine(value: "Worker - sellTickets");
SellTicketsRequest sellTicketsRequest = (SellTicketsRequest)request;
try
{
SalesDTO sale = sellTicketsRequest.Sale;
lock (server)
{
this.server.SellTickets(idMatch: sale.IdMatch, quantity: sale.Quantity, buyerPerson: sale.Person,
username: sale.Username);
}
response = new OkResponse();
}
catch (Exception e)
{
_connected = false;
response = new ErrorResponse(e.Message);
}
}
return(response);
}
public static dynamic GameLoad(GameCreateRequest request, string appId)
{
dynamic response;
string stateJson = string.Empty;
stateJson = WebApiApplication.DataAccess.StateGet(appId, request.GameId);
if (!string.IsNullOrEmpty(stateJson))
{
response = new GameLoadResponse { State = JsonConvert.DeserializeObject(stateJson) };
return response;
}
//TBD - check how deleteIfEmpty works with createifnot exists
if (stateJson == string.Empty)
{
WebApiApplication.DataAccess.StateDelete(appId, request.GameId);
if (log.IsDebugEnabled)
{
log.DebugFormat("Deleted empty state, app id {0}, gameId {1}", appId, request.GameId);
}
}
if (request.CreateIfNotExists)
{
response = new OkResponse();
return response;
}
response = new ErrorResponse { Message = "GameId not Found." };
return response;
}
public Response <DownstreamRouteHolder> Get(string upstreamUrlPath, string upstreamQueryString, string upstreamHttpMethod, IInternalConfiguration configuration, string upstreamHost)
{
var serviceName = IsSystemApi(upstreamUrlPath) ? "baseService" : GetServiceName(upstreamUrlPath);
//var downstreamPath = IsSystemApi(upstreamUrlPath) ? upstreamUrlPath : GetDownstreamPath(upstreamUrlPath);
var downstreamPath = upstreamUrlPath;
if (HasQueryString(downstreamPath))
{
downstreamPath = RemoveQueryString(downstreamPath);
}
var downstreamPathForKeys = $"/{serviceName}{downstreamPath}";
var loadBalancerKey = CreateLoadBalancerKey(downstreamPathForKeys, upstreamHttpMethod, configuration.LoadBalancerOptions);
if (_cache.TryGetValue(loadBalancerKey, out var downstreamRouteHolder))
{
return(downstreamRouteHolder);
}
var qosOptions = _qoSOptionsCreator.Create(configuration.QoSOptions, downstreamPathForKeys, new List <string> {
upstreamHttpMethod
});
var upstreamPathTemplate = new UpstreamPathTemplateBuilder().WithOriginalValue(upstreamUrlPath).Build();
var downstreamRouteBuilder = new DownstreamRouteBuilder()
.WithServiceName(serviceName)
.WithLoadBalancerKey(loadBalancerKey)
.WithDownstreamPathTemplate(downstreamPath)
.WithUseServiceDiscovery(true)
.WithHttpHandlerOptions(configuration.HttpHandlerOptions)
.WithQosOptions(qosOptions)
.WithDownstreamScheme(configuration.DownstreamScheme)
.WithLoadBalancerOptions(configuration.LoadBalancerOptions)
.WithDownstreamHttpVersion(configuration.DownstreamHttpVersion)
.WithUpstreamPathTemplate(upstreamPathTemplate);
var rateLimitOptions = configuration.Routes != null
? configuration.Routes.SelectMany(t => t.DownstreamRoute).FirstOrDefault(t => t.ServiceName == serviceName) : null;
if (rateLimitOptions != null)
{
downstreamRouteBuilder
.WithRateLimitOptions(rateLimitOptions.RateLimitOptions)
.WithEnableRateLimiting(true);
}
var downstreamRoute = downstreamRouteBuilder.Build();
var route = new RouteBuilder()
.WithDownstreamRoute(downstreamRoute)
.WithUpstreamHttpMethod(new List <string>()
{
upstreamHttpMethod
})
.WithUpstreamPathTemplate(upstreamPathTemplate)
.Build();
downstreamRouteHolder = new OkResponse <DownstreamRouteHolder>(new DownstreamRouteHolder(new List <PlaceholderNameAndValue>(), route));
_cache.AddOrUpdate(loadBalancerKey, downstreamRouteHolder, (x, y) => downstreamRouteHolder);
return(downstreamRouteHolder);
}
private IResponse handleRequest(IRequest request)
{
IResponse response = null;
if (request is LogInRequest)
{
Console.WriteLine("Login request ...");
LogInRequest logReq = (LogInRequest)request;
AngajatDTO udto = logReq.User;
Angajat user = DTOUtils.getFromDTO(udto);
try
{
lock (server)
{
bool ok = server.logIn(user.User, user.Parola);
if (ok == true)
{
response = new OkResponse();
}
else
{
response = new ErrorResponse("log in error");
}
}
}
catch (Exception e)
{
connected = false;
return(new ErrorResponse(e.Message));
}
}
else
if (request is GetFlightsRequest)
{
List <Zbor> flights = new List <Zbor>();
flights = server.getAllFlight();
response = new GetFlightsResponse(DTOUtils.getDTO(flights));
}
else
if (request is SearchFlightsRequest)
{
SearchFlightsRequest r = (SearchFlightsRequest)request;
List <Zbor> flights = new List <Zbor>();
flights = server.findByDestinatieDataplecareFlight(r.Destinatie, r.DataPlecare);
response = new SearchFlightsResponse(DTOUtils.getDTO(flights));
}
else
if (request is AddBiletRequest)
{
AddBiletRequest r = (AddBiletRequest)request;
server.addBilet(r.Client, r.Turisti, r.Adresa, r.IdDestinatie);
response = new AddBiletResponse();
}
else
{
if (request is FindByIdZborRequest)
{
FindByIdZborRequest r = (FindByIdZborRequest)request;
Zbor z = server.findByIdZbor(r.IdZbor);
response = new FindByIdResponse(DTOUtils.getDTO(z));
}
}
return(response);
}
