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; // read storage account configuration settings CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) => configSetter(RoleEnvironment.GetConfigurationSettingValue(configName))); var storageAccount = CloudStorageAccount.FromConfigurationSetting("DataConnectionString"); // initialize blob storage CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient(); container = blobStorage.GetContainerReference("converteddata"); // initialize queue storage CloudQueueClient queueStorage = storageAccount.CreateCloudQueueClient(); queue = queueStorage.GetQueueReference("workercommands"); Trace.TraceInformation("Creating container and queue..."); bool storageInitialized = false; while (!storageInitialized) { try { // create the blob container and allow public access container.CreateIfNotExist(); var permissions = container.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; container.SetPermissions(permissions); // create the message queue queue.CreateIfNotExist(); storageInitialized = true; } catch (StorageClientException e) { if (e.ErrorCode == StorageErrorCode.TransportError) { Trace.TraceError("Storage services initialization failure. " + "Check your storage account configuration settings. If running locally, " + "ensure that the Development Storage service is running. Message: '{0}'", e.Message); Thread.Sleep(5000); } else { throw; } } } return base.OnStart(); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; #if DEBUG account = CloudStorageAccount.DevelopmentStorageAccount; #else account = new CloudStorageAccount(accountAndKey, true); #endif tableContext = new TableServiceContext(account.TableEndpoint.ToString(), account.Credentials); //client = new CloudQueueClient(account.BlobEndpoint.ToString(), account.Credentials); qclient = account.CreateCloudQueueClient(); q = qclient.GetQueueReference("icd9mapplotrequests"); rows = new List<ICD9MapPlotResultEntry>(); bclient = account.CreateCloudBlobClient(); container = bclient.GetContainerReference("results"); container.CreateIfNotExist(); client = account.CreateCloudTableClient(); client.CreateTableIfNotExist("ICD9MapPlotResult"); client.CreateTableIfNotExist("DoctorDetails"); client.CreateTableIfNotExist("PatientDetails"); // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. return base.OnStart(); }
public void CreateIfNotExist(CloudBlobContainer cloudBlobContainer, bool isPublic = true) { cloudBlobContainer.CreateIfNotExist(); var permission = cloudBlobContainer.GetPermissions(); var blobContainerPermissions = new BlobContainerPermissions {PublicAccess = isPublic ? BlobContainerPublicAccessType.Container : BlobContainerPublicAccessType.Off}; cloudBlobContainer.SetPermissions(blobContainerPermissions); }
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 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 static void MyClassInitialize(TestContext testContext) { CloudStorageAccount storageAccount = CloudStorageAccount.Parse(DevConnectionString); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(TestContainerName); container.CreateIfNotExist(); }
//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()); }
static AzureHelper() { var cloudStorageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=http;AccountName=mintchipmarket;AccountKey=6wtpT0uW75m2LsThfROjp+cMA5zWx8VllZhJ5tM7kPAZZlIbPZ0t7pIXkO0s0AnzZ4sWMnl+rc5+1KjlNWKlfA=="); var blobClient = new CloudBlobClient(cloudStorageAccount.BlobEndpoint, cloudStorageAccount.Credentials); _container = blobClient.GetContainerReference("files"); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Off }); }
public AzureSystemEventStore() { Streamer = new EventStreamer(new EventSerializer(MessagesProvider.GetKnownEventTypes())); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Settings.Default.AzureConnectionString); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(Settings.Default.AzureContainerName); container.CreateIfNotExist(); }
public BlobOptimisticDataStore(CloudStorageAccount account, string containerName) { var blobClient = account.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference(containerName.ToLower()); blobContainer.CreateIfNotExist(); blobReferences = new Dictionary<string, CloudBlob>(); }
/// <summary> /// Connects to the storage account and creates the default container /// </summary> private void ConnectToBlobStorage() { storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")); blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference("testcontainer"); blobContainer.CreateIfNotExist(); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }); }
public AzureStorageClient(CloudStorageAccount account) { client = account.CreateCloudBlobClient(); client.DefaultDelimiter = "/"; container = client.GetContainerReference("documents"); container.CreateIfNotExist(); }
public Azure_Stream_Factory(CloudStorageAccount account, string container_Name) { _container_Name = container_Name; _blobClient = account.CreateCloudBlobClient(); container = _blobClient.GetContainerReference(container_Name); container.CreateIfNotExist(); }
public AzureTapeStream(string name, string connectionString, string containerName, ITapeStreamSerializer serializer) { _serializer = serializer; CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(containerName); container.CreateIfNotExist(); _blob = container.GetBlobReference(name); }
public void Setup() { _name = Guid.NewGuid().ToString().ToLowerInvariant(); CloudStorageAccount cloudStorageAccount = ConnectionConfig.StorageAccount; var cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient(); var documentStrategy = new DocumentStrategy(_name); _store = new AzureDocumentStore(documentStrategy, cloudBlobClient); _container = cloudBlobClient.GetBlobDirectoryReference(_name).Container; _container.CreateIfNotExist(); _sampleDocContainer = cloudBlobClient.GetBlobDirectoryReference(_name).Container; _sampleDocContainer.CreateIfNotExist(); }
public AzureBlobFileRepository(IConfigSettings configSettings) { var setting = configSettings.Get("StorageConnectionString"); containerName = configSettings.Get("BlobContainerName"); storageAccount = CloudStorageAccount.Parse(setting); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(containerName.ToLower()); container.CreateIfNotExist(); container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); }
public override bool OnStart() { //Initialize Indexer storageAccount = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("CrawlerStorage")); //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(); }
static void CreateContainer() { //get blob container account = CloudStorageAccount.FromConfigurationSetting("BlobConnectionString"); client = account.CreateCloudBlobClient(); container = client.GetContainerReference("userphotos"); container.CreateIfNotExist(); BlobContainerPermissions permissions = new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }; container.SetPermissions(permissions); }
public AzureShellSettingsManager(CloudStorageAccount storageAccount, IShellSettingsManagerEventHandler events) { // Setup the connection to custom storage accountm, e.g. Development Storage _storageAccount = storageAccount; _events = events; BlobClient = _storageAccount.CreateCloudBlobClient(); // Get and create the container if it does not exist // The container is named with DNS naming restrictions (i.e. all lower case) Container = new CloudBlobContainer(ContainerName, BlobClient); Container.CreateIfNotExist(); // Tenant settings are protected by default Container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off }); }
public FriendLikesService(string id) { this.UserId = id; account = CloudStorageAccount.Parse(RoleEnvironment.GetConfigurationSettingValue("DataConnectionString")); // Table Client tableClient = new CloudTableClient(account.TableEndpoint.ToString(), account.Credentials); tableClient.CreateTableIfNotExist(FRIEND_LIKES_TABLE); // Blob Client blobClient = new CloudBlobClient(account.BlobEndpoint.ToString(), account.Credentials); blobContainer = blobClient.GetContainerReference(FRIEND_LIKES_BLOB_CONTAINER); blobContainer.CreateIfNotExist(); blobContainer.SetPermissions(new BlobContainerPermissions() { PublicAccess = BlobContainerPublicAccessType.Blob }); }
private void CreateStorageContainer() { Log("Attaching to or creating the blob container"); _container = CloudStorageAccount .Parse(RoleEnvironment.GetConfigurationSettingValue(WorkerRole.StorageConnectionString)) .CreateCloudBlobClient() .GetContainerReference(WorkerRole.KinectonitorImageContainer); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); Log("Attached to the blob container"); }
/// <summary> /// Init Azure Storage if needed /// </summary> private static void InitAzureStorage() { if (storageAccount == null) { storageAccount = CloudStorageAccount.FromConfigurationSetting(connectionString); if (blobClient == null) { blobClient = storageAccount.CreateCloudBlobClient(); blobContainer = blobClient.GetContainerReference(FilesFolder); blobContainer.CreateIfNotExist(); var permissions = blobContainer.GetPermissions(); permissions.PublicAccess = BlobContainerPublicAccessType.Container; blobContainer.SetPermissions(permissions); } } }
public void SetUp() { blobSettings = new LeaseBlockBlobSettings { ConnectionString = "UseDevelopmentStorage=true", ContainerName = "test" + Guid.NewGuid().ToString("N"), BlobPath = "lease.blob", ReAquirePreviousTestLease = false, RetryCount = 2, RetryInterval = TimeSpan.FromMilliseconds(250) }; maximumStopDurationEstimateSeconds = 10; var storageAccount = CloudStorageAccount.Parse("UseDevelopmentStorage=true"); var client = storageAccount.CreateCloudBlobClient(); container = client.GetContainerReference(blobSettings.ContainerName); container.CreateIfNotExist(); leaseBlob = container.GetBlobReference(blobSettings.BlobPath); leaseBlob.UploadByteArray(new byte[0]); }
public AzureFileSystem(string containerName, string root, bool isPrivate, CloudStorageAccount storageAccount) { // Setup the connection to custom storage accountm, e.g. Development Storage _storageAccount = storageAccount; ContainerName = containerName; _root = String.IsNullOrEmpty(root) ? "" : root + "/"; _absoluteRoot = Combine(Combine(_storageAccount.BlobEndpoint.AbsoluteUri, containerName), root); BlobClient = _storageAccount.CreateCloudBlobClient(); // Get and create the container if it does not exist // The container is named with DNS naming restrictions (i.e. all lower case) Container = BlobClient.GetContainerReference(ContainerName); Container.CreateIfNotExist(); Container.SetPermissions(isPrivate ? new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Off } : new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }); }
public GenericBlobSource(string connectionStringName) { var connectionString = RoleEnvironment.IsAvailable ? RoleEnvironment.GetConfigurationSettingValue(connectionStringName) : ConfigurationManager.AppSettings[connectionStringName]; _container = CloudStorageAccount .Parse(connectionString) .CreateCloudBlobClient() .GetContainerReference("uploadedfiles"); _container.CreateIfNotExist(); _container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); }
public AzureFileSystem(string containerName, string root, bool isPrivate, CloudStorageAccount storageAccount) { // Setup the connection to custom storage accountm, e.g. Development Storage _storageAccount = storageAccount; ContainerName = containerName; _root = String.IsNullOrEmpty(root) || root == "/" ? String.Empty : root + "/"; BlobClient = _storageAccount.CreateCloudBlobClient(); // Get and create the container if it does not exist // The container is named with DNS naming restrictions (i.e. all lower case) Container = BlobClient.GetContainerReference(ContainerName); Container.CreateIfNotExist(); if ( isPrivate ) { Container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off}); } else { Container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Container }); } }
public BlobContainer(string connectionString, string containerName) { // Connect, if not already connected CloudBlobClient client; if (!clients.TryGetValue(connectionString, out client)) { // Connect client = CloudStorageAccount.Parse(connectionString).CreateCloudBlobClient(); // Store for next time clients[connectionString] = client; } // Get container Container = client.GetContainerReference(containerName); // Create if it doesn't exist Container.CreateIfNotExist(); // Set access public var perm = new BlobContainerPermissions(); perm.PublicAccess = BlobContainerPublicAccessType.Blob; Container.SetPermissions(perm); }
static void upload(string UUID, string file) { try { string path = Path.GetFullPath(@""+file); BlobContainerPermissions containerPermissions; blobContainer = blobClient.GetContainerReference(UUID); blobContainer.CreateIfNotExist(); containerPermissions = new BlobContainerPermissions(); containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob; blobContainer.SetPermissions(containerPermissions); blobContainer = blobClient.GetContainerReference(UUID); CloudBlob blob = blobContainer.GetBlobReference(UUID); Console.WriteLine("Starting file upload"); blob.UploadFile(path); Console.WriteLine("File upload complete\n"); } catch (Exception e) { Console.WriteLine("Error uploading file: " + e); } }
public void CreateDriveEx() { try { CloudBlobClient client = _account.CreateCloudBlobClient(); // Create the container for the drive if it does not already exist. CloudBlobContainer container = new CloudBlobContainer("mydrives", client); container.CreateIfNotExist(); // Get a reference to the page blob that will back the drive. CloudPageBlob pageBlob = container.GetPageBlobReference(_vhdName); _cloudDrive = new CloudDrive(pageBlob.Uri, _account.Credentials); //_cloudDrive = _account.CreateCloudDrive(_vhdName); _logger.Log("using account " + _account.BlobEndpoint + " to create " + _vhdName); var rv = _cloudDrive.CreateIfNotExist(DISK_SIZE); _logger.Log("done create drive"); } catch (Exception ex) { _logger.Log("error on CreateDrive", ex); } }
public static string MountDrive(string containerName, string vhdName, int driveSize, int driveLocalReadCacheSize) { var client = GetCloudClientInstance(); // Create the container for the drive if it does not already exist. var container = new CloudBlobContainer(containerName, client); if (container.CreateIfNotExist()) { container.SetPermissions(new BlobContainerPermissions {PublicAccess = BlobContainerPublicAccessType.Off}); } var cloudDrive = new CloudDrive(container.GetPageBlobReference(vhdName).Uri, client.Credentials); try { cloudDrive.Create(driveSize); } catch (CloudDriveException ex) { Logger.Info(string.Format("Cloud drive already exists. Uri: {0}", cloudDrive.Uri), ex); } string pathToDrive = cloudDrive.Mount(driveLocalReadCacheSize, DriveMountOptions.Force); return pathToDrive; }
public static Tuple <bool, Exception> IsValidAccount(string account, string accountKey) { bool accountValid = true; Exception exception = null; try { Microsoft.WindowsAzure.CloudStorageAccount storageAccount = null; Microsoft.WindowsAzure.StorageClient.CloudBlobClient blobClient = null; Microsoft.WindowsAzure.StorageClient.CloudBlobContainer container = null; storageAccount = new Microsoft.WindowsAzure.CloudStorageAccount(new Microsoft.WindowsAzure.StorageCredentialsAccountAndKey(account, accountKey), true); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(AzureConfigContainerName); container.CreateIfNotExist(); } catch (Exception e) { accountValid = false; exception = e; } return(new Tuple <bool, Exception>(accountValid, exception)); }
/// <summary> /// Create or Update Blob /// Works with wpsprivate public static void UpdateBlob(string containerName, string blobName, MemoryStream data, string mimeType) { try { CloudStorageAccount storageAccount = CloudStorageAccount.FromConfigurationSetting("RemoteDataStorage"); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); var container = new CloudBlobContainer(containerName, blobClient); container.CreateIfNotExist(); // Setup the permissions on the container to be public //var permissions = new BlobContainerPermissions{PublicAccess = BlobContainerPublicAccessType.Container }; //container.SetPermissions(permissions); CloudBlob blob = container.GetBlobReference(blobName); blob.UploadFromStream(data); if (mimeType.Length > 0) { // Set the properties blob.Properties.ContentType = mimeType; blob.SetProperties(); } } catch (Exception sc) { Logger.LogError(string.Format("Error getting contents of blob {0}/{1}: {2}", containerName, blobName, sc.Message)); } }
public static bool UploadConfig(string configZipPath, string AzureAccountName, string AzureAccountKey, string orgID, string studyID, string homeID, string desiredConfigFilename, NLog.Logger logger = null) { Microsoft.WindowsAzure.CloudStorageAccount storageAccount = null; Microsoft.WindowsAzure.StorageClient.CloudBlobClient blobClient = null; Microsoft.WindowsAzure.StorageClient.CloudBlobContainer container = null; Microsoft.WindowsAzure.StorageClient.CloudBlockBlob blockBlob = null; string leaseId = null; try { storageAccount = new Microsoft.WindowsAzure.CloudStorageAccount(new Microsoft.WindowsAzure.StorageCredentialsAccountAndKey(AzureAccountName, AzureAccountKey), true); blobClient = storageAccount.CreateCloudBlobClient(); container = blobClient.GetContainerReference(AzureConfigContainerName); container.CreateIfNotExist(); blockBlob = container.GetBlockBlobReference(DesiredConfigBlobName(orgID, studyID, homeID, desiredConfigFilename)); bool blobExists = BlockBlobExists(blockBlob); if (blobExists) { leaseId = AcquireLease(blockBlob, logger); // Acquire Lease on Blob } else { blockBlob.Container.CreateIfNotExist(); } if (blobExists && leaseId == null) { if (null != logger) { logger.Error("AcquireLease on Blob: " + DesiredConfigBlobName(orgID, studyID, homeID, desiredConfigFilename) + " Failed"); } return(false); } string url = blockBlob.Uri.ToString(); if (blockBlob.ServiceClient.Credentials.NeedsTransformUri) { url = blockBlob.ServiceClient.Credentials.TransformUri(url); } var req = BlobRequest.Put(new Uri(url), AzureBlobLeaseTimeout, new Microsoft.WindowsAzure.StorageClient.BlobProperties(), Microsoft.WindowsAzure.StorageClient.BlobType.BlockBlob, leaseId, 0); using (var writer = new BinaryWriter(req.GetRequestStream())) { writer.Write(File.ReadAllBytes(configZipPath)); writer.Close(); } blockBlob.ServiceClient.Credentials.SignRequest(req); req.GetResponse().Close(); ReleaseLease(blockBlob, leaseId); // Release Lease on Blob return(true); } catch (Exception e) { if (null != logger) { logger.ErrorException("UploadConfig_Azure, configZipPath: " + configZipPath, e); } ReleaseLease(blockBlob, leaseId); return(false); } }