private async Task <HttpResponseMessage> StateDiagram(HttpRequestMessage request, string service, CancellationToken cancellationToken)
{
IServiceInstance serviceInstance = _serviceResolver.GetInstanceByName(service);
var d = await _stateDiagram.GetDiagram(serviceInstance);
var msg = new HttpResponseMessage(HttpStatusCode.OK);
if (string.IsNullOrWhiteSpace(d.contentType))
{
msg.Content = new StringContent(d.diagram, Encoding.UTF8);
}
else
{
msg.Content = new StringContent(d.diagram, Encoding.UTF8, d.contentType);
}
return(msg);
}
public async Task <HttpResponseMessage> CallFromHttp <TRequest, TResponse>(IServiceInstance <TRequest, TResponse> service, HttpRequestMessage request, Action <TRequest, RequestMapping> mapping, CancellationToken cancellationToken)
where TRequest : BaseRequest, new() where TResponse : class, new()
{
Stopwatch sw = new Stopwatch();
sw.Start();
var requestJson = await request.Content.ReadAsStringAsync();
var requestPayload = new TRequest();
if (!string.IsNullOrWhiteSpace(requestJson))
{
requestPayload = JsonConvert.DeserializeObject <TRequest>(requestJson);
}
try
{
mapping(requestPayload, new RequestMapping(request));
} catch (Exception ex)
{
logger.LogError(ex, "Cannot map object. Skipping the remainder of the mapping");
}
var responsePayload = await service.Execute(requestPayload, cancellationToken);
var responseJson = JsonConvert.SerializeObject(responsePayload);
var httpStatusCode = ServiceResultExpander.HttpStatusCode(responsePayload.MetaData.Result);
var response = new HttpResponseMessage((HttpStatusCode)httpStatusCode)
{
Content = new StringContent(responseJson, Encoding.UTF8, "application/json")
};
response.Headers.Add("x-cw-svc-duration", responsePayload.MetaData.DurationMs.ToString());
response.Headers.Add("x-cw-correlationId", responsePayload.MetaData.CorrelationId.ToString());
response.Headers.Add("x-cw-result", responsePayload.MetaData.Result.ToString());
sw.Stop();
response.Headers.Add("x-cw-e2e-duration", sw.ElapsedMilliseconds.ToString());
return(response);
}
public Task <ServiceResponse> OnRequest <TReq>(IServiceInstance service, TReq request, CancellationToken cancellationToken) where TReq : BaseRequest, new()
{
var stateMachineRequest = request as BaseStatefulRequest <TTrigger>;
if (stateMachineRequest?.Trigger == null)
{
return(Task.FromResult(this.ContinuePipeline()));
}
var props = stateMachineRequest.GetType().GetProperties();
var match = props.FirstOrDefault(x => x.Name.Equals(stateMachineRequest.Trigger.Value.ToString(), StringComparison.InvariantCultureIgnoreCase));
if (match == null)
{
return(Task.FromResult(this.ContinuePipeline()));
}
var matchValue = match.GetValue(stateMachineRequest);
if (matchValue == null)
{
return
(Task.FromResult(
new ServiceResponse(new ResponseMetaData(
service,
ServiceResult.ValidationError,
validationErrors: ValidationHelper.Create("Is a required property", match.Name)))
));
}
var validationResult = _requestValidator.Validate(match.GetValue(stateMachineRequest), match.Name);
if (validationResult.Count == 0)
{
return(Task.FromResult(this.ContinuePipeline()));
}
return(Task.FromResult(new ServiceResponse(new ResponseMetaData(service, ServiceResult.ValidationError, validationErrors: validationResult))));
}
/// <summary>
/// ServiceInstance转InstanceEntry
/// </summary>
/// <param name="serviceInstance">ServiceInstance对象</param>
/// <returns>InstanceEntry对象</returns>
internal static InstanceEntry ToEntry(this IServiceInstance serviceInstance)
{
if (serviceInstance == null)
{
throw new ArgumentNullException(nameof(serviceInstance));
}
return(new InstanceEntry
{
ServiceName = serviceInstance.ServiceName,
Type = serviceInstance.ServiceType,
HostName = serviceInstance.HostName,
Port = serviceInstance.Port,
Secure = serviceInstance.IsSecure,
State = serviceInstance.ServiceState,
Weight = serviceInstance.Weight,
Balancing = serviceInstance.BalancePolicy,
FailTimeout = serviceInstance.FailTimeout,
MaxFails = serviceInstance.MaxFails,
NextWhen = serviceInstance.NextWhen,
NextTries = serviceInstance.NextTries,
NextTimeout = serviceInstance.NextTimeout,
});
}
public ResponseMetaData(
IServiceInstance service,
ServiceResult result,
TimeSpan duration,
Guid correlationId,
IDictionary <int, string>?errorCodes = null,
IDictionary <string, string[]>?validationErrors = null,
string?publicMessage = "",
string?exceptionMessage = "",
Dictionary <string, ResponseMetaData>?dependencies = null
) : this(
service.FullName,
correlationId,
result,
(long)duration.TotalMilliseconds,
responseCreated : null,
errorCodes : errorCodes,
validationErrors : validationErrors,
publicMessage : publicMessage,
exceptionMessage : exceptionMessage,
dependencies : dependencies)
{
}
public async Task <HttpResponseMessage> Handle(
HttpRequestMessage request,
IServiceInstance service,
CancellationToken cancellationToken)
{
var start = ServiceClock.CurrentTime();
try
{
var input = await _responseGenerator.ConvertRequest(service.RequestType, request);
var output = await service.Execute(input, cancellationToken);
var response = await _responseGenerator.ConvertResponse(request, output, service.ResponseType);
return(response);
}
catch (SchemaValidationException ex)
{
var error = await _responseGenerator.ConvertResponse(
request,
new ServiceResponse(
new ResponseMetaData(
service.FullName,
service.CorrelationId == default(Guid) ? Guid.Empty : service.CorrelationId,
ServiceResult.ValidationError,
(long)(ServiceClock.CurrentTime() - start).TotalMilliseconds,
ServiceClock.CurrentTime(),
validationErrors: ex.Errors
)
),
service.ResponseType);
return(error);
}
catch (Exception ex)
{
var serialEx = ex as CodeWorksSerializationException;
string originalPayload = serialEx?.RawData ?? "";
Dictionary <string, string[]> errors = null;
if (!string.IsNullOrWhiteSpace(originalPayload))
{
errors = new Dictionary <string, string[]> {
["payload"] = new[] { originalPayload }
};
}
var error = await _responseGenerator.ConvertResponse(
request,
new ServiceResponse(
new ResponseMetaData(
service.FullName,
service.CorrelationId == default(Guid) ? Guid.Empty : service.CorrelationId,
ServiceResult.PermanentError,
(long)(ServiceClock.CurrentTime() - start).TotalMilliseconds,
ServiceClock.CurrentTime(),
validationErrors: errors,
exceptionMessage: ex.ToString()
)
),
service.ResponseType);
return(error);
}
}
public InstanceEndpointDefinition(IEndpointDefinition definition, IServiceInstance instance)
{
_definition = definition;
_instance = instance;
}
public AuthentificationService(IAuthenticationService auth, IServiceInstance instance)
{
_authenticationService = auth;
_instance = instance;
}
public static Task <ServiceResponse <TRes> > CallService <TService, TReq, TRes>(this IServiceInstance service, TRes request)
where TService : IServiceInstance <TReq, TRes>
where TRes : new()
where TReq : BaseRequest, new()
{
return(null);
}
public static IAccessPolicy InternalOnly(IServiceInstance instance, bool allowAlwaysNonProd = true) => new InternalOnlyAccessPolicy(instance.CurrentEnvironment, allowAlwaysNonProd);
public InMemoryServiceInstanceConfigurator(IReceiveConfigurator <IInMemoryReceiveEndpointConfigurator> configurator, IServiceInstance instance)
: base(configurator, instance)
{
}
public TradeServiceAuth(IAuthenticationService auth, IServiceInstance instance) : base(auth, instance)
{
}
public ServiceBusServiceInstanceConfigurator(IReceiveConfigurator <IServiceBusReceiveEndpointConfigurator> configurator, IServiceInstance instance)
: base(configurator, instance)
{
}
