private void RegisterSiloInstance()
{
string partitionKey = deploymentId;
string rowKey = SiloInstanceTableEntry.ConstructRowKey(siloAddress);
IPEndPoint myEndpoint = siloAddress.Endpoint;
myEntry = new SiloInstanceTableEntry
{
PartitionKey = partitionKey,
RowKey = rowKey,
DeploymentId = deploymentId,
Address = myEndpoint.Address.ToString(),
Port = myEndpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = generation.ToString(CultureInfo.InvariantCulture),
HostName = myEndpoint.Address.ToString(),
ProxyPort = "30000",
RoleName = "MyRole",
SiloName = "MyInstance",
UpdateZone = "0",
FaultZone = "0",
StartTime = LogFormatter.PrintDate(DateTime.UtcNow),
};
logger.Info("MyEntry={0}", myEntry);
manager.RegisterSiloInstance(myEntry);
}
public async Task SiloInstanceTable_Op_InsertSiloEntryConditionally()
{
SiloInstanceTableEntry newEntry = manager.CreateTableVersionEntry(0);
bool didInsert = await manager.InsertSiloEntryConditionally(newEntry, null, null, false)
.WithTimeout(AzureTableDefaultPolicies.TableOperationTimeout);
Assert.IsTrue(didInsert, "Did insert");
}
private static SiloInstanceTableEntry ConvertPartial(MembershipEntry memEntry, string deploymentId)
{
return(new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
IAmAliveTime = TraceLogger.PrintDate(memEntry.IAmAliveTime),
PartitionKey = deploymentId,
RowKey = SiloInstanceTableEntry.ConstructRowKey(memEntry.SiloAddress)
});
}
private async Task <Tuple <SiloInstanceTableEntry, string> > FindSiloEntry(SiloAddress siloAddr)
{
string partitionKey = this.clusterId;
string rowKey = SiloInstanceTableEntry.ConstructRowKey(siloAddr);
output.WriteLine("FindSiloEntry for SiloAddress={0} PartitionKey={1} RowKey={2}", siloAddr, partitionKey, rowKey);
Tuple <SiloInstanceTableEntry, string> data = await manager.ReadSingleTableEntryAsync(partitionKey, rowKey);
output.WriteLine("FindSiloEntry returning Data={0}", data);
return(data);
}
private async Task<Tuple<SiloInstanceTableEntry, string>> FindSiloEntry(SiloAddress siloAddr)
{
string partitionKey = deploymentId;
string rowKey = SiloInstanceTableEntry.ConstructRowKey(siloAddr);
logger.Info("FindSiloEntry for SiloAddress={0} PartitionKey={1} RowKey={2}", siloAddr, partitionKey, rowKey);
Tuple<SiloInstanceTableEntry, string> data = await manager.ReadSingleTableEntryAsync(partitionKey, rowKey);
logger.Info("FindSiloEntry returning Data={0}", data);
return data;
}
private static SiloInstanceTableEntry Convert(MembershipEntry memEntry, string deploymentId)
{
var tableEntry = new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
Address = memEntry.SiloAddress.Endpoint.Address.ToString(),
Port = memEntry.SiloAddress.Endpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = memEntry.SiloAddress.Generation.ToString(CultureInfo.InvariantCulture),
HostName = memEntry.HostName,
Status = memEntry.Status.ToString(),
ProxyPort = memEntry.ProxyPort.ToString(CultureInfo.InvariantCulture),
RoleName = memEntry.RoleName,
SiloName = memEntry.SiloName,
// this is for backward compatability: in a mixed cluster of old and new version,
// we need to populate both columns.
InstanceName = memEntry.SiloName,
UpdateZone = memEntry.UpdateZone.ToString(CultureInfo.InvariantCulture),
FaultZone = memEntry.FaultZone.ToString(CultureInfo.InvariantCulture),
StartTime = LogFormatter.PrintDate(memEntry.StartTime),
IAmAliveTime = LogFormatter.PrintDate(memEntry.IAmAliveTime)
};
if (memEntry.SuspectTimes != null)
{
var siloList = new StringBuilder();
var timeList = new StringBuilder();
bool first = true;
foreach (var tuple in memEntry.SuspectTimes)
{
if (!first)
{
siloList.Append('|');
timeList.Append('|');
}
siloList.Append(tuple.Item1.ToParsableString());
timeList.Append(LogFormatter.PrintDate(tuple.Item2));
first = false;
}
tableEntry.SuspectingSilos = siloList.ToString();
tableEntry.SuspectingTimes = timeList.ToString();
}
else
{
tableEntry.SuspectingSilos = String.Empty;
tableEntry.SuspectingTimes = String.Empty;
}
tableEntry.PartitionKey = deploymentId;
tableEntry.RowKey = SiloInstanceTableEntry.ConstructRowKey(memEntry.SiloAddress);
return(tableEntry);
}
private static SiloInstanceTableEntry Convert(MembershipEntry memEntry, string deploymentId)
{
var tableEntry = new SiloInstanceTableEntry
{
DeploymentId = deploymentId,
Address = memEntry.SiloAddress.Endpoint.Address.ToString(),
Port = memEntry.SiloAddress.Endpoint.Port.ToString(CultureInfo.InvariantCulture),
Generation = memEntry.SiloAddress.Generation.ToString(CultureInfo.InvariantCulture),
HostName = memEntry.HostName,
Status = memEntry.Status.ToString(),
ProxyPort = memEntry.ProxyPort.ToString(CultureInfo.InvariantCulture),
Primary = memEntry.IsPrimary.ToString(),
RoleName = memEntry.RoleName,
InstanceName = memEntry.InstanceName,
UpdateZone = memEntry.UpdateZone.ToString(CultureInfo.InvariantCulture),
FaultZone = memEntry.FaultZone.ToString(CultureInfo.InvariantCulture),
StartTime = TraceLogger.PrintDate(memEntry.StartTime),
IAmAliveTime = TraceLogger.PrintDate(memEntry.IAmAliveTime)
};
if (memEntry.SuspectTimes != null)
{
var siloList = new StringBuilder();
var timeList = new StringBuilder();
bool first = true;
foreach (var tuple in memEntry.SuspectTimes)
{
if (!first)
{
siloList.Append('|');
timeList.Append('|');
}
siloList.Append(tuple.Item1.ToParsableString());
timeList.Append(TraceLogger.PrintDate(tuple.Item2));
first = false;
}
tableEntry.SuspectingSilos = siloList.ToString();
tableEntry.SuspectingTimes = timeList.ToString();
}
else
{
tableEntry.SuspectingSilos = String.Empty;
tableEntry.SuspectingTimes = String.Empty;
}
tableEntry.PartitionKey = deploymentId;
tableEntry.RowKey = SiloInstanceTableEntry.ConstructRowKey(memEntry.SiloAddress);
return(tableEntry);
}
private void CheckSiloInstanceTableEntry(SiloInstanceTableEntry referenceEntry, SiloInstanceTableEntry entry)
{
Assert.Equal(referenceEntry.DeploymentId, entry.DeploymentId);
Assert.Equal(referenceEntry.Address, entry.Address);
Assert.Equal(referenceEntry.Port, entry.Port);
Assert.Equal(referenceEntry.Generation, entry.Generation);
Assert.Equal(referenceEntry.HostName, entry.HostName);
//Assert.Equal(referenceEntry.Status, entry.Status);
Assert.Equal(referenceEntry.ProxyPort, entry.ProxyPort);
Assert.Equal(referenceEntry.SiloName, entry.SiloName);
Assert.Equal(referenceEntry.StartTime, entry.StartTime);
Assert.Equal(referenceEntry.IAmAliveTime, entry.IAmAliveTime);
Assert.Equal(referenceEntry.MembershipVersion, entry.MembershipVersion);
Assert.Equal(referenceEntry.SuspectingTimes, entry.SuspectingTimes);
Assert.Equal(referenceEntry.SuspectingSilos, entry.SuspectingSilos);
}
public async Task SiloInstanceTable_Unregister_CheckData()
{
RegisterSiloInstance();
manager.UnregisterSiloInstance(myEntry);
var data = await FindSiloEntry(siloAddress);
SiloInstanceTableEntry siloEntry = data.Item1;
string eTag = data.Item2;
Assert.IsNotNull(eTag, "ETag should not be null");
Assert.IsNotNull(siloEntry, "SiloInstanceTableEntry should not be null");
Assert.AreEqual(SiloInstanceTableTestConstants.INSTANCE_STATUS_DEAD, siloEntry.Status);
CheckSiloInstanceTableEntry(myEntry, siloEntry);
}
public async Task SiloInstanceTable_Unregister_CheckData()
{
RegisterSiloInstance();
await manager.UnregisterSiloInstance(myEntry);
var data = await FindSiloEntry(siloAddress);
SiloInstanceTableEntry siloEntry = data.Entity;
string eTag = data.ETag;
Assert.NotNull(eTag); // ETag should not be null
Assert.NotNull(siloEntry); // SiloInstanceTableEntry should not be null
Assert.Equal(SiloInstanceTableTestConstants.INSTANCE_STATUS_DEAD, siloEntry.Status);
CheckSiloInstanceTableEntry(myEntry, siloEntry);
}
public async Task SiloInstanceTable_Register_CheckData()
{
const string testName = "SiloInstanceTable_Register_CheckData";
logger.Info("Start {0}", testName);
RegisterSiloInstance();
var data = await FindSiloEntry(siloAddress);
SiloInstanceTableEntry siloEntry = data.Item1;
string eTag = data.Item2;
Assert.IsNotNull(eTag, "ETag should not be null");
Assert.IsNotNull(siloEntry, "SiloInstanceTableEntry should not be null");
Assert.AreEqual(SiloInstanceTableTestConstants.INSTANCE_STATUS_CREATED, siloEntry.Status);
CheckSiloInstanceTableEntry(myEntry, siloEntry);
logger.Info("End {0}", testName);
}
private void CheckSiloInstanceTableEntry(SiloInstanceTableEntry referenceEntry, SiloInstanceTableEntry entry)
{
Assert.AreEqual(referenceEntry.DeploymentId, entry.DeploymentId, "DeploymentId");
Assert.AreEqual(referenceEntry.Address, entry.Address, "Address");
Assert.AreEqual(referenceEntry.Port, entry.Port, "Port");
Assert.AreEqual(referenceEntry.Generation, entry.Generation, "Generation");
Assert.AreEqual(referenceEntry.HostName, entry.HostName, "HostName");
//Assert.AreEqual(referenceEntry.Status, entry.Status, "Status");
Assert.AreEqual(referenceEntry.ProxyPort, entry.ProxyPort, "ProxyPort");
Assert.AreEqual(referenceEntry.RoleName, entry.RoleName, "RoleName");
Assert.AreEqual(referenceEntry.InstanceName, entry.InstanceName, "InstanceName");
Assert.AreEqual(referenceEntry.UpdateZone, entry.UpdateZone, "UpdateZone");
Assert.AreEqual(referenceEntry.FaultZone, entry.FaultZone, "FaultZone");
Assert.AreEqual(referenceEntry.StartTime, entry.StartTime, "StartTime");
Assert.AreEqual(referenceEntry.IAmAliveTime, entry.IAmAliveTime, "IAmAliveTime");
Assert.AreEqual(referenceEntry.MembershipVersion, entry.MembershipVersion, "MembershipVersion");
Assert.AreEqual(referenceEntry.SuspectingTimes, entry.SuspectingTimes, "SuspectingTimes");
Assert.AreEqual(referenceEntry.SuspectingSilos, entry.SuspectingSilos, "SuspectingSilos");
}
public async Task SiloInstanceTable_Activate_CheckData()
{
RegisterSiloInstance();
manager.ActivateSiloInstance(myEntry);
var data = await FindSiloEntry(siloAddress);
Assert.NotNull(data); // Data returned should not be null
SiloInstanceTableEntry siloEntry = data.Item1;
string eTag = data.Item2;
Assert.NotNull(eTag); // ETag should not be null
Assert.NotNull(siloEntry); // SiloInstanceTableEntry should not be null
Assert.Equal(SiloInstanceTableTestConstants.INSTANCE_STATUS_ACTIVE, siloEntry.Status);
CheckSiloInstanceTableEntry(myEntry, siloEntry);
}
public void SiloAddress_ToFrom_RowKey()
{
string ipAddress = "1.2.3.4";
int port = 5555;
int generation = 6666;
IPAddress address = IPAddress.Parse(ipAddress);
IPEndPoint endpoint = new IPEndPoint(address, port);
SiloAddress siloAddress = SiloAddress.New(endpoint, generation);
string MembershipRowKey = SiloInstanceTableEntry.ConstructRowKey(siloAddress);
Console.WriteLine("SiloAddress = {0} Row Key string = {1}", siloAddress, MembershipRowKey);
SiloAddress fromRowKey = SiloInstanceTableEntry.UnpackRowKey(MembershipRowKey);
Console.WriteLine("SiloAddress result = {0} From Row Key string = {1}", fromRowKey, MembershipRowKey);
Assert.AreEqual(siloAddress, fromRowKey, "Compare SiloAddress");
Assert.AreEqual(SiloInstanceTableEntry.ConstructRowKey(siloAddress), SiloInstanceTableEntry.ConstructRowKey(fromRowKey), "SiloInstanceTableEntry.ConstructRowKey");
}
public async Task SiloInstanceTable_Register_CheckData()
{
const string testName = "SiloInstanceTable_Register_CheckData";
output.WriteLine("Start {0}", testName);
RegisterSiloInstance();
var data = await FindSiloEntry(siloAddress);
SiloInstanceTableEntry siloEntry = data.Item1;
string eTag = data.Item2;
Assert.NotNull(eTag); // ETag should not be null
Assert.NotNull(siloEntry); // SiloInstanceTableEntry should not be null
Assert.Equal(SiloInstanceTableTestConstants.INSTANCE_STATUS_CREATED, siloEntry.Status);
CheckSiloInstanceTableEntry(myEntry, siloEntry);
output.WriteLine("End {0}", testName);
}
/// <summary>
/// Initialize this Orleans silo for execution with the specified Azure clusterId
/// </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="clusterId">Azure ClusterId 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 clusterId, string connectionString)
{
if (config != null && clusterId != null)
{
throw new ArgumentException("Cannot use config and clusterId 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 clusterId was not direclty provided, take the value in the config. If it is not
// in the config too, just take the ClusterId from Azure
if (clusterId == null)
{
clusterId = string.IsNullOrWhiteSpace(host.Config.Globals.ClusterId)
? serviceRuntimeWrapper.DeploymentId
: host.Config.Globals.ClusterId;
}
myEntry = new SiloInstanceTableEntry
{
DeploymentId = clusterId,
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 = clusterId,
RowKey = myEndpoint.Address + "-" + myEndpoint.Port + "-" + generation
};
if (connectionString == null)
{
connectionString = serviceRuntimeWrapper.GetConfigurationSettingValue(DataConnectionConfigurationSettingName);
}
try
{
siloInstanceManager = OrleansSiloInstanceManager.GetManager(
clusterId, connectionString, AzureStorageClusteringOptions.DEFAULT_TABLE_NAME, this.loggerFactory).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((int)AzureSiloErrorCode.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(clusterId, connectionString);
host.SetSiloEndpoint(myEndpoint, generation);
host.SetProxyEndpoint(proxyEndpoint);
host.ConfigureSiloHostDelegate = ConfigureSiloHostDelegate;
host.InitializeOrleansSilo();
return(StartSilo());
}
private static MembershipEntry Parse(SiloInstanceTableEntry tableEntry)
{
var parse = new MembershipEntry
{
HostName = tableEntry.HostName,
Status = (SiloStatus)Enum.Parse(typeof(SiloStatus), tableEntry.Status)
};
if (!string.IsNullOrEmpty(tableEntry.ProxyPort))
{
parse.ProxyPort = int.Parse(tableEntry.ProxyPort);
}
parse.IsPrimary = false; // there are no primaries with in Azure table.
int port = 0;
if (!string.IsNullOrEmpty(tableEntry.Port))
{
int.TryParse(tableEntry.Port, out port);
}
int gen = 0;
if (!string.IsNullOrEmpty(tableEntry.Generation))
{
int.TryParse(tableEntry.Generation, out gen);
}
parse.SiloAddress = SiloAddress.New(new IPEndPoint(IPAddress.Parse(tableEntry.Address), port), gen);
parse.RoleName = tableEntry.RoleName;
parse.InstanceName = tableEntry.InstanceName;
if (!string.IsNullOrEmpty(tableEntry.UpdateZone))
{
parse.UpdateZone = int.Parse(tableEntry.UpdateZone);
}
if (!string.IsNullOrEmpty(tableEntry.FaultZone))
{
parse.FaultZone = int.Parse(tableEntry.FaultZone);
}
parse.StartTime = !string.IsNullOrEmpty(tableEntry.StartTime) ?
TraceLogger.ParseDate(tableEntry.StartTime) : default(DateTime);
parse.IAmAliveTime = !string.IsNullOrEmpty(tableEntry.IAmAliveTime) ?
TraceLogger.ParseDate(tableEntry.IAmAliveTime) : default(DateTime);
var suspectingSilos = new List <SiloAddress>();
var suspectingTimes = new List <DateTime>();
if (!string.IsNullOrEmpty(tableEntry.SuspectingSilos))
{
string[] silos = tableEntry.SuspectingSilos.Split('|');
foreach (string silo in silos)
{
suspectingSilos.Add(SiloAddress.FromParsableString(silo));
}
}
if (!string.IsNullOrEmpty(tableEntry.SuspectingTimes))
{
string[] times = tableEntry.SuspectingTimes.Split('|');
foreach (string time in times)
{
suspectingTimes.Add(TraceLogger.ParseDate(time));
}
}
if (suspectingSilos.Count != suspectingTimes.Count)
{
throw new OrleansException(String.Format("SuspectingSilos.Length of {0} as read from Azure table is not eqaul to SuspectingTimes.Length of {1}", suspectingSilos.Count, suspectingTimes.Count));
}
for (int i = 0; i < suspectingSilos.Count; i++)
{
parse.AddSuspector(suspectingSilos[i], suspectingTimes[i]);
}
return(parse);
}
/// <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> is the silo startup was successful</returns>
public bool Start(ClusterConfiguration config, string deploymentId = null, string connectionString = 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
};
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}",
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);
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);
// 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());
}
private static MembershipEntry Parse(SiloInstanceTableEntry tableEntry)
{
var parse = new MembershipEntry
{
HostName = tableEntry.HostName,
Status = (SiloStatus)Enum.Parse(typeof(SiloStatus), tableEntry.Status)
};
if (!string.IsNullOrEmpty(tableEntry.ProxyPort))
{
parse.ProxyPort = int.Parse(tableEntry.ProxyPort);
}
int port = 0;
if (!string.IsNullOrEmpty(tableEntry.Port))
{
int.TryParse(tableEntry.Port, out port);
}
int gen = 0;
if (!string.IsNullOrEmpty(tableEntry.Generation))
{
int.TryParse(tableEntry.Generation, out gen);
}
parse.SiloAddress = SiloAddress.New(new IPEndPoint(IPAddress.Parse(tableEntry.Address), port), gen);
parse.RoleName = tableEntry.RoleName;
if (!string.IsNullOrEmpty(tableEntry.SiloName))
{
parse.SiloName = tableEntry.SiloName;
}
else if (!string.IsNullOrEmpty(tableEntry.InstanceName))
{
// this is for backward compatability: in a mixed cluster of old and new version,
// some entries will have the old InstanceName column.
parse.SiloName = tableEntry.InstanceName;
}
if (!string.IsNullOrEmpty(tableEntry.UpdateZone))
{
parse.UpdateZone = int.Parse(tableEntry.UpdateZone);
}
if (!string.IsNullOrEmpty(tableEntry.FaultZone))
{
parse.FaultZone = int.Parse(tableEntry.FaultZone);
}
parse.StartTime = !string.IsNullOrEmpty(tableEntry.StartTime) ?
LogFormatter.ParseDate(tableEntry.StartTime) : default(DateTime);
parse.IAmAliveTime = !string.IsNullOrEmpty(tableEntry.IAmAliveTime) ?
LogFormatter.ParseDate(tableEntry.IAmAliveTime) : default(DateTime);
var suspectingSilos = new List <SiloAddress>();
var suspectingTimes = new List <DateTime>();
if (!string.IsNullOrEmpty(tableEntry.SuspectingSilos))
{
string[] silos = tableEntry.SuspectingSilos.Split('|');
foreach (string silo in silos)
{
suspectingSilos.Add(SiloAddress.FromParsableString(silo));
}
}
if (!string.IsNullOrEmpty(tableEntry.SuspectingTimes))
{
string[] times = tableEntry.SuspectingTimes.Split('|');
foreach (string time in times)
{
suspectingTimes.Add(LogFormatter.ParseDate(time));
}
}
if (suspectingSilos.Count != suspectingTimes.Count)
{
throw new OrleansException(String.Format("SuspectingSilos.Length of {0} as read from Azure table is not eqaul to SuspectingTimes.Length of {1}", suspectingSilos.Count, suspectingTimes.Count));
}
for (int i = 0; i < suspectingSilos.Count; i++)
{
parse.AddSuspector(suspectingSilos[i], suspectingTimes[i]);
}
return(parse);
}
