public Task Activate(JasperRuntime runtime, IGenerationConfig generation)
{
return(Task.Factory.StartNew(() =>
{
Routes.BuildRoutingTree(generation, runtime.Container);
}));
}
Task IFeature.Activate(JasperRuntime runtime, IGenerationConfig generation)
{
return(Task.Factory.StartNew(() =>
{
// TODO -- will need to be smart enough to do the conglomerate
// generation config of the base, with service bus specific stuff
_graph.Compile(generation, runtime.Container);
var transports = runtime.Container.GetAllInstances <ITransport>().ToArray();
Channels.UseTransports(transports);
configureSerializationOrder(runtime);
// TODO
// Done -- 1. Start up transports
// 2. Start up subscriptions when ready
var pipeline = runtime.Container.GetInstance <IHandlerPipeline>();
// TODO -- might parallelize this later
foreach (var transport in transports)
{
transport.Start(pipeline, Channels);
Channels
.Where(x => x.Uri.Scheme == transport.Protocol && x.Sender == null)
.Each(x =>
{
x.Sender = new NulloSender(transport, x.Uri);
});
}
}));
}
public IGenerationModel ToGenerationModel(IGenerationConfig config)
{
if (!Handlers.Any())
{
throw new InvalidOperationException("No method handlers configured for message type " + MessageType.FullName);
}
var configureMethods = Handlers.Select(x => x.HandlerType).Distinct()
.Select(x => x.GetTypeInfo().GetMethod("Configure",
new Type[] { typeof(HandlerChain) }));
foreach (var method in configureMethods)
{
method?.Invoke(null, new object[] { this });
}
foreach (var methodCall in Handlers.ToArray())
{
methodCall.Method.ForAttribute <ModifyHandlerChainAttribute>(att => att.Modify(this));
}
foreach (var handlerType in Handlers.Select(x => x.HandlerType).Distinct().ToArray())
{
handlerType.ForAttribute <ModifyHandlerChainAttribute>(att => att.Modify(this));
}
var i = 0;
var cascadingHandlers = Handlers.Where(x => x.ReturnVariable != null)
.Select(x => new CaptureCascadingMessages(x.ReturnVariable, ++i));
var frames = Wrappers.Concat(Handlers).Concat(cascadingHandlers).ToList();
return(new MessageHandlerGenerationModel(TypeName, MessageType, config, frames));
}
public Type[] CompileAll(IGenerationConfig generation)
{
var code = GenerateCode(generation);
var generator = buildGenerator(generation);
var assembly = generator.Generate(code);
return(assembly.GetExportedTypes().ToArray());
}
public void BuildRoutingTree(IGenerationConfig generation, IContainer container)
{
var handlers = CompileAndBuildAll(generation, container);
foreach (var handler in handlers)
{
var route = handler.Chain.Route;
route.Handler = handler;
Router.Add(route);
}
}
public IGenerationModel ToGenerationModel(IGenerationConfig config)
{
// TODO -- apply conneg policies here
// TODO -- look for attributes
// TODO -- add extra frames
// TODO -- return the Route generation model
var frames = new List <Frame>();
frames.Add(Action);
return(new RouteHandlerGenerationModel(TypeName, config, frames));
}
internal void Compile(IGenerationConfig generation, IContainer container)
{
if (!_hasGrouped)
{
Group();
}
var handlers = CompileAndBuildAll(generation, container);
foreach (var handler in handlers)
{
_handlers.Add(handler.Chain.MessageType, handler);
}
}
private AssemblyGenerator buildGenerator(IGenerationConfig generation)
{
// TODO -- should probably do a lot more here. See GH-6
var generator = new AssemblyGenerator();
generator.ReferenceAssembly(GetType().GetTypeInfo().Assembly);
generator.ReferenceAssembly(typeof(Task).GetTypeInfo().Assembly);
foreach (var assembly in generation.Assemblies)
{
generator.ReferenceAssembly(assembly);
}
return(generator);
}
public string GenerateCode(IGenerationConfig generation)
{
beforeGeneratingCode();
var writer = new SourceWriter();
writer.UsingNamespace <Task>();
writer.BlankLine();
writer.Namespace(generation.ApplicationNamespace);
foreach (var chain in chains)
{
var generationModel = chain.ToGenerationModel(generation);
// TODO -- figure out how to get the source code for each handler
writer.WriteLine($"// START: {chain.TypeName}");
HandlerSourceWriter.Write(generationModel, writer);
writer.WriteLine($"// END: {chain.TypeName}");
writer.WriteLine("");
writer.WriteLine("");
}
writer.FinishBlock();
var code = writer.Code();
attachSourceCodeToChains(code);
return(code);
}
protected GenerationModel(string className, string inputName, IVariableSource specific, IGenerationConfig config, IList <Frame> frames)
{
if (!frames.Any())
{
throw new ArgumentOutOfRangeException(nameof(frames), "Cannot be an empty list");
}
var handlerType = typeof(T).FindInterfaceThatCloses(typeof(IHandler <>));
if (handlerType == null)
{
throw new ArgumentOutOfRangeException(nameof(T), $"Type {typeof(T).FullName} does not implement IHandler<T>");
}
ClassName = className;
Config = config;
Frames = frames;
_specific = specific;
var inputType = handlerType.GetGenericArguments().Single();
InputVariable = new Variable(inputType, inputName);
var compiled = compileFrames(frames);
if (compiled.All(x => !x.IsAsync))
{
AsyncMode = AsyncMode.ReturnCompletedTask;
}
else if (compiled.Count(x => x.IsAsync) == 1 && compiled.Last().IsAsync&& compiled.Last().CanReturnTask())
{
AsyncMode = compiled.Any(x => x.Wraps) ? AsyncMode.AsyncTask : AsyncMode.ReturnFromLastNode;
}
Top = chainFrames(compiled);
}
public RouteHandlerGenerationModel(string className, IGenerationConfig config, IList <Frame> frames)
: base(className, RouteGraph.Context, new ContextVariableSource(), config, frames)
{
}
public THandler[] CompileAndBuildAll(IGenerationConfig generation, IContainer container)
{
var types = CompileAll(generation);
return(chains.Select(x => x.Create(types, container)).ToArray());
}
public HomogeneousTreeStrategy()
{
genCfg = new HomogeneousTreeConfig();
}
public MessageHandlerGenerationModel(string className, Type messageType, IGenerationConfig config, IList <Frame> frames)
: base(className, HandlerGraph.Context, new MessageHandlerVariableSource(messageType), config, frames)
{
}
public Task Activate(JasperRuntime runtime, IGenerationConfig generation)
{
Runtime = runtime;
WasActivated = true;
return(Task.CompletedTask);
}
public SeparableTreeStrategy()
{
genCfg = new SeparableTreeConfig();
}
