/// <inheritdoc/>
public override Task Initialize(string strProviderName, IStreamQueueMapper queueMapper, TimeSpan siloMaturityPeriod)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
var options = this.serviceProvider.GetRequiredService <IOptionsSnapshot <LeaseBasedQueueBalancerOptions> >().Get(strProviderName);
if (options == null)
{
throw new KeyNotFoundException($"No lease base queue balancer options was configured for provider {strProviderName}, nor was a default configured.");
}
this.leaseProvider = this.serviceProvider.GetRequiredService(options.LeaseProviderType) as ILeaseProvider;
this.leaseLength = options.LeaseLength;
this.allQueues = new ReadOnlyCollection <QueueId>(queueMapper.GetAllQueues().ToList());
this.siloMaturityPeriod = siloMaturityPeriod;
NotifyAfterStart().Ignore();
//make lease renew frequency to be every half of lease time, to avoid renew failing due to timing issues, race condition or clock difference.
var timerLogger = this.loggerFactory.CreateLogger <AsyncTaskSafeTimer>();
this.renewLeaseTimer = new AsyncTaskSafeTimer(timerLogger, this.MaintainAndBalanceQueues, null, this.siloMaturityPeriod, this.leaseLength.Divide(2));
//try to acquire maximum leases every leaseLength
this.tryAcquireMaximumLeaseTimer = new AsyncTaskSafeTimer(timerLogger, this.AcquireLeaseToMeetMaxResponsibilty, null, this.siloMaturityPeriod, this.leaseLength);
//Selector default to round robin selector now, but we can make a further change to make selector configurable if needed. Selector algorithm could
//be affecting queue balancing stablization time in cluster initializing and auto-scaling
this.queueSelector = new RoundRobinSelector <QueueId>(this.allQueues);
return(MaintainAndBalanceQueues(null));
}
/// <summary>
/// Create stream queue balancer by type requested
/// </summary>
/// <param name="balancerType">queue balancer type to create</param>
/// <param name="strProviderName">name of requesting stream provider</param>
/// <param name="runtime">stream provider runtime environment to run in</param>
/// <param name="queueMapper">queue mapper of requesting stream provider</param>
/// <returns>Constructed stream queue balancer</returns>
public static IStreamQueueBalancer Create(
StreamQueueBalancerType balancerType,
string strProviderName,
IStreamProviderRuntime runtime,
IStreamQueueMapper queueMapper)
{
if (string.IsNullOrWhiteSpace(strProviderName))
{
throw new ArgumentNullException("strProviderName");
}
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
switch (balancerType)
{
case StreamQueueBalancerType.ConsistenRingBalancer:
{
// Consider: for now re-use the same ConsistentRingProvider with 1 equally devided range. Remove later.
IConsistentRingProviderForGrains ringProvider = runtime.GetConsistentRingProvider(0, 1);
return(new ConsistentRingQueueBalancer(ringProvider, queueMapper));
}
default:
{
string error = string.Format("Unsupported balancerType for stream provider. BalancerType: {0}, StreamProvider: {1}", balancerType, strProviderName);
throw new ArgumentOutOfRangeException("balancerType", error);
}
}
}
public virtual void Init()
{
this.receivers = new ConcurrentDictionary <QueueId, KafkaEventBusAdapterReceiver>();
this.telemetryProducer = this.serviceProvider.GetService <ITelemetryProducer>();
if (producer == null)
{
InitKafkaProducer();
}
_adapterCache = new SimpleQueueAdapterCache(new SimpleQueueCacheOptions {
CacheSize = cacheOptions.CacheSize
}, Name, loggerFactory);
if (this.StreamFailureHandlerFactory == null)
{
//TODO: Add a queue specific default failure handler with reasonable error reporting.
this.StreamFailureHandlerFactory = partition => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
if (this.QueueMapperFactory == null)
{
var h = new HashRingStreamQueueMapperOptions {
TotalQueueCount = receiverOptions.TotalQueueCount
};
this.streamQueueMapper = new HashRingBasedStreamQueueMapper(h, Name);
this.QueueMapperFactory = () => new HashRingBasedStreamQueueMapper(h, this.Name);
}
this.logger = this.loggerFactory.CreateLogger($"{this.GetType().FullName}"); // join topics?
}
/// <summary>
/// Create stream queue balancer by type requested
/// </summary>
/// <param name="balancerType">queue balancer type to create</param>
/// <param name="strProviderName">name of requesting stream provider</param>
/// <param name="siloStatusOracle">membership services interface.</param>
/// <param name="clusterConfiguration">cluster configuration</param>
/// <param name="runtime">stream provider runtime environment to run in</param>
/// <param name="queueMapper">queue mapper of requesting stream provider</param>
/// <param name="siloMaturityPeriod">Maturity Period of a silo for queue rebalancing purposes</param>
/// <returns>Constructed stream queue balancer</returns>
public static IStreamQueueBalancer Create(
StreamQueueBalancerType balancerType,
string strProviderName,
ISiloStatusOracle siloStatusOracle,
ClusterConfiguration clusterConfiguration,
IStreamProviderRuntime runtime,
IStreamQueueMapper queueMapper,
TimeSpan siloMaturityPeriod)
{
if (string.IsNullOrWhiteSpace(strProviderName))
{
throw new ArgumentNullException("strProviderName");
}
if (siloStatusOracle == null)
{
throw new ArgumentNullException("siloStatusOracle");
}
if (clusterConfiguration == null)
{
throw new ArgumentNullException("clusterConfiguration");
}
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
bool isFixed;
switch (balancerType)
{
case StreamQueueBalancerType.ConsistentRingBalancer:
{
// Consider: for now re-use the same ConsistentRingProvider with 1 equally devided range. Remove later.
IConsistentRingProviderForGrains ringProvider = runtime.GetConsistentRingProvider(0, 1);
return new ConsistentRingQueueBalancer(ringProvider, queueMapper);
}
case StreamQueueBalancerType.DynamicAzureDeploymentBalancer:
case StreamQueueBalancerType.StaticAzureDeploymentBalancer:
{
Logger logger = LogManager.GetLogger(typeof(StreamQueueBalancerFactory).Name, LoggerType.Runtime);
var wrapper = AssemblyLoader.LoadAndCreateInstance<IDeploymentConfiguration>(Constants.ORLEANS_AZURE_UTILS_DLL, logger);
isFixed = balancerType == StreamQueueBalancerType.StaticAzureDeploymentBalancer;
return new DeploymentBasedQueueBalancer(siloStatusOracle, wrapper, queueMapper, siloMaturityPeriod, isFixed);
}
case StreamQueueBalancerType.DynamicClusterConfigDeploymentBalancer:
case StreamQueueBalancerType.StaticClusterConfigDeploymentBalancer:
{
IDeploymentConfiguration deploymentConfiguration = new StaticClusterDeploymentConfiguration(clusterConfiguration);
isFixed = balancerType == StreamQueueBalancerType.StaticClusterConfigDeploymentBalancer;
return new DeploymentBasedQueueBalancer(siloStatusOracle, deploymentConfiguration, queueMapper, siloMaturityPeriod, isFixed);
}
default:
{
string error = string.Format("Unsupported balancerType for stream provider. BalancerType: {0}, StreamProvider: {1}", balancerType, strProviderName);
throw new ArgumentOutOfRangeException("balancerType", error);
}
}
}
/// <summary>
/// Factory initialization.
/// </summary>
/// <param name="providerConfig"></param>
/// <param name="name"></param>
/// <param name="svcProvider"></param>
public void Init(IProviderConfiguration providerConfig, string name, IServiceProvider svcProvider)
{
logger = svcProvider.GetService <ILogger <MemoryAdapterFactory <TSerializer> > >();
this.loggerFactory = svcProvider.GetRequiredService <ILoggerFactory>();
serviceProvider = svcProvider;
providerName = name;
queueGrains = new ConcurrentDictionary <QueueId, IMemoryStreamQueueGrain>();
adapterConfig = new MemoryAdapterConfig(providerName);
this.telemetryProducer = svcProvider.GetService <ITelemetryProducer>();
if (CacheMonitorFactory == null)
{
this.CacheMonitorFactory = (dimensions, telemetryProducer) => new DefaultCacheMonitor(dimensions, telemetryProducer);
}
if (this.BlockPoolMonitorFactory == null)
{
this.BlockPoolMonitorFactory = (dimensions, telemetryProducer) => new DefaultBlockPoolMonitor(dimensions, telemetryProducer);
}
if (this.ReceiverMonitorFactory == null)
{
this.ReceiverMonitorFactory = (dimensions, telemetryProducer) => new DefaultQueueAdapterReceiverMonitor(dimensions, telemetryProducer);
}
purgePredicate = new TimePurgePredicate(adapterConfig.DataMinTimeInCache, adapterConfig.DataMaxAgeInCache);
grainFactory = (IGrainFactory)serviceProvider.GetService(typeof(IGrainFactory));
adapterConfig.PopulateFromProviderConfig(providerConfig);
streamQueueMapper = new HashRingBasedStreamQueueMapper(adapterConfig.TotalQueueCount, adapterConfig.StreamProviderName);
this.sharedDimensions = new MonitorAggregationDimensions(serviceProvider.GetService <GlobalConfiguration>(), serviceProvider.GetService <NodeConfiguration>());
this.serializer = MemoryMessageBodySerializerFactory <TSerializer> .GetOrCreateSerializer(svcProvider);
}
public KafkaAdapterFactory(
string name,
KafkaStreamOptions options,
SimpleQueueCacheOptions cacheOptions,
SerializationManager serializationManager,
ILoggerFactory loggerFactory,
IGrainFactory grainFactory
)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
_name = name;
_serializationManager = serializationManager;
_loggerFactory = loggerFactory;
_grainFactory = grainFactory;
_logger = loggerFactory.CreateLogger <KafkaAdapterFactory>();
if (options.Topics != null && options.Topics.Count == 0)
{
throw new ArgumentNullException(nameof(options.Topics));
}
_adapterCache = new SimpleQueueAdapterCache(
cacheOptions,
name,
loggerFactory
);
_queueProperties = GetQueuesProperties();
_streamQueueMapper = new ExternalQueueMapper(_queueProperties.Values);
}
public DeploymentBasedQueueBalancer(
ISiloStatusOracle siloStatusOracle,
IDeploymentConfiguration deploymentConfig,
IStreamQueueMapper queueMapper,
bool isFixed)
{
if (siloStatusOracle == null)
{
throw new ArgumentNullException("siloStatusOracle");
}
if (deploymentConfig == null)
{
throw new ArgumentNullException("deploymentConfig");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.siloStatusOracle = siloStatusOracle;
this.deploymentConfig = deploymentConfig;
allQueues = queueMapper.GetAllQueues().ToList();
queueBalanceListeners = new List<IStreamQueueBalanceListener>();
mySiloName = this.siloStatusOracle.SiloName;
this.isFixed = isFixed;
// register for notification of changes to silo status for any silo in the cluster
this.siloStatusOracle.SubscribeToSiloStatusEvents(this);
}
public RabbitMQAdapterFactory(
string name,
RabbitMQStreamProviderOptions config,
HashRingStreamQueueMapperOptions queueMapperOptions,
SimpleQueueCacheOptions cacheOptions,
IServiceProvider serviceProvider,
IOptions <ClusterOptions> clusterOptions,
SerializationManager serializationManager,
ILoggerFactory loggerFactory,
IMessageSerializationHandler serializationHandler,
IRabbitMQMapper mapper)
{
_config = config;
_providerName = name;
_loggeFactory = loggerFactory;
_serializationHandler = serializationHandler;
_mapper = mapper;
_mapper.Init( );
_cacheSize = cacheOptions.CacheSize;
_adapterCache = new SimpleQueueAdapterCache(cacheOptions, _providerName, _loggeFactory);
_streamQueueMapper = new HashRingBasedStreamQueueMapper(queueMapperOptions, _providerName);
}
public RabbitMqAdapter(RabbitMqStreamProviderOptions options, SerializationManager serializationManager, IStreamQueueMapper mapper, string providerName, Logger logger)
{
_serializationManager = serializationManager;
_mapper = mapper;
Name = providerName;
_rmqConnectorFactory = new RabbitMqOnlineConnectorFactory(options, logger);
_cacheFillingTimeout = options.CacheFillingTimeout;
}
public RabbitMqAdapter(RabbitMqOptions rmqOptions, CachingOptions cachingOptions, IBatchContainerSerializer serializer, IStreamQueueMapper mapper, string providerName, ILoggerFactory loggerFactory)
{
_serializer = serializer;
_mapper = mapper;
Name = providerName;
_rmqConnectorFactory = new RabbitMqOnlineConnectorFactory(rmqOptions, loggerFactory);
_cacheFillingTimeout = cachingOptions.CacheFillingTimeout;
}
public Task <IQueueAdapter> CreateAdapter()
{
if (this.streamQueueMapper == null)
{
this.streamQueueMapper = this.QueueMapperFactory();
}
return(Task.FromResult(this as IQueueAdapter));
}
public RabbitMqAdapter(RabbitMqOptions rmqOptions, IQueueDataAdapter <RabbitMqMessage, IEnumerable <IBatchContainer> > dataAdapter, string providerName, IStreamQueueMapper mapper, IRabbitMqConnectorFactory rmqConnectorFactory)
{
_dataAdapter = dataAdapter;
Name = providerName;
_mapper = mapper;
_rmqConnectorFactory = rmqConnectorFactory;
_rmqOptions = rmqOptions;
_producer = new ThreadLocal <IRabbitMqProducer>(() => _rmqConnectorFactory.CreateProducer());
}
public async Task Initialize(string strProviderName,
IStreamQueueMapper queueMapper)
{
this.leaseManagerGrain = this.grainFactory.GetGrain <ILeaseManagerGrain>(strProviderName);
await this.leaseManagerGrain.SetQueuesAsLeases(queueMapper.GetAllQueues());
this.id = $"{strProviderName}-{Guid.NewGuid()}";
await GetInitialLease();
}
public RabbitMQAdapter(RabbitMQStreamProviderConfig config, Logger logger, string providerName, IStreamQueueMapper streamQueueMapper, IRabbitMQMapper mapper)
{
_config = config;
_logger = logger;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_mapper = mapper;
_queues = new ConcurrentDictionary <QueueId, object>();
}
/// <summary>
/// Create stream queue balancer by type requested
/// </summary>
/// <param name="balancerType">queue balancer type to create</param>
/// <param name="strProviderName">name of requesting stream provider</param>
/// <param name="siloStatusOracle">membership services interface.</param>
/// <param name="clusterConfiguration">cluster configuration</param>
/// <param name="runtime">stream provider runtime environment to run in</param>
/// <param name="queueMapper">queue mapper of requesting stream provider</param>
/// <returns>Constructed stream queue balancer</returns>
public static IStreamQueueBalancer Create(
StreamQueueBalancerType balancerType,
string strProviderName,
ISiloStatusOracle siloStatusOracle,
ClusterConfiguration clusterConfiguration,
IStreamProviderRuntime runtime,
IStreamQueueMapper queueMapper)
{
if (string.IsNullOrWhiteSpace(strProviderName))
{
throw new ArgumentNullException("strProviderName");
}
if (siloStatusOracle == null)
{
throw new ArgumentNullException("siloStatusOracle");
}
if (clusterConfiguration == null)
{
throw new ArgumentNullException("clusterConfiguration");
}
if (runtime == null)
{
throw new ArgumentNullException("runtime");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
switch (balancerType)
{
case StreamQueueBalancerType.ConsistentRingBalancer:
{
// Consider: for now re-use the same ConsistentRingProvider with 1 equally devided range. Remove later.
IConsistentRingProviderForGrains ringProvider = runtime.GetConsistentRingProvider(0, 1);
return(new ConsistentRingQueueBalancer(ringProvider, queueMapper));
}
case StreamQueueBalancerType.AzureDeploymentBalancer:
{
TraceLogger logger = TraceLogger.GetLogger(typeof(StreamQueueBalancerFactory).Name, TraceLogger.LoggerType.Runtime);
var wrapper = AssemblyLoader.LoadAndCreateInstance <IDeploymentConfiguration>(Constants.ORLEANS_AZURE_UTILS_DLL, logger);
return(new DeploymentBasedQueueBalancer(siloStatusOracle, wrapper, queueMapper));
}
case StreamQueueBalancerType.StaticClusterDeploymentBalancer:
{
IDeploymentConfiguration deploymentConfiguration = new StaticClusterDeploymentConfiguration(clusterConfiguration);
return(new DeploymentBasedQueueBalancer(siloStatusOracle, deploymentConfiguration, queueMapper));
}
default:
{
string error = string.Format("Unsupported balancerType for stream provider. BalancerType: {0}, StreamProvider: {1}", balancerType, strProviderName);
throw new ArgumentOutOfRangeException("balancerType", error);
}
}
}
public override Task Initialize(IStreamQueueMapper queueMapper)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.allQueues = new ReadOnlyCollection <QueueId>(queueMapper.GetAllQueues().ToList());
NotifyAfterStart().Ignore();
return(Task.CompletedTask);
}
public GenericQueueAdapter(Logger logger, IStreamQueueMapper streamQueueMapper, string providerName, IProviderConfiguration config, IProviderQueue queueProvider, int numOfQueues)
{
Name = providerName; // WTF: If you set the name to anything else, the client won't receive any messages !?????
_config = config;
_logger = logger;
_streamQueueMapper = streamQueueMapper;
_queueProvider = queueProvider;
_providerName = providerName;
_numOfQueues = numOfQueues;
}
public override Task Initialize(IStreamQueueMapper queueMapper)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.allQueues = queueMapper.GetAllQueues().ToList();
NotifyAfterStart().Ignore();
return(base.Initialize(queueMapper));
}
public RabbitMqAdapterReceiver(IRabbitMqConnectorFactory rmqConnectorFactory, QueueId queueId, IStreamQueueMapper mapper, IQueueDataAdapter <RabbitMqMessage, IEnumerable <IBatchContainer> > dataAdapter)
{
_rmqConnectorFactory = rmqConnectorFactory;
_queueId = queueId;
_mapper = mapper;
_dataAdapter = dataAdapter;
_logger = _rmqConnectorFactory.LoggerFactory.CreateLogger($"{typeof(RabbitMqAdapterReceiver).FullName}.{queueId}");
_sequenceId = 0;
pending = new List <PendingDelivery>();
_currentGroup = new Queue <IBatchContainer>();
}
public RabbitMQAdapter(RabbitMQStreamProviderOptions config, ILoggerFactory loggerFactory, string providerName, IStreamQueueMapper streamQueueMapper, IRabbitMQMapper mapper)
{
Direction = config.Mode;
_config = config;
_loggerFactory = loggerFactory;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_mapper = mapper;
_queues = new ConcurrentDictionary <QueueId, object>();
CreateConnection();
}
public async Task Initialize(string strProviderName,
IStreamQueueMapper queueMapper,
TimeSpan siloMaturityPeriod,
IProviderConfiguration providerConfig)
{
this.leaseManagerGrain = this.grainFactory.GetGrain <ILeaseManagerGrain>(strProviderName);
await this.leaseManagerGrain.SetQueuesAsLeases(queueMapper.GetAllQueues());
this.id = $"{strProviderName}-{Guid.NewGuid()}";
await GetInitialLease();
}
public RedisQueueAdapter(
RedisStreamOptions options,
IConnectionMultiplexerFactory connectionMultiplexerFactory,
IRedisDataAdapter dataAdapter,
IStreamQueueMapper streamQueueMapper,
ILogger logger,
string serviceId,
string clusterId,
string providerName)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (connectionMultiplexerFactory == null)
{
throw new ArgumentNullException(nameof(connectionMultiplexerFactory));
}
if (dataAdapter == null)
{
throw new ArgumentNullException(nameof(dataAdapter));
}
if (streamQueueMapper == null)
{
throw new ArgumentNullException(nameof(streamQueueMapper));
}
if (string.IsNullOrEmpty(serviceId))
{
throw new ArgumentNullException(nameof(serviceId));
}
if (string.IsNullOrEmpty(clusterId))
{
throw new ArgumentNullException(nameof(clusterId));
}
if (string.IsNullOrEmpty(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
_redisStreamOptions = options;
_connectionMultiplexerFactory = connectionMultiplexerFactory;
ServiceId = serviceId;
ClusterId = clusterId;
Name = providerName;
_streamQueueMapper = streamQueueMapper;
_dataAdapter = dataAdapter;
_logger = logger.ForContext <RedisQueueAdapter>(new Dictionary <string, object>
{
{ "ServiceId", serviceId },
{ "ProviderName", providerName }
});
}
public override Task Initialize(string strProviderName,
IStreamQueueMapper queueMapper,
TimeSpan siloMaturityPeriod)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.allQueues = new ReadOnlyCollection <QueueId>(queueMapper.GetAllQueues().ToList());
this.siloMaturityPeriod = siloMaturityPeriod;
NotifyAfterStart().Ignore();
return(Task.CompletedTask);
}
public override Task Initialize(IStreamQueueMapper queueMapper)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
if (!(queueMapper is IConsistentRingStreamQueueMapper))
{
throw new ArgumentException("queueMapper for ConsistentRingQueueBalancer should implement IConsistentRingStreamQueueMapper", "queueMapper");
}
streamQueueMapper = (IConsistentRingStreamQueueMapper)queueMapper;
return(base.Initialize(queueMapper));
}
public void Init(IProviderConfiguration providerConfig, string providerName, Logger log, IServiceProvider svcProvider)
{
this.logger = log;
this.serviceProvider = svcProvider;
this.providerName = providerName;
this.queueGrains = new ConcurrentDictionary <QueueId, IMemoryStreamQueueGrain>();
this.adapterConfig = new MemoryAdapterConfig(providerName);
grainFactory = (GrainFactory)serviceProvider.GetService(typeof(GrainFactory));
adapterConfig.PopulateFromProviderConfig(providerConfig);
this.streamQueueMapper = new HashRingBasedStreamQueueMapper(adapterConfig.TotalQueueCount, adapterConfig.StreamProviderName);
// 10 meg buffer pool. 10 1 meg blocks
this.bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(adapterConfig.CacheSizeMb, () => new FixedSizeBuffer(1 << 20));
}
public override Task Initialize(string strProviderName,
IStreamQueueMapper queueMapper)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
if (!(queueMapper is IConsistentRingStreamQueueMapper))
{
throw new ArgumentException("queueMapper for ConsistentRingQueueBalancer should implement IConsistentRingStreamQueueMapper", "queueMapper");
}
streamQueueMapper = (IConsistentRingStreamQueueMapper)queueMapper;
return(Task.CompletedTask);
}
/// <summary>
/// Factory initialization.
/// </summary>
/// <param name="providerConfig"></param>
/// <param name="name"></param>
/// <param name="log"></param>
/// <param name="svcProvider"></param>
public void Init(IProviderConfiguration providerConfig, string name, Logger log, IServiceProvider svcProvider)
{
logger = log;
serviceProvider = svcProvider;
providerName = name;
queueGrains = new ConcurrentDictionary <QueueId, IMemoryStreamQueueGrain>();
adapterConfig = new MemoryAdapterConfig(providerName);
grainFactory = (IGrainFactory)serviceProvider.GetService(typeof(IGrainFactory));
adapterConfig.PopulateFromProviderConfig(providerConfig);
streamQueueMapper = new HashRingBasedStreamQueueMapper(adapterConfig.TotalQueueCount, adapterConfig.StreamProviderName);
// 10 meg buffer pool. 10 1 meg blocks
bufferPool = new FixedSizeObjectPool <FixedSizeBuffer>(() => new FixedSizeBuffer(1 << 20), adapterConfig.CacheSizeMb);
this.serializer = MemoryMessageBodySerializerFactory <TSerializer> .GetOrCreateSerializer(svcProvider);
}
/// <inheritdoc/>
public override Task Initialize(IStreamQueueMapper queueMapper)
{
if (base.Cancellation.IsCancellationRequested)
{
throw new InvalidOperationException("Cannot initialize a terminated balancer.");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.allQueues = new ReadOnlyCollection <QueueId>(queueMapper.GetAllQueues().ToList());
//Selector default to round robin selector now, but we can make a further change to make selector configurable if needed. Selector algorithm could
//be affecting queue balancing stablization time in cluster initializing and auto-scaling
this.queueSelector = new RoundRobinSelector <QueueId>(this.allQueues, new Random(this.GetHashCode()));
return(base.Initialize(queueMapper));
}
public EventStoreAdapterFactory(string providerName, IEventStoreStreamProviderConfiguration streamProviderConfiguration, ILoggerFactory loggerFactory)
{
_streamProviderConfiguration = streamProviderConfiguration;
_loggerFactory = loggerFactory;
_providerName = providerName;
_receivers = new ConcurrentDictionary <QueueId, EventStoreQueueAdapterReceiver>();
_eventStoreQueueAdapterCache = new EventStoreQueueAdapterCache(this, loggerFactory);
var hashRingStreamQueueMapperOptions = new HashRingStreamQueueMapperOptions()
{
TotalQueueCount = 2
};
_streamQueueMapper = new HashRingBasedStreamQueueMapper(hashRingStreamQueueMapperOptions, _providerName);
}
public RabbitMqAdapterFactory(
string providerName,
IOptionsMonitor <RabbitMqOptions> rmqOptionsAccessor,
IOptionsMonitor <SimpleQueueCacheOptions> cachingOptionsAccessor,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
IRabbitMqStreamQueueMapperFactory streamQueueMapperFactory)
{
if (string.IsNullOrEmpty(providerName))
{
throw new ArgumentNullException(nameof(providerName));
}
if (rmqOptionsAccessor == null)
{
throw new ArgumentNullException(nameof(rmqOptionsAccessor));
}
if (cachingOptionsAccessor == null)
{
throw new ArgumentNullException(nameof(cachingOptionsAccessor));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
if (streamQueueMapperFactory == null)
{
throw new ArgumentNullException(nameof(streamQueueMapperFactory));
}
var rmqOptions = rmqOptionsAccessor.Get(providerName);
var cachingOptions = cachingOptionsAccessor.Get(providerName);
_cache = new SimpleQueueAdapterCache(cachingOptions, providerName, loggerFactory);
_mapper = streamQueueMapperFactory.Get(providerName);
_failureHandler = Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler(false));
var dataAdapter = serviceProvider.GetServiceByName <IQueueDataAdapter <RabbitMqMessage, IEnumerable <IBatchContainer> > >(providerName) ??
RabbitMqDataAdapter.Create(serviceProvider, providerName);
_adapter = new RabbitMqAdapter(rmqOptions, dataAdapter, providerName, _mapper, serviceProvider.GetRequiredServiceByName <IRabbitMqConnectorFactory>(providerName));
}
public TestAdapterFactory(
string name,
SimpleQueueCacheOptions cacheOptions,
Func <IEnumerable <IBatchContainer> > queueMessagesProvider,
Action <IEnumerable <IBatchContainer> > onMessagesDelivered,
ILoggerFactory loggerFactory
)
{
_providerName = name;
_queueMessagesProvider = queueMessagesProvider ?? throw new ArgumentNullException(nameof(queueMessagesProvider));
_onMessagesDelivered = onMessagesDelivered ?? throw new ArgumentNullException(nameof(onMessagesDelivered));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_streamQueueMapper = new HashRingBasedStreamQueueMapper(new HashRingStreamQueueMapperOptions()
{
TotalQueueCount = 1
}, _providerName);
_adapterCache = new SimpleQueueAdapterCache(cacheOptions, _providerName, _loggerFactory);
}
/// <summary>
/// Factory initialization.
/// </summary>
public void Init()
{
this.queueGrains = new ConcurrentDictionary <QueueId, IMemoryStreamQueueGrain>();
if (CacheMonitorFactory == null)
{
this.CacheMonitorFactory = (dimensions, telemetryProducer) => new DefaultCacheMonitor(dimensions, telemetryProducer);
}
if (this.BlockPoolMonitorFactory == null)
{
this.BlockPoolMonitorFactory = (dimensions, telemetryProducer) => new DefaultBlockPoolMonitor(dimensions, telemetryProducer);
}
if (this.ReceiverMonitorFactory == null)
{
this.ReceiverMonitorFactory = (dimensions, telemetryProducer) => new DefaultQueueAdapterReceiverMonitor(dimensions, telemetryProducer);
}
this.purgePredicate = new TimePurgePredicate(this.cacheOptions.DataMinTimeInCache, this.cacheOptions.DataMaxAgeInCache);
this.streamQueueMapper = new HashRingBasedStreamQueueMapper(this.queueMapperOptions, this.Name);
}
public DeploymentBasedQueueBalancer(
ISiloStatusOracle siloStatusOracle,
IDeploymentConfiguration deploymentConfig,
IStreamQueueMapper queueMapper,
TimeSpan maturityPeriod,
bool isFixed)
{
if (siloStatusOracle == null)
{
throw new ArgumentNullException("siloStatusOracle");
}
if (deploymentConfig == null)
{
throw new ArgumentNullException("deploymentConfig");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.siloStatusOracle = siloStatusOracle;
this.deploymentConfig = deploymentConfig;
allQueues = new ReadOnlyCollection<QueueId>(queueMapper.GetAllQueues().ToList());
queueBalanceListeners = new List<IStreamQueueBalanceListener>();
immatureSilos = new ConcurrentDictionary<SiloAddress, bool>();
this.isFixed = isFixed;
siloMaturityPeriod = maturityPeriod;
isStarting = true;
// register for notification of changes to silo status for any silo in the cluster
this.siloStatusOracle.SubscribeToSiloStatusEvents(this);
// record all already active silos as already mature.
// Even if they are not yet, they will be mature by the time I mature myself (after I become !isStarting).
foreach (var silo in siloStatusOracle.GetApproximateSiloStatuses(true).Keys.Where(s => !s.Equals(siloStatusOracle.SiloAddress)))
{
immatureSilos[silo] = false; // record as mature
}
NotifyAfterStart().Ignore();
}
public DeploymentBasedQueueBalancer(
ISiloStatusOracle siloStatusOracle,
IDeploymentConfiguration deploymentConfig,
IStreamQueueMapper queueMapper)
{
if (siloStatusOracle == null)
{
throw new ArgumentNullException("siloStatusOracle");
}
if (deploymentConfig == null)
{
throw new ArgumentNullException("deploymentConfig");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
this.siloStatusOracle = siloStatusOracle;
this.deploymentConfig = deploymentConfig;
streamQueueMapper = queueMapper;
queueBalanceListeners = new List<IStreamQueueBalanceListener>();
mySiloName = this.siloStatusOracle.SiloName;
activeSiloNames = new List<string>();
allSiloNames = this.deploymentConfig.GetAllSiloInstanceNames();
List<QueueId> allQueues = streamQueueMapper.GetAllQueues().ToList();
resourceBalancer = new BestFitBalancer<string, QueueId>(allSiloNames, allQueues);
// get silo names for all active silos
foreach (SiloAddress siloAddress in this.siloStatusOracle.GetApproximateSiloStatuses(true).Keys)
{
string siloName;
if (this.siloStatusOracle.TryGetSiloName(siloAddress, out siloName))
{
activeSiloNames.Add(siloName);
}
}
// register for notification of changes to silo status for any silo in the cluster
this.siloStatusOracle.SubscribeToSiloStatusEvents(this);
}
public ConsistentRingQueueBalancer(
IConsistentRingProviderForGrains ringProvider,
IStreamQueueMapper queueMapper)
{
if (ringProvider == null)
{
throw new ArgumentNullException("ringProvider");
}
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
if (!(queueMapper is IConsistentRingStreamQueueMapper))
{
throw new ArgumentException("queueMapper for ConsistentRingQueueBalancer should implement IConsistentRingStreamQueueMapper", "queueMapper");
}
streamQueueMapper = (IConsistentRingStreamQueueMapper)queueMapper;
myRange = ringProvider.GetMyRange();
ringProvider.SubscribeToRangeChangeEvents(this);
}