public async Task InitializeGatewayListProvider()
{
this.siloInstanceManager = await OrleansSiloInstanceManager.GetManager(
this.clusterId,
this.loggerFactory,
this.options);
}
public static async Task <AzureGatewayListProvider> GetAzureGatewayListProvider(ClientConfiguration conf)
{
var provider = new AzureGatewayListProvider(conf)
{
siloInstanceManager = await OrleansSiloInstanceManager.GetManager(conf.DeploymentId, conf.DataConnectionString)
};
return(provider);
}
public void TestInitialize()
{
deploymentId = "test-" + Guid.NewGuid();
generation = SiloAddress.AllocateNewGeneration();
siloAddress = SiloAddress.NewLocalAddress(generation);
logger.Info("DeploymentId={0} Generation={1}", deploymentId, generation);
logger.Info("Initializing SiloInstanceManager");
manager = OrleansSiloInstanceManager.GetManager(deploymentId, StorageTestConstants.DataConnectionString)
.WaitForResultWithThrow(SiloInstanceTableTestConstants.Timeout);
}
public void TestCleanup()
{
if(manager != null && SiloInstanceTableTestConstants.DeleteEntriesAfterTest)
{
TimeSpan timeout = SiloInstanceTableTestConstants.Timeout;
logger.Info("TestCleanup Timeout={0}", timeout);
manager.DeleteTableEntries(deploymentId).WaitWithThrow(timeout);
logger.Info("TestCleanup - Finished");
manager = null;
}
}
public static async Task <OrleansSiloInstanceManager> GetManager(
string clusterId,
ILoggerFactory loggerFactory,
AzureStorageOperationOptions options)
{
var instance = new OrleansSiloInstanceManager(clusterId, loggerFactory, options);
try
{
await instance.storage.InitTableAsync();
}
catch (Exception ex)
{
instance.logger.LogError((int)TableStorageErrorCode.AzureTable_33, ex, "Exception trying to create or connect to the Azure table {TableName}", instance.storage.TableName);
throw new OrleansException($"Exception trying to create or connect to the Azure table {instance.storage.TableName}", ex);
}
return(instance);
}
public static async Task <OrleansSiloInstanceManager> GetManager(
string clusterId,
ILoggerFactory loggerFactory,
AzureStorageOperationOptions options)
{
var instance = new OrleansSiloInstanceManager(clusterId, loggerFactory, options);
try
{
await instance.storage.InitTableAsync();
}
catch (Exception ex)
{
string errorMsg = string.Format("Exception trying to create or connect to the Azure table: {0}", ex.Message);
instance.logger.Error((int)TableStorageErrorCode.AzureTable_33, errorMsg, ex);
throw new OrleansException(errorMsg, ex);
}
return(instance);
}
public static async Task <OrleansSiloInstanceManager> GetManager(string deploymentId, string storageConnectionString)
{
var instance = new OrleansSiloInstanceManager(deploymentId, storageConnectionString);
try
{
await instance.storage.InitTableAsync()
.WithTimeout(initTimeout);
}
catch (TimeoutException)
{
instance.logger.Fail(ErrorCode.AzureTable_32, String.Format("Unable to create or connect to the Azure table in {0}", initTimeout));
}
catch (Exception ex)
{
instance.logger.Fail(ErrorCode.AzureTable_33, String.Format("Exception trying to create or connect to the Azure table: {0}", ex));
}
return(instance);
}
public async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, TraceLogger traceLogger)
{
logger = traceLogger;
AzureTableDefaultPolicies.MaxBusyRetries = config.MaxStorageBusyRetries;
TraceLogger.SetExceptionDecoder(typeof(StorageException), AzureStorageUtils.PrintStorageException);
tableManager = await OrleansSiloInstanceManager.GetManager(
config.DeploymentId, config.DataConnectionString);
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if (tryInitTableVersion)
{
// ignore return value, since we don't care if I inserted it or not, as long as it is in there.
bool created = await tableManager.TryCreateTableVersionEntryAsync().WithTimeout(AzureTableDefaultPolicies.TableOperationTimeout);
if(created) logger.Info("Created new table version row.");
}
}
public static async Task <OrleansSiloInstanceManager> GetManager(string clusterId, string storageConnectionString, ILoggerFactory loggerFactory)
{
var instance = new OrleansSiloInstanceManager(clusterId, storageConnectionString, loggerFactory);
try
{
await instance.storage.InitTableAsync()
.WithTimeout(initTimeout);
}
catch (TimeoutException te)
{
string errorMsg = String.Format("Unable to create or connect to the Azure table in {0}", initTimeout);
instance.logger.Error((int)TableStorageErrorCode.AzureTable_32, errorMsg, te);
throw new OrleansException(errorMsg, te);
}
catch (Exception ex)
{
string errorMsg = String.Format("Exception trying to create or connect to the Azure table: {0}", ex.Message);
instance.logger.Error((int)TableStorageErrorCode.AzureTable_33, errorMsg, ex);
throw new OrleansException(errorMsg, ex);
}
return(instance);
}
public async Task InitializeGatewayListProvider()
{
siloInstanceManager = await OrleansSiloInstanceManager.GetManager(this.deploymentId, this.options.ConnectionString, this.loggerFactory);
}
/// <summary>
/// Initialize this Orleans silo for execution with the specified Azure deploymentId
/// </summary>
/// <param name="config">If null, Config data will be read from silo config file as normal, otherwise use the specified config data.</param>
/// <param name="deploymentId">Azure DeploymentId this silo is running under</param>
/// <returns><c>true</c> is the silo startup was successful</returns>
public bool Start(ClusterConfiguration config, string deploymentId = null)
{
// Program ident
Trace.TraceInformation("Starting {0} v{1}", this.GetType().FullName, RuntimeVersion.Current);
// Check if deployment id was specified
if (deploymentId == null)
deploymentId = serviceRuntimeWrapper.DeploymentId;
// Read endpoint info for this instance from Azure config
string instanceName = serviceRuntimeWrapper.InstanceName;
// Configure this Orleans silo instance
if (config == null)
{
host = new SiloHost(instanceName);
host.LoadOrleansConfig(); // Load config from file + Initializes logger configurations
}
else
{
host = new SiloHost(instanceName, config); // Use supplied config data + Initializes logger configurations
}
IPEndPoint myEndpoint = serviceRuntimeWrapper.GetIPEndpoint(SiloEndpointConfigurationKeyName);
IPEndPoint proxyEndpoint = serviceRuntimeWrapper.GetIPEndpoint(ProxyEndpointConfigurationKeyName);
host.SetSiloType(Silo.SiloType.Secondary);
int generation = SiloAddress.AllocateNewGeneration();
// Bootstrap this Orleans silo instance
myEntry = new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
Address = myEndpoint.Address.ToString(),
Port = myEndpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = generation.ToString(CultureInfo.InvariantCulture),
HostName = host.Config.GetConfigurationForNode(host.Name).DNSHostName,
ProxyPort = (proxyEndpoint != null ? proxyEndpoint.Port : 0).ToString(CultureInfo.InvariantCulture),
RoleName = serviceRuntimeWrapper.RoleName,
InstanceName = instanceName,
UpdateZone = serviceRuntimeWrapper.UpdateDomain.ToString(CultureInfo.InvariantCulture),
FaultZone = serviceRuntimeWrapper.FaultDomain.ToString(CultureInfo.InvariantCulture),
StartTime = TraceLogger.PrintDate(DateTime.UtcNow),
PartitionKey = deploymentId,
RowKey = myEndpoint.Address + "-" + myEndpoint.Port + "-" + generation
};
var connectionString = serviceRuntimeWrapper.GetConfigurationSettingValue(DataConnectionConfigurationSettingName);
try
{
siloInstanceManager = OrleansSiloInstanceManager.GetManager(
deploymentId, connectionString).WithTimeout(AzureTableDefaultPolicies.TableCreationTimeout).Result;
}
catch (Exception exc)
{
var error = String.Format("Failed to create OrleansSiloInstanceManager. This means CreateTableIfNotExist for silo instance table has failed with {0}",
TraceLogger.PrintException(exc));
Trace.TraceError(error);
logger.Error(ErrorCode.AzureTable_34, error, exc);
throw new OrleansException(error, exc);
}
// Always use Azure table for membership when running silo in Azure
host.SetSiloLivenessType(GlobalConfiguration.LivenessProviderType.AzureTable);
host.SetReminderServiceType(GlobalConfiguration.ReminderServiceProviderType.AzureTable);
host.SetExpectedClusterSize(serviceRuntimeWrapper.RoleInstanceCount);
siloInstanceManager.RegisterSiloInstance(myEntry);
// Initialise this Orleans silo instance
host.SetDeploymentId(deploymentId, connectionString);
host.SetSiloEndpoint(myEndpoint, generation);
host.SetProxyEndpoint(proxyEndpoint);
host.InitializeOrleansSilo();
logger.Info(ErrorCode.Runtime_Error_100288, "Successfully initialized Orleans silo '{0}' as a {1} node.", host.Name, host.Type);
return StartSilo();
}
public static async Task<OrleansSiloInstanceManager> GetManager(string deploymentId, string storageConnectionString)
{
var instance = new OrleansSiloInstanceManager(deploymentId, storageConnectionString);
try
{
await instance.storage.InitTableAsync()
.WithTimeout(initTimeout);
}
catch (TimeoutException te)
{
string errorMsg = String.Format("Unable to create or connect to the Azure table in {0}", initTimeout);
instance.logger.Error(ErrorCode.AzureTable_32, errorMsg, te);
throw new OrleansException(errorMsg, te);
}
catch (Exception ex)
{
string errorMsg = String.Format("Exception trying to create or connect to the Azure table: {0}", ex.Message);
instance.logger.Error(ErrorCode.AzureTable_33, errorMsg, ex);
throw new OrleansException(errorMsg, ex);
}
return instance;
}
/// <summary>
/// Initialize this Orleans silo for execution with the specified Azure deploymentId
/// </summary>
/// <param name="config">If null, Config data will be read from silo config file as normal, otherwise use the specified config data.</param>
/// <param name="deploymentId">Azure DeploymentId this silo is running under</param>
/// <param name="connectionString">Azure DataConnectionString. If null, defaults to the DataConnectionString setting from the Azure configuration for this role.</param>
/// <returns><c>true</c> if the silo startup was successful</returns>
internal bool Start(ClusterConfiguration config, string deploymentId, string connectionString)
{
if (config != null && deploymentId != null)
throw new ArgumentException("Cannot use config and deploymentId on the same time");
// Program ident
Trace.TraceInformation("Starting {0} v{1}", this.GetType().FullName, RuntimeVersion.Current);
// Read endpoint info for this instance from Azure config
string instanceName = serviceRuntimeWrapper.InstanceName;
// Configure this Orleans silo instance
if (config == null)
{
host = new SiloHost(instanceName);
host.LoadOrleansConfig(); // Load config from file + Initializes logger configurations
}
else
{
host = new SiloHost(instanceName, config); // Use supplied config data + Initializes logger configurations
}
IPEndPoint myEndpoint = serviceRuntimeWrapper.GetIPEndpoint(SiloEndpointConfigurationKeyName);
IPEndPoint proxyEndpoint = serviceRuntimeWrapper.GetIPEndpoint(ProxyEndpointConfigurationKeyName);
host.SetSiloType(Silo.SiloType.Secondary);
int generation = SiloAddress.AllocateNewGeneration();
// Bootstrap this Orleans silo instance
// If deploymentId was not direclty provided, take the value in the config. If it is not
// in the config too, just take the DeploymentId from Azure
if (deploymentId == null)
deploymentId = host.Config.Globals.DeploymentId ?? serviceRuntimeWrapper.DeploymentId;
myEntry = new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
Address = myEndpoint.Address.ToString(),
Port = myEndpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = generation.ToString(CultureInfo.InvariantCulture),
HostName = host.Config.GetOrCreateNodeConfigurationForSilo(host.Name).DNSHostName,
ProxyPort = (proxyEndpoint != null ? proxyEndpoint.Port : 0).ToString(CultureInfo.InvariantCulture),
RoleName = serviceRuntimeWrapper.RoleName,
SiloName = instanceName,
UpdateZone = serviceRuntimeWrapper.UpdateDomain.ToString(CultureInfo.InvariantCulture),
FaultZone = serviceRuntimeWrapper.FaultDomain.ToString(CultureInfo.InvariantCulture),
StartTime = LogFormatter.PrintDate(DateTime.UtcNow),
PartitionKey = deploymentId,
RowKey = myEndpoint.Address + "-" + myEndpoint.Port + "-" + generation
};
if (connectionString == null)
connectionString = serviceRuntimeWrapper.GetConfigurationSettingValue(DataConnectionConfigurationSettingName);
try
{
siloInstanceManager = OrleansSiloInstanceManager.GetManager(
deploymentId, connectionString).WithTimeout(AzureTableDefaultPolicies.TableCreationTimeout).Result;
}
catch (Exception exc)
{
var error = String.Format("Failed to create OrleansSiloInstanceManager. This means CreateTableIfNotExist for silo instance table has failed with {0}",
LogFormatter.PrintException(exc));
Trace.TraceError(error);
logger.Error(ErrorCode.AzureTable_34, error, exc);
throw new OrleansException(error, exc);
}
// Always use Azure table for membership when running silo in Azure
host.SetSiloLivenessType(GlobalConfiguration.LivenessProviderType.AzureTable);
if (host.Config.Globals.ReminderServiceType == GlobalConfiguration.ReminderServiceProviderType.NotSpecified ||
host.Config.Globals.ReminderServiceType == GlobalConfiguration.ReminderServiceProviderType.ReminderTableGrain)
{
host.SetReminderServiceType(GlobalConfiguration.ReminderServiceProviderType.AzureTable);
}
host.SetExpectedClusterSize(serviceRuntimeWrapper.RoleInstanceCount);
siloInstanceManager.RegisterSiloInstance(myEntry);
// Initialize this Orleans silo instance
host.SetDeploymentId(deploymentId, connectionString);
host.SetSiloEndpoint(myEndpoint, generation);
host.SetProxyEndpoint(proxyEndpoint);
host.InitializeOrleansSilo();
return StartSilo();
}
public async Task InitializeGatewayListProvider(ClientConfiguration conf, TraceLogger traceLogger)
{
config = conf;
siloInstanceManager = await OrleansSiloInstanceManager.GetManager(conf.DeploymentId, conf.DataConnectionString);
}
public async Task InitializeGatewayListProvider(ClientConfiguration conf, TraceLogger traceLogger)
{
config = conf;
siloInstanceManager = await OrleansSiloInstanceManager.GetManager(conf.DeploymentId, conf.DataConnectionString);
}
