public override void Run() { Log("SolrMasterHostWorkerRole Run() called", "Information"); while (true) { Thread.Sleep(10000); Log("Working", "Information"); if ((_solrProcess != null) && (_solrProcess.HasExited == true)) { Log("Solr Process Exited. Hence recycling master role.", "Information"); RoleEnvironment.RequestRecycle(); return; } } }
private void InstallPackages() { Tracer.WriteLine("InstallPackages", "Information"); bool alwaysInstallPackages = bool.Parse(RoleEnvironment.GetConfigurationSettingValue("AlwaysInstallPackages")); Tracer.WriteLine(string.Format("AlwaysInstallPackages: {0}", alwaysInstallPackages), "Information"); string workingDirectory = GetWorkingDirectory(); // Retrieve the semicolon delimitted list of zip file packages and install them string[] packages = RoleEnvironment.GetConfigurationSettingValue(PACKAGES).Split(';'); foreach (string package in packages) { try { if (package != string.Empty) { // Parse out the container\file pair string[] fields = package.Split(new char[] { '/', '\\' }, 2); string containerName = fields[0]; string packageName = fields[1]; if (packageName == "*") { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(DATA_CONNECTION_STRING)); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); var container = blobClient.GetContainerReference(containerName); foreach (var blobListItem in container.ListBlobs().OrderBy(x => x.Uri.ToString())) { var blob = container.GetBlobReferenceFromServer(blobListItem.Uri.ToString()); InstallPackageIfNewer(alwaysInstallPackages, workingDirectory, containerName, blob.Name); } } else { InstallPackageIfNewer(alwaysInstallPackages, workingDirectory, containerName, packageName); } } } catch (Exception e) { Tracer.WriteLine(string.Format("Package \"{0}\" failed to install, {1}", package, e), "Information"); } } }
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()); }
protected void Load_Data() { #if AZURE //Access the storage account var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("fiftyonedegrees")); //Create the service context to access the table var serviceContext = new TableServiceContext(storageAccount.TableEndpoint.ToString(), storageAccount.Credentials); //Getting the table entries foreach (var row in serviceContext.CreateQuery <LogMessageEntity>("log")) //"log" - the name of the table you wish to see { OutBox.Text += row.Message; } #else OutBox.Text = "This page will only work when compiled for use with Windows Azure"; #endif }
public virtual string GetCloudSetting(string settingName) { string value = null; try { if (RoleEnvironment.IsAvailable) { value = RoleEnvironment.GetConfigurationSettingValue(settingName); } } catch (Exception) { // Not in the role environment or config setting not found... } return(value); }
public void InitializeStorage() { // summary // get image queue and blob container using credentials from .cscfg file. // Open storage account using credentials from .cscfg file. var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); // Get context object for working with blobs, and // set a default retry policy appropriate for a web user interface. var blobClient = storageAccount.CreateCloudBlobClient(); blobClient.DefaultRequestOptions.RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(3), 3); // Get a reference to the blob container. imagesBlobContainer = blobClient.GetContainerReference("scoreimages"); }
public void WriteEntry(string eventName, string notes, string label) { try { string tableName = RoleEnvironment.GetConfigurationSettingValue("LogTableName"); CloudTable table = cloudTableClient.GetTableReference(tableName); table.CreateIfNotExists(); TableOperation insertOperation = TableOperation.Insert(new LogEntry(eventName, notes, label)); table.Execute(insertOperation); } catch (Exception e) { Tracer.WriteLine(e.ToString(), "Critical"); } }
private static string TryGetConfigurationSetting(string configName) { string ret = null; try { if (RoleEnvironment.IsAvailable) { ret = RoleEnvironment.GetConfigurationSettingValue(configName); } } catch (RoleEnvironmentException) { return(null); } return(ret); }
protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)); }); } ; CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudBlobClient blobClient = account.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference("ornekcontainer"); container.Create(); }
//Jean: Refactored, moved from Data Management component public static Action <string, Func <string, bool> > GetConfigurationSettingPublisher() { try { if (RoleEnvironment.IsAvailable) { return((configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName))); } } catch (Exception) { // Compatibility with VisualStudio 2013 } return((configName, configSetter) => configSetter(ConfigurationManager.AppSettings[configName])); }
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. bool result = base.OnStart(); _storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); var queueClient = _storageAccount.CreateCloudQueueClient(); _pushQueue = queueClient.GetQueueReference("pushes"); _pushQueue.CreateIfNotExists(); CreatePushBroker(); Trace.TraceInformation("Foo.PushProcess has been started"); return(result); }
protected void Application_Start() { Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)); }); AreaRegistration.RegisterAllAreas(); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); AuthConfig.RegisterAuth(); this.LoadProducts(); }
public static void SendStatusEmail(string emailAddress, Guid jobID, int iteration) { SmtpClient client = new SmtpClient(RoleEnvironment.GetConfigurationSettingValue("mailSmtpHost"), int.Parse(RoleEnvironment.GetConfigurationSettingValue("mailSmtpPort"))) { Credentials = new NetworkCredential(RoleEnvironment.GetConfigurationSettingValue("mailSendingAddress"), RoleEnvironment.GetConfigurationSettingValue("mailSendingPassword")), EnableSsl = bool.Parse(RoleEnvironment.GetConfigurationSettingValue("mailSmtpSsl")) }; try { client.Send(RoleEnvironment.GetConfigurationSettingValue("mailSendingAddress"), emailAddress, string.Format("CloudClustering job {0}", jobID), string.Format("CloudClustering job {0} has begun iteration {1}.", jobID, iteration)); } catch (Exception e) { System.Diagnostics.Trace.WriteLine("Failed to send status email: " + e.ToString()); } }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { int totalStubjectCount = Convert.ToInt32(RoleEnvironment.GetConfigurationSettingValue("SubjectCount")); if (string.IsNullOrEmpty(Name)) { yield return(new ValidationResult("Student name is Required")); } else if (ObtainedMarks < 0) { yield return(new ValidationResult("Invalid Obtained Marks")); } else if (ObtainedMarks > (totalStubjectCount * 100)) { yield return(new ValidationResult("Obtained Marks should be less then Total Marks")); } }
// before deployment: public MyNoteContext() : base(RoleEnvironment.GetConfigurationSettingValue("MyNoteContext")) // locally //public MyNoteContext() : base(("MyNoteContext")) { string connString; //try //{ // connString = RoleEnvironment.GetConfigurationSettingValue("MyNoteContext"); //} //catch //{ // connString = "MyNoteContext"; //} // Database.Connection = new = connString; }
private static int GetSleepTimeFromConfig() { int sleepTime; if (!int.TryParse(RoleEnvironment.GetConfigurationSettingValue("WorkerSleepTime"), out sleepTime)) { sleepTime = 0; } // polling less than a second seems too eager if (sleepTime < 1000) { sleepTime = 2000; } return(sleepTime); }
/// <summary> /// Query node mapping data from node mapping table /// </summary> /// <returns></returns> private Dictionary <string, string> GetNodeMappingData() { try { string dataConnectionString = RoleEnvironment.GetConfigurationSettingValue(SchedulerConfigNames.DataConnectionString); string nodeMappingTableName = RoleEnvironment.GetConfigurationSettingValue(SchedulerConfigNames.NodeMapping); NodeMapping nodeMapping = new NodeMapping(CloudStorageAccount.Parse(dataConnectionString), nodeMappingTableName); // Following GetLogicalNameIPMapping calls RefreshMapping, so we don't need to call it beforehand. return(nodeMapping.GetLogicalNameIPMapping()); } catch (Exception e) { TraceHelper.TraceError("0", "[NodeMappingCache] .GetNodeMappingData: Failed to get node mapping. {0}", e); return(null); } }
/// <summary> /// Gets the value of the named setting configured in the ServiceConfiguration.cscfg file. /// </summary> /// <param name="settingName">The name of the setting.</param> /// <returns>The setting value, or string.Empty if the setting is not found.</returns> internal static string GetConfigurationSettingValue(string settingName) { string result; try { result = RoleEnvironment.GetConfigurationSettingValue(settingName); } catch (RoleEnvironmentException) { // The setting was not found. System.Diagnostics.Trace.WriteLine("WebRole environment diagnostics error: " + settingName + " not found."); result = string.Empty; } return(result); }
public async Task Initialize() { defaultConsumerGroup = eventHubClient.GetConsumerGroup("workerrole"); string blobConnectionString = RoleEnvironment.GetConfigurationSettingValue("AzureStorage"); eventProcessorHost = new EventProcessorHost( "singleworker", eventHubClient.Path, defaultConsumerGroup.GroupName, RoleEnvironment.GetConfigurationSettingValue("Microsoft.ServiceBus.ConnectionString"), blobConnectionString); client = CloudStorageAccount.Parse(blobConnectionString).CreateCloudTableClient(); table = client.GetTableReference("TwitterItem"); await table.CreateIfNotExistsAsync(); await eventProcessorHost.RegisterEventProcessorFactoryAsync(new TwitterEventProcessorFactory(OnEventHubMessagesReveived)); }
public override bool OnStart() { var config = DiagnosticMonitor.GetDefaultInitialConfiguration(); var cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString")); TimeSpan transferPeriod; if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.ScheduledTransferPeriod"), out transferPeriod)) { transferPeriod = TimeSpan.FromMinutes(1); } TimeSpan sampleRate; if (!TimeSpan.TryParse(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.PerformanceCounterSampleRate"), out sampleRate)) { sampleRate = TimeSpan.FromSeconds(30); } LogLevel logLevel; if (!Enum.TryParse <LogLevel>(RoleEnvironment.GetConfigurationSettingValue("Diagnostics.LogLevelFilter"), out logLevel)) { logLevel = LogLevel.Verbose; } // Setup performance counters config.PerformanceCounters.DataSources.Add( new PerformanceCounterConfiguration { CounterSpecifier = @"\Processor(_Total)\% Processor Time", SampleRate = sampleRate }); config.PerformanceCounters.ScheduledTransferPeriod = transferPeriod; // Setup logs config.Logs.ScheduledTransferPeriod = transferPeriod; config.Logs.ScheduledTransferLogLevelFilter = logLevel; DiagnosticMonitor.Start(cloudStorageAccount, config); return(base.OnStart()); }
protected void NewDrive_Click(object sender, EventArgs e) { if (RoleEnvironment.IsAvailable) { // retrieve storage account CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // build page blob URI for the new cloud drive by changing the extension in the original URI string imageStoreBlobUri = RoleEnvironment.GetConfigurationSettingValue("ImageStoreBlobUri"); string cloneStoreBlobUri = Path.ChangeExtension(imageStoreBlobUri, "bak"); // create drive and its associated page blob CloudDrive clonedDrive = account.CreateCloudDrive(cloneStoreBlobUri); if (this.MountedDrives.Items.Count < 2) { try { clonedDrive.Create(16); } catch (CloudDriveException) { // cloud drive already exists } // mount the drive and retrieve its path LocalResource cache = RoleEnvironment.GetLocalResource("LocalDriveCache"); string clonedStorePath = clonedDrive.Mount(cache.MaximumSizeInMegabytes / 2, DriveMountOptions.None); // copy the contents from the original drive to the new drive foreach (string sourceFileName in Directory.GetFiles(Global.ImageStorePath, "*.*").Where(name => name.EndsWith(".jpg") || name.EndsWith(".png"))) { string destinationFileName = Path.Combine(clonedStorePath, Path.GetFileName(sourceFileName)); File.Copy(sourceFileName, destinationFileName, true); } this.SelectImageStore(clonedStorePath); } else { clonedDrive.Unmount(); clonedDrive.Delete(); this.SelectImageStore(Global.ImageStorePath); } } }
private void CreateOnceContainerAndQueue() { if (s_createdContainerAndQueue) { return; } lock (s_lock) { if (s_createdContainerAndQueue) { return; } try { var storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("DataConnectionString")); blobStorage = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobStorage.GetContainerReference("photogallery"); container.CreateIfNotExist(); var permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); queueStorage = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueStorage.GetQueueReference("thumbnailmaker"); queue.CreateIfNotExist(); } catch (WebException) { // display a nice error message if the local development storage tool is not running or if there is // an error in the account configuration that causes this exception throw new WebException("The Windows Azure storage services cannot be contacted " + "via the current account configuration or the local development storage tool is not running. " + "Please start the development storage tool if you run the service locally!"); } s_createdContainerAndQueue = true; } }
public override bool OnStart() { // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. CloudStorageAccount.SetConfigurationSettingPublisher( (name, publisher) => { var connectionString = RoleEnvironment.GetConfigurationSettingValue(name); publisher(connectionString); } ); var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); AzureQueue <UserRegistrationMessage> queue = new AzureQueue <UserRegistrationMessage>(account); queue.EnsureExist(); AzureBlobContainer <RegistrationTokenEntity> registrationBlob = new AzureBlobContainer <RegistrationTokenEntity>(account, true); registrationBlob.EnsureExist(); // We could do the 'worker role' portion here aslo //Task.Factory.StartNew(() => //{ // while (true) // { // try // { // var message = queue.GetMessage(); // if (message != null) // { // var entity = new RegistrationTokenEntity(); // entity.RegistrationToken = (new Random()).Next().ToString(); // registrationBlob.Save(message.ContainerId, entity); // queue.DeleteMessage(message); // } // } // catch { } // Thread.Sleep(5000); // } //}); return(base.OnStart()); }
private static void SendMessage(EMailMessage eMessage) { var smtpSettings = RoleEnvironment.GetConfigurationSettingValue("SmtpSettings"); var parts = smtpSettings.Split(',', ';'); if (parts.Length < 6) { Trace.TraceError("SmtpSettings must contain 6 parts: host, [port#], [<ssl>], from, [user],[password]."); return; } int i = 0; var host = parts[i++].Trim(); var port = parts[i++].Trim(); var ssl = parts[i++].Trim(); var from = parts[i++].Trim(); var accountName = parts[i++].Trim(); var password = parts[i]; int portNumber; int.TryParse(port, out portNumber); var message = new MailMessage(from, eMessage.To, eMessage.Subject, eMessage.Body) { IsBodyHtml = eMessage.IsBodyHtml }; var smtpClient = new SmtpClient(host) { EnableSsl = ssl.ToLowerInvariant() == "ssl", UseDefaultCredentials = false, }; if (portNumber != 0) { smtpClient.Port = portNumber; } if (!string.IsNullOrEmpty(accountName)) { smtpClient.Credentials = new NetworkCredential(accountName, password); } else { Trace.TraceError("Anonymous SMTP authentication will be applied."); } smtpClient.Send(message); }
/// <summary> /// Used to delete all records /// </summary> public void DeleteRecords() { try { // Retrieve storage account from connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(Constatns.StorageAccountConnectionString)); // Create the table client CloudTableClient tableClient = storageAccount.CreateCloudTableClient(); //get table references CloudTable updateTable = tableClient.GetTableReference("updatedcityrecord"); CloudTable globalTable = tableClient.GetTableReference("globalvariables"); // Get the data service context TableServiceContext serviceContext = tableClient.GetTableServiceContext(); //// Specify a partition query List <UpdatedCityRecord> cityRecordsList = (from e in serviceContext.CreateQuery <UpdatedCityRecord>("updatedcityrecord") select e).ToList(); foreach (UpdatedCityRecord city in cityRecordsList) { city.ETag = "*"; TableOperation deleteOperation = TableOperation.Delete(city); updateTable.Execute(deleteOperation); } //// Specify a partition query List <GlobalVariables> global = (from e in serviceContext.CreateQuery <GlobalVariables>("globalvariables") select e).ToList(); foreach (GlobalVariables city in global) { city.ETag = "*"; TableOperation deleteOperation = TableOperation.Delete(city); globalTable.Execute(deleteOperation); } } catch (Exception ex) { string message = ex.Message; } }
/// <summary> /// Get a MongoServerSettings object that can then be used to create a connection to the /// MongoDB Replica Set. Note this assumes the name of the replica ser role is ReplicaSetRole. /// The connection settings should be cached on the client side and should only be obtained /// if there is a connect exception. /// </summary> /// <returns>A MongoServerSettings object that corresponds to the replica set instances</returns> /// <example>var server = MongoServer.Create(MongoDBAzureHelper.GetReplicaSetSettings());</example> /// <example>var setting = MongoDBAzureHelper.GetReplicaSetSettings(); /// setting.SlaveOk = true; /// var server = MongoServer.Create(setting);</example> public static MongoServerSettings GetReplicaSetSettings() { var settings = new MongoServerSettings(); // TODO - Should only have 1 setting across both roles var replicaSetName = RoleEnvironment.GetConfigurationSettingValue(ReplicaSetNameSetting).ToLower(); settings.ReplicaSetName = replicaSetName; ReadOnlyCollection <RoleInstance> workerRoleInstances = null; try { workerRoleInstances = RoleEnvironment.Roles[RoleEnvironment.CurrentRoleInstance.Role.Name].Instances; } catch (KeyNotFoundException ke) { throw new ReplicaSetEnvironmentException( string.Format("The MongoDB worker role should be called {0}", RoleEnvironment.CurrentRoleInstance.Role.Name), ke); } catch (Exception e) { throw new ReplicaSetEnvironmentException( "Exception when trying to obtain worker role instances", e); } int replicaSetRoleCount = workerRoleInstances.Count; var servers = new List <MongoServerAddress>(); foreach (var instance in workerRoleInstances) { var endpoint = instance.InstanceEndpoints[MongodPortSetting].IPEndpoint; var instanceIdString = instance.Id; int instanceId = int.Parse(instanceIdString.Substring(instanceIdString.LastIndexOf("_") + 1)); var server = new MongoServerAddress( endpoint.Address.ToString(), (RoleEnvironment.IsEmulated ? endpoint.Port + instanceId : endpoint.Port) ); servers.Add(server); } settings.Servers = servers; settings.ConnectionMode = ConnectionMode.ReplicaSet; return(settings); }
public MembershipCreateStatus CreateUser(UserData userInfo) { if (String.IsNullOrEmpty(userInfo.Email)) { throw new ArgumentException("Value cannot be null or empty.", "Email"); } if (String.IsNullOrEmpty(userInfo.Password)) { throw new ArgumentException("Value cannot be null or empty.", "Password"); } if (String.IsNullOrEmpty(userInfo.FirstName)) { throw new ArgumentException("Value cannot be null or empty.", "First Name"); } if (String.IsNullOrEmpty(userInfo.LastName)) { throw new ArgumentException("Value cannot be null or empty.", "First Name"); } if (String.IsNullOrEmpty(userInfo.Role)) { userInfo.Role = "Guest"; } userInfo.LastLogin = new DateTime(1900, 1, 1); userInfo.Email = userInfo.Email.ToLower(); var account = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("DataConnectionString")); var context = account.CreateCloudTableClient().GetDataServiceContext(); var currentUser = context.CreateQuery <UserData>("Users") .Where(user => user.PartitionKey == "wedding" && user.Email == userInfo.Email) .FirstOrDefault(); if (currentUser != null) { return(MembershipCreateStatus.DuplicateUserName); } context.AddObject("Users", userInfo); context.SaveChangesWithRetries(); return(MembershipCreateStatus.Success); }
private static void InstallPackages() { Console.WriteLine("InstallPackages", "Information"); var workingDirectory = GetWorkingDirectory(); // Retrieve the semicolon delimitted list of zip file packages and install them var packages = RoleEnvironment.GetConfigurationSettingValue(PACKAGES).Split(';', ','); foreach (string package in packages) { Console.WriteLine("Installing Package " + package); try { if (!string.IsNullOrWhiteSpace(package)) { // Parse out the container\file pair var fields = package.Trim().Split(new char[] { '/', '\\' }, 2); var containerName = fields[0]; var packageName = fields[1]; if (packageName == "*") { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(DATA_CONNECTION_STRING)); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); var container = blobClient.GetContainerReference(containerName); foreach (var blobListItem in container.ListBlobs().OrderBy(x => x.Uri.ToString())) { var blob = container.GetBlobReference(blobListItem.Uri.ToString()); InstallPackageIfNewer(true, workingDirectory, containerName, blob.Name); } } else { InstallPackageIfNewer(true, workingDirectory, containerName, packageName); } } } catch (Exception e) { Console.WriteLine(string.Format("Package \"{0}\" failed to install, {1}", package, e), "Information"); } } }
// Below is an example of how to define a full configuration for a new storage provider that is not already specified in the config file. private void Example_ConfigureNewStorageProvider(ClusterConfiguration config) { const string myProviderFullTypeName = "Orleans.Storage.AzureTableStorage"; // Alternatively, can be something like typeof(AzureTableStorage).FullName const string myProviderName = "MyNewAzureStoreProvider"; // what ever arbitrary name you want to give to your provider var properties = new Dictionary <string, string>(); string connectionString = RoleEnvironment.GetConfigurationSettingValue(DATA_CONNECTION_STRING_KEY); properties.Add(DATA_CONNECTION_STRING_KEY, connectionString); properties.Add("MyCustomProperty4", "MyCustomPropertyValue4"); config.Globals.RegisterStorageProvider(myProviderFullTypeName, myProviderName, properties); // Once silo starts you can see that it prints in the log: // Providers: // StorageProviders: // Name=MyNewAzureStoreProvider, Type=Orleans.Storage.AzureTableStorage, Properties=[DataConnectionString, MyCustomProperty4] }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; //DiagnosticMonitor.Start("DiagnosticsConnectionString"); // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. //RoleEnvironment.Changing += RoleEnvironmentChanging; CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName))); this.container = new WindsorContainer().Install(new BookingWorkerRoleWindsorInstaller()); return(base.OnStart()); }