public void Send(FunicularMessage message)
{
if (_pipeServer.CanWrite)
{
_pipeServer.WriteMessage(message);
}
}
public static void WriteMessage(this PipeStream pipeStream, FunicularMessage message)
{
var compressedMessage = FunicularSerializer.Serialize(message);
var messageSizeCompressed = BitConverter.GetBytes(compressedMessage.Length);
var md5Compressed = Encoding.UTF8.GetBytes(message.Md5Hash);
pipeStream.Write(messageSizeCompressed);
pipeStream.Write(compressedMessage);
pipeStream.Write(md5Compressed);
}
public bool ReadMessage(out FunicularMessage message)
{
if (_pipeClient.CanRead)
{
return(_pipeClient.ReadMessage(out message));
}
message = FunicularMessage.Default;
return(false);
}
public static bool ReadMessage(this PipeStream pipeStream, out FunicularMessage message)
{
var compressedSize = pipeStream.Read(4);
var size = BitConverter.ToInt32(compressedSize);
var compressedMessage = pipeStream.Read(size);
message = FunicularDeserializer.Deserialize <FunicularMessage>(compressedMessage);
var md5Compressed = pipeStream.Read(32);
var md5 = Encoding.UTF8.GetString(md5Compressed);
return(md5 == message.Md5Hash);
}
public void Send(FunicularMessage message)
{
message.PipeName = _pipeName;
message.CreatedTimeUtc = DateTime.UtcNow;
if (!_pipeClient.IsConnected)
{
_pipeClient.Connect();
}
if (_pipeClient.CanWrite)
{
_pipeClient.WriteMessage(message);
}
}
private async Task InvokeAsync(MethodInfo callingMethod, params object[] parameters)
{
var isAwaitable = callingMethod.GetCustomAttributes <AsyncStateMachineAttribute>().Any();
object result = null;
bool isVoid;
var returnType = callingMethod.ReturnType;
if (isAwaitable)
{
isVoid = !callingMethod.ReturnType.IsGenericType;
if (isVoid)
{
await InvokeAsyncMethod(callingMethod, parameters).ConfigureAwait(false);
}
else
{
returnType = callingMethod.ReturnType.GenericTypeArguments[0];
result = await InvokeAsyncMethodAndReturn(callingMethod, parameters).ConfigureAwait(false);
}
}
else
{
isVoid = callingMethod.ReturnType == typeof(void);
if (isVoid)
{
callingMethod.Invoke(this, parameters);
}
else
{
result = callingMethod.Invoke(this, parameters);
}
}
if (!isVoid)
{
var entireResult = Convert.ChangeType(result, returnType);
ResponseMessage = new FunicularMessage
{
MessageType = FunicularMessageType.Response,
Route = Route
};
ResponseMessage.SetPayload(entireResult);
}
}
private async Task HandlePipeRequest(FunicularMessage funicularMessage, CancellationToken cancellationToken)
{
if (funicularMessage.Route == FunicularMessage.EmptyRoute)
{
_funicularServer.Send(new FunicularMessage
{
ErrorMessage = "Requested empty route"
});
throw new FunicularPipeRouterException(_funicularServer.PipeName, funicularMessage.Route, "Requested empty route");
}
var parts = funicularMessage.Route
.Split('/')
.Where(x => !string.IsNullOrEmpty(x))
.Select(x => x.ToLowerInvariant())
.ToArray();
if (parts.Length < 2)
{
_funicularServer.Send(new FunicularMessage
{
ErrorMessage = "Requested invalid route"
});
throw new FunicularPipeRouterException(_funicularServer.PipeName, funicularMessage.Route, "Invalid path (#1)");
}
if (!_baseRoutePaths.TryGetValue(parts[0], out var controllerType))
{
_funicularServer.Send(new FunicularMessage
{
ErrorMessage = "Requested invalid route"
});
throw new FunicularPipeRouterException(_funicularServer.PipeName, funicularMessage.Route, "Invalid path (#2)");
}
using var scope = _serviceProvider.CreateScope();
var controller = scope.ServiceProvider.GetRequiredService(controllerType) as FunicularController;
await controller !.HandlePipeRequest(funicularMessage, string.Join('/', parts.Skip(1)));
if (!funicularMessage.IsPost)
{
_funicularServer.Send(controller.ResponseMessage);
}
}
internal async Task HandlePipeRequest(FunicularMessage funicularMessage, string route)
{
RequestMessage = funicularMessage;
Route = route;
if (funicularMessage.MessageType == FunicularMessageType.Response)
{
ResponseMessage = new FunicularMessage
{
MessageType = FunicularMessageType.Response,
ErrorMessage = "Expected request, but received response"
};
return;
// throw ControllerException("Expected request, but received response");
}
if (!_actionMethodInputParameters.TryGetValue(Route, out var callingMethod))
{
ResponseMessage = new FunicularMessage
{
MessageType = FunicularMessageType.Response,
ErrorMessage = $"Method \"{Route}\" is not declared"
};
return;
// throw ControllerException($"Method \"{Route}\" is not declared");
}
var inputType = callingMethod
.GetParameters()
.FirstOrDefault(x => x.ParameterType != typeof(CancellationToken))?.ParameterType;
if (RequestMessage.HasValue && inputType != null)
{
await InvokeAsync(callingMethod, RequestMessage.GetPayload(inputType)).ConfigureAwait(false);
}
else
{
await InvokeAsync(callingMethod).ConfigureAwait(false);
}
}
public FunicularPipeControllerException(FunicularMessage requestMessage, string message) : base(message)
{
RequestMessage = requestMessage;
}
