public void LoadStorageAccountConfigurationSettings() { StorageAccountConfigurationSettings storageSettings = ApplicationConfiguration.Current.GetConfigurationSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); Assert.IsNotNull(storageSettings, "No StorageAccountConfigurationSettings section was found"); Assert.IsFalse(storageSettings.Accounts.Count == 0, "Accounts collection is empty"); Assert.IsFalse(String.IsNullOrEmpty(storageSettings.Accounts.Get(0).Name), "Name property is null or empty"); Assert.IsFalse(String.IsNullOrEmpty(storageSettings.Accounts.Get(0).AccountName), "AccountName property is null or empty"); Assert.IsFalse(String.IsNullOrEmpty(storageSettings.Accounts.Get(0).AccountKey), "AccountKey property is null or empty"); using (MemoryStream memoryBuffer = new MemoryStream()) { XmlWriterSettings writerRettings = new XmlWriterSettings(); writerRettings.CloseOutput = false; writerRettings.CheckCharacters = false; writerRettings.ConformanceLevel = ConformanceLevel.Fragment; writerRettings.NamespaceHandling = NamespaceHandling.OmitDuplicates; using (XmlWriter writer = XmlWriter.Create(memoryBuffer, writerRettings)) { storageSettings.WriteXml(writer); writer.Flush(); } memoryBuffer.Seek(0, SeekOrigin.Begin); StreamReader sr = new StreamReader(memoryBuffer); string sectionXml = sr.ReadToEnd(); Assert.IsNotNull(sectionXml, "sectionXml is null"); } }
/// <summary> /// Returns the Windows Azure table storage from the specified storage account. /// </summary> /// <param name="accountName">The storage account name.</param> /// <returns>An instance of the object supporting storage operations against Windows Azure tables.</returns> public ICloudTableStorage GetTableStorage(string accountName) { Guard.ArgumentNotNull(accountName, "accountName"); var callToken = TraceManager.WorkerRoleComponent.TraceIn(accountName); try { StorageAccountConfigurationSettings storageSettings = this.roleConfigExtension.GetSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); if (storageSettings != null) { StorageAccountInfo storageAccount = storageSettings.Accounts.Get(accountName); if (storageAccount != null) { return(new ReliableCloudTableStorage(storageAccount, GetStorageAccountRetryPolicy(storageAccount))); } else { throw new ConfigurationErrorsException(String.Format(CultureInfo.InvariantCulture, ExceptionMessages.StorageAccountNotFoundInConfigSource, accountName)); } } else { throw new ConfigurationErrorsException(String.Format(CultureInfo.InvariantCulture, ExceptionMessages.ConfigSectionNotFoundInConfigSource, StorageAccountConfigurationSettings.SectionName)); } } finally { TraceManager.WorkerRoleComponent.TraceOut(callToken); } }
/// <summary> /// Extends the OnStart phase that is called by Windows Azure runtime to initialize the role instance. /// </summary> /// <returns>True if initialization succeeds, otherwise false.</returns> protected override bool OnRoleStart() { this.EnsureExists <ScalableTransformConfigurationExtension>(); this.EnsureExists <CloudStorageProviderExtension>(); this.EnsureExists <XslTransformMetadataProviderExtension>(); this.EnsureExists <XslTransformInProcCacheExtension>(); this.EnsureExists <XslTransformProviderExtension>(); this.EnsureExists <EndpointConfigurationDiscoveryExtension>(); IEndpointConfigurationDiscoveryExtension discoveryExtension = Extensions.Find <IEndpointConfigurationDiscoveryExtension>(); IRoleConfigurationSettingsExtension roleConfigExtension = Extensions.Find <IRoleConfigurationSettingsExtension>(); IScalableTransformConfigurationExtension serviceConfigExtension = Extensions.Find <IScalableTransformConfigurationExtension>(); StorageAccountConfigurationSettings storageSettings = roleConfigExtension.GetSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); XslTransformCloudBlobCacheExtension cloudBlobCache = new XslTransformCloudBlobCacheExtension(storageSettings.Accounts.Get(serviceConfigExtension.Settings.CacheStorageAccount)); CloudStorageLoadBalancingExtension storageLoadBalancer = new CloudStorageLoadBalancingExtension(from name in serviceConfigExtension.Settings.StorageAccounts.AllKeys select storageSettings.Accounts.Get(name)); // Configure the cache TTL for the blob caching extension. cloudBlobCache.CacheTimeToLive = serviceConfigExtension.Settings.BlobCacheTimeToLive; // Configure the cache TTL for the in-proc caching extension. XslTransformInProcCacheExtension memoryCache = Extensions.Find <XslTransformInProcCacheExtension>(); memoryCache.CacheTimeToLive = serviceConfigExtension.Settings.MemoryCacheTimeToLive; Extensions.Add(cloudBlobCache); Extensions.Add(storageLoadBalancer); // Done with configuring all infrastructure extensions, now proceed with registering the service extension that implements the core methods. this.EnsureExists <ScalableTransformServiceExtension>(); var contractTypeMatchCondition = ServiceEndpointDiscoveryCondition.ContractTypeExactMatch(typeof(IScalableTransformationServiceContract)); var bindingTypeMatchCondition = ServiceEndpointDiscoveryCondition.BindingTypeExactMatch(typeof(NetTcpRelayBinding)); discoveryExtension.RegisterDiscoveryAction(new[] { contractTypeMatchCondition, bindingTypeMatchCondition }, (endpoint) => { NetTcpRelayBinding relayBinding = endpoint.Binding as NetTcpRelayBinding; if (relayBinding != null) { relayBinding.TransferMode = TransferMode.Streamed; } }); return(true); }
private static ICloudBlobStorage GetCloudBlobStorage() { StorageAccountConfigurationSettings storageSettings = ApplicationConfiguration.Current.GetConfigurationSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); return(new ReliableCloudBlobStorage(storageSettings.Accounts.Get(storageSettings.DefaultQueueStorage))); }
/// <summary> /// Notifies this extension component that it has been registered in the owner's collection of extensions. /// </summary> /// <param name="owner">The extensible owner object that aggregates this extension.</param> public void Attach(IExtensibleCloudServiceComponent owner) { IRoleConfigurationSettingsExtension roleConfigExtension = owner.Extensions.Find <IRoleConfigurationSettingsExtension>(); if (roleConfigExtension != null && CloudEnvironment.IsAvailable) { ApplicationDiagnosticSettings diagnosticSettings = roleConfigExtension.GetSection <ApplicationDiagnosticSettings>(ApplicationDiagnosticSettings.SectionName); StorageAccountConfigurationSettings storageSettings = roleConfigExtension.GetSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); if (diagnosticSettings != null) { if (diagnosticSettings.DiagnosticEnabled) { DiagnosticMonitorConfiguration diagnosticConfig = DiagnosticMonitor.GetDefaultInitialConfiguration(); // Configure the scheduled transfer period for all logs. diagnosticConfig.DiagnosticInfrastructureLogs.ScheduledTransferPeriod = diagnosticSettings.DiagnosticLogsTransferPeriod.Coalesce(diagnosticSettings.DefaultTransferPeriod); diagnosticConfig.Directories.ScheduledTransferPeriod = diagnosticSettings.FileLogsTransferPeriod.Coalesce(diagnosticSettings.DefaultTransferPeriod); diagnosticConfig.Logs.ScheduledTransferPeriod = diagnosticSettings.TraceLogsTransferPeriod.Coalesce(diagnosticSettings.DefaultTransferPeriod); diagnosticConfig.PerformanceCounters.ScheduledTransferPeriod = diagnosticSettings.PerformanceCountersTransferPeriod.Coalesce(diagnosticSettings.DefaultTransferPeriod); diagnosticConfig.WindowsEventLog.ScheduledTransferPeriod = diagnosticSettings.EventLogsTransferPeriod.Coalesce(diagnosticSettings.DefaultTransferPeriod); // Configure the logs levels for scheduled transfers. diagnosticConfig.DiagnosticInfrastructureLogs.ScheduledTransferLogLevelFilter = FromTraceSourceLevel(diagnosticSettings.DiagnosticLogsTransferFilter); diagnosticConfig.Logs.ScheduledTransferLogLevelFilter = FromTraceSourceLevel(diagnosticSettings.TraceLogsTransferFilter); diagnosticConfig.WindowsEventLog.ScheduledTransferLogLevelFilter = FromTraceSourceLevel(diagnosticSettings.EventLogsTransferFilter); // Configure the Windows Event Log data sources. foreach (string logName in diagnosticSettings.EventLogDataSources.AllKeys) { diagnosticConfig.WindowsEventLog.DataSources.Add(logName); } // Configure the data sources for file-based logs. foreach (string containerName in diagnosticSettings.FileLogDirectories.AllKeys) { diagnosticConfig.Directories.DataSources.Add(new DirectoryConfiguration() { Container = containerName, Path = diagnosticSettings.FileLogDirectories[containerName].Value }); } // Configure the data sources for performance counter data foreach (string counterName in diagnosticSettings.PerformanceCountersDataSources.AllKeys) { diagnosticConfig.PerformanceCounters.DataSources.Add(new PerformanceCounterConfiguration() { CounterSpecifier = counterName, SampleRate = TimeSpan.Parse(diagnosticSettings.PerformanceCountersDataSources[counterName].Value) }); } // Configure crash dumps collection. if (diagnosticSettings.CrashDumpCollectionEnabled) { CrashDumps.EnableCollection(true); } // Look up for the storage account definition. StorageAccountInfo storageAccountInfo = storageSettings.Accounts.Get(diagnosticSettings.DiagnosticStorageAccount); if (storageAccountInfo != null) { CloudStorageAccount storageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(storageAccountInfo.AccountName, storageAccountInfo.AccountKey), true); RetryPolicy retryPolicy = roleConfigExtension.StorageRetryPolicy; // Start the Azure Diagnostic Monitor using a retryable scope. this.diagnosticMonitor = retryPolicy.ExecuteAction <DiagnosticMonitor>(() => { return(DiagnosticMonitor.Start(storageAccount, diagnosticConfig)); }); } } else { // Do not proceed any further since diagnostic is not enabled in the application configuration. return; } } } if (null == this.diagnosticMonitor) { // Configuration extension is not available by some reasons, let try and see if DiagnosticsConnectionString property is set in the configuration. string diagConnectionString = CloudEnvironment.GetConfigurationSettingValue(Resources.DiagnosticsConnectionStringSettingName); // If DiagnosticsConnectionString is defined, start a Diagnostic Monitor using the storage account configuration specified in the setting. if (!String.IsNullOrEmpty(diagConnectionString)) { this.diagnosticMonitor = DiagnosticMonitor.Start(diagConnectionString, GetDiagnosticMonitorDefaultConfiguration()); } } }
/// <summary> /// Initializes a new instance of the trace listener using the specified configuration settings. /// </summary> /// <param name="diagnosticServiceEndpoint">The name of the Service Bus endpoint definition that corresponds to the on-premises hosted diagnostic service.</param> /// <param name="diagnosticStorageAccount">The name of the storage account in which diagnostic data will be queued before relayed to the on-premises hosted diagnostic service.</param> /// <param name="inMemoryQueueCapacity">The maximum capacity of the non-durable in-memory queue in which trace events are being stored before they are persisted into an Azure queue.</param> /// <param name="inMemoryQueueListenerSleepTimeout">The interval in milliseconds during which a dequeue thread is waiting for new events in the in-memory queue.</param> /// <param name="diagQueueEventBatchSize">The maximum number of trace events in a batch that is submitted to the on-premises hosted diagnostic service.</param> /// <param name="diagQueueListenerSleepTimeout">The interval in milliseconds during which a dequeue thread is waiting for new events to be deposited into the Azure queue.</param> public OnPremisesBufferedTraceListener(string diagnosticServiceEndpoint, string diagnosticStorageAccount, int inMemoryQueueCapacity, int inMemoryQueueListenerSleepTimeout, int diagQueueEventBatchSize, int diagQueueListenerSleepTimeout) { Guard.ArgumentNotNullOrEmptyString(diagnosticServiceEndpoint, "diagnosticServiceEndpoint"); Guard.ArgumentNotZeroOrNegativeValue(inMemoryQueueCapacity, "inMemoryQueueCapacity"); Guard.ArgumentNotZeroOrNegativeValue(inMemoryQueueListenerSleepTimeout, "inMemoryQueueListenerSleepTimeout"); Guard.ArgumentNotZeroOrNegativeValue(diagQueueEventBatchSize, "diagQueueEventBatchSize"); Guard.ArgumentNotZeroOrNegativeValue(diagQueueListenerSleepTimeout, "diagQueueListenerSleepTimeout"); // Configure the general properties of the trace listener. Name = ListenerName; NeedIndent = false; // Configure the in-memory queue and its parameters, set up a backup trace listener. this.inMemoryQueue = new ConcurrentQueue <TraceEventRecord>(); this.inMemoryQueueCapacity = inMemoryQueueCapacity; this.inMemoryQueueListenerSleepTimeout = inMemoryQueueListenerSleepTimeout; this.diagQueueEventBatchSize = diagQueueEventBatchSize; this.diagQueueListenerSleepTimeout = diagQueueListenerSleepTimeout; this.diagQueueName = GetServiceBusQueueName(CloudEnvironment.CurrentRoleInstanceId); this.backupTraceListener = new CloudDiagnosticTraceListener(); // Configure Service Bus endpoint for the Diagnostic Service. ServiceBusEndpointInfo diagServiceEndpointInfo = ApplicationConfiguration.Current.ServiceBusSettings.Endpoints[diagnosticServiceEndpoint]; // Validate Service Bus endpoints. if (null == diagServiceEndpointInfo) { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.SpecifiedServiceBusEndpointNotFound, diagnosticServiceEndpoint, ServiceBusConfigurationSettings.SectionName)); } // Retrieve the storage account settings from application configuration. StorageAccountConfigurationSettings storageSettings = ApplicationConfiguration.Current.GetConfigurationSection <StorageAccountConfigurationSettings>(StorageAccountConfigurationSettings.SectionName); // Validate the presence of storage account settings. if (null == storageSettings) { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigSectionNotFoundInConfigSource, StorageAccountConfigurationSettings.SectionName)); } // Determine the storage account for storing tracing data. By default, assume that storage account is defined in the trace listener configuration. string diagStorageAccountName = diagnosticStorageAccount; // If storage account is not defined in the trace listener configuration, switch to the storage account specified in the Application Diagnostic Settings section. if (String.IsNullOrEmpty(diagStorageAccountName)) { // Retrieve the diagnostic settings from application configuration. ApplicationDiagnosticSettings diagSettings = ApplicationConfiguration.Current.GetConfigurationSection <ApplicationDiagnosticSettings>(ApplicationDiagnosticSettings.SectionName); // Validate the presence of diagnostic settings. if (null == diagSettings) { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.ConfigSectionNotFoundInConfigSource, ApplicationDiagnosticSettings.SectionName)); } diagStorageAccountName = diagSettings.DiagnosticStorageAccount; } // Resolve the storage account details based on the account name defined in the diagnostic settings . StorageAccountInfo diagStorageAccount = storageSettings.Accounts.Get(diagStorageAccountName); // Validate storage account details. if (null == diagStorageAccount) { throw new ConfigurationErrorsException(String.Format(CultureInfo.CurrentCulture, ExceptionMessages.StorageAccountNotFoundInConfigSource, diagStorageAccountName)); } // Configure retry policies. this.sbRetryPolicy = new RetryPolicy <ServiceBusTransientErrorDetectionStrategy>(DefaultRetryCount); this.queueRetryPolicy = new RetryPolicy <StorageTransientErrorDetectionStrategy>(DefaultRetryCount); this.sbRetryPolicy.RetryOccurred += HandleServiceBusEndpointRetryState; this.queueRetryPolicy.RetryOccurred += HandleCloudQueueRetryState; // Configure Service Bus and Message Queue clients. this.diagnosticService = new ReliableServiceBusClient <IDiagnosticLoggingServiceChannel>(diagServiceEndpointInfo, this.sbRetryPolicy); this.diagQueueStorage = new ReliableCloudQueueStorage(diagStorageAccount, this.queueRetryPolicy); this.diagQueueReaderDone = new ManualResetEvent(false); this.diagQueueWriterDone = new ManualResetEvent(false); // Ensure that destination cloud queue exists, create if necessary. this.diagQueueStorage.CreateQueue(this.diagQueueName); // Enable background listeners to run. this.isRunning = true; StartInMemoryQueueListener(); StartServiceBusQueueListener(); }