public void GetRoutesShouldReturnTheVerb()
{
RouteMetadata metadata =
this.service.GetRoutes(typeof(IHasRoutes))
.Where(rm => rm.Method.Name == nameof(IHasRoutes.DeleteMethod))
.Single();
Assert.That(metadata.Verb, Is.EqualTo("DELETE").IgnoreCase);
}
public void InitializeShouldSetTheRouteMetadataFactory()
{
var metadata = new RouteMetadata
{
Method = typeof(IFakeRoute).GetMethod(nameof(IFakeRoute.Route)),
RouteUrl = "route",
Verb = "GET"
};
this.bootstrapper.DiscoveryService.GetDiscoveredTypes().Returns(new[] { typeof(IFakeRoute) });
this.bootstrapper.DiscoveryService.GetRoutes(typeof(IFakeRoute)).Returns(new[] { metadata });
this.bootstrapper.Initialize();
Assert.That(metadata.Factory, Is.Not.Null);
}
private RouterEntry ToRouterEntry(PluginMetadata plugin, RouteMetadata metadata)
{
RouteTargetType targetType;
string target;
if (RouteHandlerFactory.IsRpc(metadata))
{
targetType = RouteTargetType.Lambda;
target = _namingConventions.GetLambdaName(plugin);
}
else
{
targetType = RouteTargetType.Sqs;
target = _namingConventions.GetSqsName(plugin);
}
return(new RouterEntry(plugin.ServiceKey, metadata.Route, targetType, target));
}
public Route()
{
Metadata = new RouteMetadata();
Coordinates = new List <Coordinate>();
}
private void ImplementRouteHandler(MethodDefinition method, FieldDefinition serviceField, RouteMetadata route, bool isRpc)
{
var parameters = route.Method.GetParameters();
// (Message) (T) (Message, CancellationToken) (T, CancellationToken)
if (parameters.Length != 1 && parameters.Length != 2)
{
throw new NotImplementedException();
}
var il = method.Body.GetILProcessor();
var messageParam = parameters[0];
var hasCancellationToken = parameters.Length == 2;
if (messageParam.ParameterType == typeof(Message))
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, serviceField);
il.Emit(OpCodes.Ldarg_1);
if (hasCancellationToken)
{
il.Emit(OpCodes.Ldarg_2);
}
il.Emit(route.Method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, _module.ImportReference(route.Method));
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, serviceField);
il.Emit(OpCodes.Ldftn, _module.ImportReference(route.Method));
il.Emit(OpCodes.Newobj, _module.ImportReference(GetFuncConstructor(_module.ImportReference(route.Method.ReturnType), _module.ImportReference(messageParam.ParameterType))));
var jsonHandlerMethod = new GenericInstanceMethod(serviceField.DeclaringType.BaseType.Resolve().Methods.Single(x => x.Name == (isRpc ? "JsonRpcHandler" : "JsonBusHandler")));
jsonHandlerMethod.GenericArguments.Add(_module.ImportReference(messageParam.ParameterType));
if (isRpc)
{
jsonHandlerMethod.GenericArguments.Add(_module.ImportReference(route.Method.ReturnType.GetGenericArguments()[0]));
}
il.Emit(OpCodes.Call, jsonHandlerMethod);
}
il.Emit(OpCodes.Ret);
}
private void ImplementRegisterRoute(ILProcessor il, TypeDefinition functionType, FieldDefinition serviceField, VariableDefinition modelVariable, PluginMetadata service, RouteMetadata route)
{
var key = $"Handle_{serviceField.Name}_{route.Method.Name}";
var isRpc = RouteHandlerFactory.IsRpc(route);
// create private handler function
var method = functionType.Methods.SingleOrDefault(x => x.Name == key);
if (method == null)
{
var returnType = _module.ImportReference(isRpc ? _rpcReturnType : _busReturnType);
method = new MethodDefinition(key, MethodAttributes.Private | MethodAttributes.HideBySig, returnType);
method.Parameters.Add(new ParameterDefinition("message", ParameterAttributes.None, _messageType));
method.Parameters.Add(new ParameterDefinition("cancellationToken", ParameterAttributes.None, _cancellationTokenType));
functionType.Methods.Add(method);
ImplementRouteHandler(method, serviceField, route, isRpc);
}
il.Emit(OpCodes.Ldloc, modelVariable);
// RoutePatternParser.Parse("...")
il.Emit(OpCodes.Ldstr, RouterPatternParser.UnParse(route.Route));
var routePatternParserType = _routingModule.GetType("Toxon.Micro.RabbitBlog.Routing.Patterns.RouterPatternParser").Resolve();
var patternParse = _module.ImportReference(routePatternParserType.Methods.Single(x => x.Name == "Parse"));
il.Emit(OpCodes.Call, patternParse);
// new Func<...>(method)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldftn, method);
il.Emit(OpCodes.Newobj, _module.ImportReference(isRpc ? _rpcFuncConstructor : _busFuncConstructor));
// ...
il.Emit(OpCodes.Ldc_I4, (int)(isRpc ? RouteExecution.Synchronous : RouteExecution.Asynchronous));
il.Emit(OpCodes.Ldc_I4, (int)(isRpc ? RouteMode.Capture : RouteMode.Observe));
var cancellationTokenNone = _module.ImportReference(_cancellationTokenType.Resolve().Properties.Single(x => x.Name == "None").GetMethod);
il.Emit(OpCodes.Call, cancellationTokenNone);
// model.RegisterAsync(...)
var registerMethod = _module.ImportReference(isRpc ? _rpcRegisterMethod : _busRegisterMethod);
il.Emit(OpCodes.Callvirt, registerMethod);
}
public Route()
{
Metadata = new RouteMetadata();
Coordinates = new List<Coordinate>();
}
public Route()
{
Metadata = new RouteMetadata();
Waypoints = new List <Waypoint>();
}
public static ICollection<HttpMethod> GetHttpMethods(RouteMetadata metadata)
{
HashSet<HttpMethod> allowedMethods;
return httpMethods.TryGetValue(metadata, out allowedMethods) ? allowedMethods : new HashSet<HttpMethod>();
}
