protected void Application_Start() { var savedContext = HttpContext.Current; HttpContext.Current = null; // 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)); }); AreaRegistration.RegisterAllAreas(); RegisterGlobalFilters(GlobalFilters.Filters); RegisterRoutes(RouteTable.Routes); RouteTable.Routes.AddWcfServiceRoute <AuthenticationService>("AuthenticationService"); RouteTable.Routes.AddWcfServiceRoute <SharedAccessSignatureService>("SharedAccessSignatureService"); RouteTable.Routes.AddWcfServiceRoute <SamplePushUserRegistrationService>("PushNotificationService"); var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CreateCloudTables(account.CreateCloudTableClient()); HttpContext.Current = savedContext; }
// Constructor - get settings from a hosted service configuration or .NET configuration file. public BlobHelper(string configurationSettingName, bool hostedService) { if (hostedService) { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = RoleEnvironment.GetConfigurationSettingValue(configName); configSettingPublisher(connectionString); } ); } else { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = ConfigurationManager.ConnectionStrings[configName].ConnectionString; configSettingPublisher(connectionString); } ); } Account = CloudStorageAccount.FromConfigurationSetting(configurationSettingName); BlobClient = Account.CreateCloudBlobClient(); BlobClient.RetryPolicy = RetryPolicies.Retry(4, TimeSpan.Zero); }
public override void Run() { // This is a sample worker implementation. Replace with your logic. Trace.WriteLine("RdStorage_WorkerRole entry point called", "Information"); // initialize the account information var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // retrieve a reference to the messages queue var queueClient = storageAccount.CreateCloudQueueClient(); var queue = queueClient.GetQueueReference("messagequeue"); // retrieve messages and write them to the compute emulator log while (true) { Thread.Sleep(10000); if (queue.Exists()) { var msg = queue.GetMessage(); if (msg != null) { Trace.TraceInformation(string.Format("Message '{0}' processed.", msg.AsString)); queue.DeleteMessage(msg); } } } }
void Application_Start(object sender, EventArgs e) { // Code that runs on application startup BundleConfig.RegisterBundles(BundleTable.Bundles); AuthConfig.RegisterOpenAuth(); if (imageStorePath == null) { ImageStorePath = WebConfigurationManager.AppSettings["ImageStorePath"]; } // initialize storage account configuration setting publisher CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { string connectionString = RoleEnvironment.GetConfigurationSettingValue(configName); configSetter(connectionString); }); try { // initialize the local cache for the Azure drive LocalResource cache = RoleEnvironment.GetLocalResource("LocalDriveCache"); CloudDrive.InitializeCache(cache.RootPath + "cache", cache.MaximumSizeInMegabytes); // retrieve storage account CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // retrieve URI for the page blob that contains the cloud drive from configuration settings string imageStoreBlobUri = RoleEnvironment.GetConfigurationSettingValue("ImageStoreBlobUri"); // unmount any previously mounted drive. foreach (var drive in CloudDrive.GetMountedDrives()) { var mountedDrive = new CloudDrive(drive.Value, account.Credentials); mountedDrive.Unmount(); } // create the Windows Azure drive and its associated page blob CloudDrive imageStoreDrive = account.CreateCloudDrive(imageStoreBlobUri); if (CloudDrive.GetMountedDrives().Count == 0) { try { imageStoreDrive.Create(16); } catch (CloudDriveException) { // drive already exists } } // mount the drive and initialize the application with the path to the image store on the Azure drive Global.ImageStorePath = imageStoreDrive.Mount(cache.MaximumSizeInMegabytes / 2, DriveMountOptions.None); } catch (CloudDriveException driveException) { Trace.WriteLine("Error: " + driveException.Message); } }
public static void DeleteArticle(int AnnouncementID) { var statusMessage = String.Empty; try { var account = CloudStorageAccount.FromConfigurationSetting("TableDataConnectionString"); var context = new MessageDataServiceContext(account.TableEndpoint.ToString(), account.Credentials); while (true) { var o = (from message in context.Messages where message.IsNotification == false && message.AnnouncementID == AnnouncementID select message).FirstOrDefault(); if (o == null) { return; } context.DeleteObject(o); context.SaveChanges(); } } catch (DataServiceRequestException ex) { statusMessage = "Unable to connect to the table storage server. Please check that the service is running.<br>" + ex.Message; } }
private void InitializeQueueListener() { Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment.GetConfigurationSettingValue(configName)); }); var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); var queueStorage = storageAccount.CreateCloudQueueClient(); var queue = queueStorage.GetQueueReference("myqueue"); queue.CreateIfNotExist(); while (true) { CloudQueueMessage msg = queue.GetMessage(); if (msg != null) { // DO SOMETHING HERE queue.DeleteMessage(msg); } else { System.Threading.Thread.Sleep(1000); } } }
private void Init(string configurationSettingName) { if (RoleEnvironment.IsAvailable) { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = RoleEnvironment.GetConfigurationSettingValue(configName); configSettingPublisher(connectionString); } ); } else { CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSettingPublisher) => { var connectionString = ConfigurationManager.ConnectionStrings[configName].ConnectionString; configSettingPublisher(connectionString); } ); } Account = CloudStorageAccount.FromConfigurationSetting(configurationSettingName); TableClient = Account.CreateCloudTableClient(); TableClient.RetryPolicy = RetryPolicies.Retry(3, TimeSpan.FromMilliseconds(100)); }
private string CreateBlob(Stream content, string name) { if (string.IsNullOrEmpty(name)) { throw new ArgumentException("blob name can't be null or empty"); } if (content == null) { throw new ArgumentException("stream is null or emply"); } var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); var blobClient = storageAccount.CreateCloudBlobClient(); //#warning TODO: find better place for creating the cross domain policy file // CreateStorageCrossDomainPolicy(blobClient); var container = blobClient.GetContainerReference(ContainerName); container.CreateIfNotExist(); CloudBlob blob = container.GetBlobReference(name); blob.UploadFromStream(content); return(blob.Uri.AbsoluteUri); }
static PersonTableStorageContext() { account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudTableClient tableClient = new CloudTableClient(account.TableEndpoint.AbsoluteUri, account.Credentials); tableClient.CreateTableIfNotExist(TableName); }
/// <summary> /// Initializes the queue. /// </summary> private void InitializeQueue() { bool storageInitialized = false; CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(GetConnectionString("DataConnectionString")); }); var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // initialize queue storage CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient(); queue = queueStorage.GetQueueReference("cybernanny"); Trace.TraceInformation("Creating queue..."); while (!storageInitialized) { try { queue.CreateIfNotExist(); storageInitialized = true; } catch (StorageClientException e) { if (e.ErrorCode == StorageErrorCode.TransportError) { Trace.TraceError("Storage services initialization failure. Message:{0}", e.Message); System.Threading.Thread.Sleep(3000); } else { throw; } } } }
protected void Button1_Click(object sender, EventArgs e) { CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("dataConnStr"); CloudBlobClient blobClient = account.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference("testing12"); container.CreateIfNotExist(); BlobContainerPermissions containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; container.SetPermissions(containerPermissions); var blob = container.GetBlobReference("file.x"); blob.UploadFromStream(FileUpload1.FileContent); Response.Write(blob.Uri.ToString()); //using (FileStream fs = File.OpenRead(path)) //{ // // Create the Blob and upload the file // var blob = _BlobContainer.GetBlobReference(Guid.NewGuid().ToString() + "/" + filename); // blob.UploadFromStream(fs); // // Set the metadata into the blob // blob.Metadata["FileName"] = filename; // blob.Metadata["Submitter"] = "Automated Encoder"; // blob.SetMetadata(); // // Set the properties // blob.Properties.ContentType = "video/x-ms-wmv"; // blob.SetProperties(); //} }
public static void PreStart() { // Configure the default values for the Push Notifications Registration Service: // - Anonymous access // - Windows Azure Storage Tables as the storage provider NotificationServiceContext.Current.Configure( c => { // TODO: Specify additional authentication rules c.AuthenticateRequest = currentRequest => true; // TODO: Specify a rule for whether users can access the Management Operations (get, all) c.AuthorizeManagementRequest = currentRequest => true; // TODO: Specify a rule for authorizing users when registring (register, unregister) c.AuthorizeRegistrationRequest = AuthorizeUserRequest; // TODO: Replace with your own Windows Azure Storage account name and key, or read it from a configuration file CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSettingPublisher) => { var connectionString = ConfigurationManager.AppSettings[configName]; configSettingPublisher(connectionString); }); //var act = new CloudStorageAccount(new StorageCredentialsAccountAndKey("ajholwp","DMZ6Gaec53G7EF4u4HcsgUjZCRutx0pKxwi40s+u1DRPwUow+UaZSb1fhbpdTFsDpsuOYMZqai/Bv83suRfVUQ=="), true); var act = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); c.StorageProvider = new WindowsAzureEndpointRepository(act); // TODO: Specify the handlers you want for ASP.NET Web API Registration Service (authentication, logging, etc) // c.DelegatingHandlers = new[] { // Your DelegatingHandler instances }; }); RouteTable.Routes.MapRegistrationServiceRoute("endpoints"); }
public AzureVirtualPathProvider(string blobStorageConnection) { // Setup the connection to Windows Azure Storage var cloudStorageAccount = CloudStorageAccount.FromConfigurationSetting(blobStorageConnection); CloudBlobClient = cloudStorageAccount.CreateCloudBlobClient(); }
public WorkerRole() { // 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(); } } }; }); this.storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); }
internal static bool InitializeStorage() { try { // 仅为测试目的,如果我们不在计算仿真程序中运行该服务,我们始终使用 dev 存储. if (RoleEnvironment.IsAvailable) { CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(RoleEnvironment.GetConfigurationSettingValue(configName)); }); StorageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); } else { StorageAccount = CloudStorageAccount.DevelopmentStorageAccount; } CloudBlobClient blobClient = new CloudBlobClient(StorageAccount.BlobEndpoint, StorageAccount.Credentials); CloudBlobContainer container = blobClient.GetContainerReference("videostories"); container.CreateIfNotExist(); CloudQueueClient queueClient = new CloudQueueClient(StorageAccount.QueueEndpoint, StorageAccount.Credentials); CloudQueue queue = queueClient.GetQueueReference("videostories"); queue.CreateIfNotExist(); CloudTableClient tableClient = new CloudTableClient(StorageAccount.TableEndpoint.AbsoluteUri, StorageAccount.Credentials); tableClient.CreateTableIfNotExist("Stories"); return(true); } catch (Exception ex) { Trace.Write("错误初始化存储: " + ex.Message, "Error"); return(false); } }
public override void Run() { // This is a sample worker implementation. Replace with your logic. Trace.WriteLine("NumberWorkerRole entry point called", "Information"); CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); QueueUtilities qutil = new QueueUtilities(account); CloudQueue queue = qutil.CreateQueueIfNotExists("numbers"); while (true) { CloudQueueMessage msg = queue.GetMessage(); if (msg != null) { int number = Convert.ToInt32(msg.AsString); Trace.WriteLine(string.Format("Processing number: {0}", number), "Information"); number--; if (number > 0) { CloudQueueMessage newmsg = new CloudQueueMessage(number.ToString()); queue.AddMessage(newmsg); } queue.DeleteMessage(msg); } else { Thread.Sleep(10000); Trace.WriteLine("Working", "Information"); } } }
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; Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { string configuration = RoleEnvironment.IsAvailable ? RoleEnvironment.GetConfigurationSettingValue(configName) : ConfigurationManager.AppSettings[configName]; configSetter(configuration); }); StorageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudTableClient.CreateTablesFromModel( typeof(DataContext), StorageAccount.TableEndpoint.AbsoluteUri, StorageAccount.Credentials); return(base.OnStart()); }
protected static IQueryable <ChirpEntity> Find() { CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); ChirpContext context = new ChirpContext(account.TableEndpoint.ToString(), account.Credentials); return(context.ChirpEntities); }
/// <summary> /// Removes the request. /// </summary> /// <param name="userIdentifier">The user identifier.</param> /// <param name="removeAll">if set to <c>true</c> [remove all].</param> /// <returns></returns> public bool RemoveRequest(int userIdentifier, bool removeAll, out StringBuilder message) { var retval = false; message = new StringBuilder(); CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { configSetter(GetConnectionString("DataConnectionString")); }); if (userIdentifier.Equals(Common.AngelId) || userIdentifier.Equals(Common.MeryId)) { var account = CloudStorageAccount.FromConfigurationSetting(Common.ConnectionString); var queueClient = account.CreateCloudQueueClient(); var queue = queueClient.GetQueueReference("cybernanny"); if (queue.RetrieveApproximateMessageCount() > 0) { if (!removeAll) { var messageObj = queue.GetMessage(); message.Append(messageObj.AsString); queue.DeleteMessage(messageObj); } else { queue.Clear(); } retval = true; } } return(retval); }
private static void InitializeStorage() { if (_storageInitialized) { return; } lock (_locker) { try { var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); _blobStorage = storageAccount.CreateCloudBlobClient(); CloudBlobContainer blobContainer = _blobStorage.GetContainerReference("logitems"); blobContainer.CreateIfNotExist(); _queueStorage = storageAccount.CreateCloudQueueClient(); CloudQueue queue = _queueStorage.GetQueueReference("logmessages"); queue.CreateIfNotExist(); } catch (System.Net.WebException) { throw new System.Net.WebException("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running."); } _storageInitialized = true; } }
public static void Initialize() { CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudTableClient ctc = account.CreateCloudTableClient(); ctc.CreateTableIfNotExist(TABLE_NAME); }
static void Main(string[] args) { Microsoft.WindowsAzure.CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { string configuration = RoleEnvironment.IsAvailable ? RoleEnvironment.GetConfigurationSettingValue(configName) : ConfigurationManager.AppSettings[configName]; configSetter(configuration); }); CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); Processor = new Processor(account); (new Thread(new ThreadStart(GetResponse))).Start(); while (true) { string program = ""; string line = System.Console.ReadLine(); while (line != "send") { program += line; program += "\r\n"; line = System.Console.ReadLine(); } Processor.SendRequest(program); } }
void Application_Start(object sender, EventArgs e) { // Code that runs on application startup BundleConfig.RegisterBundles(BundleTable.Bundles); AuthConfig.RegisterOpenAuth(); // 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)); }); /// Create data table from MessageDataServiceContext /// It is recommended the data tables should be only created once. It is typically done as a /// provisioning step and rarely in application code. var account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // dynamically create the tables CloudTableClient.CreateTablesFromModel( typeof(MessageDataServiceContext), account.TableEndpoint.AbsoluteUri, account.Credentials); }
private static IAzureStorageConfig CreateCloudStorageConfig() { DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"); CloudStorageAccount.SetConfigurationSettingPublisher( (configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName))); return(AzureStorage.CreateConfig(CloudStorageAccount.FromConfigurationSetting("StorageConnectionString"))); }
public BlobDocumentStorage() { this.container = ConfigurationManager.AppSettings["blobStorageContainer"]; var account = CloudStorageAccount.FromConfigurationSetting(ConfigurationManager.AppSettings["DataConnectionString"]); this.cloudBlobClient = account.CreateCloudBlobClient(); }
private static CloudBlobClient GetClient() { CloudStorageAccount account = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); CloudBlobClient cloudBlobClient = account.CreateCloudBlobClient(); return(cloudBlobClient); }
private static void InitializeStorage() { if (storageInitialized) { return; } lock (gate) { if (storageInitialized) { return; } try // инициализируем BLOB-хранилище { // read account configuration settings var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // create blob container for images blobStorage = storageAccount.CreateCloudBlobClient(); container = blobStorage.GetContainerReference("intellects"); container.CreateIfNotExist(); // configure container for public access var permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); // create queue for matches queueClient = storageAccount.CreateCloudQueueClient(); queue = queueClient.GetQueueReference("queue"); queue.CreateIfNotExist(); // раньше DbconnectionString для EntityConnection парсилась RoleEnviroment.GetConfiguration, но парсилась как-то.. // плохо. временно заменяю на прямое указание! //db = new DBContext(new EntityConnection(@"metadata=res://*/DBModel.csdl|res://*/DBModel.ssdl|res://*/DBModel.msl;provider=System.Data.SqlClient;provider connection string='data source=localhost\SQLEXPRESS;initial catalog=WarSpotDB;integrated security=True;multipleactiveresultsets=True;App=EntityFramework'")); // инициализируем базу данных db = new DBContext(Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment.GetConfigurationSettingValue("DBConnectionString")); } catch (WebException) { throw new WebException("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running."); } catch (TypeInitializationException) { throw new WebException("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running."); } storageInitialized = true; } }
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()); }
public FilesDataSource() { //Init the storage account _storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); _cloudTableClient = _storageAccount.CreateCloudTableClient(); _cloudTableClient.CreateTableIfNotExist("Files"); }
private CloudBlobContainer GetContainer() { // Get a handle on account, create a blob service client and get container proxy var account = CloudStorageAccount.FromConfigurationSetting("StorageConnectionString"); var client = account.CreateCloudBlobClient(); return(client.GetContainerReference(RoleEnvironment.GetConfigurationSettingValue("StorageName"))); }