static void Main(string[] args) { var rawRabbitOptions = new RawRabbitOptions { ClientConfiguration = GetRawRabbitConfiguration() }; var busClient = RawRabbitFactory.CreateSingleton(); try { var qq = busClient.SubscribeAsync <CreateInvoiceCommand>(async(msg) => { await Handle(msg); }, CFG => CFG.UseSubscribeConfiguration(F => F.Consume(c => c .WithRoutingKey("createinvoicecommand1")) .OnDeclaredExchange(E => E .WithName("amq.direct") .WithType(ExchangeType.Direct)) .FromDeclaredQueue(q => q .WithName("createinvoicecommand1")) )); } catch (Exception e) { Console.WriteLine(e.Message); } Console.ReadKey(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); /* var builder = new ConfigurationBuilder().AddConfiguration(Configuration); * services.AddRawRabbit(cfg =>cfg.AddJsonFile("rawrabbit.json")); */ /* services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); * var options = new RawRabbitOptions(); * var section = Configuration.GetSection("rabbitmq"); * section.Bind(options); * * services.AddRawRabbit(options); * var service = new ServiceCollection() * .AddRawRabbit<CustomContext>() * .BuildServiceProvider(); * var client = service.GetService<IBusClient<CustomContext>>(); */ var options = new RawRabbitOptions(); var section = Configuration.GetSection("rabbitmq"); section.Bind(options); var client = RawRabbitFactory.CreateSingleton(options); services.AddSingleton <IBusClient>(_ => client); services.AddSingleton <IRepository, InMemoryRepository>(); services.AddTransient <IEventHandler <ValueCalculatedEvent>, ValueCalculatedHandler>(); }
public static IKernel RegisterRawRabbit(this IKernel config, RawRabbitOptions options = null) { if (options != null) { config.Bind <RawRabbitOptions>().ToConstant(options); } config.Load <RawRabbitModule>(); return(config); }
public static void ConfigureRawRabbit(IServiceCollection services, RawRabbitConfiguration configuration) { var options = new RawRabbitOptions { ClientConfiguration = configuration, Plugins = p => p.UseAttributeRouting() }; services.AddRawRabbit(options); }
public static void AddRabbitMq(this IServiceCollection services, IConfigurationSection configuration) { var config = configuration.Get <RawRabbitConfiguration>(); RawRabbitOptions options = new RawRabbitOptions() { ClientConfiguration = config }; var client = RawRabbitFactory.CreateSingleton(options); services.AddSingleton <IBusClient>(_ => client); }
public static void AddRabbitMqHealthCheck(this IServiceCollection services, IConfigurationSection configuration) { var config = configuration.Get <RawRabbitConfiguration>(); RawRabbitOptions options = new RawRabbitOptions() { ClientConfiguration = config }; services.AddHealthChecks().AddCheck("RabbitMq check", new RabbitMqHealthCheck(config), tags: new List <string> { "order queue", "payment queue" }); }
static async Task Main(string[] args) { var host = new HostBuilder() .ConfigureHostConfiguration(configurationBuilder => { configurationBuilder.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); configurationBuilder.AddEnvironmentVariables(); }) .ConfigureLogging((hostContext, loggerBuilder) => { loggerBuilder.AddConsole(); }) .ConfigureServices((hostContext, services) => { services.AddFighting(fightBuilder => { fightBuilder.ConfigureCacheing(cacheBuilder => { cacheBuilder.UseRedisCache(options => { options.ConnectionString = hostContext.Configuration.GetConnectionString("Fighting.Redis"); }); }); fightBuilder.ConfigureMessageServices(messageServiceBuilder => { messageServiceBuilder.UseLotteryDispatchingMessagePublisher(); messageServiceBuilder.UseLotteryNoticingMessagePublisher(); }); fightBuilder.ConfigureLotteryDispatcher(dispatchBuilder => { var dispatcherOptions = hostContext.Configuration.GetSection("DispatcherConfiguration").Get <DispatcherConfiguration>(); dispatchBuilder.UseSuicaiExecuteDispatcher(dispatcherOptions); }); RawRabbitOptions Options = new RawRabbitOptions { ClientConfiguration = hostContext.Configuration.GetSection("RawRabbitConfiguration").Get <RawRabbitConfiguration>() }; services.AddRawRabbit(Options); }); }); await host.RunConsoleAsync(); }
public static IBusClient CreateClient(RawRabbitOptions options = null) { options = options ?? new RawRabbitOptions(); options.DependencyInjection = options.DependencyInjection ?? (register => { }); options.DependencyInjection += register => register.AddSingleton <IConfigurationEvaluator, ConfigurationEvaluator>(); options.ClientConfiguration = options?.ClientConfiguration ?? RawRabbitConfiguration.Local; options.Plugins = options.Plugins ?? (builder => { }); options.Plugins += builder => builder .UseMessageContext(context => new MessageContext { GlobalRequestId = Guid.NewGuid() }) .UseContextForwarding(); var simpleIoc = new SimpleDependencyInjection(); var client = Instantiation.RawRabbitFactory.CreateSingleton(options, simpleIoc, ioc => simpleIoc); return(new BusClient(client, simpleIoc.GetService <IConfigurationEvaluator>())); }
static void Main(string[] args) { var rawRabbitOptions = new RawRabbitOptions { ClientConfiguration = GetRawRabbitConfiguration() }; var busClient = RawRabbitFactory.CreateSingleton(); var qq = busClient.SubscribeAsync <CreateInvoiceCommand>(async(msg) => { await Handle(msg); }, CFG => CFG.UseSubscribeConfiguration(F => F.OnDeclaredExchange(E => E.WithName("")) .FromDeclaredQueue(q => q.WithName("createinvoicecommand"))) ); Console.ReadKey(); }
private static void ConfigureBus(IServiceCollection services, IConfiguration configuration) { var rawRabbitOptions = configuration.GetOptions <RabbitMqOptions>(SectionName); var rawRabbitConfiguration = configuration.GetOptions <RawRabbitConfiguration>(SectionName); var namingConventions = new CustomNamingConventions(rawRabbitOptions.Namespace); var options = new RawRabbitOptions { DependencyInjection = ioc => { ioc.AddSingleton(rawRabbitOptions); ioc.AddSingleton(rawRabbitConfiguration); ioc.AddSingleton <INamingConventions>(namingConventions); }, Plugins = p => p.UseAttributeRouting().UseMessageContext <CorrelationContext>().UseContextForwarding() }; services.AddRawRabbit(options); }
public static void AddRabbitMq(this IServiceCollection services, IConfiguration configuration) { var options = new RabbitMqOptions(); var section = configuration.GetSection("rabbitmq"); var namingConventions = new CustomNamingConventions(options.Namespace); section.Bind(options); var rawRabbitOptions = new RawRabbitOptions { ClientConfiguration = options, DependencyInjection = ioc => { ioc.AddSingleton <INamingConventions>(namingConventions); } }; var client = RawRabbitFactory.CreateSingleton(rawRabbitOptions); services.AddSingleton <IBusClient>(_ => client); }
static void Main(string[] args) { var rawRabbitOptions = new RawRabbitOptions { ClientConfiguration = GetRawRabbitConfiguration() }; var busClient = RawRabbitFactory.CreateSingleton(); var random = new Random(); while (true) { var message = random.Next(1, 1000); var cmd = new CreateInvoiceCommand() { Name = message.ToString() }; busClient.PublishAsync(cmd, CFG => CFG.UsePublishConfiguration(C => C.OnExchange("amq.direct") .WithRoutingKey("createinvoicecommand1") )); Console.WriteLine($"{DateTime.Now} Sended: {cmd.Name}"); Thread.Sleep(2000); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.AddSingleton <ICalculate, Calculate>(); services.AddTransient <ICommandHandler <CalculateValueCommand>, CalculateValueHandler>(); /* var options = new RawRabbitOptions(); * var section = Configuration.GetSection("rabbitmq"); * section.Bind(options); * * services.AddRawRabbit(options); */ var options = new RawRabbitOptions(); var section = Configuration.GetSection("rabbitmq"); section.Bind(options); var client = RawRabbitFactory.CreateSingleton(options); services.AddSingleton <IBusClient>(_ => client); }
public static ContainerBuilder RegisterRawRabbit(this ContainerBuilder builder, RawRabbitOptions options = null) { builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource(type => type.Namespace.StartsWith(RawRabbit))); var adapter = new ContainerBuilderAdapter(builder); adapter.AddRawRabbit(options); return(builder); }
public static IDependencyRegister AddRawRabbit(this IDependencyRegister register, RawRabbitOptions options = null) { register .AddSingleton(options?.ClientConfiguration ?? RawRabbitConfiguration.Local) .AddSingleton <IConnectionFactory, ConnectionFactory>(provider => { var cfg = provider.GetService <RawRabbitConfiguration>(); return(new ConnectionFactory { VirtualHost = cfg.VirtualHost, UserName = cfg.Username, Password = cfg.Password, Port = cfg.Port, HostName = cfg.Hostnames.FirstOrDefault() ?? string.Empty, AutomaticRecoveryEnabled = cfg.AutomaticRecovery, TopologyRecoveryEnabled = cfg.TopologyRecovery, NetworkRecoveryInterval = cfg.RecoveryInterval, ClientProperties = provider.GetService <IClientPropertyProvider>().GetClientProperties(cfg), Ssl = cfg.Ssl }); }) .AddSingleton <IChannelPoolFactory, AutoScalingChannelPoolFactory>() .AddSingleton(resolver => AutoScalingOptions.Default) .AddSingleton <IClientPropertyProvider, ClientPropertyProvider>() .AddSingleton <ISerializer>(resolver => new Serialization.JsonSerializer(new Newtonsoft.Json.JsonSerializer { TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple, Formatting = Formatting.None, CheckAdditionalContent = true, ContractResolver = new DefaultContractResolver { NamingStrategy = new CamelCaseNamingStrategy() }, ObjectCreationHandling = ObjectCreationHandling.Auto, DefaultValueHandling = DefaultValueHandling.Ignore, TypeNameHandling = TypeNameHandling.Auto, ReferenceLoopHandling = ReferenceLoopHandling.Serialize, MissingMemberHandling = MissingMemberHandling.Ignore, PreserveReferencesHandling = PreserveReferencesHandling.Objects, NullValueHandling = NullValueHandling.Ignore })) .AddSingleton <IConsumerFactory, ConsumerFactory>() .AddSingleton <IChannelFactory>(resolver => { var channelFactory = new ChannelFactory(resolver.GetService <IConnectionFactory>(), resolver.GetService <RawRabbitConfiguration>()); channelFactory .ConnectAsync() .ConfigureAwait(false) .GetAwaiter() .GetResult(); return(channelFactory); }) .AddSingleton <ISubscriptionRepository, SubscriptionRepository>() .AddSingleton <ITopologyProvider, TopologyProvider>() .AddTransient <IPublisherConfigurationFactory, PublisherConfigurationFactory>() .AddTransient <IBasicPublishConfigurationFactory, BasicPublishConfigurationFactory>() .AddTransient <IConsumerConfigurationFactory, ConsumerConfigurationFactory>() .AddTransient <IConsumeConfigurationFactory, ConsumeConfigurationFactory>() .AddTransient <IExchangeDeclarationFactory, ExchangeDeclarationFactory>() .AddTransient <IQueueConfigurationFactory, QueueDeclarationFactory>() .AddSingleton <INamingConventions, NamingConventions>() .AddSingleton <IExclusiveLock, ExclusiveLock>() .AddSingleton <IBusClient, BusClient>() .AddSingleton <IResourceDisposer, ResourceDisposer>() .AddTransient <IInstanceFactory>(resolver => new InstanceFactory(resolver)) .AddSingleton <IPipeContextFactory, PipeContextFactory>() .AddTransient <IExtendedPipeBuilder, PipeBuilder>(resolver => new PipeBuilder(resolver)) .AddSingleton <IPipeBuilderFactory>(provider => new PipeBuilderFactory(provider)); var clientBuilder = new ClientBuilder(); options?.Plugins?.Invoke(clientBuilder); clientBuilder.DependencyInjection?.Invoke(register); register.AddSingleton(clientBuilder.PipeBuilderAction); options?.DependencyInjection?.Invoke(register); return(register); }
public static IServiceCollection AddRawRabbit(this IServiceCollection collection, RawRabbitOptions options = null) { var adapter = new ServiceCollectionAdapter(collection); adapter.AddRawRabbit(options); options?.DependencyInjection?.Invoke(adapter); return(collection); }