public void TopologyHelper_Client_PlugIn()
{
LeafRouter router = null;
ITopologyProvider cluster = null;
System.Type type;
try
{
router = CreateLeaf("detached", "hub", Helper.NewGuid().ToString(), group);
type = typeof(BasicTopology);
Config.SetConfig(string.Format("topology-type={0}:{1}\r\nargs=cluster-ep=logical://foo", type.FullName, type.Assembly.Location));
cluster = TopologyHelper.OpenClient(router, "topology-type", "args");
Assert.AreEqual(type.FullName, cluster.GetType().FullName);
Assert.IsTrue(cluster.IsClient);
}
finally
{
if (cluster != null)
{
cluster.Close();
}
if (router != null)
{
router.Stop();
}
Config.SetConfig(null);
}
}
public QueueBindMiddleware(ITopologyProvider topologyProvider, QueueBindOptions options = null)
{
TopologyProvider = topologyProvider;
QueueNameFunc = options?.QueueNameFunc ?? (context => context.GetConsumeConfiguration()?.QueueName);
ExchangeNameFunc = options?.ExchangeNameFunc ?? (context => context.GetConsumeConfiguration()?.ExchangeName);
RoutingKeyFunc = options?.RoutingKeyFunc ?? (context => context.GetConsumeConfiguration()?.RoutingKey);
}
public ExchangeDeclareMiddleware(ITopologyProvider topologyProvider, ILogger <ExchangeDeclareMiddleware> logger, ExchangeDeclareOptions options = null)
{
TopologyProvider = topologyProvider ?? throw new ArgumentNullException(nameof(topologyProvider));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
ExchangeFunc = options?.ExchangeFunc ?? (context => context.GetExchangeDeclaration());
ThrowOnFailFunc = options?.ThrowOnFailFunc ?? (context => false);
}
public RabbitMqConsumer(IRabbitMqConnector connection, string queueName, ITopologyProvider topologyProvider)
{
_connection = connection;
_connection.ModelCreated += OnModelCreated;
_queueProperties = topologyProvider.GetQueueProperties(queueName);
_declarationHelper = new DeclarationHelper(topologyProvider);
}
public RabbitMqProducer(IRabbitMqConnector connection, ITopologyProvider topologyProvider)
{
_connection = connection;
_connection.BasicAcks += OnBasicAck;
_connection.BasicNacks += OnBasicNack;
_connection.ModelCreated += OnModelCreated;
_declarationHelper = new DeclarationHelper(topologyProvider);
}
public QueueBindMiddleware(ITopologyProvider topologyProvider, ILogger <QueueBindMiddleware> logger, QueueBindOptions options = null)
{
TopologyProvider = topologyProvider ?? throw new ArgumentNullException(nameof(topologyProvider));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
QueueNameFunc = options?.QueueNameFunc ?? (context => context.GetConsumeConfiguration()?.QueueName);
ExchangeNameFunc = options?.ExchangeNameFunc ?? (context => context.GetConsumeConfiguration()?.ExchangeName);
RoutingKeyFunc = options?.RoutingKeyFunc ?? (context => context.GetConsumeConfiguration()?.RoutingKey);
}
public DefaultStrategy(IMessageSerializer serializer, INamingConventions conventions, IBasicPropertiesProvider propertiesProvider, ITopologyProvider topologyProvider, IChannelFactory channelFactory)
{
_serializer = serializer;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_channelFactory = channelFactory;
_errorExchangeCfg = ExchangeConfiguration.Default;
_errorExchangeCfg.ExchangeName = conventions.ErrorExchangeNamingConvention();
}
/// <summary>
/// Создает новый экзмемпляр класса <see cref="TopologyProviderTests"/>.
/// </summary>
public TopologyProviderTests()
{
var namingConvention = new DefaultNamingConvention(
new ServiceInfoAccessor(
new ServiceInfo("1.2.0-rc1", "MyAwesomeApplication", "app-hcsa-1245", "Production"))
);
_topologyProvider = new DefaultTopologyProvider(namingConvention);
}
public void TopologyHelper_Server_PlugIn()
{
LeafRouter client = null;
LeafRouter server = null;
ITopologyProvider clientCluster = null;
ITopologyProvider serverCluster = null;
System.Type type;
PropertyMsg reply;
try
{
client = CreateLeaf("detached", "hub", Helper.NewGuid().ToString(), group);
server = CreateLeaf("detached", "hub", Helper.NewGuid().ToString(), group);
type = typeof(BasicTopology);
Config.SetConfig(string.Format("topology-type={0}:{1}\r\nargs=cluster-ep=logical://foo", type.FullName, type.Assembly.Location));
clientCluster = TopologyHelper.OpenClient(client, "topology-type", "args");
Assert.AreEqual(type.FullName, clientCluster.GetType().FullName);
Assert.IsTrue(clientCluster.IsClient);
Config.SetConfig(string.Format("topology-type={0}:{1}\r\nargs=cluster-ep=logical://foo", type.FullName, type.Assembly.Location));
serverCluster = TopologyHelper.OpenServer(client, "A", this, "topology-type", "args");
Assert.AreEqual(type.FullName, serverCluster.GetType().FullName);
Assert.IsFalse(serverCluster.IsClient);
Thread.Sleep(2000);
reply = (PropertyMsg)clientCluster.Query(null, new PropertyMsg());
Assert.AreEqual("Hello World!", reply["value"]);
}
finally
{
if (client != null)
{
client.Stop();
}
if (server != null)
{
server.Stop();
}
if (clientCluster != null)
{
clientCluster.Close();
}
if (serverCluster != null)
{
serverCluster.Close();
}
Config.SetConfig(null);
}
}
public DefaultStrategy(IMessageSerializer serializer, INamingConventions conventions, IBasicPropertiesProvider propertiesProvider, ITopologyProvider topologyProvider, IChannelFactory channelFactory)
{
_serializer = serializer;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_channelFactory = channelFactory;
_errorExchangeCfg = ExchangeConfiguration.Default;
_errorExchangeCfg.ExchangeName = conventions.ErrorExchangeNamingConvention();
}
public RetryLaterMiddleware(ITopologyProvider topology, INamingConventions conventions, IChannelFactory channelFactory, IRetryInformationHeaderUpdater headerUpdater, RetryLaterOptions options = null)
{
TopologyProvider = topology;
Conventions = conventions;
ChannelFactory = channelFactory;
_headerUpdater = headerUpdater;
AcknowledgementFunc = options?.AcknowledgementFunc ?? (context => context.GetMessageAcknowledgement());
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
}
public Publisher(IChannelFactory channelFactory, ITopologyProvider topologyProvider, IMessageSerializer serializer, IMessageContextProvider <TMessageContext> contextProvider, IPublishAcknowledger acknowledger, IBasicPropertiesProvider propertiesProvider, RawRabbitConfiguration config)
{
_channelFactory = channelFactory;
_topologyProvider = topologyProvider;
_serializer = serializer;
_contextProvider = contextProvider;
_acknowledger = acknowledger;
_propertiesProvider = propertiesProvider;
_config = config;
}
public Publisher(IChannelFactory channelFactory, ITopologyProvider topologyProvider, IMessageSerializer serializer, IPublishAcknowledger acknowledger,
IBasicPropertiesProvider propertiesProvider, RabbitMqConfiguration config, ILogger <Publisher> logger)
{
_logger = logger;
_channelFactory = channelFactory;
_topologyProvider = topologyProvider;
_serializer = serializer;
_acknowledger = acknowledger;
_propertiesProvider = propertiesProvider;
_config = config;
}
public ExplicitAckMiddleware(INamingConventions conventions, ITopologyProvider topology, IChannelFactory channelFactory, ExplicitAckOptions options = null)
{
Conventions = conventions;
Topology = topology;
ChannelFactory = channelFactory;
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
ConsumerFunc = options?.ConsumerFunc ?? (context => context.GetConsumer());
MessageAcknowledgementFunc = options?.GetMessageAcknowledgement ?? (context => context.GetMessageAcknowledgement());
AbortExecution = options?.AbortExecution ?? (ack => !(ack is Ack));
AutoAckFunc = options?.AutoAckFunc ?? (context => context.GetConsumeConfiguration().AutoAck);
}
public Subscriber(IChannelFactory channelFactory, IConsumerFactory consumerFactory, ITopologyProvider topologyProvider,
IMessageSerializer serializer, RabbitMqConfiguration config, ILogger <Subscriber> logger)
{
_logger = logger;
_channelFactory = channelFactory;
_consumerFactory = consumerFactory;
_topologyProvider = topologyProvider;
_serializer = serializer;
_config = config;
_subscriptions = new List <ISubscription>();
}
/// <summary>
/// Создает экземпляр класса <see cref="DefaultAcknowledgementBehaviour"/>.
/// </summary>
/// <param name="retryDelayComputerResolver">
/// Получатель вычислителей задержек между повторными обработками.
/// </param>
/// <param name="namingConvention">Конвенция именования.</param>
/// <param name="topologyProvider">Провайдер топологий.</param>
/// <param name="logger">Логгер.</param>
public DefaultAcknowledgementBehaviour(
INamedResolver <string, IRetryDelayComputer> retryDelayComputerResolver,
INamingConvention namingConvention,
ITopologyProvider topologyProvider,
ILogger <DefaultAcknowledgementBehaviour> logger
)
{
_retryDelayComputerResolver = retryDelayComputerResolver;
_namingConvention = namingConvention;
_topologyProvider = topologyProvider;
_logger = logger;
}
/// <summary>
/// Associates the service handler with a message router by registering
/// the necessary application message handlers.
/// </summary>
/// <param name="router">The message router.</param>
/// <param name="settings">The configuration settings.</param>
/// <param name="perfCounters">The application's performance counter set (or <c>null</c>).</param>
/// <param name="perfPrefix">The string to prefix any performance counter names (or <c>null</c>).</param>
/// <remarks>
/// <para>
/// Applications that expose performance counters will pass a non-<c>null</c> <b>perfCounters</b>
/// instance. The service handler should add any counters it implements to this set.
/// If <paramref name="perfPrefix" /> is not <c>null</c> then any counters added should prefix their
/// names with this parameter.
/// </para>
/// </remarks>
public void Start(MsgRouter router, GeoTrackerServerSettings settings, PerfCounterSet perfCounters, string perfPrefix)
{
if (this.isRunning)
{
throw new InvalidOperationException("This node has already been started.");
}
if (router == null)
{
throw new ArgumentNullException("router");
}
// Initialize the performance counters
this.startTime = DateTime.UtcNow;
this.perf = new Perf(perfCounters, perfPrefix);
// General initialization
this.settings = settings;
this.bkTimer = new GatedTimer(new TimerCallback(OnBkTimer), null, settings.BkInterval);
this.ipGeocoder = new IPGeocoder(this);
this.clusterClient = Helper.CreateInstance <ITopologyProvider>(settings.ClusterTopology);
this.clusterServer = Helper.CreateInstance <ITopologyProvider>(settings.ClusterTopology);
this.fixCache = new GeoFixCache(settings);
this.archiver = Helper.CreateInstance <IGeoFixArchiver>(settings.GeoFixArchiver);
EntityState.MaxEntityFixes = settings.MaxEntityGeoFixes;
try
{
// Initialize the router
this.router = router;
this.router.Dispatcher.AddTarget(this, "GeoTrackerServerEP", new SimpleEPMunger(settings.ServerEP), null);
// Initialize the cluster
this.clusterClient.OpenClient(router, settings.ClusterEP, settings.ClusterArgs);
this.clusterServer.OpenServer(router, "GeoTrackerClusterEP", settings.ClusterEP, this, settings.ClusterArgs);
// Start the archiver.
archiver.Start(this, settings.GeoFixArchiverArgs);
this.isRunning = true;
}
catch
{
Stop();
throw;
}
}
public SubscriptionExceptionMiddleware(
IPipeBuilderFactory factory,
IChannelFactory channelFactory,
ITopologyProvider provider,
INamingConventions conventions,
SubscriptionExceptionOptions options)
: base(factory, new ExceptionHandlingOptions {
InnerPipe = options.InnerPipe
})
{
_channelFactory = channelFactory;
_provider = provider;
_conventions = conventions;
ChannelFunc = options?.ChannelFunc ?? ((c, f) => f.CreateChannelAsync());
}
/// <summary>
/// Создает экземпляр класса <see cref="DefaultSubscriber"/>.
/// </summary>
/// <param name="logger">Логгер.</param>
/// <param name="serializer">Сервис сериализации/десериализации.</param>
/// <param name="topologyProvider">Провайдер топологий.</param>
/// <param name="namingConvention">Конвенция именования.</param>
/// <param name="acknowledgementBehaviourFactory">
/// Фабрика поведений оповещения брокера сообщений об успешности/не успешности обработки.
/// </param>
/// <param name="permanentConnectionManager">Менеджер постоянных соединений.</param>
public DefaultSubscriber(
ILogger <DefaultSubscriber> logger,
ISerializer serializer,
ITopologyProvider topologyProvider,
INamingConvention namingConvention,
IAcknowledgementBehaviourFactory acknowledgementBehaviourFactory,
IPermanentConnectionManager permanentConnectionManager
)
{
_logger = logger;
_serializer = serializer;
_topologyProvider = topologyProvider;
_namingConvention = namingConvention;
_acknowledgementBehaviourFactory = acknowledgementBehaviourFactory;
_permanentConnectionManager = permanentConnectionManager;
}
public RetryLaterMiddleware(
ITopologyProvider topology,
INamingConventions conventions,
IChannelFactory channelFactory,
IRetryInformationHeaderUpdater headerUpdater,
ILogger <RetryLaterMiddleware> logger,
RetryLaterOptions options = null)
{
TopologyProvider = topology ?? throw new ArgumentNullException(nameof(topology));
Conventions = conventions ?? throw new ArgumentNullException(nameof(conventions));
ChannelFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
_headerUpdater = headerUpdater ?? throw new ArgumentNullException(nameof(headerUpdater));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
AcknowledgementFunc = options?.AcknowledgementFunc ?? (context => context.GetMessageAcknowledgement());
DeliveryArgsFunc = options?.DeliveryArgsFunc ?? (context => context.GetDeliveryEventArgs());
}
public SubscriptionExceptionMiddleware(
IPipeBuilderFactory factory,
IChannelFactory channelFactory,
ITopologyProvider provider,
INamingConventions conventions,
ILogger <ExceptionHandlingMiddleware> logger,
SubscriptionExceptionOptions options)
: base(factory, logger, new ExceptionHandlingOptions {
InnerPipe = options.InnerPipe
})
{
_channelFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
_provider = provider ?? throw new ArgumentNullException(nameof(provider));
_conventions = conventions ?? throw new ArgumentNullException(nameof(conventions));
ChannelFunc = options?.ChannelFunc ?? ((c, f) => f.CreateChannelAsync());
}
public MessageChainTopologyUtil(
IChannelFactory channelFactory,
ITopologyProvider topologyProvider,
IConfigurationEvaluator configEvaluator,
IMessageSerializer serializer,
IMessageContextProvider <TMessageContext> contextProvider,
IMessageChainDispatcher messageDispatcher,
QueueConfiguration queueConfig)
{
_channelFactory = channelFactory;
_topologyProvider = topologyProvider;
_configEvaluator = configEvaluator;
_queueConfig = queueConfig;
_messageDispatcher = messageDispatcher;
_contextProvider = contextProvider;
_serializer = serializer;
InitializeConsumer();
}
public Subscriber(
IChannelFactory channelFactory,
IConsumerFactory consumerFactory,
ITopologyProvider topologyProvider,
IMessageSerializer serializer,
IMessageContextProvider <TMessageContext> contextProvider,
IContextEnhancer contextEnhancer,
IErrorHandlingStrategy errorHandling,
RawRabbitConfiguration config)
{
_channelFactory = channelFactory;
_consumerFactory = consumerFactory;
_topologyProvider = topologyProvider;
_serializer = serializer;
_contextProvider = contextProvider;
_contextEnhancer = contextEnhancer;
_errorHandling = errorHandling;
_config = config;
_subscriptions = new List <ISubscription>();
}
public Requester(
IChannelFactory channelFactory,
IConsumerFactory consumerFactory,
IMessageSerializer serializer,
IMessageContextProvider <TMessageContext> contextProvider,
IErrorHandlingStrategy errorStrategy,
IBasicPropertiesProvider propertiesProvider,
ITopologyProvider topologyProvider,
RawRabbitConfiguration config)
{
_channelFactory = channelFactory;
_consumerFactory = consumerFactory;
_serializer = serializer;
_contextProvider = contextProvider;
_errorStrategy = errorStrategy;
_propertiesProvider = propertiesProvider;
_topologyProvider = topologyProvider;
_config = config;
_responseDictionary = new ConcurrentDictionary <string, ResponseCompletionSource>();
_consumerCompletionSources = new ConcurrentDictionary <IModel, ConsumerCompletionSource>();
}
/// <summary>
/// Initiates an asynchronous attempt to reliably deliver a message to a cluster.
/// </summary>
/// <param name="topologyProvider">The cluster's topology provider.</param>
/// <param name="key">The optional topology key.</param>
/// <param name="query">The query message.</param>
/// <param name="confirmDelivery">Indicates whether or not the delivery should be confirmed.</param>
/// <param name="callback">The delegate to be called when the operation completes (or <c>null</c>).</param>
/// <param name="state">Application defined state.</param>
/// <returns>The <see cref="IAsyncResult" /> instance to be used to track the operation's progress.</returns>
/// <remarks>
/// <note>
/// The operation doesn't complete until the message has been safely
/// submitted to the queuing message implemented by the class. This is done
/// to ensure that the message is actually accepted by the messenger and
/// also as a flow control mechanism.
/// </note>
/// <note>
/// Every successful call to <see cref="BeginDelivery(MsgEP,Msg,bool,AsyncCallback,object)" /> must eventually
/// be followed by a call to <see cref="EndDelivery" />.
/// </note>
/// </remarks>
public IAsyncResult BeginDelivery(ITopologyProvider topologyProvider, object key, Msg query, bool confirmDelivery,
AsyncCallback callback, object state)
{
if (!router.IsOpen)
{
throw new ArgumentException(ReliableMessenger.RouterClosedMsg);
}
var confirmation = new DeliveryConfirmation();
var deliverAR = new AsyncResult(null, callback, state);
confirmation.TargetEP = topologyProvider.ClusterEP;
confirmation.Query = query;
confirmation.TopologyID = topologyProvider.InstanceID;
confirmation.TopologyInfo = topologyProvider.SerializeClient();
confirmation.TopologyParam = null;
confirmation.State = new QueryState(deliverAR, confirmDelivery && confirmCallback != null, topologyProvider);
topologyProvider.BeginQuery(key, query, onClusterDelivery, confirmation);
deliverAR.Started();
return(deliverAR);
}
public QueueDeclareMiddleware(ITopologyProvider topology, QueueDeclareOptions options = null)
{
Topology = topology;
QueueDeclareFunc = options?.QueueDeclarationFunc ?? (context => context.GetQueueDeclaration());
}
public RabbitMqDataAdapter(SerializationManager serializationManager, IStreamQueueMapper mapper, ITopologyProvider topologyProvider) : base(mapper, topologyProvider)
{
_serializationManager = serializationManager;
}
public QueueDeclareMiddleware(ITopologyProvider topology, ILogger <Pipe.Middleware.QueueDeclareMiddleware> logger, QueueDeclareOptions options = null)
: base(topology, logger, options)
{
}
public QueueBindMiddleware(ITopologyProvider topologyProvider, ILogger <Pipe.Middleware.QueueBindMiddleware> logger, QueueBindOptions options = null)
: base(topologyProvider, logger, options)
{
}
public ProtoBufDataAdapter(IStreamQueueMapper mapper, ITopologyProvider topologyProvider) : base(mapper, topologyProvider)
{
}
public QueueDeclareMiddleware(ITopologyProvider topology, QueueDeclareOptions options = null)
: base(topology, options)
{
}
