//ADD AILMENT DETAILS public void AddAilmentDetails(AilmentDetails AilData) { #if DEBUG account = CloudStorageAccount.DevelopmentStorageAccount; #else account = new CloudStorageAccount(accountAndKey, true); #endif client = account.CreateCloudTableClient(); client.CreateTableIfNotExist("PatientDetails"); tableContext = new TableServiceContext(account.TableEndpoint.ToString(), account.Credentials); AilmentDetails x = new AilmentDetails(); x.AttendingPhysician = AilData.AttendingPhysician; x.Diagnosis = AilData.Diagnosis; x.DiagnosisID = AilData.DiagnosisID; x.GeneralPhysician = AilData.GeneralPhysician; x.Hospital = AilData.Hospital; x.Lab_Pathology = AilData.Lab_Pathology; x.Lab_Physical = AilData.Lab_Physical; x.Lab_Radiology = AilData.Lab_Physical; x.Medication = AilData.Medication; x.PatientIDLinkRowKey = AilData.PatientIDLinkRowKey; x.ProgressNotes = AilData.ProgressNotes; x.Symptoms = AilData.Symptoms; x.TimeIn = AilData.TimeIn; x.TimeOut = AilData.TimeOut; x.Treatment = AilData.Treatment; x.AilmentDetailRowKey = AilData.AilmentDetailRowKey; tableContext.AddObject("PatientDetails", x); tableContext.SaveChanges(); }
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; } }
private void OnInitialize() { var selfInstance = InstanceEnumerator.GetSelf(); cloudStorageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(ConfigurationSettingsKeys.StorageConnectionString)); log.Info("Storage account selected: {0}",cloudStorageAccount.BlobEndpoint); cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient(); log.Info("Storage client created"); var containerName = ConfigurationProvider.GetSetting(ConfigurationSettingsKeys.StorageContainerName,"ravendb"); // In order to force a connection we just enumerate all available containers: var availableContainers = cloudBlobClient.ListContainers().ToArray(); foreach (var container in availableContainers) { log.Info("Available container: {0}",container.Name); } if (!availableContainers.Any(c => c.Name.Equals(containerName))) { log.Info("Container {0} does not exist, creating",containerName); // Container does not exist: cloudBlobClient.GetContainerReference(containerName).Create(); } cloudBlobContainer = cloudBlobClient.GetContainerReference(containerName); log.Info("Container {0} selected",cloudBlobContainer.Name); localCache = RoleEnvironment.GetLocalResource(ConfigurationSettingsKeys.StorageCacheResource); log.Info("Cache resource retrieved: {0}, path: {1}",localCache.Name,localCache.RootPath); CloudDrive.InitializeCache(localCache.RootPath, localCache.MaximumSizeInMegabytes); log.Info("Cache initialized: {0} mb",localCache.MaximumSizeInMegabytes); var driveName = string.Format("{0}{1}.vhd", selfInstance.RoleName, selfInstance.RoleInstanceIndex).ToLowerInvariant(); log.Info("Virtual drive name: {0}",driveName); var pageBlob = cloudBlobContainer.GetPageBlobReference(driveName); log.Info("Virtual drive blob: {0}",pageBlob.Uri); cloudDrive = cloudStorageAccount.CreateCloudDrive(pageBlob.Uri.ToString()); log.Info("Virtual drive created: {0}",cloudDrive.Uri); var storageSize = ConfigurationProvider.GetSetting(ConfigurationSettingsKeys.StorageSizeInMb, 50000); log.Info("Storage size: {0} mb",storageSize); cloudDrive.CreateIfNotExist(storageSize); log.Info("Virtual drive initialized: {0}",cloudDrive.Uri); var mountedDirectoryPath = cloudDrive.Mount(storageSize, DriveMountOptions.None); log.Info("Virtual drive mounted at: {0}",mountedDirectoryPath); mountedDirectory = new DirectoryInfo(mountedDirectoryPath); log.Info("Executing drive benchmark for: {0}",mountedDirectoryPath); ExecuteBenchmarks(mountedDirectory,storageSize); log.Info("Storage initialization succeeded"); }
private Stream GetTableStream(CloudStorageAccount account, string tableName, string query) { var requestUri = new StringBuilder(); requestUri.AppendFormat("{0}{1}()", account.TableEndpoint.ToString(), tableName); if (String.IsNullOrWhiteSpace(query)) { requestUri.AppendFormat("?{0}", query); } // create Http Request var request = (HttpWebRequest)HttpWebRequest.Create(requestUri.ToString()); // For requests using the $select query option, the request must be made using version 2011-08-18 // or newer. In addition, the DataServiceVersion and MaxDataServiceVersion headers must be set // to 2.0. // http://msdn.microsoft.com/en-us/library/dd179421.aspx request.Headers.Add("x-ms-version", "2011-08-18"); request.Headers.Add("MaxDataServiceVersion", "2.0"); // signs request using the specified credentials under the Shared Key Lite authentication account.Credentials.SignRequestLite(request); var response = (HttpWebResponse)request.GetResponse(); // get stream from response with response encoding var sr = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(response.CharacterSet)); return sr.BaseStream; }
public Uri GetBlobUri(CloudStorageAccount account, string blobRelativePath) { var blobsStoragePath = account.BlobEndpoint.AbsoluteUri; var blobPath = blobsStoragePath.CombineUris(blobRelativePath); var blobUri = new Uri(blobPath); return blobUri; }
/// <summary> /// Copies a blob from one account and container to another. /// </summary> /// <param name="copyBlockBlobSettings">A <see cref="CopyBlockBlobSettings"/>.</param> public static void CopyBlockBlob(CopyBlockBlobSettings copyBlockBlobSettings) { Contract.Requires(copyBlockBlobSettings != null, "The copy block blob settings cannot be null."); var sourceStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(copyBlockBlobSettings.BlobStorageSource, copyBlockBlobSettings.BlobStorageSourceKey), copyBlockBlobSettings.UseHttps); var sourceClient = sourceStorageAccount.CreateCloudBlobClient(); var destinationStorageAccount = new CloudStorageAccount(new StorageCredentialsAccountAndKey(copyBlockBlobSettings.BlobStorageDestination, copyBlockBlobSettings.BlobStorageDestinationKey), copyBlockBlobSettings.UseHttps); var destinationClient = destinationStorageAccount.CreateCloudBlobClient(); var destinationContainer = destinationClient.GetContainerReference(copyBlockBlobSettings.DestinationContainerName); try { destinationContainer.CreateIfNotExist(); } catch { // do nothing, create if not exists blows up if it already exists... nice. } var sourceBlob = sourceClient.GetBlockBlobReference(copyBlockBlobSettings.BlobSourcePath); sourceBlob.FetchAttributes(); CloudBlob destinationBlob = destinationClient.GetBlockBlobReference(copyBlockBlobSettings.BlobDestinationPath); destinationBlob.StartCopyFromBlob(sourceBlob.Uri); MonitorCopy(destinationBlob.Container); }
public SharedAccessSignatureController(CloudStorageAccount storageAccount) { if (storageAccount == null) throw new ArgumentNullException("storageAccount", Constants.CloudStorageAccountNullArgumentErrorMessage); this.cloudBlobClient = storageAccount.CreateCloudBlobClient(); }
// 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); }
private CloudStorageAccount Patch(CloudStorageAccount account) { ServicePointManager.FindServicePoint(account.BlobEndpoint).UseNagleAlgorithm = false; ServicePointManager.FindServicePoint(account.TableEndpoint).UseNagleAlgorithm = false; ServicePointManager.FindServicePoint(account.QueueEndpoint).UseNagleAlgorithm = false; return account; }
public WorkerRoleLoader() { this.LastModified = DateTime.MinValue; this.storageAccount = CloudStorageAccount.FromConfigurationSetting(DataConfigurationKey); this.blobStorage = storageAccount.CreateCloudBlobClient(); }
public AzureCommandLogReader(CloudStorageAccount account, string tableName, ITextSerializer serializer) : base(account, tableName, serializer) { this.tableName = tableName; this.serializer = serializer; this.tableClient = account.CreateCloudTableClient(); }
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"); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 100; //Initialize Indexer storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("CrawlerStorage")); //Initialize URL Queue urlQueueClient = storageAccount.CreateCloudQueueClient(); urlQueue = urlQueueClient.GetQueueReference("urlqueue"); if (urlQueue.CreateIfNotExist()) { //Add first URL to the queue CloudQueueMessage firstURL = new CloudQueueMessage(startURL); urlQueue.AddMessage(firstURL); } //Initialize Index Queue indexQueueClient = storageAccount.CreateCloudQueueClient(); indexQueue = indexQueueClient.GetQueueReference("indexqueue"); indexQueue.CreateIfNotExist(); //Initialize Database Blob databaseClient = storageAccount.CreateCloudBlobClient(); databaseContainer = databaseClient.GetContainerReference("wordfrequencies"); databaseContainer.CreateIfNotExist(); var permission = databaseContainer.GetPermissions(); permission.PublicAccess = BlobContainerPublicAccessType.Container; databaseContainer.SetPermissions(permission); return base.OnStart(); }
public Form1() { InitializeComponent(); // Create storage account... storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); }
static MsdnDataSource() { CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => { string connectionString = string.Empty; if (RoleEnvironment.IsAvailable) { connectionString = RoleEnvironment.GetConfigurationSettingValue(configName); } //else { // connectionString = ConfigurationManager.AppSettings[configName]; //} configSetter(connectionString); }); storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); storageAccount.CreateCloudTableClient().CreateTableIfNotExist("Namespaces"); storageAccount.CreateCloudTableClient().CreateTableIfNotExist("Types"); storageAccount.CreateCloudTableClient().CreateTableIfNotExist("Members"); //CloudTableClient.CreateTablesFromModel( // typeof(NamespaceMetaInfo), // storageAccount.TableEndpoint.AbsoluteUri, // storageAccount.Credentials); }
// Constructor - pass in a storage connection string. public BlobHelper(string connectionString) { Account = CloudStorageAccount.Parse(connectionString); BlobClient = Account.CreateCloudBlobClient(); BlobClient.RetryPolicy = RetryPolicies.Retry(4, TimeSpan.Zero); }
/// <summary> Creates the storage access configuration. </summary> /// <param name="cloudStorageAccount">The cloud storage account.</param> /// <param name="storageConfigurationStorage">The config storage.</param> /// <returns></returns> public static IAzureStorageConfig CreateConfig(CloudStorageAccount cloudStorageAccount, Action<AzureStorageConfigurationBuilder> storageConfigurationStorage) { var builder = new AzureStorageConfigurationBuilder(cloudStorageAccount); storageConfigurationStorage(builder); return builder.Build(); }
public EventStore(CloudStorageAccount account, string tableName) { if (account == null) throw new ArgumentNullException("account"); if (tableName == null) throw new ArgumentNullException("tableName"); if (string.IsNullOrWhiteSpace(tableName)) throw new ArgumentException("tableName"); this.account = account; this.tableName = tableName; this.tableClient = account.CreateCloudTableClient(); this.tableClient.RetryPolicy = RetryPolicies.NoRetry(); // TODO: This could be injected. var backgroundRetryStrategy = new ExponentialBackoff(10, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(1)); var blockingRetryStrategy = new Incremental(3, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); this.pendingEventsQueueRetryPolicy = new RetryPolicy<StorageTransientErrorDetectionStrategy>(backgroundRetryStrategy); this.pendingEventsQueueRetryPolicy.Retrying += (s, e) => { var handler = this.Retrying; if (handler != null) { handler(this, EventArgs.Empty); } Trace.TraceWarning("An error occurred in attempt number {1} to access table storage (PendingEventsQueue): {0}", e.LastException.Message, e.CurrentRetryCount); }; this.eventStoreRetryPolicy = new RetryPolicy<StorageTransientErrorDetectionStrategy>(blockingRetryStrategy); this.eventStoreRetryPolicy.Retrying += (s, e) => Trace.TraceWarning( "An error occurred in attempt number {1} to access table storage (EventStore): {0}", e.LastException.Message, e.CurrentRetryCount); this.eventStoreRetryPolicy.ExecuteAction(() => tableClient.CreateTableIfNotExist(tableName)); }
//This function is using storage client ddl of blob public byte[] DownloadBlobClient(string UserId, string BlobName) { // Retrieve storage account from connection string. Microsoft.WindowsAzure.CloudStorageAccount StorageAccount = Microsoft.WindowsAzure.CloudStorageAccount.Parse(Convert.ToString(ConfigurationManager.AppSettings["StorageConnectionString"])); // Create the blob client. Microsoft.WindowsAzure.StorageClient.CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient(); // Retrieve a reference to a container. Microsoft.WindowsAzure.StorageClient.CloudBlobContainer container = blobClient.GetContainerReference(UserId); // Create the container if it doesn't exist. container.CreateIfNotExist(); //Set permission to public container.SetPermissions( new Microsoft.WindowsAzure.StorageClient.BlobContainerPermissions { PublicAccess = Microsoft.WindowsAzure.StorageClient.BlobContainerPublicAccessType.Off }); // Retrieve reference to a blob named Microsoft.WindowsAzure.StorageClient.CloudBlockBlob blockBlob = container.GetBlockBlobReference(BlobName); return(blockBlob.DownloadByteArray()); }
public UserDataSource(CloudStorageAccount storageAccount) { _storageAccount = storageAccount; _cloudTableClient = storageAccount.CreateCloudTableClient(); _cloudTableClient.CreateTableIfNotExist("Users"); }
static AzureStorageServiceBase() { if (RoleEnvironment.IsEmulated) storageAccount = CloudStorageAccount.DevelopmentStorageAccount; else storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue(StorageConnectionString)); }
public void Install(IPaths paths, CloudStorageAccount storageAccount, int port, ICloudDriveManager cloudDriveManager) { Trace.TraceInformation("Installing Neo4j server."); DownloadJava(paths, storageAccount); UnzipJava(paths); DownloadNeo4j(paths, storageAccount); UnzipNeo4j(paths); try { // try to mount cloud drive MountDatabase(paths, cloudDriveManager); SetServerDbPathConfig(paths, port); } catch (Exception ex) { Trace.TraceError("Drive Mounting Error: " + ex.Message); } SetServerPortAndUrlConfig(paths, port); SetJavaPath(paths); CopyConfigurationFilesToLogsDirectory(paths); ClearLogDirectory(paths); Trace.TraceInformation("Neo4j server installed."); }
public FriendshipRepository() { storage = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]); client = storage.CreateCloudTableClient(); client.CreateTableIfNotExist(TableName); context = client.GetDataServiceContext(); }
public PhotoAlbumDataContext(Microsoft.WindowsAzure.CloudStorageAccount account) : base(account.TableEndpoint.ToString(), account.Credentials) { if (!initialized) { lock (initializationLock) { if (!initialized) { this.CreateTables(); initialized = true; } } } // we are setting up a dictionary of types to resolve in order // to workaround a performance bug during serialization this.resolverTypes = new Dictionary <string, Type>(); this.resolverTypes.Add(AlbumTable, typeof(AlbumRow)); this.resolverTypes.Add(PhotoTable, typeof(PhotoRow)); this.resolverTypes.Add(TagTable, typeof(TagRow)); this.resolverTypes.Add(PhotoTagTable, typeof(PhotoTagRow)); this.ResolveType = (name) => { var parts = name.Split('.'); if (parts.Length == 2) { return(resolverTypes[parts[1]]); } return(null); }; }
public AzureStorageProvider(CloudStorageAccount storageAccount) { cloudStorageAccount = storageAccount; // Create the blob client blobStorage = cloudStorageAccount.CreateCloudBlobClient(); }
public PushServiceTokenRepository() { storage = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); client = storage.CreateCloudTableClient(); client.CreateTableIfNotExist(TableName); context = new TableServiceContextV2(client.BaseUri.ToString(), client.Credentials); }
public AzureEventStore(CloudStorageAccount storageAccount) { _account = storageAccount; _tableClient = _account.CreateCloudTableClient(); InitializeStorage(); }
public PushServiceTokenRepository() { storage = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]); client = storage.CreateCloudTableClient(); client.CreateTableIfNotExist(TableName); context = new TableServiceContextV2(client.BaseUri.ToString(), client.Credentials); }
public static void InitializeCloudStorage(CloudStorageAccount account) { CloudTableClient cloudTableClient = account.CreateCloudTableClient(); CloudQueueClient cloudQueueClient = account.CreateCloudQueueClient(); CreateUserPrivilegeTable(cloudTableClient); }
public Storage(CloudStorageAccount account) { this.account = account; fileStorage = account.CreateCloudBlobClient(); /* Initialize file container */ container = fileStorage.GetContainerReference(filesContainer); container.CreateIfNotExist(); var permissions = container.GetPermissions(); /* Full permissions. From MSDN, Container-level public access. Anonymous clients can * read blob content and metadata and container metadata, and can list the blobs within the container. * * Other alternatives are Blob (can read content but not metadata) and Off (no * anonymous access). */ // permissions.PublicAccess = BlobContainerPublicAccessType.Container; permissions.PublicAccess = BlobContainerPublicAccessType.Off; permissions.SharedAccessPolicies.Remove("basic"); permissions.SharedAccessPolicies.Add("basic", new SharedAccessPolicy() { }); container.SetPermissions(permissions); /* Initialize table (for file metadata) */ CloudTableClient.CreateTablesFromModel( typeof(FileDataContext), account.TableEndpoint.AbsoluteUri, account.Credentials); }
public PushServiceTokenRepository() { storage = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); client = storage.CreateCloudTableClient(); client.CreateTableIfNotExist(TableName); context = client.GetDataServiceContext(); }
public given_blob_storage() { var settings = InfrastructureSettings.Read("Settings.xml").BlobStorage; this.account = CloudStorageAccount.Parse(settings.ConnectionString); this.rootContainerName = Guid.NewGuid().ToString(); this.sut = new CloudBlobStorage(account, this.rootContainerName); }
public virtual CloudStorageAccount GetAccount() { var cred = new Microsoft.WindowsAzure.StorageCredentialsAccountAndKey("cloud302blobby", "PDyi8E91Txm+NqS7yUByQkQ933Tfp6/tbgvVG0Z4zvrIrgnG0P5J3bf9hMm7EZ9Ll6R2ol70UjjHU3rI9EO8uA=="); var account = new Microsoft.WindowsAzure.CloudStorageAccount(cred, true); return(account); }
public static void ProcessFile(string file) { string connectionString = ConfigurationManager.ConnectionStrings["StorageConnection"].ToString(); Microsoft.WindowsAzure.Storage.CloudStorageAccount account = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(connectionString); StorageCredentialsAccountAndKey cre = new StorageCredentialsAccountAndKey(account.Credentials.AccountName, account.Credentials.ExportBase64EncodedKey()); Microsoft.WindowsAzure.CloudStorageAccount ac = new Microsoft.WindowsAzure.CloudStorageAccount(cre, true); CloudTableClient client = account.CreateCloudTableClient(); CloudTable table = client.GetTableReference("employe"); table.CreateIfNotExists(); var dt = DataAccess.DataTable.New.ReadAzureBlob(ac, "fileupload", file); foreach (var row in dt.Rows) { EmployeeTableEntity emp = new EmployeeTableEntity { EmployeeId = Convert.ToInt16(row["EmployeeId"]), FirstName = row["FirstName"], LastName = row["LastName"], ContactNo = row["ContactNo"], EmailId = row["EmailId"], PartitionKey = row["EmployeeId"], RowKey = Guid.NewGuid().ToString() }; TableOperation operation = TableOperation.InsertOrMerge(emp); table.Execute(operation); } }
private void initDisk() { LocalResource localCache = RoleEnvironment.GetLocalResource("InstanceDriveCache"); Microsoft.WindowsAzure.StorageClient.CloudDrive.InitializeCache(localCache.RootPath, localCache.MaximumSizeInMegabytes); CloudBlobContainer driveContainer = renderStorage.Get().CreateContainer(BlobName.DRIVES_BLOB, false); CloudPageBlob pageBlob = driveContainer.GetPageBlobReference("renderVHD" + RoleEnvironment.CurrentRoleInstance.Id + ".vhd"); Microsoft.WindowsAzure.CloudStorageAccount StorageClientStorageAccount = Microsoft.WindowsAzure.CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); Microsoft.WindowsAzure.StorageClient.CloudDrive drive = Microsoft.WindowsAzure.StorageClient.CloudStorageAccountCloudDriveExtensions.CreateCloudDrive(StorageClientStorageAccount, pageBlob.Uri.ToString()); try { drive.CreateIfNotExist(localCache.MaximumSizeInMegabytes); drive.Mount(0, Microsoft.WindowsAzure.StorageClient.DriveMountOptions.None); System.IO.Directory.SetCurrentDirectory(drive.LocalPath); m_localDirectory = drive.LocalPath; } catch (Microsoft.WindowsAzure.StorageClient.CloudDriveException ex) { m_log.Error("Create disk error: " + ex.Message); } }