public static async Task <CompetitionReadModel> Query(IRootResolver resolver, CompetitionId exampleId)
{
// Resolve the query handler and use the built-in query for fetching
// read models by identity to get our read model representing the
// state of our aggregate root
return(await resolver.Resolve <IQueryProcessor>().ProcessAsync(new ReadModelByIdQuery <CompetitionReadModel>(exampleId), CancellationToken.None));
}
public TestBase()
{
var services = new ServiceCollection();
var configuration = ConfigurationRootCreator.Create(services);
var elasticsearchUrl = configuration["ElasticsearchUrl"];
var connection = new ConnectionSettings(new Uri(elasticsearchUrl));
connection.DisableDirectStreaming(true);
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterModule <ElasticsearchReadModelModule>()
.RegisterModule <ElasticsearchQueryHandlersModule>()
.ConfigureElasticsearch(connection)
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
QueryProcessor = Resolver.Resolve <IQueryProcessor>();
var indexer = Resolver.Resolve <BookingReadModelIndexer>();
indexer.PrepareIndex();
}
/*
* Creates ContentObject from filename.
*/
static void CreateContentObjectFromFilename(
Node contentNode,
MimePart part,
IStreamService streamService,
IRootResolver rootResolver)
{
var filename = contentNode.GetEx <string>() ?? throw new HyperlambdaException("No [filename] value provided");
// Checking if explicit encoding was supplied.
ContentEncoding encoding = ContentEncoding.Default;
var encodingNode = contentNode.Children.FirstOrDefault(x => x.Name == "Content-Encoding");
if (encodingNode != null)
{
encoding = (ContentEncoding)Enum.Parse(typeof(ContentEncoding), encodingNode.GetEx <string>(), true);
}
// Checking if explicit disposition was specified.
if (part.ContentDisposition == null)
{
// Defaulting Content-Disposition to; "attachment; filename=whatever.xyz"
part.ContentDisposition = new ContentDisposition("attachment")
{
FileName = Path.GetFileName(filename)
};
}
part.Content = new MimeContent(
streamService.OpenFile(
rootResolver.AbsolutePath(filename.TrimStart('/'))),
encoding);
}
/*
* Creates a leaf part, implying no MimePart children.
*/
static MimePart CreateLeafPart(
string mainType,
string subType,
Node messageNode,
IStreamService streamService,
IRootResolver rootResolver)
{
// Retrieving [content] node.
var contentNode = messageNode.Children.FirstOrDefault(x => x.Name == "content" || x.Name == "filename") ??
throw new HyperlambdaException("No [content] or [filename] provided for your entity");
var result = new MimePart(ContentType.Parse(mainType + "/" + subType));
DecorateEntityHeaders(result, messageNode);
switch (contentNode.Name)
{
case "content":
CreateContentObjectFromObject(contentNode, result);
break;
case "filename":
CreateContentObjectFromFilename(contentNode, result, streamService, rootResolver);
break;
}
return(result);
}
public static void ValidateRegistrations(
this IRootResolver resolver)
{
var exceptions = new List <Exception>();
using (var scopeResolver = resolver.BeginScope())
{
foreach (var type in scopeResolver.GetRegisteredServices())
{
try
{
scopeResolver.Resolve(type);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
if (!exceptions.Any())
{
return;
}
var message = string.Join(", ", exceptions.Select(e => e.Message));
throw new AggregateException(message, exceptions);
}
public void Assert_Decorator()
{
// The order should be like this (like unwrapping a present with the order of
// wrapping paper applied)
//
// Call MagicClassDecorator2
// Call MagicClassDecorator1
// Call MagicClass
// Return to MagicClassDecorator1
// Return to MagicClassDecorator2
_sut.Decorate <IMagicInterface>((r, inner) => new MagicClassDecorator1(inner));
_sut.Decorate <IMagicInterface>((r, inner) => new MagicClassDecorator2(inner));
IRootResolver resolver = _sut.CreateResolver();
var magic = resolver.Resolve <IMagicInterface>();
magic.ShouldBeAssignableTo <MagicClassDecorator2>();
var magicClassDecorator2 = (MagicClassDecorator2)magic;
magicClassDecorator2.Inner.ShouldBeAssignableTo <MagicClassDecorator1>();
var magicClassDecorator1 = (MagicClassDecorator1)magicClassDecorator2.Inner;
magicClassDecorator1.Inner.ShouldBeAssignableTo <MagicClass>();
}
public void if_any_exception_appears_on_disposing_events_root_container_should_be_dispose_finally()
{
ISomeManager manager = null;
IRootResolver rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.RegisterServices(r =>
{
r.Register <ISomeManager, SomeManager>();
r.OnDisposing += (sender, args) =>
{
manager = args.Context.Resolver.Resolve <ISomeManager>();
manager.Shutdown();
throw new HandlerException();
};
})
.CreateResolver();
Action act = () => rootResolver.Dispose();
act.ShouldThrow <HandlerException>();
Action containerDisposedAction = () => rootResolver.Container.Resolve <ISomeManager>();
containerDisposedAction.ShouldThrow <ObjectDisposedException>();
Action rootResolverDisposedAction = () => rootResolver.Resolve <ISomeManager>();
rootResolverDisposedAction.ShouldThrow <ObjectDisposedException>();
manager.ShutdownCount.ShouldBe(1);
}
public static void Main(string[] args)
{
NHibernateProfiler.Initialize();
IRootResolver rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStove <StoveDemoBootstrapper>()
.UseStoveNullLogger()
.UseStoveNHibernate(nhCfg =>
{
nhCfg.FluentConfiguration
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(nhCfg.Configuration.DefaultNameOrConnectionString))
.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));
return(nhCfg);
})
.UseStoveDefaultConnectionStringResolver()
.UseStoveDapper()
.UseStoveEventBus()
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
using (rootResolver)
{
rootResolver.Resolve <ProductDomainService>().DoSomeCoolStuff();
}
NHibernateProfiler.Shutdown();
Console.ReadLine();
}
public void Assert_Service()
{
IRootResolver resolver = _sut.CreateResolver();
var magicInterface = resolver.Resolve <IMagicInterface>();
magicInterface.ShouldNotBeNull();
magicInterface.ShouldBeAssignableTo <MagicClass>();
}
public void SetUp()
{
_resolver = EventFlowOptions.New
.ConfigureShippingDomain()
.ConfigureShippingQueriesInMemory()
.CreateResolver();
_eventStore = _resolver.Resolve <IEventStore>();
_commandBus = _resolver.Resolve <ICommandBus>();
}
public TestBase()
{
BookingId = BookingId.New;
Resolver = EventFlowOptions.New
.ConfigureBookingDomain()
.CreateResolver();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
public TestBase()
{
Resolver = EventFlowOptions.New.ConfigureBookingDomain()
.ConfigureBookingCommands()
.ConfigureBookingCommandHandlers()
.ConfigureReadModel()
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
}
public void Initialize(ExtensionConfigContext context)
{
_resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
context.AddBindingRule <InjectAttribute>()
.BindToInput <dynamic>(inject => _resolver.Resolve(inject.Type));
}
/// <summary>
/// Creates an instance of your type.
/// </summary>
/// <param name="signaler">Signaler necessary to execute endpoint.</param>
/// <param name="fileService">Needed to resolve endpoint files.</param>
/// <param name="rootResolver">Needed to resolve root folder names.</param>
/// <param name="argumentsHandler">Needed to attach arguments to endpoint invocation.</param>
public HttpExecutorAsync(
ISignaler signaler,
IFileService fileService,
IRootResolver rootResolver,
IHttpArgumentsHandler argumentsHandler)
{
_signaler = signaler;
_fileService = fileService;
_rootResolver = rootResolver;
_argumentsHandler = argumentsHandler;
}
/*
* Commonalities between the move/copy folder/file async/sync implementations.
*/
public static void Execute(
ISignaler signaler,
IRootResolver resolver,
Node input,
string slot,
Action <string, string> functor)
{
SanityCheckInvocation(input, slot);
signaler.Signal("eval", input);
ExecuteImplementation(resolver, input, functor);
}
public SelectJourneysCommandHandlerTests()
{
_bookingId = BookingId.New;
_resolver = EventFlowOptions.New
.ConfigureBookingDomain()
.ConfigureBookingCommands()
.ConfigureBookingCommandHandlers()
.CreateResolver();
_commandBus = _resolver.Resolve <ICommandBus>();
_aggregateStore = _resolver.Resolve <IAggregateStore>();
}
/*
* Commonalities between the move/copy folder/file async/sync implementations.
*/
public static async Task ExecuteAsync(
ISignaler signaler,
IRootResolver resolver,
Node input,
string slot,
Action <string, string> functor)
{
SanityCheckInvocation(input, slot);
await signaler.SignalAsync("eval", input);
ExecuteImplementation(resolver, input, functor);
}
/// <summary>
/// Creates the container.
/// </summary>
/// <param name="iocBuilder">The ioc builder.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">
/// Make sure to configure the IocBuilder for Autofac using the
/// .UseAutofacContainerBuilder(...)
/// </exception>
public static IContainer CreateContainer(this IIocBuilder iocBuilder)
{
IRootResolver rootResolver = iocBuilder.CreateResolver();
var autofacRootResolver = rootResolver as RootResolver;
if (autofacRootResolver == null)
{
throw new InvalidOperationException(
"Make sure to configure the IocBuilder for Autofac using the .UseAutofacContainerBuilder(...)");
}
return(autofacRootResolver.Container);
}
private void PrepareIndexes(IRootResolver resolver)
{
_elasticClient = resolver.Resolve <IElasticClient>();
var readModelTypes =
GetLoadableTypes <ElasticsearchTypeAttribute>(typeof(ElasticsearchThingyReadModel).Assembly);
foreach (var readModelType in readModelTypes)
{
var esType = readModelType.GetTypeInfo()
.GetCustomAttribute <ElasticsearchTypeAttribute>();
//var indexName = GetIndexName(esType.RelationName);
var aliasResponse = _elasticClient.Indices.GetAlias(esType.RelationName);
var alias2Response = _elasticClient.GetAliasesPointingToIndex(esType.RelationName);
var indexResponse = _elasticClient.Indices.Get(esType.RelationName);
if (aliasResponse.ApiCall.Success)
{
if (aliasResponse.Indices != null)
{
foreach (var indice in aliasResponse?.Indices)
{
_elasticClient.Indices.DeleteAlias(
indice.Key,
esType.RelationName
);
_elasticClient.Indices.Delete(
indice.Key,
d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound))
);
}
_elasticClient.Indices.Delete(
esType.RelationName,
d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound))
);
}
}
var indexName = GetIndexName(esType.RelationName);
_indexes.Add(indexName);
_elasticClient.Indices.Create(indexName, c => c
.Settings(s => s
.NumberOfShards(1)
.NumberOfReplicas(0))
.Aliases(a => a.Alias(esType.RelationName)));
}
}
public static void Main(string[] args)
{
EntityFrameworkProfiler.Initialize();
Database.SetInitializer(new NullDatabaseInitializer <AnimalStoveDbContext>());
Database.SetInitializer(new NullDatabaseInitializer <PersonStoveDbContext>());
IRootResolver resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStove <StoveDemoBootstrapper>(false)
.UseStoveEntityFramework()
.UseStoveDapper()
.UseStoveMapster()
.UseStoveEventBus()
.UseStoveDbContextEfTransactionStrategy()
.UseStoveTypedConnectionStringResolver()
.UseStoveNLog()
.UseStoveBackgroundJobs()
.UseStoveRedisCaching()
.UseStoveRabbitMQ(configuration =>
{
configuration.HostAddress = "rabbitmq://localhost/";
configuration.Username = "******";
configuration.Password = "******";
configuration.QueueName = "Default";
return(configuration);
})
.UseStoveHangfire(configuration =>
{
configuration.GlobalConfiguration
.UseSqlServerStorage("Default")
.UseNLogLogProvider();
return(configuration);
})
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
//var someDomainService = resolver.Resolve<SomeDomainService>();
//someDomainService.DoSomeStuff();
var productDomainService = resolver.Resolve <ProductDomainService>();
productDomainService.DoSomeStuff();
resolver.Dispose();
EntityFrameworkProfiler.Shutdown();
Console.ReadKey();
}
public TestBase()
{
var services = new ServiceCollection();
ConfigurationRootCreator.Create(services);
BookingId = BookingId.New;
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
.CreateResolver();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
public OnDisposingEvent_Tests()
{
_rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.RegisterServices(r =>
{
r.Register <ISomeManager, SomeManager>();
r.OnDisposing += (sender, args) =>
{
_manager = args.Context.Resolver.Resolve <ISomeManager>();
_manager.Shutdown();
};
})
.CreateResolver();
}
public void Test()
{
IEventFlowOptions eventFlow = EventFlowOptions.New
.AddDefaults(typeof(CustomerTests).Assembly);
CustomerDefinition.Define(eventFlow);
IRootResolver resolver = eventFlow.CreateResolver();
ICommandBus bus = resolver.Resolve <ICommandBus>();
CustomerId aggregateId = CustomerId.New;
bus.PublishAsync(new CreateCustomer(aggregateId), CancellationToken.None);
bus.PublishAsync(new DeleteCustomer(aggregateId), CancellationToken.None);
}
/// <summary>
/// Creates the resolver.
/// </summary>
/// <param name="ignoreStartableComponents"></param>
/// <returns></returns>
public IRootResolver CreateResolver(bool ignoreStartableComponents = false)
{
BeforeRegistrationCompleted?.Invoke(this, new BeforeRegistrationCompletedEventArgs(_containerBuilder));
IContainer container = _containerBuilder.Build(ignoreStartableComponents ? ContainerBuildOptions.IgnoreStartableComponents : ContainerBuildOptions.None);
_rootResolver = new RootResolver(container);
EventHandler <RegistrationCompletedEventArgs> handler = RegistrationCompleted;
handler?.Invoke(this, new RegistrationCompletedEventArgs(_rootResolver));
_rootResolver.OnDisposing += (sender, args) => { OnServicesDisposing(args.Context.Resolver); };
return(_rootResolver);
}
/*
* Creates a multipart of some sort.
*/
static Multipart CreateMultipart(
ISignaler signaler,
string subType,
Node messageNode,
IStreamService streamService,
IRootResolver rootResolver)
{
var result = new Multipart(subType);
DecorateEntityHeaders(result, messageNode);
foreach (var idxPart in messageNode.Children.Where(x => x.Name == "entity"))
{
result.Add(Create(signaler, idxPart, streamService, rootResolver));
}
return(result);
}
public TestBase()
{
var services = new ServiceCollection();
ConfigurationRootCreatorForTesting.Create(services);
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <FlightAvailabilityDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterServices(r => r.Register <IDbContextProvider <EventStoreContext>, FakedEventStoreContextProvider>())
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
AggregateStore = Resolver.Resolve <IAggregateStore>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().AddControllersAsServices();
IRootResolver resolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStoveWithNullables <StoveWebApiCoreBootstrapper>()
.RegisterServices(r =>
{
r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly());
r.BeforeRegistrationCompleted += (sender, args) =>
{
args.ContainerBuilder.Populate(services);
};
}).CreateResolver();
return(new AutofacServiceProvider(resolver.Container));
}
/*
* Actual implementation retrieving source and destination,
* for the to invoke lambda callback supplied by caller.
*/
static void ExecuteImplementation(
IRootResolver rootResolver,
Node input,
Action <string, string> functor)
{
// Retrieving source path.
string sourcePath = PathResolver.CombinePaths(
rootResolver.RootFolder,
input.GetEx <string>());
// Retrieving destination path.
var destinationPath = PathResolver
.CombinePaths(
rootResolver.RootFolder,
input.Children.First().GetEx <string>());
// Sanity checking arguments.
functor(sourcePath, destinationPath);
}
public Bootstrap()
{
var mquri = new Uri("amqp://*****:*****@127.0.0.1");
var mqconf = RabbitMqConfiguration.With(
mquri, true, 5, "loxnet"
);
_resolver = EventFlowOptions.New
.ConfigureTransportDomain()
.UseConsoleLog()
.PublishToRabbitMq(mqconf)
.CreateResolver();
_aggregateStore = _resolver
.Resolve <IAggregateStore>();
_commandBus = _resolver
.Resolve <ICommandBus>();
}
public TestBase()
{
var services = new ServiceCollection();
var runner = MongoDbRunner.Start();
Resolver = EventFlowOptions.New
.UseServiceCollection(services)
.RegisterModule <BookingDomainModule>()
.RegisterModule <CommandModule>()
.RegisterModule <CommandHandlersModule>()
.RegisterModule <MongoDbReadModelModule>()
.RegisterModule <MongoDbQueryHandlersModule>()
.ConfigureMongoDb(runner.ConnectionString, "restairline")
.CreateResolver();
CommandBus = Resolver.Resolve <ICommandBus>();
QueryProcessor = Resolver.Resolve <IQueryProcessor>();
}
public override IRootResolver CreateRootResolver(IEventFlowOptions eventFlowOptions)
{
// Disable SSL certificate validation
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
var url = Environment.GetEnvironmentVariable("ELASTICSEARCH_URL");
if (string.IsNullOrEmpty(url))
{
Assert.Inconclusive("The environment variabel named 'ELASTICSEARCH_URL' isn't set. Set it to e.g. 'http://localhost:9200'");
}
_resolver = eventFlowOptions
.ConfigureElasticsearch(new Uri(url))
.UseElasticsearchReadModel<ElasticsearchTestAggregateReadModel>()
.CreateResolver();
_elasticClient = _resolver.Resolve<IElasticClient>();
_readModelPopulator = _resolver.Resolve<IReadModelPopulator>();
_readModelDescriptionProvider = _resolver.Resolve<IReadModelDescriptionProvider>();
_readModelStore = _resolver.Resolve<IElasticsearchReadModelStore<ElasticsearchTestAggregateReadModel>>();
return _resolver;
}
