private string RabbitConnectionChecker()
{
var connstr = Config.GetString("jobmoni:rabbitconn", "");
if (string.IsNullOrWhiteSpace(connstr))
{
return(null);
}
try
{
RabbitMQ.Client.ConnectionFactory cf = new RabbitMQ.Client.ConnectionFactory();
cf.AutomaticRecoveryEnabled = true;
cf.Uri = connstr;
cf.RequestedConnectionTimeout = 5000;
var currConn = cf.CreateConnection();
var md = currConn.CreateModel();
md.Close();
currConn.Close();
return(null);
}
catch (Exception ex)
{
return("rabbit状态异常！");
}
}
public void Should_be_able_to_configure_EasyNetQ_to_allow_message_with_a_blank_type_field()
{
var are = new System.Threading.AutoResetEvent(false);
var validation = new NullMessageValidator();
var bus = RabbitHutch.CreateBus("host=localhost", r =>
r.Register <IMessageValidationStrategy>(x => validation));
bus.Subscribe <MyMessage>("null_validation_test", message =>
{
Console.Out.WriteLine("Got message: {0}", message.Text);
are.Set();
});
// now use the basic client API to publish some JSON to the message type exchange ...
var factory = new RabbitMQ.Client.ConnectionFactory
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string exchange = "EasyNetQ_Tests_MyMessage:EasyNetQ_Tests";
const string routingKey = "#";
const string bodyString = "{ Text: \"Hello from Mr Raw :)\" }";
var body = System.Text.Encoding.UTF8.GetBytes(bodyString);
var properties = channel.CreateBasicProperties();
channel.BasicPublish(exchange, routingKey, properties, body);
}
are.WaitOne(1000);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_settings.ContextNames).AsSelf().SingleInstance();
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>()
.SingleInstance();
builder.RegisterInstance(new CqrsContextNamesSettings()).AsSelf().SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.ConnectionString, UriKind.Absolute)
};
var messagingEngine = new MessagingEngine(_log, new TransportResolver(
new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}), new RabbitMqTransportFactory());
builder.RegisterType <EodStartedProjection>().AsSelf();
builder.Register(ctx => CreateEngine(ctx, messagingEngine))
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
protected virtual RabbitMQ.Client.ConnectionFactory BuildConnectionFactory(Uri endpointUri)
{
var factory = new RabbitMQ.Client.ConnectionFactory
{
Uri = endpointUri,
AutomaticRecoveryEnabled = true,
TopologyRecoveryEnabled = true
};
var assembly = typeof(Broker).GetTypeInfo().Assembly;
var properties = new Dictionary <String, Object>
{
{ "client_api", ProductName(assembly) },
{ "client_version", assembly.GetName().Version.ToString() },
{ "hostname", Environment.MachineName },
{ "connected_on", _dateTimeProvider.UtcNow().ToString("R") },
{ "process_id", Process.GetCurrentProcess().Id.ToString() },
{ "process_name", Process.GetCurrentProcess().ProcessName }
};
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
properties.Add("entry_assembly", entryAssembly.GetName().Name);
}
factory.ClientProperties = properties;
return(factory);
}
public virtual ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnel(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return tunnel;
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>()
.SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.ConnectionString, UriKind.Absolute)
};
builder.RegisterAssemblyTypes(GetType().Assembly).Where(t =>
new[] { "Saga", "CommandsHandler", "Projection" }.Any(ending => t.Name.EndsWith(ending))).AsSelf();
builder.Register(ctx => CreateEngine(ctx, new MessagingEngine(
new LykkeLoggerAdapter <CqrsModule>(ctx.Resolve <ILogger <CqrsModule> >()),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory())))
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public Task <(string, bool)> IsHealthy(HttpContext context, bool isDevelopment, CancellationToken cancellationToken = new CancellationToken())
{
try
{
var factory = new Rmq.Client.ConnectionFactory();
factory.Uri = new Uri(_rabbitMqConnectionString);
using (var connection = factory.CreateConnection())
{
if (connection.IsOpen)
{
return(Task.FromResult((BeatPulseKeys.BEATPULSE_HEALTHCHECK_DEFAULT_OK_MESSAGE, true)));
}
}
return(Task.FromResult((BeatPulseKeys.BEATPULSE_HEALTHCHECK_DEFAULT_ERROR_MESSAGE, false)));
}
catch (Exception ex)
{
var message = !isDevelopment
? string.Format(BeatPulseKeys.BEATPULSE_HEALTHCHECK_DEFAULT_ERROR_MESSAGE, Name)
: $"Exception {ex.GetType().Name} with message ('{ex.Message}')";
return(Task.FromResult((message, false)));
}
}
protected virtual RabbitMQ.Client.ConnectionFactory BuildConnectionFactory(Uri endpointUri)
{
var factory = new RabbitMQ.Client.ConnectionFactory
{
Uri = endpointUri.ToString(),
AutomaticRecoveryEnabled = true,
TopologyRecoveryEnabled = true
};
var assembly = typeof(Broker).Assembly;
var properties = new Dictionary<String, Object>
{
{ "client_api", ProductName(assembly) },
{ "client_version", assembly.GetName().Version.ToString() },
{ "net_version", Environment.Version.ToString() },
{ "hostname", Environment.MachineName },
{ "connected_on", _dateTimeProvider.UtcNow().ToString("R") },
{ "process_id", Process.GetCurrentProcess().Id.ToString() },
{ "process_name", Process.GetCurrentProcess().ProcessName }
};
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
properties.Add("entry_assembly", entryAssembly.GetName().Name);
factory.ClientProperties = properties;
return factory;
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterInstance(_settings.ContextNames).AsSelf().SingleInstance();
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>()
.SingleInstance();
builder.RegisterType <CqrsSender>().As <ICqrsSender>()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies)
.SingleInstance();
builder.RegisterInstance(new CqrsContextNamesSettings()).AsSelf().SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = _settings.ConnectionString
};
var messagingEngine = new MessagingEngine(_log, new TransportResolver(
new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}), new RabbitMqTransportFactory());
// Sagas & command handlers
builder.RegisterAssemblyTypes(GetType().Assembly).Where(t =>
new [] { "Saga", "CommandsHandler", "Projection" }.Any(ending => t.Name.EndsWith(ending))).AsSelf();
builder.Register(ctx => CreateEngine(ctx, messagingEngine)).As <ICqrsEngine>().SingleInstance()
.AutoActivate();
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>()
.SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.ConnectionString, UriKind.Absolute)
};
var messagingEngine = new MessagingEngine(_log,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory());
// Sagas & command handlers
builder.RegisterAssemblyTypes(GetType().Assembly)
.Where(t => t.Name.EndsWith("Saga") || t.Name.EndsWith("CommandsHandler"))
.AsSelf();
builder.Register(ctx => CreateEngine(ctx, messagingEngine))
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public void Should_be_able_to_configure_EasyNetQ_to_allow_message_with_a_blank_type_field()
{
var are = new System.Threading.AutoResetEvent(false);
var validation = new NullMessageValidator();
var bus = RabbitHutch.CreateBus("host=localhost", r =>
r.Register<IMessageValidationStrategy>(x => validation));
bus.Subscribe<MyMessage>("null_validation_test", message =>
{
Console.Out.WriteLine("Got message: {0}", message.Text);
are.Set();
});
// now use the basic client API to publish some JSON to the message type exchange ...
var factory = new RabbitMQ.Client.ConnectionFactory
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string exchange = "EasyNetQ_Tests_MyMessage:EasyNetQ_Tests";
const string routingKey = "#";
const string bodyString = "{ Text: \"Hello from Mr Raw :)\" }";
var body = System.Text.Encoding.UTF8.GetBytes(bodyString);
var properties = channel.CreateBasicProperties();
channel.BasicPublish(exchange, routingKey, properties, body);
}
are.WaitOne(1000);
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = new Uri(_settings.CurrentValue.SiriusCashoutProcessorJob.Cqrs.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>();
builder.RegisterType <CashoutCommandHandler>()
.WithParameter(TypedParameter.From(_settings.CurrentValue.SiriusApiServiceClient.BrokerAccountId))
.WithParameter(TypedParameter.From(_settings.CurrentValue.SiriusCashoutProcessorJob.RetrySettings.NotEnoughBalanceRetryDelayInSeconds))
.SingleInstance();
builder.Register(ctx => new MessagingEngine(ctx.Resolve <ILogFactory>(),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()))).As <IMessagingEngine>().SingleInstance();
const string environment = "lykke";
builder.Register(ctx =>
{
var engine = new CqrsEngine(ctx.Resolve <ILogFactory>(),
ctx.Resolve <IDependencyResolver>(),
ctx.Resolve <IMessagingEngine>(),
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: environment)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.BoundedContext(SiriusCashoutProcessorBoundedContext.Name)
.ListeningCommands(typeof(StartCashoutCommand))
.On("commands")
.WithCommandsHandler <CashoutCommandHandler>()
.PublishingEvents(
typeof(CashoutCompletedEvent),
typeof(CashoutFailedEvent)
)
.With("events")
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public CqrsEngine CreateEngine()
{
var rabbitMqConventionEndpointResolver = new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: _settings.EnvironmentName);
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.ConnectionString, UriKind.Absolute)
};
return(new CqrsEngine(
_log,
new AutofacDependencyResolver(Mock.Of <IComponentContext>()),
new MessagingEngine(_log,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory()),
new DefaultEndpointProvider(),
false,
Register.DefaultEndpointResolver(rabbitMqConventionEndpointResolver),
RegisterContext()));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var connectionFactory = new RabbitMQ.Client.ConnectionFactory();
var connection = connectionFactory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(queue: "identity.user",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body.ToArray();
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", message);
};
channel.BasicConsume(queue: "identity.user",
consumerTag: "consumer",
noLocal: false,
arguments: null,
exclusive: true,
autoAck: true,
consumer: consumer);
Console.ReadLine();
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory)
{
return RabbitTunnel.Factory.Create(hostName, virtualHost, username, password, watcher);
}
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
return new RabbitTunnelWithPriorityQueuesSupport(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
if (RabbitTunnel.Factory is DependencyInjectionTunnelFactory)
{
return(RabbitTunnel.Factory.Create(hostName, virtualHost, username, password, watcher));
}
var rabbitWatcher = watcher ?? Global.DefaultWatcher;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), rabbitWatcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, rabbitWatcher);
var msgHandlerFactory = new DefaultMessageHandlerFactory(errorHandler, Global.DefaultSerializer, rabbitWatcher);
var consumerManager = new ConsumerManager(rabbitWatcher, msgHandlerFactory, Global.DefaultSerializer);
var tunnel = new RabbitTunnelWithPriorityQueuesSupport(consumerManager,
rabbitWatcher,
new DefaultRouteFinder(),
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
tunnel.AddSerializerObserver(errorHandler);
tunnel.AddSerializerObserver(msgHandlerFactory);
tunnel.AddSerializerObserver(consumerManager);
return(tunnel);
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? _burrowResolver.Resolve<IRabbitWatcher>() ?? Global.DefaultWatcher;
var serializer = _burrowResolver.Resolve<ISerializer>() ?? Global.DefaultSerializer;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(_burrowResolver.Resolve<IRetryPolicy>() ?? new DefaultRetryPolicy(),
rabbitWatcher,
connectionFactory);
Func<IConsumerErrorHandler> errorHandler = () => new ConsumerErrorHandler(connectionFactory,
serializer,
rabbitWatcher);
Func<IMessageHandlerFactory> handlerFactory = () => new DefaultMessageHandlerFactory(_burrowResolver.Resolve<IConsumerErrorHandler>() ?? errorHandler(), rabbitWatcher);
Func<IConsumerManager> consumerManager = () => new ConsumerManager(rabbitWatcher,
_burrowResolver.Resolve<IMessageHandlerFactory>() ?? handlerFactory(),
serializer);
return new RabbitTunnel(_burrowResolver.Resolve<IConsumerManager>() ?? consumerManager(),
rabbitWatcher,
_burrowResolver.Resolve<IRouteFinder>() ?? new DefaultRouteFinder(),
durableConnection,
serializer,
_burrowResolver.Resolve<ICorrelationIdGenerator>() ?? Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
private void RegisterCqrsEngine(IReloadingManagerWithConfiguration <BackOfficeBundle> appSettings,
ContainerBuilder builder)
{
builder.Register(context => new AutofacDependencyResolver(context))
.As <IDependencyResolver>()
.SingleInstance();
var rabbitSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = appSettings.CurrentValue.PayBackOffice.RabbitMq.SagasConnectionString
};
builder.RegisterType <EmployeeRegistrationErrorProjection>().SingleInstance();
builder.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
return(new MessagingEngine(
logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(
rabbitSettings.Endpoint.ToString(),
rabbitSettings.UserName,
rabbitSettings.Password,
"None", "RabbitMq")
}
}),
new RabbitMqTransportFactory(logFactory)));
});
builder.Register(ctx => new CqrsEngine(
ctx.Resolve <ILogFactory>(),
ctx.Resolve <IDependencyResolver>(),
ctx.Resolve <MessagingEngine>(),
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
Lykke.Messaging.Serialization.SerializationFormat.ProtoBuf,
environment: "lykke")),
Register.BoundedContext("lykkepay-employee-registration-ui")
.PublishingCommands(typeof(RegisterEmployeeCommand), typeof(UpdateEmployeeCommand))
.To("lykkepay-employee-registration")
.With("commands")
.ListeningEvents(typeof(EmployeeRegistrationFailedEvent), typeof(EmployeeUpdateFailedEvent))
.From("lykkepay-employee-registration")
.On("paybo")
.WithProjection(
typeof(EmployeeRegistrationErrorProjection),
"lykkepay-employee-registration")
))
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.SagasRabbitMq.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
builder.RegisterType <HistoryExportProjection>().SingleInstance();
var messagingEngine = new MessagingEngine(_log,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory());
builder
.Register(ctx =>
{
const string defaultPipeline = "commands";
const string defaultRoute = "self";
var engine = new CqrsEngine(_log,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s")),
Register.BoundedContext("apiv2")
.PublishingCommands(typeof(CreateCashoutCommand), typeof(CreateSwiftCashoutCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline)
.ListeningEvents(
typeof(ClientHistoryExpiredEvent),
typeof(ClientHistoryExportedEvent))
.From(HistoryExportBuilderBoundedContext.Name).On(defaultRoute)
.WithProjection(typeof(HistoryExportProjection), HistoryExportBuilderBoundedContext.Name)
.PublishingCommands(typeof(ConfirmCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline),
Register.DefaultRouting
.PublishingCommands(typeof(ExportClientHistoryCommand))
.To(HistoryExportBuilderBoundedContext.Name).With(defaultPipeline)
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
static void Main(string[] args)
{
var factory = new RabbitMQ.Client.ConnectionFactory()
{
HostName = "localhost"
};
TaskManager.Run(factory, new MatchingManager());
}
protected override void Load(ContainerBuilder builder)
{
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _appSettings.CurrentValue.SagasRabbitMq.RabbitConnectionString
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
builder.RegisterType <AssetsProjection>();
builder.Register(ctx => new MessagingEngine(ctx.Resolve <ILogFactory>(),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(rabbitMqSettings.Endpoint.ToString(), rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory(ctx.Resolve <ILogFactory>()))).As <IMessagingEngine>().SingleInstance();
builder.Register(ctx =>
{
var msgPackResolver = new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s");
var engine = new CqrsEngine(
ctx.Resolve <ILogFactory>(),
ctx.Resolve <IDependencyResolver>(),
ctx.Resolve <IMessagingEngine>(),
new DefaultEndpointProvider(),
true,
Register.EventInterceptors(new DefaultEventLoggingInterceptor(ctx.Resolve <ILogFactory>())),
Register.DefaultEndpointResolver(msgPackResolver),
Register.BoundedContext(LimitationsBoundedContext.Name)
.ListeningEvents(typeof(AssetCreatedEvent), typeof(AssetUpdatedEvent))
.From(Assets.BoundedContext.Name).On("events")
.WithProjection(typeof(AssetsProjection), Assets.BoundedContext.Name)
.PublishingEvents(
typeof(ClientDepositEvent),
typeof(ClientWithdrawEvent)
).With("events")
.WithEndpointResolver(msgPackResolver)
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.AutoActivate()
.SingleInstance();
}
public override ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var rabbitWatcher = watcher ?? _burrowResolver.Resolve <IRabbitWatcher>() ?? Global.DefaultWatcher;
var serializer = _burrowResolver.Resolve <ISerializer>() ?? Global.DefaultSerializer;
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(_burrowResolver.Resolve <IRetryPolicy>() ?? new DefaultRetryPolicy(),
rabbitWatcher,
connectionFactory);
var abc = new ObjectObserver <IObserver <ISerializer> >();
Func <IConsumerErrorHandler> errorHandler = () =>
{
var handdler = new ConsumerErrorHandler(connectionFactory, serializer, rabbitWatcher);
abc.FireEvent(handdler);
return(handdler);
};
Func <IMessageHandlerFactory> handlerFactory = () =>
{
var factory = new DefaultMessageHandlerFactory(_burrowResolver.Resolve <IConsumerErrorHandler>() ?? errorHandler(),
serializer,
rabbitWatcher);
abc.FireEvent(factory);
return(factory);
};
Func <IConsumerManager> consumerManager = () =>
{
var manager = new ConsumerManager(rabbitWatcher,
_burrowResolver.Resolve <IMessageHandlerFactory>() ?? handlerFactory(),
serializer);
abc.FireEvent(manager);
return(manager);
};
var tunnel = new RabbitTunnel(_burrowResolver.Resolve <IConsumerManager>() ?? consumerManager(),
rabbitWatcher,
_burrowResolver.Resolve <IRouteFinder>() ?? new DefaultRouteFinder(),
durableConnection,
serializer,
_burrowResolver.Resolve <ICorrelationIdGenerator>() ?? Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
abc.ObjectCreated += tunnel.AddSerializerObserver;
return(tunnel);
}
protected override void Load(ContainerBuilder builder)
{
Messaging.Serialization.MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSagasSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _settings.CurrentValue.SwiftWithdrawalService.Cqrs.RabbitConnectionString
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>();
var messagingEngine = new MessagingEngine(_log,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "SagasRabbitMq", new TransportInfo(rabbitMqSagasSettings.Endpoint.ToString(), rabbitMqSagasSettings.UserName, rabbitMqSagasSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory());
var sagasEndpointResolver = new RabbitMqConventionEndpointResolver(
"SagasRabbitMq",
"messagepack",
environment: "lykke",
exclusiveQueuePostfix: "k8s");
builder.RegisterType <SwiftCashoutRequestCommandHandler>().SingleInstance();
builder.RegisterType <SwiftRequestLogProjection>().SingleInstance();
builder.Register(ctx =>
{
string commandsRoute = "commands";
string eventsRoute = "events";
return(new CqrsEngine(_log,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(sagasEndpointResolver),
Register.BoundedContext(SwiftWithdrawalBoundedContext.Name)
.ListeningCommands(typeof(SwiftCashoutCreateCommand))
.On(commandsRoute)
.WithCommandsHandler <SwiftCashoutRequestCommandHandler>()
.PublishingEvents(typeof(SwiftCashoutCreatedEvent))
.With(eventsRoute)
.ListeningEvents(typeof(SwiftCashoutCreatedEvent))
.From(SwiftWithdrawalBoundedContext.Name)
.On(eventsRoute)
.WithProjection(typeof(SwiftRequestLogProjection), SwiftWithdrawalBoundedContext.Name)));
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddMvc();
AutoMapper.Mapper.Initialize(c => c.AddProfile <ILanni.FarmMarket.Repository.Mongo.AutoMapperProfile>());
Elasticsearch.Net.StaticConnectionPool pool = new StaticConnectionPool(new[] { new Uri("http://localhost:9200") });
ConnectionSettings estSettings = new ConnectionSettings(pool);
estSettings.BasicAuthentication("elastic", "123456");
estSettings.InferMappingFor <Models.Product>(d => d.IdProperty(p => p.Id).IndexName("product").TypeName("product"));
ElasticClient client = new ElasticClient(estSettings);
services.AddSingleton <ElasticClient>(client);
MongoClientSettings mSettings = new MongoClientSettings()
{
Credential = MongoCredential.CreateCredential("admin", "sa", "1"),
Server = new MongoServerAddress("127.0.0.1", 27017),
};
MongoClient mClient = new MongoClient(mSettings);
services.AddSingleton <MongoClient>(mClient);
services.AddSingleton <ILanni.FarmMarket.MQ.Settings>(new ILanni.FarmMarket.MQ.Settings());
var rmqConnFactory = new RabbitMQ.Client.ConnectionFactory()
{
UserName = "******",
Password = "******"
};
services.AddSingleton <RabbitMQ.Client.ConnectionFactory>(rmqConnFactory);
PoolingSettings mqSetting = new PoolingSettings()
{
MaxChannelPerConnection = 5, MaxConnections = 2
};
ChannelPool channelPool = new ChannelPool(rmqConnFactory, mqSetting);
services.AddSingleton(channelPool);
services.AddScoped <ProductRepository>();
services.AddScoped <ProductPublisher>();
services.AddScoped <ProductService>();
}
static void Main(string[] args)
{
var connectionFactory = new RabbitMQ.Client.ConnectionFactory()
{
Password = Password,
UserName = UserName,
HostName = HostName
};
var connection = connectionFactory.CreateConnection();
var model = connection.CreateModel();
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = new Uri(_settings.RabbitConnectionString)
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
builder
.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var messagingEngine = new MessagingEngine(
logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqSettings.Endpoint.ToString(),
rabbitMqSettings.UserName,
rabbitMqSettings.Password,
"None",
"RabbitMq")
}
}),
new RabbitMqTransportFactory(logFactory));
const string defaultPipeline = "commands";
var engine = new CqrsEngine(logFactory,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s")),
Register.BoundedContext("hft-api")
.PublishingCommands(typeof(CreateCashoutCommand))
.To(OperationsBoundedContext.Name).With(defaultPipeline));
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
protected override void Load(ContainerBuilder builder)
{
string eventsRoute = "events";
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
var rabbitMqSagasSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _settings.CurrentValue.SagasRabbitMq.RabbitConnectionString
};
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>();
builder.RegisterType <RegistrationSaga>().SingleInstance();
builder.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var messagingEngine = new MessagingEngine(logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"SagasRabbitMq",
new TransportInfo(rabbitMqSagasSettings.Endpoint.ToString(),
rabbitMqSagasSettings.UserName, rabbitMqSagasSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory(logFactory));
var sagasEndpointResolver = new RabbitMqConventionEndpointResolver(
"SagasRabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "k8s");
return(new CqrsEngine(logFactory,
new AutofacDependencyResolver(ctx.Resolve <IComponentContext>()),
messagingEngine,
new DefaultEndpointProvider(),
true,
false, //don't log input messages
Register.DefaultEndpointResolver(sagasEndpointResolver),
Register.Saga <RegistrationSaga>("regulation-registration-saga")
.ListeningEvents(typeof(ClientRegisteredEvent))
.From(RegistrationBoundedContext.Name).On(eventsRoute)
.WithEndpointResolver(sagasEndpointResolver)
.ProcessingOptions(eventsRoute).MultiThreaded(2).QueueCapacity(256)
));
})
.As <ICqrsEngine>()
.AutoActivate()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
RegisterChaosKitty(builder);
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
RegisterComponents(builder);
const string settlementTransport = "Settlement";
var mainSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = _appSettings.CurrentValue.PaySettlementCqrs.ConnectionString
};
builder.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var settlementBroker = mainSettings.Endpoint.ToString();
var settlementMessagingEngine = new MessagingEngine(logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
settlementTransport,
new TransportInfo(settlementBroker, mainSettings.UserName, mainSettings.Password, "None",
_appSettings.CurrentValue.PaySettlementCqrs.Messaging)
}
}),
new RabbitMqTransportFactory(logFactory));
return(new CqrsEngine(logFactory,
ctx.Resolve <IDependencyResolver>(),
settlementMessagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
settlementTransport,
_appSettings.CurrentValue.PaySettlementCqrs.SerializationFormat,
environment: _appSettings.CurrentValue.PaySettlementCqrs.Environment)),
Register.BoundedContext(InternalBoundedContext)
.ListeningEvents(typeof(SettlementTransferToMarketQueuedEvent),
typeof(SettlementTransferredToMerchantEvent), typeof(SettlementErrorEvent))
.From(_appSettings.CurrentValue.PaySettlementCqrs.SettlementBoundedContext)
.On(_appSettings.CurrentValue.PaySettlementCqrs.EventsRoute)
.WithProjection(ctx.Resolve <SettlementProjection>(),
_appSettings.CurrentValue.PaySettlementCqrs.SettlementBoundedContext)
));
})
.As <ICqrsEngine>().SingleInstance().AutoActivate();
}
public QueuePushHandle()
{
sqlDb = new SqlDb(QT.Entities.Server.ConnectionStringCrawler);
factory = new RabbitMQ.Client.ConnectionFactory()
{
HostName = QT.Entities.Server.RabbitMQ_Host,
Port = QT.Entities.Server.RabbitMQ_Port,
UserName = QT.Entities.Server.RabbitMQ_User,
Password = QT.Entities.Server.RabbitMQ_Pass
};
connection = factory.CreateConnection();
chanel = connection.CreateModel();
}
public void SubscribeToQueue(string queue)
{
RabbitMQ.Client.ConnectionFactory config = new RabbitMQ.Client.ConnectionFactory();
config.HostName = Configuration.RabbitMQNotificationServer;
config.UserName = Configuration.RabbitMQNotificationUserNameConsumer;
config.Password = Configuration.RabbitMQNotificationUserPasswordConsumer;
config.VirtualHost = Configuration.RabbitMQVHostNotification;
eventLogRepository.WriteInformationLog(string.Format("Subscribing to notification queue: {0}", queue));
this.listenForQueueMessagesTask = Task.Factory.StartNew
(() => genericSubscriptionQueue.Subscribe(config, queue));
}
public void Publish <TEvent>(TEvent @event)
where TEvent : Domain.Core.Events.Event
{
try
{
var factory =
new RabbitMQ.Client.ConnectionFactory
{
UserName = "******",
Password = "******",
HostName = "localhost",
};
string eventTypeName = @event.TypeName;
string queueName = eventTypeName;
string exchangeName = string.Empty;
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.QueueDeclare
(queue: queueName,
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
string message =
Newtonsoft.Json.JsonConvert.SerializeObject(@event);
byte[] body =
System.Text.Encoding.UTF8.GetBytes(message);
channel.BasicPublish
(exchange: exchangeName,
routingKey: queueName,
mandatory: false,
basicProperties: null,
body: body);
System.Console.WriteLine($"Sent message: { message }");
}
}
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
protected override void Load(ContainerBuilder builder)
{
MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory {
Uri = _settings.CurrentValue.MarketDataService.Cqrs.ConnectionString
};
builder.Register(ctx =>
{
var logFactory = ctx.Resolve <ILogFactory>();
var broker = rabbitMqSettings.Endpoint.ToString();
var messagingEngine = new MessagingEngine(logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo(broker, rabbitMqSettings.UserName, rabbitMqSettings.Password, "None", "RabbitMq") }
}),
new RabbitMqTransportFactory(logFactory));
var engine = new CqrsEngine(logFactory,
ctx.Resolve <IDependencyResolver>(),
messagingEngine,
new DefaultEndpointProvider(),
true,
Register.DefaultEndpointResolver(new RabbitMqConventionEndpointResolver(
"RabbitMq",
SerializationFormat.MessagePack,
environment: "lykke",
exclusiveQueuePostfix: "marketdata")),
Register.CommandInterceptors(new DefaultCommandLoggingInterceptor(logFactory)),
Register.EventInterceptors(new DefaultEventLoggingInterceptor(logFactory)),
Register.BoundedContext(MarketDataBoundedContext.Name)
.WithAssetsReadModel(route: System.Environment.MachineName)
.PublishingEvents(
typeof(MarketDataChangedEvent)
)
.With("events")
);
engine.StartPublishers();
return(engine);
})
.As <ICqrsEngine>()
.AutoActivate()
.SingleInstance();
}
public RabbitMQ.Client.ConnectionFactory RabbitMqConnection()
{
var factory = new RabbitMQ.Client.ConnectionFactory
{
HostName = ConfigurationManager.AppSettings["MessagingQueueHostAddress"],
UserName = ConfigurationManager.AppSettings["RabbitMQUserName"],
Password = ConfigurationManager.AppSettings["RabbitMQPassword"],
VirtualHost = ConfigurationManager.AppSettings["RabbitMQVirtualHost"],
Port = Convert.ToInt32(ConfigurationManager.AppSettings["RabbitMQPort"]),
ContinuationTimeout = TimeSpan.FromHours(1)
};
return(factory);
}
public void SubscribeToQueue()
{
RabbitMQ.Client.ConnectionFactory config = new RabbitMQ.Client.ConnectionFactory();
config.HostName = Configuration.RabbitMQConfirmationServer;
config.UserName = Configuration.RabbitMQUserNameConsumer;
config.Password = Configuration.RabbitMQUserPasswordConsumer;
config.VirtualHost = Configuration.RabbitMQVHostConfirmation;
_log.WriteInformationLog
(string.Format("Subscribing to order updates queue: {0}", Configuration.RabbitMQQueueHourlyUpdates));
this._queueTask = Task.Factory.StartNew
(() => _genericSubscriptionQueue.Subscribe(config, Configuration.RabbitMQQueueHourlyUpdates));
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>().SingleInstance();
var rabbitMqSettings = new RabbitMQ.Client.ConnectionFactory
{
Uri = _settings.RabbitConnectionString
};
var rabbitMqEndpoint = _rabbitMqVirtualHost == null
? rabbitMqSettings.Endpoint.ToString()
: $"{rabbitMqSettings.Endpoint}/{_rabbitMqVirtualHost}";
builder.Register(c => new MessagingEngine(c.Resolve <ILogFactory>(),
new TransportResolver(new Dictionary <string, TransportInfo>
{
{
"RabbitMq",
new TransportInfo(rabbitMqEndpoint, rabbitMqSettings.UserName,
rabbitMqSettings.Password, "None", "RabbitMq")
}
}),
new RabbitMqTransportFactory(c.Resolve <ILogFactory>())))
.As <IMessagingEngine>()
.SingleInstance()
.AutoActivate();
// Sagas
builder.RegisterType <CashoutRegistrationSaga>();
builder.RegisterType <HeartBeatCashoutSaga>();
// Command handlers
builder.RegisterType <RegisterCashoutRegistrationLastMomentCommandHandler>();
builder.RegisterType <RegisterHeartbeatCashoutLastMomentCommandHandler>();
builder.RegisterType <AcquireCashoutLockCommandHandler>();
builder.RegisterType <ReleaseCashoutLockCommandHandler>();
builder.RegisterType <StartHeartbeatCashoutCommandHandler>();
builder.RegisterType <CheckCashoutPreconditionsCommandHandler>();
builder.RegisterType <RetrieveAssetInfoCommandHandler>();
builder.Register(CreateEngine)
.As <ICqrsEngine>()
.SingleInstance()
.AutoActivate();
}
public virtual ITunnel Create(string hostName, string virtualHost, string username, string password, IRabbitWatcher watcher)
{
var connectionFactory = new RabbitMQ.Client.ConnectionFactory
{
HostName = hostName,
VirtualHost = virtualHost,
UserName = username,
Password = password
};
var durableConnection = new DurableConnection(new DefaultRetryPolicy(), watcher, connectionFactory);
var errorHandler = new ConsumerErrorHandler(connectionFactory, Global.DefaultSerializer, Global.DefaultWatcher);
var consumerManager = new ConsumerManager(watcher, errorHandler, Global.DefaultSerializer, Global.DefaultConsumerBatchSize);
return new RabbitTunnel(consumerManager,
watcher,
Global.DefaultRouteFinder,
durableConnection,
Global.DefaultSerializer,
Global.DefaultCorrelationIdGenerator,
Global.DefaultPersistentMode);
}
