private static IContainer BuildContainer(IConfiguration configuration)
{
var services = new ServiceCollection();
services.AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Information);
logging.AddConsole();
});
var containerBuilder = new ContainerBuilder();
containerBuilder.Populate(services);
containerBuilder.RegisterType<Account>()
.AsSelf()
.InstancePerDependency();
containerBuilder.RegisterType<AccountBalanceMinion>()
.AsSelf()
.InstancePerDependency();
var builder = new AutofacClaptrapBootstrapperBuilder(new NullLoggerFactory(), containerBuilder);
var claptrapBootstrapper = builder
.ScanClaptrapModule()
.AddConfiguration(configuration)
.ScanClaptrapDesigns(new[]
{
typeof(IAccount),
typeof(Account),
typeof(IAccountBalanceMinion),
typeof(AccountBalanceMinion),
})
.Build();
claptrapBootstrapper.Boot();
var container = containerBuilder.Build();
return container;
}
public static IHostBuilder UseClaptrap(this IHostBuilder hostBuilder,
Action <IClaptrapBootstrapperBuilder> builderAction,
Action <ContainerBuilder>?containerBuilderAction = null)
{
return(hostBuilder
.ConfigureServices((context, collection) =>
{
var configSection =
context.Configuration.GetSection(ClaptrapServerOptions.ConfigurationSectionName);
collection.Configure <ClaptrapServerOptions>(configSection);
})
.UseServiceProviderFactory(context =>
{
var serviceProviderFactory = new AutofacServiceProviderFactory(
builder =>
{
var collection = new ServiceCollection().AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Debug);
});
var buildServiceProvider = collection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
bootstrapperBuilder
.ScanClaptrapModule()
.AddConfiguration(context);
builderAction.Invoke(bootstrapperBuilder);
var claptrapBootstrapper = bootstrapperBuilder.Build();
claptrapBootstrapper.Boot();
containerBuilderAction?.Invoke(builder);
});
return serviceProviderFactory;
}));
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
var loggerFactory = new ServiceCollection()
.AddLogging(logging => logging.AddConsole())
.BuildServiceProvider()
.GetRequiredService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory);
_claptrapBootstrapper = (AutofacClaptrapBootstrapper)bootstrapperBuilder
.ScanClaptrapModule()
.AddConfiguration(configuration)
.ScanClaptrapDesigns(new[]
{
typeof(IAccount),
typeof(Account),
typeof(IAccountBalanceMinion),
typeof(AccountBalanceMinion),
typeof(IAccountHistoryBalanceMinion),
typeof(AccountHistoryBalanceMinion)
})
.ConfigureClaptrapDesign(x =>
x.ClaptrapOptions.EventCenterOptions.EventCenterType = EventCenterType.None)
.Build();
_claptrapDesignStore = _claptrapBootstrapper.DumpDesignStore();
}
/// <summary>
/// Get attribute based claptrap design. It is used in unit test in common.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static IClaptrapDesign GetDesign(Type type)
{
var claptrapBootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder()
.ScanClaptrapDesigns(new[] { type })
.SetDesignValidation(false)
.Build();
var claptrapDesignStore = claptrapBootstrapperBuilder.DumpDesignStore();
var claptrapDesign = claptrapDesignStore.First();
return(claptrapDesign);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup <Startup>(); })
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
})
.UseNLog()
.UseOrleansClaptrap()
.ConfigureAppConfiguration(builder =>
{
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("appsettings.json");
var config = configBuilder.Build();
var options = new BurningDatabaseOptions();
config.GetSection("BurningDatabase").Bind(options);
builder.AddJsonFile($"Claptrap/claptrap.{options.DatabaseType:G}.json");
})
.ConfigureServices((context, collection) =>
{
collection.Configure <BurningDatabaseOptions>(options =>
{
context.Configuration.GetSection("BurningDatabase").Bind(options);
});
})
.UseServiceProviderFactory(context =>
{
var serviceProviderFactory = new AutofacServiceProviderFactory(
builder =>
{
builder.RegisterModule <BurningModule>();
var collection = new ServiceCollection()
.AddLogging(logging => { logging.SetMinimumLevel(LogLevel.Debug); });
var buildServiceProvider = collection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
var claptrapBootstrapper = bootstrapperBuilder
.ScanClaptrapModule()
.AddConfiguration(context)
.ScanClaptrapDesigns(new[]
{
typeof(Burning).Assembly
})
.Build();
claptrapBootstrapper.Boot();
});
return(serviceProviderFactory);
});
public void NothingAdded()
{
var serviceCollection = new ServiceCollection().AddLogging(logging => logging.AddConsole());
var buildServiceProvider = serviceCollection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetRequiredService <ILoggerFactory>();
using var mocker = AutoMockHelper.Create();
var containerBuilder = new ContainerBuilder();
var builder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, containerBuilder);
var claptrapBootstrapper = builder.Build();
claptrapBootstrapper.Should().NotBeNull();
}
static async Task Main(string[] args)
{
var hostBuilder = new SiloHostBuilder();
hostBuilder
.UseLocalhostClustering()
.UseServiceProviderFactory(collection =>
{
collection.AddLogging(logging =>
{
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Debug);
logging.AddFilter((s, level) => s.StartsWith("Orleans") && level >= LogLevel.Warning);
logging.AddFilter((s, level) => s.Contains("Claptrap"));
});
var builder = new ContainerBuilder();
builder.Populate(collection);
var buildServiceProvider = collection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
var claptrapBootstrapper = bootstrapperBuilder
.ScanClaptrapModule()
.UseSQLiteAsTestingStorage()
.ScanClaptrapDesigns(new[]
{
typeof(ArticleGrain).Assembly
})
.Build();
claptrapBootstrapper.Boot();
var container = builder.Build();
var serviceProvider = new AutofacServiceProvider(container);
return(serviceProvider);
})
.ConfigureApplicationParts(manager =>
manager.AddFromDependencyContext().WithReferences())
;
var siloHost = hostBuilder.Build();
Console.WriteLine("server starting");
await siloHost.StartAsync();
Console.WriteLine("server started");
Console.ReadLine();
}
private static IClaptrapBootstrapper CreateClaptrapBootstrapper(ILoggerFactory loggerFactory,
ContainerBuilder builder)
{
var claptrapBootstrapperBuilder =
new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
var bootstrapper = claptrapBootstrapperBuilder
.ScanClaptrapModule()
.ScanClaptrapDesigns(new[]
{
typeof(IAccountClaptrap).Assembly
})
.UseSQLiteAsTestingStorage()
.Build();
return(bootstrapper);
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
var loggerFactory = new ServiceCollection()
.AddLogging(logging => logging.AddConsole())
.BuildServiceProvider()
.GetRequiredService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory);
_claptrapBootstrapper = (AutofacClaptrapBootstrapper)bootstrapperBuilder
.ScanClaptrapModule()
.AddConfiguration(configuration)
.ScanClaptrapDesigns(new[] { typeof(SeatActor).Assembly })
.Build();
_claptrapDesignStore = _claptrapBootstrapper.DumpDesignStore();
}
private static IContainer CreateContainer()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(logging => logging.AddConsole());
var builder = new ContainerBuilder();
builder.Populate(serviceCollection);
var autofacClaptrapBootstrapperBuilder =
new AutofacClaptrapBootstrapperBuilder(new NullLoggerFactory(), builder);
var claptrapBootstrapper = autofacClaptrapBootstrapperBuilder
.ScanClaptrapDesigns(new[] { typeof(SagaClaptrap).Assembly })
.ScanClaptrapModule()
.ConfigureClaptrapDesign(x =>
x.ClaptrapOptions.EventCenterOptions.EventCenterType = EventCenterType.None)
.UseSQLiteAsTestingStorage()
.Build();
claptrapBootstrapper.Boot();
builder.RegisterType <SagaClaptrap>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <TestStep1>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <TestStep2>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <CompensateStep1>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <CompensateStep2>()
.AsSelf()
.InstancePerLifetimeScope();
builder.RegisterType <ExceptionStep>()
.AsSelf()
.InstancePerLifetimeScope();
var container = builder.Build();
return(container);
}
public void NothingAdded()
{
var serviceCollection = new ServiceCollection()
.AddLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddNLog();
});
var buildServiceProvider = serviceCollection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetRequiredService <ILoggerFactory>();
using var mocker = AutoMockHelper.Create();
var containerBuilder = new ContainerBuilder();
containerBuilder.Populate(serviceCollection);
var builder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, containerBuilder);
var claptrapBootstrapper = builder.Build();
claptrapBootstrapper.Should().NotBeNull();
}
public static IHost BuildHost(
DatabaseType databaseType,
RelationLocatorStrategy strategy,
IEnumerable <string> configJsonFilenames,
Action <ContainerBuilder> builderAction = null,
Action <IClaptrapBootstrapperBuilder> bootstrapperAction = null,
Action <HostBuilder> configureHostBuilder = null)
{
var hostBuilder = new HostBuilder();
hostBuilder
.ConfigureAppConfiguration(configurationBuilder =>
{
configurationBuilder
.AddJsonFile("configs/appsettings.json")
.AddJsonFile($"configs/db_configs/claptrap.{databaseType:G}.json".ToLower())
.AddJsonFile($"configs/db_configs/claptrap.{databaseType:G}.{strategy:G}.json".ToLower());
foreach (var filename in configJsonFilenames)
{
configurationBuilder.AddJsonFile(filename);
}
configurationBuilder.AddEnvironmentVariables();
})
.ConfigureServices(collection =>
{
collection.AddLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddNLog();
});
})
.UseServiceProviderFactory(context =>
{
return(new AutofacServiceProviderFactory(builder =>
{
var loggerFactory = new ServiceCollection()
.AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Trace);
logging.AddConsole();
})
.BuildServiceProvider()
.GetRequiredService <ILoggerFactory>();
var claptrapBootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory)
.ScanClaptrapModule()
.AddConfiguration(context.Configuration)
.ScanClaptrapDesigns(new[]
{
typeof(IAccount),
typeof(Account),
typeof(IAccountBalanceMinion),
typeof(AccountBalanceMinion),
typeof(IAccountHistoryBalanceMinion),
typeof(AccountHistoryBalanceMinion)
})
.ConfigureClaptrapDesign(x =>
x.ClaptrapOptions.EventCenterOptions.EventCenterType = EventCenterType.None);
bootstrapperAction?.Invoke(claptrapBootstrapperBuilder);
var claptrapBootstrapper =
(AutofacClaptrapBootstrapper)claptrapBootstrapperBuilder
.Build();
claptrapBootstrapper.Boot(builder);
builder.RegisterType <Account>()
.AsSelf()
.InstancePerDependency();
builder.RegisterType <AccountBalanceMinion>()
.AsSelf()
.InstancePerDependency();
builderAction?.Invoke(builder);
}));
})
.ConfigureServices((_, collection) => { collection.AddClaptrapServerOptions(); });
configureHostBuilder?.Invoke(hostBuilder);
var host = hostBuilder.Build();
return(host);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseOrleansClaptrap()
.UseOrleans((context, builder) =>
{
var config = context.Configuration.GetSection(ClaptrapServeringOptions.ConfigurationSectionName);
var claptrapConfig = new ClaptrapClusteringOptions();
config.Bind(claptrapConfig);
if (claptrapConfig?.Orleans?.EnableDashboard == true)
{
builder.UseDashboard(options => options.Port = 9000);
}
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(LogLevel.Trace);
})
.UseNLog()
.UseServiceProviderFactory(context =>
{
var serviceProviderFactory = new AutofacServiceProviderFactory(
builder =>
{
builder.RegisterModule <RepositoryModule>();
var collection = new ServiceCollection().AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Debug);
});
var buildServiceProvider = collection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
var claptrapBootstrapper = bootstrapperBuilder
.ScanClaptrapModule()
.AddDefaultConfiguration(context)
.ScanClaptrapDesigns(new[]
{
typeof(UserGrain).Assembly
})
.UsePostgreSQL(mysql =>
mysql
.AsEventStore(eventStore =>
eventStore.SharedTable())
.AsStateStore(stateStore =>
stateStore.SharedTable())
)
.Build();
claptrapBootstrapper.Boot();
});
return(serviceProviderFactory);
})
#if !DEBUG
.UseOrleans((context, siloBuilder) =>
{
siloBuilder
.UseConsulClustering(options =>
{
options.Address =
new Uri(context.Configuration["Claptrap:Orleans:Clustering:ConsulUrl"]);
})
.ConfigureApplicationParts(manager =>
manager.AddFromDependencyContext().WithReferences());
})
#endif
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup <Startup>(); });
public static async Task Old()
{
var services = new ServiceCollection();
services.AddLogging(logging =>
{
// logging.AddConsole();
});
var containerBuilder = new ContainerBuilder();
containerBuilder.Populate(services);
containerBuilder.RegisterType <Burning>()
.AsSelf()
.InstancePerDependency();
var builder = new AutofacClaptrapBootstrapperBuilder(new NullLoggerFactory(), containerBuilder);
var claptrapBootstrapper = builder
.ScanClaptrapDesigns(new[]
{
typeof(Burning),
typeof(IBurning),
})
.ScanClaptrapModule()
.UseSQLiteAsTestingStorage()
.Build();
claptrapBootstrapper.Boot();
var container = containerBuilder.Build();
var factory = container.Resolve <Burning.Factory>();
var sw = Stopwatch.StartNew();
const int maxBurningCount = 100;
var burnings = Enumerable.Range(0, maxBurningCount)
.Select(x => factory.Invoke(new ClaptrapIdentity(x.ToString(), Codes.Burning)))
.ToArray();
await Task.WhenAll(burnings.Select(x => x.ActivateAsync()));
Console.WriteLine($"cost {sw.ElapsedMilliseconds} ms to activate all");
var total = Stopwatch.StartNew();
var rd = new Random();
for (var i = 0; i < 1_000_000; i++)
{
sw.Restart();
var tasks = Enumerable.Range(0, 1_000)
.Select(x =>
{
var id = rd.Next(0, maxBurningCount);
return(burnings[id].HandleOneAsync());
})
.ToArray();
await Task.WhenAll(tasks);
Console.WriteLine($"cost {sw.ElapsedMilliseconds} ms, {i}");
}
Console.WriteLine($"total cost {total.ElapsedMilliseconds} ms");
// var container = containerBuilder.Build();
// var factory = (ClaptrapFactory) container.Resolve<IClaptrapFactory>();
// var id = new ClaptrapIdentity("1", Codes.Burning);
// var lifetimeScope = factory.BuildClaptrapLifetimeScope(id);
// var eventSaver = lifetimeScope.Resolve<IEventSaver>();
// var sw = Stopwatch.StartNew();
//
// var total = Stopwatch.StartNew();
// for (var i = 0; i < 1_000_000; i++)
// {
// sw.Restart();
// const int batchItemCount = 1_000;
// var tasks = Enumerable.Range(i * batchItemCount, batchItemCount)
// .Select(x =>
// {
// var unitEvent = new UnitEvent(id, Codes.BurningEvent,
// UnitEvent.UnitEventData.Create())
// {
// Version = x,
// };
// return eventSaver.SaveEventAsync(unitEvent);
// });
// await Task.WhenAll(tasks);
// Thread.Sleep(1);
// Console.WriteLine($"cost {sw.ElapsedMilliseconds} ms, {(i + 1) * batchItemCount}");
// }
//
// Console.WriteLine($"total cost {total.ElapsedMilliseconds} ms");
}
