public int HowManyContainers() { var blobServiceClient = new BlobServiceClient(Environment.GetEnvironmentVariable("CONNECT_STR")); var randyTestContainer = "justtestingthisout" + Guid.NewGuid().ToString(); return(blobServiceClient.GetBlobContainers().Count()); }
public List <string> ListContainers() { var blobServiceClient = new BlobServiceClient(Environment.GetEnvironmentVariable("CONNECT_STR")); var randyTestContainer = "justtestingthisout" + Guid.NewGuid().ToString(); return(blobServiceClient.GetBlobContainers().Select(s => s.Name).ToList()); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ExecutionContext context, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); var config = new ConfigurationBuilder() .SetBasePath(context.FunctionAppDirectory) .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) // <- This gives you access to your application settings in your local development environment .AddEnvironmentVariables() // <- This is what actually gets you the application settings in Azure .Build(); TokenCredential credential = new ClientSecretCredential(config["TenantId"], config["ApplicationId"], config["ApplicationSecret"], new TokenCredentialOptions() { AuthorityHost = new Uri(config["ActiveDirectoryAuthEndpoint"]) }); var client = new BlobServiceClient(new Uri(config["ActiveDirectoryBlobUri"]), credential); var containers = client.GetBlobContainers(); var responseMessage = containers.Select(r => r.Name).ToArray(); return(new OkObjectResult(responseMessage)); }
private void InitContainers() { var service = new BlobServiceClient(AppConstants.AzureStorageConnectionString); var containers = service.GetBlobContainers(); var draftsExists = false; var publishedExists = false; foreach (var c in containers) { if (c.Name == DRAFTS) { draftsExists = true; } if (c.Name == PUBLISHED) { publishedExists = true; } if (draftsExists && publishedExists) { break; } } if (!draftsExists) { service.CreateBlobContainer(DRAFTS); } if (!publishedExists) { service.CreateBlobContainer(PUBLISHED); } }
public static async Task <string> WriteBlob([ActivityTrigger] IDurableActivityContext writeBlobContext, ILogger log) { BlobContainerClient containerClient = null; var newMsg = writeBlobContext.GetInput <NewMessage>(); //log.LogInformation($"Message: {JsonConvert.SerializeObject(newMsg)}"); //log.LogInformation($"MessageId:{msgId}"); // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(Environment.GetEnvironmentVariable("AzureWebJobsStorage")); //Create a container if it does not exist string containerName = "durablefunctest"; if (blobServiceClient.GetBlobContainers().Where(cont => cont.Name.ToLowerInvariant() == containerName).ToList().Count() > 0) { containerClient = blobServiceClient.GetBlobContainerClient(containerName); } else { // Create the container and return a container client object containerClient = blobServiceClient.CreateBlobContainer(containerName); } // Get a reference to a blob BlobClient blobClient = containerClient.GetBlobClient(msgId); using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(newMsg)))) { await blobClient.UploadAsync(stream); } return(blobClient.Uri.AbsoluteUri); }
public void Dispose() { foreach (var testContainer in _blobServiceClient.GetBlobContainers(prefix: TestArtifactPrefix)) { _blobServiceClient.GetBlobContainerClient(testContainer.Name).Delete(); } }
/// <summary> /// List containers by container name prefix /// </summary> /// <param name="prefix">Container name prefix</param> /// <returns>An enumerable collection of cloudblobcontainer</returns> internal IEnumerable <Tuple <AzureStorageContainer, BlobContinuationToken> > ListContainersByPrefix(string prefix, Func <string, bool> containerFilter = null) { BlobServiceClient blobServiceClient = Util.GetTrack2BlobServiceClient(this.Channel.StorageContext, ClientOptions); BlobContainerTraits traits = BlobContainerTraits.Metadata; BlobContainerStates states = BlobContainerStates.None; if (this.IncludeDeleted.IsPresent) { states = BlobContainerStates.Deleted; } if (!string.IsNullOrEmpty(prefix) && !NameUtil.IsValidContainerPrefix(prefix)) { throw new ArgumentException(String.Format(Resources.InvalidContainerName, prefix)); } int listCount = InternalMaxCount; int MaxListCount = 5000; int requestCount = MaxListCount; int realListCount = 0; string continuationToken = this.ContinuationToken is null ? null : this.ContinuationToken.NextMarker; do { requestCount = Math.Min(listCount, MaxListCount); realListCount = 0; IEnumerator <Page <BlobContainerItem> > enumerator = blobServiceClient.GetBlobContainers(traits, states, prefix, this.CmdletCancellationToken) .AsPages(continuationToken, requestCount) .GetEnumerator(); Page <BlobContainerItem> page; enumerator.MoveNext(); page = enumerator.Current; foreach (BlobContainerItem item in page.Values) { if (containerFilter == null || containerFilter(item.Name)) { yield return(new Tuple <AzureStorageContainer, BlobContinuationToken>( new AzureStorageContainer(item, Channel.StorageContext, blobServiceClient), string.IsNullOrEmpty(page.ContinuationToken) ? null : new BlobContinuationToken() { NextMarker = page.ContinuationToken })); realListCount++; } realListCount++; } continuationToken = page.ContinuationToken; if (InternalMaxCount != int.MaxValue) { listCount -= realListCount; } }while (listCount > 0 && !string.IsNullOrEmpty(continuationToken)); }
public void RefreshContainerDetails() { BlobContainerClient = new Dictionary <string, BlobContainerClient>(); BlobContainerItems = BlobServiceClient.GetBlobContainers(); foreach (var container in BlobContainerItems) { BlobContainerClient.Add(container.Name, BlobServiceClient.GetBlobContainerClient(container.Name)); } }
public TestScriptController() { _aviMock = new Mock <IAviBL>(); _blobSC = new BlobServiceClient("DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;"); foreach (var c in _blobSC.GetBlobContainers()) { _blobSC.DeleteBlobContainer(c.Name); } }
public IEnumerable <StorageContainerModel> GetContainers() { Pageable <BlobContainerItem> response = _blobServiceClient.GetBlobContainers(); return(response.Select(c => new StorageContainerModel() { Name = c.Name })); }
private async Task DeleteContainersAsync() { Console.WriteLine($"Deleting containers in storage account '{_serviceClient.AccountName}'"); foreach (var container in _serviceClient.GetBlobContainers()) { await _serviceClient.DeleteBlobContainerAsync(container.Name); Console.WriteLine($"\t{container.Name}"); } }
private void PopulateContainerList() { var containerList = _blobServiceClient.GetBlobContainers(); foreach (var container in containerList) { Containers.Add(new KeyValuePair <string, BlobContainerClient>(container.Name, new BlobContainerClient(Constants.StorageAccountConnectionString, container.Name))); } }
public static void CreateBlobContainerIfNotExists() { BlobServiceClient client = new BlobServiceClient(ConnectionString); if (client.GetBlobContainers(prefix: ContainerName).Any(container => container.Name.Equals(ContainerName))) { return; } client.CreateBlobContainer(ContainerName, PublicAccessType.BlobContainer); }
private static async Task ReadInfos(string connString) { BlobServiceClient storageAccount; try { storageAccount = new BlobServiceClient(connString); AccountInfo accountInfo = await storageAccount.GetAccountInfoAsync(); Console.WriteLine("AccountKind: " + accountInfo.AccountKind); Console.WriteLine("AccountSku: " + accountInfo.SkuName); if (accountInfo.SkuName == SkuName.StandardRagrs) { BlobServiceStatistics stats = await storageAccount.GetStatisticsAsync(); Console.WriteLine("Statistics (GeoReplication): " + stats.GeoReplication); } var containers = storageAccount.GetBlobContainers(); foreach (var container in containers) { Console.WriteLine("checking Container: " + container.Name); if (container.IsDeleted ?? true) { BlobContainerClient containerClient = new BlobContainerClient(connString, container.Name); BlobContainerProperties containerProperties = await containerClient.GetPropertiesAsync(); //TODO: Generate Demo SASPolicy GenerateSASPolicy(containerClient); Console.WriteLine("Container has LegalHold? " + containerProperties.HasLegalHold); Console.WriteLine("Container is Immutable? " + containerProperties.HasImmutabilityPolicy); await foreach (BlobItem blob in containerClient.GetBlobsAsync()) { Console.WriteLine("Blob: " + blob.Name); Console.WriteLine(" Type Of:" + blob.Properties.BlobType); Console.WriteLine(blob.Properties.ContentLength > 1024 ? " Size (KB):" + (blob.Properties.ContentLength / 1024) : " Size (byte):" + blob.Properties.ContentLength); } } else { Console.WriteLine(" >>>> Is Deleted!" + container.Properties.RemainingRetentionDays); } } } catch (Exception e) { Console.WriteLine("OH SNAP!: " + e.Message); } }
/// <summary> /// Constructor responsible for obtaining an <see cref="AzureStorageOptions"/> from DI. /// </summary> /// <param name="options">Azure storage options.</param> public AzureStorageService(AzureStorageOptions options) { this.serviceClient = new BlobServiceClient(options.ConnectionString); this.StorageName = options.StorageName; // add existing containers into indexed property foreach (var containerItem in serviceClient.GetBlobContainers()) { this[containerItem.Name] = new AzureContainer(serviceClient.GetBlobContainerClient(containerItem.Name)); } }
//------------------------------------------ // Download multiple blobs simultaneously //------------------------------------------ // <Snippet_DownloadFilesAsync> private static async Task DownloadFilesAsync() { BlobServiceClient blobServiceClient = GetBlobServiceClient(); // Path to the directory to upload string downloadPath = Directory.GetCurrentDirectory() + "\\download\\"; Directory.CreateDirectory(downloadPath); Console.WriteLine($"Created directory {downloadPath}"); // Specify the StorageTransferOptions var options = new StorageTransferOptions { // Set the maximum number of workers that // may be used in a parallel transfer. MaximumConcurrency = 8, // Set the maximum length of a transfer to 50MB. MaximumTransferSize = 50 * 1024 * 1024 }; List <BlobContainerClient> containers = new List <BlobContainerClient>(); foreach (BlobContainerItem container in blobServiceClient.GetBlobContainers()) { containers.Add(blobServiceClient.GetBlobContainerClient(container.Name)); } // Start a timer to measure how long it takes to download all the files. Stopwatch timer = Stopwatch.StartNew(); // Download the blobs try { int count = 0; // Create a queue of tasks that will each upload one file. var tasks = new Queue <Task <Response> >(); foreach (BlobContainerClient container in containers) { // Iterate through the files foreach (BlobItem blobItem in container.GetBlobs()) { string fileName = downloadPath + blobItem.Name; Console.WriteLine($"Downloading {blobItem.Name} to {downloadPath}"); BlobClient blob = container.GetBlobClient(blobItem.Name); // Add the download task to the queue tasks.Enqueue(blob.DownloadToAsync(fileName, default, options));
/// <summary> /// Create the sprite settings. /// </summary> /// <param name="spriteFilename">The name of the sprite file that will be created or overwritten.</param> /// <param name="spriteUrl">The URL of the sprite file.</param> /// <param name="cssFilename">The name of the CSS file that will be created or overwritten.</param> /// <param name="connectionString"></param> /// <param name="cssContainerName"></param> /// <param name="spriteContainerName"></param> public AzureStorageSpriteSettings(string spriteFilename, string spriteUrl, string cssFilename, string connectionString, string cssContainerName, string spriteContainerName) { SpriteFilename = spriteFilename; SpriteUrl = spriteUrl; CssFilename = cssFilename; ConnectionString = connectionString; CssContainerName = cssContainerName; SpriteContainerName = spriteContainerName; var blobServiceClient = new BlobServiceClient(ConnectionString); var cssBlobContainer = blobServiceClient.GetBlobContainers().FirstOrDefault(x => x.Name == CssContainerName); _cssBlobContainerClient = cssBlobContainer == null ? blobServiceClient.CreateBlobContainer(CssContainerName) : blobServiceClient.GetBlobContainerClient(CssContainerName); var spriteBlobContainer = blobServiceClient.GetBlobContainers().FirstOrDefault(x => x.Name == SpriteContainerName); _spriteBlobContainerClient = spriteBlobContainer == null ? blobServiceClient.CreateBlobContainer(SpriteContainerName) : blobServiceClient.GetBlobContainerClient(SpriteContainerName); }
public MainPage() { this.InitializeComponent(); storageAccount = CloudStorageAccount.Parse(connectionString); tableClient = storageAccount.CreateCloudTableClient(); _blobServiceClient = new BlobServiceClient(connectionString); var container = _blobServiceClient.GetBlobContainers().FirstOrDefault(c => c.Name == CONTAINER_NAME); if (container is null) { _blobServiceClient.CreateBlobContainer(CONTAINER_NAME); } }
public IEnumerable <string> ListContainersAsync(string prefix, CancellationToken cancel) { var containerNames = new List <string>(); var containers = blobService.GetBlobContainers(prefix: prefix, cancellationToken: cancel); using var containerEnumerator = containers.GetEnumerator(); while (containerEnumerator.MoveNext()) { if (containerEnumerator.Current != null) { containerNames.Add(containerEnumerator.Current.Name); } } return(containerNames); }
private static async Task ListContainers() { await ConnectToStorageAccount(); foreach (BlobContainerItem ci in blobServiceClient.GetBlobContainers()) { if (config.IsVerbose()) { Console.WriteLine($"container: {ci.Name} properties: {JsonConvert.SerializeObject(ci.Properties)}"); } else { Console.WriteLine($"container: {ci.Name}"); } } }
public async Task OnGet() { string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING"); // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString); var containers = blobServiceClient.GetBlobContainers(); foreach (var item in containers) { Containers += item.Name + "\n"; } Containers.TrimEnd(); }
static async Task <BlobContainerClient> CreateContainerIfNotExists() { var containerName = "blobstorageolivier"; var blobServiceClient = new BlobServiceClient(connectionString); var containers = blobServiceClient.GetBlobContainers().ToList(); if (containers.FirstOrDefault(c => c.Name.Equals(containerName)) == null) { var response = await blobServiceClient.CreateBlobContainerAsync(containerName); return(response.Value); } return(blobServiceClient.GetBlobContainerClient(containerName)); }
static async Task Main(string[] args) { try { Stopwatch.Start(); SetConnectionString(); var blobServiceClient = new BlobServiceClient(_connectionString); SetBasePath(); _availableBlobContainers = blobServiceClient.GetBlobContainers().AsPages().SelectMany(p => p.Values).ToArray(); SetBlobContainerFolder(); var blobContainer = blobServiceClient.GetBlobContainerClient(_blobsContainer); var blobs = blobContainer.GetBlobs(BlobTraits.All); _blobCount = blobs.Count(); foreach (var blobItem in blobs) { _currentLocalPath = Path.Combine(_currentLocalPath, blobItem.Name); var blobClient = blobContainer.GetBlobClient(blobItem.Name); if (DirOrFileAlreadyExists(blobItem)) { continue; } await Download(blobClient); ResetPath(); Console.WriteLine($"Downloaded {blobItem.Name}"); } } catch (Exception e) { Console.WriteLine(e); } Console.WriteLine((_downloadCount + _skippedCount) != _blobCount ? "Not all blobs seem to have been processed, try run tool again" : "All blobs where processed"); Stopwatch.Stop(); Console.WriteLine($"Tool took {Stopwatch.Elapsed:g} to finish"); }
private async Task <BlobContainerClient> StartAzureConnection() { string connectionString = "DefaultEndpointsProtocol=https;AccountName=azurepoc1993;AccountKey=GeDcGm2eVpVOwIoJxhd28Q5tbE3LYOqK+LOsSBoykLk6dnvq9jkwHeGCCgKFLxgeLryzdTaM5WDJEV6pIOakuQ==;EndpointSuffix=core.windows.net"; BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString); //Create a unique name for the container string containerName = "poc4"; // Create the container and return a container client object BlobContainerClient containerClient; BlobContainerItem container = blobServiceClient.GetBlobContainers().Where(b => b.Name == containerName).FirstOrDefault(); if (container == null) { containerClient = await blobServiceClient.CreateBlobContainerAsync(containerName, PublicAccessType.Blob); } else { containerClient = blobServiceClient.GetBlobContainerClient(containerName); } return(containerClient); }
/// <summary> /// Validates the connection to the storage account. This method will try to perform list containers /// operation (fetching just one container) if <paramref name="containerName"/> parameter is not defined /// otherwise it will try to perform list blobs operation (fetching just one blob). The objective of this /// method is to capture 403 error. /// </summary> /// <param name="containerName"></param> /// <returns>True if connecting is validated else false.</returns> public static async Task <bool> ValidateConnectionAsync(string containerName = null) { try { if (string.IsNullOrWhiteSpace(containerName) || containerName == "*") { s_blobServiceClient.GetBlobContainers(); } else { BlobContainerClient blobContainer = s_blobServiceClient.GetBlobContainerClient(containerName); await blobContainer.GetPropertiesAsync(); } return(true); } catch (RequestFailedException ex) when(ex.Status == 403) { return(false); } }
private async Task Initialize() { // If the container client has already been created, then there is nothing to do here if (containerClient != null) { return; } // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(this.connectionString); BlobContainerItem item = blobServiceClient.GetBlobContainers(prefix: this.containerName).FirstOrDefault(); if (item == null) { this.containerClient = await blobServiceClient.CreateBlobContainerAsync(this.containerName); } else { this.containerClient = blobServiceClient.GetBlobContainerClient(this.containerName); } }
public async Task DownloadAllBlobsInContainer() { var containerClients = _client.GetBlobContainers(); foreach (BlobContainerItem container in containerClients) { var containerClient = _client.GetBlobContainerClient(container.Name); Console.WriteLine(container.Name); await foreach (var blobItem in containerClient.GetBlobsAsync()) { Console.WriteLine(blobItem.Name); Console.WriteLine($"Downloading blob to: {_downloadPath}"); BlobClient blobClient = containerClient.GetBlobClient(blobItem.Name); BlobDownloadInfo blobDownloadInfo = blobClient.Download(); // Access blob properties BlobProperties props = blobClient.GetProperties(); Console.WriteLine("Properties"); Console.WriteLine($"Access tier: {props.AccessTier}"); Console.WriteLine($"Blob expires on: {props.ExpiresOn.UtcDateTime.ToLongDateString()}"); // Access blob metadata Console.WriteLine("Metadata keyvalue pair"); foreach (var metadata in props.Metadata) { Console.WriteLine($"{metadata.Key}: {metadata.Value}"); } using (FileStream fs = File.OpenWrite($"{_downloadPath}\\{blobItem.Name}")) { blobDownloadInfo.Content.CopyTo(fs); fs.Close(); } } } }
public async Task UploadFile(MemoryStream fileStream, string fileName) { BlobContainerClient blobContainerClient; BlobServiceClient blobServiceClient = new BlobServiceClient(containerConnectionString); var containers = blobServiceClient.GetBlobContainers(); var container = containers.FirstOrDefault(o => o.Name.Equals(Constants.ContainerName)); if (container == null) { blobContainerClient = blobServiceClient.CreateBlobContainer(Constants.ContainerName); } else { blobContainerClient = blobServiceClient.GetBlobContainerClient(Constants.ContainerName); } //blobServiceClient.GetChangeFeedClient(); fileStream.Position = 0; await blobContainerClient.UploadBlobAsync(fileName, fileStream); await this.AddMetadata(blobContainerClient, fileName); fileStream.Dispose(); }
public static IActionResult Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, [AzureClient("StorageConnection")] BlobServiceClient client) { return(new OkObjectResult(client.GetBlobContainers().ToArray())); }
public Azure.Pageable <BlobContainerItem> GetContainers() { return(_blobServiceClient.GetBlobContainers()); }