private GossipTableInstanceManager(Guid globalServiceId, string storageConnectionString, ILoggerFactory loggerFactory)
{
GlobalServiceId = globalServiceId.ToString();
this.logger = loggerFactory.CreateLogger <GossipTableInstanceManager>();
storage = new AzureTableDataManager <GossipTableEntry>(
INSTANCE_TABLE_NAME, storageConnectionString, loggerFactory);
}
public static async Task DeleteAll()
{
var dataManager = new AzureTableDataManager <TableEntity>(TableName, TestDefaultConfiguration.DataConnectionString, NullLoggerFactory.Instance.CreateLogger <AzureTableDataManager <TableEntity> >());
await dataManager.InitTableAsync();
await dataManager.DeleteTableAsync();
}
public static async Task DeleteAll()
{
var dataManager = new AzureTableDataManager <TableEntity>(TableName, StorageTestConstants.DataConnectionString);
await dataManager.InitTableAsync();
await dataManager.DeleteTableAsync();
}
private async Task CreateTable()
{
var tableManager = new AzureTableDataManager <TableEntity>(this.options.TableName, this.options.ConnectionString, this.loggerFactory);
await tableManager.InitTableAsync().ConfigureAwait(false);
this.table = tableManager.Table;
}
private EventHubCheckpointer(AzureTableStreamCheckpointerOptions options, string streamProviderName, string partition, string serviceId, ILoggerFactory loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (string.IsNullOrWhiteSpace(streamProviderName))
{
throw new ArgumentNullException(nameof(streamProviderName));
}
if (string.IsNullOrWhiteSpace(partition))
{
throw new ArgumentNullException(nameof(partition));
}
this.logger = loggerFactory.CreateLogger <EventHubCheckpointer>();
this.logger.LogInformation(
"Creating EventHub checkpointer for partition {Partition} of stream provider {StreamProviderName} with serviceId {ServiceId}.",
partition,
streamProviderName,
serviceId);
persistInterval = options.PersistInterval;
dataManager = new AzureTableDataManager <EventHubPartitionCheckpointEntity>(
options,
loggerFactory.CreateLogger <EventHubPartitionCheckpointEntity>());
entity = EventHubPartitionCheckpointEntity.Create(streamProviderName, serviceId, partition);
}
public override void Dispose()
{
var dataManager = new AzureTableDataManager<TableEntity>(CheckpointerSettings.TableName, CheckpointerSettings.DataConnectionString);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
base.Dispose();
}
public override void Dispose()
{
base.Dispose();
var dataManager = new AzureTableDataManager<TableEntity>(CheckpointerSettings.TableName, CheckpointerSettings.DataConnectionString, NullLoggerFactory.Instance);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
}
public static async Task DeleteAll()
{
var dataManager = new AzureTableDataManager <TableEntity>(TableName, TestDefaultConfiguration.DataConnectionString);
await dataManager.InitTableAsync();
await dataManager.DeleteTableAsync();
}
public override void Dispose()
{
var dataManager = new AzureTableDataManager <TableEntity>(CheckpointSettings.TableName, CheckpointSettings.DataConnectionString);
dataManager.InitTableAsync().Wait();
dataManager.DeleteTableAsync().Wait();
base.Dispose();
}
public override void Dispose()
{
base.Dispose();
var dataManager = new AzureTableDataManager<TableEntity>(CheckpointerSettings.TableName, CheckpointerSettings.DataConnectionString);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
TestAzureTableStorageStreamFailureHandler.DeleteAll().Wait();
}
public override void Dispose()
{
base.Dispose();
var dataManager = new AzureTableDataManager <TableEntity>(EHCheckpointTable, TestDefaultConfiguration.DataConnectionString, NullLoggerFactory.Instance);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
}
public override void Dispose()
{
base.Dispose();
var dataManager = new AzureTableDataManager <TableEntity>(CheckpointerSettings.TableName, CheckpointerSettings.DataConnectionString);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
TestAzureTableStorageStreamFailureHandler.DeleteAll().Wait();
}
public override void Dispose()
{
base.Dispose();
if (!isSkippable)
{
var dataManager = new AzureTableDataManager <TableEntity>(CheckpointerSettings.TableName, CheckpointerSettings.DataConnectionString);
dataManager.InitTableAsync().Wait();
dataManager.ClearTableAsync().Wait();
}
}
async Task IClientMetricsDataPublisher.Init(ClientConfiguration config, IPAddress address, string clientId)
{
deploymentId = config.DeploymentId;
this.clientId = clientId;
this.address = address;
myHostName = config.DNSHostName;
storage = new AzureTableDataManager<ClientMetricsData>(
INSTANCE_TABLE_NAME, config.DataConnectionString, logger);
await storage.InitTableAsync().WithTimeout(initTimeout);
}
public static async Task DeleteAll()
{
var dataManager = new AzureTableDataManager <TableEntity>(
new AzureStorageOperationOptions {
TableName = TableName
}.ConfigureTestDefaults(),
NullLoggerFactory.Instance.CreateLogger <AzureTableDataManager <TableEntity> >());
await dataManager.InitTableAsync();
await dataManager.DeleteTableAsync();
}
public static async Task <int> GetDeliveryFailureCount(string streamProviderName)
{
var dataManager = new AzureTableDataManager <TableEntity>(TableName, TestDefaultConfiguration.DataConnectionString);
dataManager.InitTableAsync().Wait();
IEnumerable <Tuple <TableEntity, string> > deliveryErrors =
await
dataManager.ReadAllTableEntriesForPartitionAsync(
StreamDeliveryFailureEntity.MakeDefaultPartitionKey(streamProviderName, DeploymentId));
return(deliveryErrors.Count());
}
async Task IStatisticsPublisher.Init(bool isSilo, string storageConnectionString, string deploymentId, string address, string siloName, string hostName)
{
this.deploymentId = deploymentId;
this.address = address;
name = siloName;
myHostName = hostName;
this.isSilo = isSilo;
if (!this.isSilo)
{
clientEpoch = SiloAddress.AllocateNewGeneration();
}
counter = 0;
var tableName = isSilo ? "OrleansSiloStatistics" : "OrleansClientStatistics";
tableManager = new AzureTableDataManager<StatsTableData>(tableName, storageConnectionString, logger);
await tableManager.InitTableAsync().WithTimeout(initTimeout);
}
public static async Task <int> GetDeliveryFailureCount(string streamProviderName, ILoggerFactory loggerFactory)
{
var dataManager = new AzureTableDataManager <TableEntity>(
new AzureStorageOperationOptions {
TableName = TableName
}.ConfigureTestDefaults(),
loggerFactory.CreateLogger <AzureTableDataManager <TableEntity> >());
await dataManager.InitTableAsync();
IEnumerable <Tuple <TableEntity, string> > deliveryErrors =
await
dataManager.ReadAllTableEntriesForPartitionAsync(
StreamDeliveryFailureEntity.MakeDefaultPartitionKey(streamProviderName, DeploymentId));
return(deliveryErrors.Count());
}
private EventHubPartitionCheckpoint(ICheckpointSettings settings, string streamProviderName, string partition)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (string.IsNullOrWhiteSpace(streamProviderName))
{
throw new ArgumentNullException("streamProviderName");
}
if (string.IsNullOrWhiteSpace(partition))
{
throw new ArgumentNullException("partition");
}
persistInterval = settings.PersistInterval;
dataManager = new AzureTableDataManager<EventHubPartitionCheckpointEntity>(settings.TableName, settings.DataConnectionString);
entity = EventHubPartitionCheckpointEntity.Create(streamProviderName, settings.CheckpointNamespace, partition);
}
private EventHubCheckpointer(ICheckpointerSettings settings, string streamProviderName, string partition, ILoggerFactory loggerFactory)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (string.IsNullOrWhiteSpace(streamProviderName))
{
throw new ArgumentNullException(nameof(streamProviderName));
}
if (string.IsNullOrWhiteSpace(partition))
{
throw new ArgumentNullException(nameof(partition));
}
persistInterval = settings.PersistInterval;
dataManager = new AzureTableDataManager <EventHubPartitionCheckpointEntity>(settings.TableName, settings.DataConnectionString, loggerFactory);
entity = EventHubPartitionCheckpointEntity.Create(streamProviderName, settings.CheckpointNamespace, partition);
}
/// <summary>
/// Delivery failure handler that writes failures to azure table storage.
/// </summary>
/// <param name="serializer"></param>
/// <param name="loggerFactory">logger factory to use</param>
/// <param name="faultOnFailure"></param>
/// <param name="clusterId"></param>
/// <param name="azureStorageOptions"></param>
/// <param name="createEntity"></param>
public AzureTableStorageStreamFailureHandler(Serializer <StreamSequenceToken> serializer, ILoggerFactory loggerFactory, bool faultOnFailure, string clusterId, AzureStorageOperationOptions azureStorageOptions, Func <TEntity> createEntity = null)
{
if (string.IsNullOrEmpty(clusterId))
{
throw new ArgumentNullException(nameof(clusterId));
}
if (string.IsNullOrEmpty(azureStorageOptions.TableName))
{
throw new ArgumentNullException(nameof(azureStorageOptions.TableName));
}
this.serializer = serializer;
this.clusterId = clusterId;
ShouldFaultSubsriptionOnError = faultOnFailure;
this.createEntity = createEntity ?? DefaultCreateEntity;
dataManager = new AzureTableDataManager <TEntity>(
azureStorageOptions,
loggerFactory.CreateLogger <AzureTableDataManager <TEntity> >());
}
/// <summary>
/// Delivery failure handler that writes failures to azure table storage.
/// </summary>
/// <param name="faultOnFailure"></param>
/// <param name="deploymentId"></param>
/// <param name="tableName"></param>
/// <param name="storageConnectionString"></param>
/// <param name="createEntity"></param>
public AzureTableStorageStreamFailureHandler(bool faultOnFailure, string deploymentId, string tableName, string storageConnectionString, Func <TEntity> createEntity = null)
{
if (string.IsNullOrEmpty(deploymentId))
{
throw new ArgumentNullException("deploymentId");
}
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName");
}
if (string.IsNullOrEmpty(storageConnectionString))
{
throw new ArgumentNullException("storageConnectionString");
}
this.deploymentId = deploymentId;
ShouldFaultSubsriptionOnError = faultOnFailure;
this.createEntity = createEntity ?? DefaultCreateEntity;
dataManager = new AzureTableDataManager <TEntity>(tableName, storageConnectionString);
}
/// <summary>
/// Delivery failure handler that writes failures to azure table storage.
/// </summary>
/// <param name="serializationManager"></param>
/// <param name="loggerFactory">logger factory to use</param>
/// <param name="faultOnFailure"></param>
/// <param name="clusterId"></param>
/// <param name="tableName"></param>
/// <param name="storageConnectionString"></param>
/// <param name="createEntity"></param>
public AzureTableStorageStreamFailureHandler(SerializationManager serializationManager, ILoggerFactory loggerFactory, bool faultOnFailure, string clusterId, string tableName, string storageConnectionString, Func <TEntity> createEntity = null)
{
if (string.IsNullOrEmpty(clusterId))
{
throw new ArgumentNullException(nameof(clusterId));
}
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName");
}
if (string.IsNullOrEmpty(storageConnectionString))
{
throw new ArgumentNullException("storageConnectionString");
}
this.serializationManager = serializationManager;
this.clusterId = clusterId;
ShouldFaultSubsriptionOnError = faultOnFailure;
this.createEntity = createEntity ?? DefaultCreateEntity;
dataManager = new AzureTableDataManager <TEntity>(tableName, storageConnectionString, loggerFactory);
}
public GrainStateTableDataManager(string tableName, string storageConnectionString, ILoggerFactory loggerFactory)
{
this.logger = loggerFactory.CreateLogger <GrainStateTableDataManager>();
TableName = tableName;
tableManager = new AzureTableDataManager <DynamicTableEntity>(tableName, storageConnectionString, loggerFactory);
}
public GrainStateTableDataManager(string tableName, string storageConnectionString, Logger logger)
{
this.logger = logger;
TableName = tableName;
tableManager = new AzureTableDataManager <DynamicTableEntity>(tableName, storageConnectionString);
}
private OrleansSiloInstanceManager(string deploymentId, string storageConnectionString)
{
DeploymentId = deploymentId;
logger = TraceLogger.GetLogger(this.GetType().Name, TraceLogger.LoggerType.Runtime);
storage = new AzureTableDataManager<SiloInstanceTableEntry>(
INSTANCE_TABLE_NAME, storageConnectionString, logger);
}
public GrainStateTableDataManager(AzureStorageOperationOptions options, ILogger logger)
{
this.logger = logger;
TableName = options.TableName;
tableManager = new AzureTableDataManager <TableEntity>(options, logger);
}
public async Task Init(string deploymentId, string storageConnectionString, SiloAddress siloAddress, string siloName, IPEndPoint gateway, string hostName)
{
this.deploymentId = deploymentId;
this.siloAddress = siloAddress;
this.siloName = siloName;
this.gateway = gateway;
myHostName = hostName;
storage = new AzureTableDataManager<SiloMetricsData>( INSTANCE_TABLE_NAME, storageConnectionString, logger);
await storage.InitTableAsync().WithTimeout(initTimeout);
}
public GrainStateTableDataManager(string tableName, string storageConnectionString, Logger logger)
{
this.logger = logger;
TableName = tableName;
tableManager = new AzureTableDataManager<GrainStateEntity>(tableName, storageConnectionString);
}
private GossipTableInstanceManager(Guid globalServiceId, string storageConnectionString, Logger logger)
{
GlobalServiceId = globalServiceId.ToString();
this.logger = logger;
storage = new AzureTableDataManager<GossipTableEntry>(
INSTANCE_TABLE_NAME, storageConnectionString, logger);
}
public GrainStateTableDataManager(string tableName, string storageConnectionString, ILogger logger, AzureStoragePolicyOptions storagePolicyOptions)
{
this.logger = logger;
TableName = tableName;
tableManager = new AzureTableDataManager <DynamicTableEntity>(tableName, storageConnectionString, logger, storagePolicyOptions);
}
