private void SetupConfigurationSettingPublisher()
{
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
Trace.WriteLine("Setting up configuration setting publishing");
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
}
/// <summary>
/// Run method to start tomcat process in the worker role instances
/// </summary>
public override void Run()
{
// This is a sample worker implementation. Replace with your logic.
Trace.WriteLine("ElasticSearch entry point called", "Information");
Trace.TraceInformation("Configuring Elastic Search");
ConfigureElasticSearch();
Trace.TraceInformation("Configured Elastic Search");
while (true)
{
Thread.Sleep(10000);
Trace.WriteLine("Working", "Information");
try
{
if ((_process != null) && _process.HasExited)
{
_elastic.Log("ElasticSearch Process Exited. Hence recycling role.", "Information");
RoleEnvironment.RequestRecycle();
return;
}
}
catch (Exception ex)
{
Trace.TraceError(ex.Message + " " + ex.StackTrace);
}
}
}
void HostControl.Stop()
{
_log.Debug("Stop requested by hosted service");
// this should ask the role to restart
RoleEnvironment.RequestRecycle();
}
public override bool OnStart()
{
DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += this.RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
return(base.OnStart());
}
void CatchUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
_log.Fatal("The service threw an unhandled exception", (Exception)e.ExceptionObject);
HostLogger.Shutdown();
// // IF not terminating, then no reason to stop the service?
// if (!e.IsTerminating)
// return;
// This needs to be a configuration option to avoid breaking compatibility
// ExitCode = (int)TopshelfExitCode.UnhandledServiceException;
_unhandledException = e.ExceptionObject as Exception;
RoleEnvironment.RequestRecycle();
// it isn't likely that a TPL thread should land here, but if it does let's no block it
if (Task.CurrentId.HasValue)
{
return;
}
int deadThreadId = Interlocked.Increment(ref _deadThread);
Thread.CurrentThread.IsBackground = true;
Thread.CurrentThread.Name = "Unhandled Exception " + deadThreadId.ToString();
while (true)
{
Thread.Sleep(TimeSpan.FromHours(1));
}
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
Trace.TraceInformation("WorkerRoleCS218 On Start", "Information");
RoleEnvironment.Changing += RoleEnvironmentChanging;
RoleEnvironment.Changing += RoleEnvironmentChanging;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
return(base.OnStart());
}
protected void Application_Start()
{
#if AZURESDK
RoleEnvironment.Changed +=
(s, a) => { RoleEnvironment.RequestRecycle(); };
#endif
MaintenanceMode.RefreshIsInMaintainanceMode();
DatabaseSetup.Initialize();
container = CreateContainer();
DependencyResolver.SetResolver(new UnityServiceLocator(container));
RegisterGlobalFilters(GlobalFilters.Filters);
RouteTable.Routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
AreaRegistration.RegisterAllAreas();
AppRoutes.RegisterRoutes(RouteTable.Routes);
#if AZURESDK
if (RoleEnvironment.IsAvailable)
{
Trace.Listeners.Add(new DiagnosticMonitorTraceListener());
Trace.AutoFlush = true;
}
#endif
OnStart();
}
public override bool OnStart()
{
DiagnosticMonitorConfiguration config = DiagnosticMonitor.GetDefaultInitialConfiguration();
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
DiagnosticMonitor.Start("DiagnosticsConnectionString", config);
RoleEnvironment.Changing += RoleEnvironmentChanging;
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (anotherSender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
ChirpManager.Initialize();
AvatarManager.Initialize();
ResizeRequestManager.Initialize();
return(base.OnStart());
}
public override bool OnStart()
{
try
{
ServicePointManager.DefaultConnectionLimit = 12;
RoleEnvironment.Changing += roleEnvironmentChanging;
m_log = new RenderLog("mergerlog");
m_engine = new LuxEngine(m_log);
m_engine.Init();
m_log.Info("storageAccount created");
m_dispatcherQueues = new Dictionary <int, MessageQueue <DispetcherMessage> >();
initQueue();
m_log.Info("Queue initialized");
initBlob();
m_log.Info("Blob initialized");
m_oneBatchInPercents = 0;
m_totalRenderTime = 0;
m_percentageCompleted = 0;
m_log.Info("OnStart successfull");
}
catch
{
Trace.TraceWarning("Method OnStart() of MergerRole is failed.");
m_log.Error("Method OnStart() of MergerRole is failed.");
RoleEnvironment.RequestRecycle();
return(false);
}
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
return(base.OnStart());
}
public override void Run()
{
Log("SolrSlaveHostWorkerRole Run() called", "Information");
while (true)
{
Thread.Sleep(10000);
string masterUrl = HelperLib.Util.GetMasterUrl();
if (masterUrl != _masterUrl) // master changed?
{
Log("Master Url changed, recycling slave role", "Information");
RoleEnvironment.RequestRecycle();
return;
}
if ((_solrProcess != null) && (_solrProcess.HasExited == true))
{
Log("Solr Process Exited. Hence recycling slave role.", "Information");
RoleEnvironment.RequestRecycle();
return;
}
Log("Working", "Information");
}
}
public override bool OnStart()
{
try
{
ServicePointManager.DefaultConnectionLimit = 12;
RoleEnvironment.Changing += roleEnvironmentChanging;
Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
// Each render role has own log file
m_log = new RenderLog("renderlog" + Utils.RoleID().ToString());
initQueue();
initBlob();
initDisk();
m_log.Info("OnStart successfull");
m_engine = new LuxEngine(m_log);
m_engine.Init();
}
catch
{
m_log.Error("OnStart failed");
RoleEnvironment.RequestRecycle();
Trace.TraceWarning("Method OnStart() of WorkerRole is failed.");
return(false);
}
return(base.OnStart());
}
public override bool OnStart()
{
try
{
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += roleEnvironmentChanging;
m_threadsID = new Dictionary <string, int>();
m_renderAbortHandlers = new Dictionary <int, List <MessageQueue <RenderMessage> > >();
m_connectionHandlers = new Dictionary <string, NetMessageHandler>();
m_log = new RenderLog("dispatcherlog");
m_log.Info("storageAccount created");
initQueue();
m_log.Info("Queue initialized");
initBlob();
m_log.Info("Blob initialized");
m_log.Info("RolesCnt initialized");
m_scenesId = SceneID.Get();
m_instanceManager = InstanceManager.Get(m_log);
m_log.Info("OnStart completed");
}
catch (Exception ex)
{
RoleEnvironment.RequestRecycle(); //request role restart
System.Diagnostics.Trace.TraceWarning("Method OnStart() of WebRole is failed.");
m_log.Error("Error when initializing: " + ex.Message);
return(false);
}
return(base.OnStart());
}
private static void SetupEnvironmentChangeHandlers()
{
// For information on handling configuration changes see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
#region Setup CloudStorageAccount Configuration Setting Publisher
// From: http://www.tsjensen.com/blog/2009/11/30/Windows+Azure+10+CloudTableClient+Minimal+Configuration.aspx
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((string configName, Func <string, bool> configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (object sender, RoleEnvironmentChangedEventArgs e) =>
{
if (e.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((RoleEnvironmentConfigurationSettingChange change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
RoleEnvironment.RequestRecycle();
}
}
};
});
return(base.OnStart());
}
public override bool OnStart()
{
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (anotherSender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// Create the table and add some dummy data.
CloudTableClient tableClient = new CloudTableClient(account.TableEndpoint.AbsoluteUri, account.Credentials);
tableClient.CreateTableIfNotExist("Person");
PersonTableStorageContext ctx = new PersonTableStorageContext();
Person person1 = new Person("DefaultPartition", "Row1")
{
Name = "Ared", Age = 24
};
Person person2 = new Person("DefaultPartition", "Row2")
{
Name = "Lante", Age = 24
};
Person person3 = new Person("DefaultPartition", "Row3")
{
Name = "Bright", Age = 24
};
this.InsertEntityIfNotExist(ctx, person1);
this.InsertEntityIfNotExist(ctx, person2);
this.InsertEntityIfNotExist(ctx, person3);
return(base.OnStart());
}
private void StartGameService(int retries)
{
if (retries == 0)
{
RoleEnvironment.RequestRecycle();
return;
}
Trace.TraceInformation("Starting game service host...");
_serviceHost = new ServiceHost(typeof(GameService));
_serviceHost.Faulted += (sender, e) =>
{
Trace.TraceError("Host fault occured. Aborting and restarting the host. Retry count: {0}", retries);
_serviceHost.Abort();
StartGameService(--retries);
};
var binding = new NetTcpBinding(SecurityMode.None);
RoleInstanceEndpoint externalEndPoint =
RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["GameServer"];
RoleInstanceEndpoint mexpEndPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["mexport"];
var metadatabehavior = new ServiceMetadataBehavior();
_serviceHost.Description.Behaviors.Add(metadatabehavior);
Binding mexBinding = MetadataExchangeBindings.CreateMexTcpBinding();
string mexendpointurl = string.Format("net.tcp://{0}/GameServerMetadata", mexpEndPoint.IPEndpoint);
_serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), mexBinding, mexendpointurl);
_serviceHost.AddServiceEndpoint(
typeof(IGameService),
binding,
string.Format("net.tcp://{0}/GameServer", externalEndPoint.IPEndpoint));
try
{
_serviceHost.Open();
Trace.TraceInformation("Game service host started successfully.");
}
catch (TimeoutException timeoutException)
{
Trace.TraceError(
"The service operation timed out. {0}",
timeoutException.Message);
}
catch (CommunicationException communicationException)
{
Trace.TraceError(
"Could not start game service host. {0}",
communicationException.Message);
}
}
void RoleEnvironment_Changed(object sender, RoleEnvironmentChangedEventArgs e)
{
WorkerTrace.TraceEvent(TraceEventType.Information, 18, "Role configuration has been changed. Requesting instance recycle");
if (current != null)
{
current.Abandon();
}
Thread.Sleep(25); //waiting for logs transfer
RoleEnvironment.RequestRecycle();
}
/// <summary>
/// This method is to restart the role instance when a configuration setting is changing
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
{
// If a configuration setting is changing
if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
{
RoleEnvironment.RequestRecycle();
// Set e.Cancel to true to restart this role instance
e.Cancel = true;
}
}
public override bool OnStart()
{
string wadConnectionString = "Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString";
RoleInstanceDiagnosticManager roleInstanceDiagnosticManager =
CloudAccountDiagnosticMonitorExtensions.CreateRoleInstanceDiagnosticManager(RoleEnvironment.GetConfigurationSettingValue(wadConnectionString),
RoleEnvironment.DeploymentId, RoleEnvironment.CurrentRoleInstance.Role.Name,
RoleEnvironment.CurrentRoleInstance.Id);
DiagnosticMonitorConfiguration config = roleInstanceDiagnosticManager.GetCurrentConfiguration();
// should never be null, but this is a fallback in case it is. I recommend removing this in a production
// deployment
if (null == config)
{
config = DiagnosticMonitor.GetDefaultInitialConfiguration();
}
config.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(15);
config.Logs.ScheduledTransferLogLevelFilter = Microsoft.WindowsAzure.Diagnostics.LogLevel.Undefined;
config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = Microsoft.WindowsAzure.Diagnostics.LogLevel.Warning;
config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(15);
config.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(15);
roleInstanceDiagnosticManager.SetCurrentConfiguration(config);
System.Diagnostics.Trace.TraceInformation("Diagnostics Running");
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
RoleEnvironment.Changed += (sender, arg) =>
{
var key = CloudConfigurationManager.GetSetting(arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>().ToString());
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == key.ToString())))
{
// The corresponding configuration setting has changed, propagate the value
RoleEnvironment.GetConfigurationSettingValue(key.ToString());
// {
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
//}
}
};
//});
#endregion
return(base.OnStart());
}
public override bool OnStart()
{
try
{
DiagnosticMonitorConfiguration diagConfig = DiagnosticMonitor.GetDefaultInitialConfiguration();
//diagConfig.Directories.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
diagConfig.Logs.ScheduledTransferPeriod = TimeSpan.FromMinutes(1);
diagConfig.Logs.ScheduledTransferLogLevelFilter = LogLevel.Verbose;
DiagnosticMonitor.Start("DataConnectionString", diagConfig);
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (s, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
var azureTraceListener = new Microsoft.WindowsAzure.Diagnostics.DiagnosticMonitorTraceListener();
Trace.Listeners.Add(azureTraceListener);
}
catch (Exception)
{
}
return(base.OnStart());
}
protected void Application_Start(object sender, EventArgs e)
{
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (anotherSender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString");
// Create the table and add some dummy data.
CloudTableClient tableClient = new CloudTableClient(account.TableEndpoint.AbsoluteUri, account.Credentials);
tableClient.CreateTableIfNotExist("Person");
PersonTableStorageContext ctx = new PersonTableStorageContext();
Person person1 = new Person("DefaultPartition", "Row1")
{
Name = "Ared", Age = 24
};
Person person2 = new Person("DefaultPartition", "Row2")
{
Name = "Lante", Age = 24
};
Person person3 = new Person("DefaultPartition", "Row3")
{
Name = "Bright", Age = 24
};
this.InsertEntityIfNotExist(ctx, person1);
this.InsertEntityIfNotExist(ctx, person2);
this.InsertEntityIfNotExist(ctx, person3);
}
public static void RequestRecycleIfConfigSettingChanged(ConfigSettings config)
{
RoleEnvironment.Changing += (_, e) =>
{
var shouldRecycle = e.Changes
.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any(c => config.IsConfigSettingName(c.ConfigurationSettingName));
if (shouldRecycle)
{
RoleEnvironment.RequestRecycle();
}
};
}
static void OnRoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
{
// we restart all workers if the configuration changed (e.g. the storage account)
// for now.
// We do not request a recycle if only the topology changed,
// e.g. if some instances have been removed or added.
var configChanges = e.Changes.OfType <RoleEnvironmentConfigurationSettingChange>();
if (configChanges.Any())
{
RoleEnvironment.RequestRecycle();
}
}
private void StartWCFService(int retries)
{
// recycle the role if host cannot be started
// after the specified number of retries
if (retries == 0)
{
RoleEnvironment.RequestRecycle();
return;
}
Trace.TraceInformation("Starting notification service host...");
this.serviceHost = new ServiceHost(typeof(NotificationService));
// Recover the service in case of failure.
// Log the fault and attempt to restart the service host.
this.serviceHost.Faulted += (sender, e) =>
{
Trace.TraceError("Host fault occured. Aborting and restarting the host. Retry count: {0}", retries);
this.serviceHost.Abort();
this.StartWCFService(--retries);
};
// use NetTcpBinding with no security
NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);
// define an external endpoint for client traffic
RoleInstanceEndpoint externalEndPoint =
RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["NotificationService"];
this.serviceHost.AddServiceEndpoint(
typeof(INotificationService),
binding,
String.Format("net.tcp://{0}/NotificationService", externalEndPoint.IPEndpoint));
try
{
this.serviceHost.Open();
Trace.TraceInformation("Chat service host started successfully.");
}
catch (TimeoutException timeoutException)
{
Trace.TraceError("The service operation timed out. {0}", timeoutException.Message);
}
catch (CommunicationException communicationException)
{
Trace.TraceError("Could not start chat service host. {0}", communicationException.Message);
}
}
public override bool OnStart()
{
/*
* var config = DiagnosticMonitor.GetDefaultInitialConfiguration();
*
* config.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = LogLevel.Error;
* config.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = TimeSpan.FromMinutes(5);
* // Start the diagnostic monitor with the modified configuration.
* DiagnosticMonitor.Start("DiagnosticsConnectionString", config);
*
* DiagnosticMonitor.AllowInsecureRemoteConnections = true;
*
* // enable collection of crashdumps
* CrashDumps.EnableCollection(true);
*/
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
return(base.OnStart());
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 48;
RoleEnvironment.Changing += RoleEnvironmentChanging;
try
{
Trace.WriteLine("OnStart:System is starting up", "Information");
var endpoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["Http"].IPEndpoint;
string param;
if (!AzureSettingsProvider.TryGetString("params", out param))
{
param = "";
}
var options = new NodeOptions();
if (!CommandLineParser.Default.ParseArguments(param.Split(' '), options))
{
throw new Exception("Failed to parse: " + param);
}
options.HttpPort = endpoint.Port;
options.LocalHttpIp = endpoint.Address.ToString();
// Uncomment these lines and class BlobTraceListener to write traces into blob.
//var parts = options.StoreLocation.Split('|');
//var account = CloudStorageAccount.Parse(parts[0]);
//var client = account.CreateCloudBlobClient();
//var container = client.GetContainerReference(parts[1]);
//var blobListener = new BlobTraceListener(container.GetBlobReference("log.txt"));
//Trace.Listeners.Add(blobListener);
Trace.WriteLine("");
Trace.WriteLine(string.Format("Listening endpoint http://{0}:{1}/", endpoint.Address, endpoint.Port), "Information");
_entryPoint = NodeEntryPoint.StartWithOptions(options, i => RoleEnvironment.RequestRecycle());
}
catch (Exception ex)
{
Trace.WriteLine("OnStart:Failed " + ex, "Information");
throw;
}
var result = base.OnStart();
Trace.WriteLine("OnStart:Exit");
return(result);
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
#region Setup CloudStorageAccount Configuration Setting Publisher
// This code sets up a handler to update CloudStorageAccount instances when their corresponding
// configuration settings change in the service configuration file.
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
// Provide the configSetter with the initial value
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
RoleEnvironment.Changed += (sender, arg) =>
{
if (arg.Changes.OfType <RoleEnvironmentConfigurationSettingChange>()
.Any((change) => (change.ConfigurationSettingName == configName)))
{
// The corresponding configuration setting has changed, propagate the value
if (!configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)))
{
// In this case, the change to the storage account credentials in the
// service configuration is significant enough that the role needs to be
// recycled in order to use the latest settings. (for example, the
// endpoint has changed)
RoleEnvironment.RequestRecycle();
}
}
};
});
#endregion
// load up the desired image sizes
var imageSizes = RoleEnvironment.GetConfigurationSettingValue("ImageSizes");
foreach (var size in imageSizes.Split(','))
{
var dims = size.Split('x');
_imageSizes.Add(new Size(Int32.Parse(dims[0]), Int32.Parse(dims[1])));
}
return(base.OnStart());
}
public override bool OnStart()
{
Log("SolrSlaveHostWorkerRole Start() called", "Information");
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
RoleEnvironment.Changing += (sender, arg) =>
{
RoleEnvironment.RequestRecycle();
};
InitDiagnostics();
StartSolr();
return(base.OnStart());
}
