protected override void RegisterMiscHandlersImpl(ICommandRegistry commandRegistry, Func <IServiceProvider> serviceProviderFactory)
{
commandRegistry.Register <BatchMapDataCommand>(() => serviceProviderFactory().GetService <QueueCommandDispatcher>());
commandRegistry.Register <WriteMappedDataCommand>(() => serviceProviderFactory().GetService <QueueCommandDispatcher>());
commandRegistry.Register <BatchReduceDataCommand>(() => serviceProviderFactory().GetService <QueueCommandDispatcher>());
commandRegistry.Register <WriteReducedDataCommand>(() => serviceProviderFactory().GetService <QueueCommandDispatcher>());
}
public static IServiceCollection UseShoppingCart(this IServiceCollection serviceCollection,
ICommandRegistry commandRegistry)
{
serviceCollection.AddSingleton <IShoppingCartRepository, ShoppingCartRepository>();
commandRegistry.Register <GetCartQueryHandler>();
commandRegistry.Register <AddToCartCommandHandler>();
return(serviceCollection);
}
public static IServiceCollection UseCheckout(this IServiceCollection serviceCollection,
ICommandRegistry registry)
{
serviceCollection.AddSingleton <IOrderRepository, OrderRepository>();
registry.Register <CreateOrderCommandHandler>();
registry.Register <MakePaymentCommandHandler>();
return(serviceCollection);
}
public IRegisterFireAndForgetHandler RegisterFireAndForgetFunctionImpl <TFunction, TCommand>()
where TFunction : class, IFireAndForgetFunction
where TCommand : ICommand
{
_serviceCollection.AddTransient <TFunction>();
var commandHandlerType = _functionHandlerType.MakeGenericType(typeof(TFunction), typeof(TCommand));
_commandRegistry.Register(commandHandlerType);
if (_customCommandDispatcher != null)
{
_commandRegistry.Register <TCommand>(() => _customCommandDispatcher);
}
return(this);
}
private void RegisterCommandHandlersForCommandsWithNoAssociatedHandler(FunctionHostBuilder builder, ICommandRegistry commandRegistry)
{
// IN PROGRESS: This looks from the loaded set of assemblies and looks for a command handler for each command associated with a function.
// If the handler is not already registered in the command registry then this registers it.
IRegistrationCatalogue registrationCatalogue = (IRegistrationCatalogue)commandRegistry;
HashSet <Type> registeredCommandTypes = new HashSet <Type>(registrationCatalogue.GetRegisteredCommands());
Dictionary <Type, List <Type> > commandTypesToHandlerTypes = null;
foreach (AbstractFunctionDefinition functionDefinition in builder.FunctionDefinitions)
{
if (registeredCommandTypes.Contains(functionDefinition.CommandType))
{
continue;
}
if (commandTypesToHandlerTypes == null)
{
commandTypesToHandlerTypes = HarvestCommandHandlers();
}
if (commandTypesToHandlerTypes.TryGetValue(functionDefinition.CommandType, out List <Type> handlerTypes))
{
foreach (Type handlerType in handlerTypes)
{
commandRegistry.Register(handlerType);
}
}
}
}
public static ICommandRegistry RegisterAmazonS3ObjectStore(this ICommandRegistry commandRegistry)
{
return(commandRegistry
.Register <AmazonS3StoreObjectCommandHandler>()
.Register <AmazonS3RetrieveObjectCommandHandler>()
.Register <AmazonS3ListObjectKeysCommandHandler>());
}
public static ICommandRegistry RegisterFileSystemObjectStore(this ICommandRegistry commandRegistry)
{
return(commandRegistry
.Register <FileSystemStoreObjectCommandHandler>()
.Register <FileSystemRetrieveObjectCommandHandler>()
.Register <FileSystemListObjectKeysCommandHandler>());
}
public static ICommandRegistry RegisterMemoryObjectStore(this ICommandRegistry commandRegistry)
{
return(commandRegistry
.Register <MemoryStoreObjectCommandHandler>()
.Register <MemoryRetrieveObjectCommandHandler>()
.Register <MemoryListObjectKeysCommandHandler>());
}
private static void ConfigureCommanding(CloudQueue queue, out ICommandDispatcher dispatcher, out IAzureStorageCommandQueueProcessorFactory listenerFactory)
{
ServiceCollection serviceCollection = new ServiceCollection();
CommandingDependencyResolverAdapter dependencyResolver = serviceCollection.GetCommandingDependencyResolver(() => _serviceProvider);
ICommandRegistry registry = dependencyResolver.AddCommanding();
dependencyResolver.AddQueues(
(msg, cmd, ex) =>
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(msg);
},
(msg, cmd, ex) =>
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(msg);
},
(msg, cmd, ex) =>
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(msg);
})
.AddAzureStorageCommanding();
registry
.Register <OutputWorldToConsoleCommandHandler>(1000, dispatcherFactoryFunc: queue.CreateCommandDispatcherFactory())
.Register <OutputBigglesToConsoleCommandHandler>();
_serviceProvider = serviceCollection.BuildServiceProvider();
dispatcher = _serviceProvider.GetService <ICommandDispatcher>();
listenerFactory = _serviceProvider.GetService <IAzureStorageCommandQueueProcessorFactory>();
}
public static ICommandRegistry AddNotificationClient(this ICommandRegistry commandRegistry, string serviceBusConnectionString)
{
// Configure the SendEmailCommand to be dispatched to a service bus queue
QueueClient queueClient = new QueueClient(serviceBusConnectionString, "sendEmailQueue");
commandRegistry.Register <SendEmailCommand>(queueClient.CreateCommandDispatcherFactory());
return(commandRegistry);
}
/// <summary>
/// Registers a command so that it can be inspected.
/// </summary>
/// <param name="commandType">The type of the command to register.</param>
public void Register(Type commandType)
{
if (commandType == null)
{
throw new ArgumentNullException("commandType");
}
commandRegistry.Register(commandType);
}
/// <summary>
/// Register a command type.
/// </summary>
/// <param name="commandType">The <see cref="Type" /> implementing the command.</param>
public void RegisterCommandType(Type commandType)
{
if (commandType == null)
{
throw new ArgumentNullException(nameof(commandType));
}
_commandRegistry.Register(commandType);
}
public static IServiceCollection UseStore(this IServiceCollection serviceCollection,
ICommandRegistry commandRegistry)
{
serviceCollection.AddSingleton <IStoreProductRepository, StoreProductRepository>();
commandRegistry.Register <GetStoreProductQueryHandler>();
return(serviceCollection);
}
public void RegisterHostingEnvironment(ICommandRegistry commandRegistry, IServiceCollection serviceCollection, Func <IServiceProvider> serviceProviderFactory, Action <IRegisterFireAndForgetHandler> registerFireAndForgetHandlers)
{
commandRegistry.Register(TerminatorHandlerTypeFactory());
RegisterMiscHandlersImpl(commandRegistry, serviceProviderFactory);
RegisterObjectStoreImpl(commandRegistry);
registerFireAndForgetHandlers(new RegisterFireAndForgetHandler(commandRegistry, serviceCollection, FireAndForgetHandlerType(), CustomCommandDispatcherFactory()));
serviceCollection.AddSingleton(QueueClientFactory);
serviceCollection.AddSingleton(x => ConfigFactory());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
CommandingDependencyResolverAdapter resolver = new CommandingDependencyResolverAdapter(
(fromType, toInstance) => services.AddSingleton(fromType, toInstance),
(fromType, toType) => services.AddTransient(fromType, toType),
(resolveTo) => _serviceProvider.GetService(resolveTo));
ICommandRegistry registry = resolver.AddCommanding();
registry.Register <UpdatePropertyValueCommandHandler>();
registry.Register <GetPropertyValueQueryHandler>();
registry.Register <GetMessageQueryHandler>();
services
.AddMvc(cfg => cfg.Filters.Add <ClaimsInjectionFilter>())
.AddAspNetCoreCommanding(cfg =>
{
cfg
// Define RESTful controllers and actions based on commands
.Controller("PropertyValue",
attributes => attributes.Attribute <AuthorizeAttribute>(),
actions => actions
.Action <GetPropertyValueQuery>(HttpMethod.Get)
.Action <UpdatePropertyValueCommand>(HttpMethod.Put))
.Controller("Message", actions => { actions.Action <GetMessageQuery>(HttpMethod.Get); })
// Configure claims to automatically populate properties on commands
.Claims(mapping =>
{
mapping
.MapClaimToCommandProperty <GetPropertyValueQuery>("UserId", cmd => cmd.MisspelledUserId)
.MapClaimToPropertyName("UserId", "UserId");
});
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "My API", Version = "v1"
});
c.AddAspNetCoreCommanding();
});
}
/// <summary>
/// Create a new instance.
/// </summary>
public Runtime()
{
var nameValidator = new NameValidator();
var commandDescriptorGenerator = new CommandAttributeInspector();
_commandRegistry = new CommandRegistry(nameValidator, commandDescriptorGenerator);
_commandServices = new CommandServices();
_parser = new Parser();
_variableReplacer = new VariableReplacer();
_sessionObjectTypes = new ScopedObjectRegistry();
_sessionObjectTypes.Register <VariableCollection>();
_commandRegistry.Register(typeof(Help));
_commandRegistry.Register(typeof(Var));
_commandServices.Register(_commandRegistry);
_commandServices.Register <IPhraseDictionary>(new PhraseDictionary());
}
public Form1()
{
InitializeComponent();
IServiceCollection serviceCollection = new ServiceCollection();
ICommandingDependencyResolver resolver = new CommandingDependencyResolver((type, instance) => serviceCollection.AddSingleton(type, instance),
(type, impl) => serviceCollection.AddTransient(type, impl),
type => _serviceProvider.GetService(type));
ICommandRegistry registry = resolver.UseCommanding();
registry.Register <GetTextCommandHandler>();
_serviceProvider = serviceCollection.BuildServiceProvider();
_dispatcher = _serviceProvider.GetService <ICommandDispatcher>();
}
public static void RegisterHttpCommand <TCommand, TResult>(this ICommandRegistry registry,
Uri uri,
HttpMethod httpMethod = null,
Func <string> authenticationHeaderContent = null,
IHttpCommandSerializer httpCommandSerializer = null,
IUriCommandQueryBuilder uriCommandQueryBuilder = null) where TCommand : ICommand <TResult>
{
registry.Register <TCommand, TResult>(() => new HttpCommandDispatcher(new HttpCommandExecuter(
uri,
httpMethod, authenticationHeaderContent, httpCommandSerializer ?? new JsonCommandSerializer(),
uriCommandQueryBuilder ?? new UriCommandQueryBuilder(),
HttpCommandingDependencies.HttpClientProvider)));
}
public static IServiceCollection UseStore(this IServiceCollection serviceCollection,
Func <IServiceProvider> serviceProvider,
ICommandRegistry commandRegistry, ApplicationModeEnum applicationMode = ApplicationModeEnum.InProcess)
{
serviceCollection.AddSingleton <IStoreProductRepository, StoreProductRepository>();
if (applicationMode == ApplicationModeEnum.InProcess || applicationMode == ApplicationModeEnum.Server)
{
commandRegistry.Register <GetStoreProductQueryHandler>();
}
else if (applicationMode == ApplicationModeEnum.Client)
{
// this configures the command dispatcher to send the command over HTTP and wait for the result
Uri functionUri = new Uri("http://localhost:7071/api/GetStoreProduct");
commandRegistry.Register <GetStoreProductQuery, CommandResponse <StoreProduct> >(() =>
{
IHttpCommandDispatcherFactory httpCommandDispatcherFactory = serviceProvider().GetService <IHttpCommandDispatcherFactory>();
return(httpCommandDispatcherFactory.Create(functionUri, HttpMethod.Get));
});
}
serviceCollection.RegisterValidators();
return(serviceCollection);
}
static ICommandDispatcher Configure()
{
Uri uri = new Uri("http://localhost:52933/api/personalDetails");
ServiceCollection serviceCollection = new ServiceCollection();
CommandingDependencyResolverAdapter dependencyResolver = serviceCollection.GetCommandingDependencyResolver(() => _serviceProvider);
ICommandRegistry registry = dependencyResolver.AddCommanding();
dependencyResolver.AddHttpCommanding();
_serviceProvider = serviceCollection.BuildServiceProvider();
registry.Register <UpdatePersonalDetailsCommand, UpdateResult>(HttpCommandDispatcherFactory.Create(uri, HttpMethod.Put));
ICommandDispatcher dispatcher = _serviceProvider.GetService <ICommandDispatcher>();
return(dispatcher);
}
public static IServiceCollection UseServiceBusScheduler <TCommandDispatcherType>(
this IServiceCollection serviceCollection,
ICommandRegistry commandRegistry,
Options options) where TCommandDispatcherType : IFrameworkCommandDispatcher
{
serviceCollection
.AddSingleton <IQueueClientProvider>(new QueueClientProvider(options.ServiceBusConnectionString, options.QueueName))
.AddTransient <ICommandRescheduler, CommandRescheduler>()
.AddTransient <ICommandScheduler, CommandScheduler>()
.AddTransient <IScheduledDateCalculator, ScheduledDateCalculator>()
;
if (serviceCollection.All(x => x.ServiceType != typeof(ICancelledCommandRepository)))
{
serviceCollection.AddTransient <ICancelledCommandRepository, CancellationUnsupportedCommandRepository>();
}
commandRegistry.Register <ScheduledMessageHandler <TCommandDispatcherType> >();
return(serviceCollection);
}
private static IServiceBusCommandQueueProcessorFactory ConfigureForDequeue()
{
if (_dequeueServiceProvider == null)
{
IServiceCollection serviceCollection = new ServiceCollection();
CommandingDependencyResolverAdapter resolver = new CommandingDependencyResolverAdapter(
(fromType, toInstance) => serviceCollection.AddSingleton(fromType, toInstance),
(fromType, toType) => serviceCollection.AddTransient(fromType, toType),
(resolveType) => _dispatchServiceProvider.GetService(resolveType));
ICommandRegistry commandRegistry = resolver.AddCommanding();
resolver.AddQueues().AddAzureServiceBus();
// register our command to dispatch to a servie bus queue
commandRegistry.Register <SimpleCommandHandler>();
_dequeueServiceProvider = serviceCollection.BuildServiceProvider();
}
IServiceBusCommandQueueProcessorFactory serviceBusCommandQueueProcessorFactory = _dispatchServiceProvider.GetService <IServiceBusCommandQueueProcessorFactory>();
return(serviceBusCommandQueueProcessorFactory);
}
private static ICommandDispatcher ConfigureForDispatchToQueue()
{
if (_dispatchServiceProvider == null)
{
IServiceCollection serviceCollection = new ServiceCollection();
CommandingDependencyResolverAdapter resolver = new CommandingDependencyResolverAdapter(
(fromType, toInstance) => serviceCollection.AddSingleton(fromType, toInstance),
(fromType, toType) => serviceCollection.AddTransient(fromType, toType),
(resolveType) => _dispatchServiceProvider.GetService(resolveType));
ICommandRegistry commandRegistry = resolver.AddCommanding();
resolver.AddAzureServiceBus();
// register our command to dispatch to a servie bus queue
QueueClient client = new QueueClient(ServiceBusConnectionString, "myqueue");
commandRegistry.Register <SimpleCommand>(client.CreateCommandDispatcherFactory());
_dispatchServiceProvider = serviceCollection.BuildServiceProvider();
}
ICommandDispatcher dispatcher = _dispatchServiceProvider.GetService <ICommandDispatcher>();
return(dispatcher);
}
private void RegisterCommandHandlersForCommandsWithNoAssociatedHandler(FunctionHostBuilder builder, ICommandRegistry commandRegistry)
{
// TODO: We can improve this so that auto-registration is decoupled and can be provided by a mediator package
if (builder.MediatorType != typeof(DefaultMediatorDecorator))
{
return;
}
// IN PROGRESS: This looks from the loaded set of assemblies and looks for a command handler for each command associated with a function.
// If the handler is not already registered in the command registry then this registers it.
IRegistrationCatalogue registrationCatalogue = (IRegistrationCatalogue)commandRegistry;
HashSet <Type> registeredCommandTypes = new HashSet <Type>(registrationCatalogue.GetRegisteredCommands());
Dictionary <Type, List <Type> > commandTypesToHandlerTypes = null;
foreach (AbstractFunctionDefinition functionDefinition in builder.FunctionDefinitions)
{
if (registeredCommandTypes.Contains(functionDefinition.CommandType))
{
continue;
}
if (commandTypesToHandlerTypes == null)
{
commandTypesToHandlerTypes = HarvestCommandHandlers();
}
if (commandTypesToHandlerTypes.TryGetValue(functionDefinition.CommandType, out List <Type> handlerTypes))
{
foreach (Type handlerType in handlerTypes)
{
commandRegistry.Register(handlerType);
}
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public virtual void ConfigureServices(IServiceCollection services)
{
string storageAccountConnectionString = Configuration["storage:connectionstring"];
string expensiveOperationQueueName = Configuration["storage:queuename"];
CommandingDependencyResolverAdapter resolver = new CommandingDependencyResolverAdapter(
(fromType, toInstance) => services.AddSingleton(fromType, toInstance),
(fromType, toType) => services.AddTransient(fromType, toType),
(resolveTo) => _serviceProvider.GetService(resolveTo));
// Using an instance of CommandingRuntime rather than the static helpers isolates
// this commanding infrastructure to this startup class / instance of the web app
// which means that acceptance tests can be run in parallel with multiple instances
// of the ASP.Net Core test server.
ICommandRegistry registry = _commandingRuntime.AddCommanding(resolver);
//ICommandRegistry registry = resolver.AddCommanding();
resolver.AddQueues().AddAzureStorageCommanding();
// Register our command handlers using the discovery approach. Our handlers are in this assembly
// so we just pass through our assembly
registry.Discover(typeof(Startup).Assembly);
// Register our expensive operation command to be sent to a queue
registry.Register <ExpensiveOperationCommand>(
CloudQueueDispatcherFactory.Create(storageAccountConnectionString, expensiveOperationQueueName));
// Register our commands as REST endpoints. This results in an API where the AddCommand, GetPostsQuery,
// GetPostsForCurrentUserQuery and GetPostQuery are handled as GET requests and executed immediately
// in process by the registered handlers while the ExpensiveOperationCommand is exposed as a POST operation
// and results in the command being placed on a queue
services
.AddMvc(ConfigureMvcOptions)
// this block configures our commands to be exposed on endpoints
.AddAspNetCoreCommanding(cfg => cfg
.Controller("Post", controller => controller
.Action <GetPostsQuery>(HttpMethod.Get)
.Action <GetPostQuery, FromRouteAttribute>(HttpMethod.Get, "{PostId}")
.Action <AddNewPostCommand>(HttpMethod.Post)
.Action <DeletePostCommand>(HttpMethod.Delete, "{PostId}")
)
.Controller("Profile", controller => controller
.Action <GetPostsForCurrentUserQuery>(HttpMethod.Get, "Posts"))
.Controller("ExpensiveOperation", controller => controller
.Action <ExpensiveOperationCommand>(HttpMethod.Post))
.Controller("SecurityTest", controller => controller
.Action <SecurityTestCommand>(HttpMethod.Post)
// we wire this one up with an ActionDefinition model to cover that test path
.Action(new ActionDefinition
{
BindingAttributeType = typeof(FromQueryAttribute),
CommandType = typeof(SecurityTestCommand),
ResultType = null,
Route = "asQueryParam",
Verb = HttpMethod.Get
}))
.Claims(ConfigureClaimsMapping)
.LogControllerCode(code =>
{
// this will output the code that is compiled for each controller to the debug window
Debug.WriteLine(code);
})
);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Acceptance Test API", Version = "v1"
});
c.AddAspNetCoreCommanding();
});
}
public static ICommandRegistry AddProductClient(this ICommandRegistry commandRegistry, Uri endpoint)
{
commandRegistry.Register <GetProductQuery>(HttpCommandDispatcherFactory.Create(endpoint, HttpMethod.Get));
return(commandRegistry);
}