public static async Task <string> UploadText(User entity) { BlobServiceClient blobServiceClient = new BlobServiceClient(Settings.storageConnectionString); BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(entity.name); if (!containerClient.Exists()) { containerClient = await blobServiceClient.CreateBlobContainerAsync(entity.name, PublicAccessType.BlobContainer); } //Get a container string container = Guid.NewGuid().ToString(); BlobClient blobClient = containerClient.GetBlobClient(container); int index = entity.dataUri.IndexOf(",") + 1; string base64 = entity.dataUri.Substring(index); var bytes = Convert.FromBase64String(base64); using (var stream = new MemoryStream(bytes)) { //cblob.UploadFromStream(stream); await blobClient.UploadAsync(stream); } string FileURL = await new BlobStorage().getUriFromBlobAsync(entity.name, container); if (string.IsNullOrEmpty(FileURL)) { throw new Exception("FileURL is empty"); } return(FileURL); }
public async Task <string> UploadBlob(IFormFile Pixel) { string con = _config.GetSection("BlobStorageString").Value; BlobServiceClient blobService = new BlobServiceClient(con); //creates container to hold BLOBs. //container name should NOT have any special characters or capitals! BlobContainerClient containerClient = new BlobContainerClient("UseDevelopmentStorage=true", "pixel-arts"); //makes sure container exists if (!containerClient.Exists()) { await containerClient.CreateAsync(); await containerClient.SetAccessPolicyAsync(PublicAccessType.Blob); } //Add BLOB to container. string newfileName = Guid.NewGuid().ToString() + Path.GetExtension(Pixel.FileName); BlobClient blobClient = containerClient.GetBlobClient(newfileName); await blobClient.UploadAsync(Pixel.OpenReadStream()); return(newfileName); }
public CreatedID Create(ScriptCreate apiModel) { string scriptURL = null; Script sc = _aviBL.GetScriptByPilotID(apiModel.PilotID); if (sc != null) { scriptURL = sc.ScriptURL; _aviBL.DeleteScriptIfExists(apiModel.PilotID); } _aviBL.DeleteScenesIfExists(apiModel.PilotID); foreach (SceneCreate sceneApiModel in apiModel.Scenes) { sceneApiModel.PilotID = apiModel.PilotID; _aviBL.AddScene(sceneApiModel.ToDLModel()); } BlobContainerClient containerClient = _blobSC.GetBlobContainerClient($"pilot{apiModel.PilotID}"); if (!containerClient.Exists()) { containerClient = _blobSC.CreateBlobContainer($"pilot{apiModel.PilotID}", Azure.Storage.Blobs.Models.PublicAccessType.BlobContainer); } else if (scriptURL != null) { containerClient.DeleteBlob(scriptURL.Substring(scriptURL.LastIndexOf('/') + 1)); } BlobClient blobClient = containerClient.GetBlobClient($"script{Guid.NewGuid().ToString()}.html"); blobClient.Upload(GenerateStreamFromString(apiModel.ScriptBody)); apiModel.ScriptURL = blobClient.Uri.AbsoluteUri; return(new CreatedID { ID = _aviBL.AddScript(apiModel.ToDLModel()).ID }); }
static async void SendToBlobAsync(string fileName, IntPtr buf, uint bufSize, BlobServiceClient blobServiceClient) { if (IntPtr.Zero != buf && bufSize > 0) { byte[] pic = new byte[bufSize]; Marshal.Copy(buf, pic, 0, (int)bufSize); //unique name for the container using (MemoryStream stream = new MemoryStream(pic)) { try { // Create a BlobServiceClient object which will be used to create a container client //BlobServiceClient blobServiceClient = new BlobServiceClient(StorageConnString); //BlobServiceClient blobServiceClient = new BlobServiceClient(EdgeStorageConnString); BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(localContainerName); if (!containerClient.Exists()) { await blobServiceClient.CreateBlobContainerAsync(localContainerName); } BlobClient blobClient = containerClient.GetBlobClient(fileName); await blobClient.UploadAsync(stream, true); stream.Close(); } catch (Exception e) { Console.WriteLine(e); } } } }
/// <summary>Check to see if a blob already exists in the specified container</summary> /// <param name="containerName"></param> /// <param name="blobName">File or blob name to check for</param> /// <returns></returns> /// <remarks>Remember to include a file extension</remarks> public bool BlobExists(string containerName, string blobName) { // blob container name - can we set a default somehow if (containerName == null || blobName == null) { throw new System.ArgumentNullException("Arguments can not be null."); } containerName = containerName.Trim(); blobName = blobName.Trim(); if (containerName == String.Empty || blobName == String.Empty) { return(false); } // Get a reference to a share and then create it BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName); // check the container exists Response <bool> exists = container.Exists(); if (!exists.Value) { return(false); } // Get a reference to the blob name BlobClient blob = container.GetBlobClient(blobName); exists = blob.Exists(); return(exists.Value); }
private async Task <List <string> > GetThumbNailUrls() { List <string> thumbnailUrls = new(); // Create a URI to the storage account Uri accountUri = new Uri("https://" + _storageConfig.AccountName + ".blob.core.windows.net/"); // Create BlobServiceClient from the account URI BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri); // Get reference to the container BlobContainerClient container = blobServiceClient.GetBlobContainerClient(_storageConfig.ThumbnailContainer); if (container.Exists()) { foreach (BlobItem blobItem in container.GetBlobs()) { thumbnailUrls.Add(container.Uri + "/" + blobItem.Name); } } else { _logger.LogWarning($"ThumbnailContainer: '{_storageConfig.ThumbnailContainer}' do not exist!"); } return(await Task.FromResult(thumbnailUrls)); }
public static async Task <List <string> > GetThumbNailUrls(AzureStorageConfig _storageConfig, TokenAcquisitionTokenCredential tokenCredential, TelemetryClient telemetryClient, string pathBase) { List <string> thumbnailUrls = new List <string>(); // Create a URI to the storage account Uri blobUri = new Uri(_storageConfig.FullAccountName); BlobServiceClient blobServiceClient = new BlobServiceClient(blobUri, tokenCredential, null); // Get reference to the container BlobContainerClient container = blobServiceClient.GetBlobContainerClient(_storageConfig.ImageContainer); if (container.Exists()) { foreach (BlobItem blobItem in container.GetBlobs()) { if (IsImage(blobItem.Name)) { string imageUrl = string.Format("{0}api/images/thumbnail?ImageName={1}", pathBase, blobItem.Name); thumbnailUrls.Add(imageUrl); telemetryClient.TrackTrace("Found Thumbnail - " + imageUrl); } } } else { telemetryClient.TrackException(new ArgumentNullException(string.Format("Container {0} not found!", container.Name))); container.CreateIfNotExists(PublicAccessType.None, null, null); } return(await Task.FromResult(thumbnailUrls)); }
private static IEnumerable <BlobItem> GetAllElements(BlobContainerClient container) { if (!container.Exists()) { throw new ArgumentException($"The container {container.Uri} does not exists or is not public."); } var resultSegment = container.GetBlobs(BlobTraits.Metadata, BlobStates.None).AsPages(default, 1000);
/// <summary>Gets a blob from Azure Storage as just raw bytes with metadata</summary> /// <param name="containerName">container name</param> /// <param name="blobName">blob name</param> /// <returns>Wrapped raw bytes with some metadata</returns> public RawFileWrapper GetRawBlob(string containerName, string blobName) { RawFileWrapper results = new RawFileWrapper(); // validate input if (String.IsNullOrWhiteSpace(containerName) || String.IsNullOrWhiteSpace(blobName)) { return(results); } containerName = containerName.Trim(); blobName = blobName.Trim(); // Get a reference to a share and then create it BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName); // check the container exists Response <bool> exists = container.Exists(); if (!exists.Value) { return(results); } // set options BlobOpenReadOptions op = new BlobOpenReadOptions(false); // read the blob to an array BlobClient blob = container.GetBlobClient(blobName); using Stream stream = blob.OpenRead(op); results.Data = new byte[stream.Length]; stream.Read(results.Data, 0, results.Data.Length); stream.Close(); // get the properties BlobProperties props = blob.GetProperties().Value; if (props == null) { return(results); } results.ContentType = props.ContentType; // get a filename if (props.Metadata.ContainsKey("filename")) { results.Filename = props.Metadata["filename"].ToString(); } else { results.Filename = blob.Name; } return(results); }
public AzureFileStorage() { string connectionString = ConfigurationManager.AppSettings["AzureStorageConnectionString"]; blobServiceClient = new BlobServiceClient(connectionString); containerClient = blobServiceClient.GetBlobContainerClient(ContainerName); if (containerClient == null || !containerClient.Exists()) { containerClient = blobServiceClient.CreateBlobContainer(ContainerName); } }
public void CreateContainer(string containerName) { BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient(containerName); if (containerClient.Exists()) { throw new ApplicationException($"Unable to create container '{containerName}' as it already exists"); } containerClient.Create(); }
public bool Method() { /* step 1 */ Console.WriteLine("Inside SomeClass.Method"); /* step 2 */ BlobContainerClient container = new BlobContainerClient("****connectionstring****", "code"); Console.WriteLine(container.Exists()); return(true); }
public void DeleteContainer(string containerName) { BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient(containerName); if (!containerClient.Exists()) { throw new ApplicationException($"Unable to delete container '{containerName}' as it does not exists"); } containerClient.Delete(); }
private async Task <BlobContainerClient> CreateContainer() { var blobServiceClient = new BlobServiceClient(_config.AzureStorageConnectionString); BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(_config.ContainerName); if (!containerClient.Exists()) { await containerClient.CreateAsync(); } return(containerClient); }
public BlockBlobClient Create(string blobContainerName, string blobName) { var blobContainerClient = new BlobContainerClient(_blobStorageConfig.ConnectionString, blobContainerName); if (!blobContainerClient.Exists()) { blobContainerClient.CreateIfNotExists(); } var blockBlobClient = new BlockBlobClient(_blobStorageConfig.ConnectionString, blobContainerName, blobName); return(blockBlobClient); }
public async Task <IActionResult> PostNewMap() { IFormFile postedFile = Request.Form.Files[0]; bool foundMapName = Request.Form.TryGetValue("mapName", out StringValues mapNameValues); if (!foundMapName) { return(BadRequest()); } string mapName = mapNameValues.AsEnumerable().First(); string currentUser = User.FindFirstValue(ClaimTypes.NameIdentifier); BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(currentUser); if (!containerClient.Exists()) { containerClient = await blobServiceClient.CreateBlobContainerAsync(currentUser); containerClient.SetAccessPolicy(PublicAccessType.BlobContainer); } BlobClient primaryBlobClient = containerClient.GetBlobClient(postedFile.FileName); // Open the file and upload its data using Stream uploadFileStream = postedFile.OpenReadStream(); await primaryBlobClient.UploadAsync(uploadFileStream, true); uploadFileStream.Close(); Map map = new Map { CampaignID = _context.Campaigns.First(x => x.UserId == currentUser).CampaignID, FileName = postedFile.FileName, FilePath = primaryBlobClient.Uri.ToString(), UserId = currentUser, MapName = mapName, }; bool foundNote = Request.Form.TryGetValue("noteId", out StringValues noteValues); if (foundNote) { map = await LinkNewMapToNote(noteValues, map); } await _context.AddAsync(map); await _context.SaveChangesAsync(); return(Ok()); }
public AsyncPageable <BlobItem> ListBlobs(string containerName) { blobServiceClient = new BlobServiceClient(STORAGE_CONNECTION_STRING); blobContainerClient = blobServiceClient.GetBlobContainerClient(containerName); if (blobContainerClient.Exists()) { return(blobContainerClient.GetBlobsAsync()); } else { throw new Exception("Container does not exists"); } }
public void TestConnection() { try { if (_client.Exists(cancellationToken: _cancellationToken) == false) { throw new ContainerNotFoundException($"Container '{_storageContainer}' wasn't found!"); } } catch (UnauthorizedAccessException) { // we don't have the permissions to see if the container exists } }
public void UploadFile(string containerName, BlobFileData fileData, bool isPrivate) { var container = new BlobContainerClient(connectionString, containerName); if (!container.Exists()) { container.Create(); var accessType = isPrivate ? Azure.Storage.Blobs.Models.PublicAccessType.None : Azure.Storage.Blobs.Models.PublicAccessType.Blob; container.SetAccessPolicy(accessType); } using (MemoryStream blobStream = new MemoryStream(fileData.Contents)) { container.UploadBlob(fileData.Name, blobStream); } }
public BlobStorageService(string connectionString, string containerName) { try { BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString); _blobContainerClient = blobServiceClient.GetBlobContainerClient(containerName); if (!_blobContainerClient.Exists()) { throw new BlobContainerNotFoundException(containerName); } } catch (Exception e) when(e is RequestFailedException || e is FormatException || e is AggregateException) { throw new InvalidBlobStorageConnectionStringException(connectionString); } }
private static async Task ClearBlobContainer(string containerName) { BlobContainerClient cloudBlobContainer = CreateBlobContainerClient(containerName); if (!cloudBlobContainer.Exists()) { return; } await foreach (BlobItem item in cloudBlobContainer.GetBlobsAsync()) { Console.WriteLine(item.Name); BlobClient cloudBlob = cloudBlobContainer.GetBlobClient(item.Name); await cloudBlob.DeleteIfExistsAsync(); } }
public static async Task <List <string> > GetThumbNailUrls(AzStorageConfig storageConfig) { List <string> thumbnailUrls = new List <string>(); Uri accountUri = new Uri(string.Format(storageConfig.AccountUri, storageConfig.AccountName)); BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri); BlobContainerClient container = blobServiceClient.GetBlobContainerClient(storageConfig.ThumbnailContainer); if (container.Exists()) { foreach (BlobItem blobItem in container.GetBlobs()) { thumbnailUrls.Add($"{container.Uri}/{blobItem.Name}"); } } return(await Task.FromResult(thumbnailUrls)); }
public IActionResult Create([FromForm] FileCreate apiModel) { BlobContainerClient containerClient = _blobSC.GetBlobContainerClient($"pilot{apiModel.PilotID}"); if (!containerClient.Exists()) { containerClient = _blobSC.CreateBlobContainer($"pilot{apiModel.PilotID}", Azure.Storage.Blobs.Models.PublicAccessType.BlobContainer); } BlobClient blobClient = containerClient.GetBlobClient(apiModel.FileName); if (blobClient.Exists()) { return(BadRequest(new { error = "File name already taken for this pilot" })); } blobClient.Upload(apiModel.File.OpenReadStream()); apiModel.FileURL = blobClient.Uri.AbsoluteUri; return(Ok(FileMinimal.FromDLModel(_aviBL.AddFile(apiModel.ToDLModel())))); }
private static string GenSASToken(string blobName) { // Create a URI to the storage account Uri accountUri = new Uri("https://" + BLOB_STORAGE_NAME + ".blob.core.windows.net/"); // Create BlobServiceClient from the account URI BlobServiceClient blobServiceClient = new BlobServiceClient(accountUri); // Get reference to the container BlobContainerClient container = blobServiceClient.GetBlobContainerClient(BLOB_STORAGE_CONTAINER); string sasBlobUri = ""; if (container.Exists()) { // Set the expiration time and permissions for the container. // In this case, the start time is specified as a few // minutes in the past, to mitigate clock skew. // The shared access signature will be valid immediately. BlobSasBuilder sas = new BlobSasBuilder { Resource = "c", BlobContainerName = BLOB_STORAGE_CONTAINER, StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5), ExpiresOn = DateTimeOffset.UtcNow.AddHours(BLOB_SAS_LENTGTH) }; sas.SetPermissions(BlobContainerSasPermissions.All); // Create StorageSharedKeyCredentials object by reading // the values from the configuration (appsettings.json) StorageSharedKeyCredential storageCredential = new StorageSharedKeyCredential(BLOB_STORAGE_NAME, BLOB_STORAGE_KEY); // Create a SAS URI to the storage account UriBuilder sasUri = new UriBuilder(accountUri); sasUri.Query = sas.ToSasQueryParameters(storageCredential).ToString(); // Create the URI using the SAS query token. sasBlobUri = container.Uri + "/" + blobName + sasUri.Query; } return(sasBlobUri); }
//------------------------------------------------- // Create root container //------------------------------------------------- private static void CreateRootContainer(BlobServiceClient blobServiceClient) { try { // Create the root container or handle the exception if it already exists BlobContainerClient container = blobServiceClient.CreateBlobContainer("$root"); if (container.Exists()) { Console.WriteLine("Created root container."); } } catch (RequestFailedException e) { Console.WriteLine("HTTP error code {0}: {1}", e.Status, e.ErrorCode); Console.WriteLine(e.Message); } }
/// <summary>Get a list of All blobs in the specified contaier</summary> /// <param name="containerName">container name</param> /// <returns>A list of blob names</returns> /// <remarks>Still need to determine what we need back for each blob</remarks> public List <string> ListBlobs(string containerName, string pattern = null) { List <string> blobs = new List <string>(); // blob container name - can we set a default somehow if (String.IsNullOrWhiteSpace(containerName)) { return(new List <string>()); } // Get a reference to a share and then create it BlobContainerClient container = new BlobContainerClient(this.ConnectionString, containerName); // check the container exists Response <bool> exists = container.Exists(); if (!exists.Value) { return(new List <string>()); } Pageable <BlobItem> results = null; if (String.IsNullOrWhiteSpace(pattern)) { results = container.GetBlobs(); } else { results = container.GetBlobs(prefix: pattern.Trim()); } IEnumerator <BlobItem> enu = results?.GetEnumerator(); while (enu.MoveNext()) { blobs.Add(enu.Current.Name); } ; return(blobs); }
public static Task <BlobContainerClient> CreateContainerAsync(BlobServiceClient blobServiceClient, string containerName) { var newContainerName = _container + containerName; try { BlobContainerClient container = blobServiceClient.CreateBlobContainer(containerName); if (container.Exists()) { return(Task.FromResult(container)); } } catch (RequestFailedException e) { // TODO: Logging in here. Console.WriteLine("HTTP error code {0}: {1}", e.Status, e.ErrorCode); Console.WriteLine(e.Message); } return(null); }
private async Task <string> UploadWikiImage(WikiPage wikiPage) { BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(wikiPage.UserId); if (!containerClient.Exists()) { containerClient = await blobServiceClient.CreateBlobContainerAsync(wikiPage.UserId); containerClient.SetAccessPolicy(PublicAccessType.BlobContainer); } BlobClient primaryBlobClient = containerClient.GetBlobClient(wikiPage.PageName); // Open the file and upload its data using Stream uploadFileStream = wikiPage.ImageFile.OpenReadStream(); await primaryBlobClient.UploadAsync(uploadFileStream, true); uploadFileStream.Close(); return(primaryBlobClient.Uri.ToString()); }
public async Task OnGetAsync() { try { var blobContainerClient = new BlobContainerClient(ContainerUri, new DefaultAzureCredential()); if (!blobContainerClient.Exists()) { Blobs = Enumerable.Empty <BlobModel>(); } else { Blobs = await blobContainerClient.GetBlobsAsync() .Select(b => new BlobModel(b.Name)) .ToListAsync(); } } catch (Exception e) { ErrorMessage = e.Message; } }
// // // **** Cmdlet start **** // // protected override void ProcessRecord() { //var cred = new ManagedIdentityCredential(identity); //var containerClient = new BlobContainerClient(new Uri(container), cred); var cred = new ManagedIdentityCredential(Identity); var containerClient = new BlobContainerClient(new Uri(Container), cred); if (containerClient.Exists()) { WriteVerbose("Trying to read container..."); List <string> blobsListing = containerClient.GetBlobs().Select(i => i.Name).ToList(); WriteVerbose($"Obtained {blobsListing.Count} blobs"); blobsListing.ForEach(b => WriteObject(b)); } else { //WriteVerbose($"Container {container} does not exist or cannot be accessed."); WriteVerbose($"Container {Container} does not exist or cannot be accessed."); // switch to error // https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/adding-non-terminating-error-reporting-to-your-cmdlet?view=powershell-7.1#reporting-nonterminating-errors } }