private async Task DumpJson <T>(T obj, string fileName) { // Dump to local temp file (need to do this because need to know file size before copying to Azure File Share). var tmpFile = Path.GetTempFileName(); using (StreamWriter sw = new StreamWriter(tmpFile)) using (JsonWriter jtw = new JsonTextWriter(sw)) { var serializer = new JsonSerializer(); serializer.Serialize(jtw, obj); } try { // Copy the temp file to Azure File Share ShareClient share = new ShareClient(DataDumpStorageConnectionString, DataDumpStorageShareName); ShareDirectoryClient directory = share.GetDirectoryClient("/"); ShareFileClient file = directory.GetFileClient(fileName); using (FileStream stream = File.OpenRead(tmpFile)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync(new HttpRange(0, stream.Length), stream); } } finally { // Clean up the temp file File.Delete(tmpFile); } }
private ShareFileClient StorageSetup(IFormFile loadedFile, string fileType) { string dirName = fileType; string fileName = loadedFile.FileName; ShareClient share = new ShareClient(_storagekey, _storageshare); try { // Try to create the share again share.Create(); } catch (RequestFailedException ex) when(ex.ErrorCode == ShareErrorCode.ShareAlreadyExists) { // Ignore any errors if the share already exists } ShareDirectoryClient directory = share.GetDirectoryClient(dirName); try { // Try to create the share again directory.Create(); } catch (RequestFailedException ex) { // Ignore any errors if the share already exists } ShareFileClient shareFile = directory.GetFileClient(fileName); return(shareFile); }
public async Task DeleteFileAsync(String filename) { ShareDirectoryClient raiz = this.cliente.GetRootDirectoryClient(); ShareFileClient file = raiz.GetFileClient(filename); await file.DeleteAsync(); }
public async Task PathClient_CanGetParentDirectoryClient() { // Arrange var parentDirName = SharesClientBuilder.GetNewDirectoryName(); await using DisposingShare test = await SharesClientBuilder.GetTestShareAsync(); ShareDirectoryClient parentDirClient = InstrumentClient(test.Container .GetRootDirectoryClient() .GetSubdirectoryClient(parentDirName)); await parentDirClient.CreateAsync(); ShareFileClient fileClient = InstrumentClient(parentDirClient .GetFileClient(SharesClientBuilder.GetNewFileName())); await fileClient.CreateAsync(Constants.KB); // Act parentDirClient = fileClient.GetParentShareDirectoryClient(); // make sure that client is functional var dirProperties = await parentDirClient.GetPropertiesAsync(); // Assert Assert.AreEqual(fileClient.Path.GetParentPath(), parentDirClient.Path); Assert.AreEqual(fileClient.AccountName, parentDirClient.AccountName); Assert.IsNotNull(dirProperties); }
/// <summary> /// Download a file. /// </summary> /// <param name="connectionString"> /// A connection string to your Azure Storage account. /// </param> /// <param name="shareName"> /// The name of the share to download from. /// </param> /// <param name="localFilePath"> /// Path to download the local file. /// </param> public static async Task DownloadAsync(string connectionString, string shareName, string localFilePath) { #region Snippet:Azure_Storage_Files_Shares_Samples_Sample01b_HelloWorldAsync_DownloadAsync //@@ string connectionString = "<connection_string>"; // Name of the share, directory, and file we'll download from //@@ string shareName = "sample-share"; string dirName = "sample-dir"; string fileName = "sample-file"; // Path to the save the downloaded file //@@ string localFilePath = @"<path_to_local_file>"; // Get a reference to the file ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetDirectoryClient(dirName); ShareFileClient file = directory.GetFileClient(fileName); // Download the file ShareFileDownloadInfo download = await file.DownloadAsync(); using (FileStream stream = File.OpenWrite(localFilePath)) { await download.Content.CopyToAsync(stream); } #endregion Snippet:Azure_Storage_Files_Shares_Samples_Sample01b_HelloWorldAsync_DownloadAsync }
public static bool WriteStringToAzureFileShare(string storageConnString, string shareName, string fileName, string content) { if (!azureAuthenticated) { return(false); } try { ShareClient share = new ShareClient(storageConnString, shareName); ShareDirectoryClient directory = share.GetRootDirectoryClient(); directory.DeleteFile(fileName); ShareFileClient file = directory.GetFileClient(fileName); byte[] byteArray = Encoding.UTF8.GetBytes(content); using (MemoryStream stream = new MemoryStream(byteArray)) { file.Create(stream.Length); file.UploadRange( new HttpRange(0, stream.Length), stream); } return(true); } catch (Exception _) { // Log Ex.Message here return(false); } }
public async Task UploadAsync(ConnectorConfig config, string fullFileName, MemoryStream stream) { var dirName = Path.GetDirectoryName(fullFileName).ToString(); var fileName = Path.GetFileName(fullFileName).ToString(); ShareClient share = new ShareClient(config.connectionString, config.shareName); if (!share.Exists()) { await share.CreateAsync(); } ShareDirectoryClient directory = share.GetDirectoryClient(dirName); if (!directory.Exists()) { await directory.CreateAsync(); } ShareFileClient file = directory.GetFileClient(fileName); await file.CreateAsync(stream.Length); await file.UploadAsync(stream); /* * await file.UploadRange( * ShareFileRangeWriteType.Update, * new HttpRange(0, stream.Length), * stream);*/ }
// <snippet_RestoreFileFromSnapshot> //------------------------------------------------- // Restore file from snapshot //------------------------------------------------- public async Task RestoreFileFromSnapshot(string shareName, string directoryName, string fileName, string snapshotTime) { // Get the connection string from app settings string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; // Instatiate a ShareServiceClient ShareServiceClient shareService = new ShareServiceClient(connectionString); // Get a ShareClient ShareClient share = shareService.GetShareClient(shareName); // Get a ShareDirectoryClient, then a ShareFileClient to the live file ShareDirectoryClient liveDir = share.GetDirectoryClient(directoryName); ShareFileClient liveFile = liveDir.GetFileClient(fileName); // Get as ShareClient that points to a snapshot ShareClient snapshot = share.WithSnapshot(snapshotTime); // Get a ShareDirectoryClient, then a ShareFileClient to the snapshot file ShareDirectoryClient snapshotDir = snapshot.GetDirectoryClient(directoryName); ShareFileClient snapshotFile = snapshotDir.GetFileClient(fileName); // Restore the file from the snapshot ShareFileCopyInfo copyInfo = await liveFile.StartCopyAsync(snapshotFile.Uri); // Display the status of the operation Console.WriteLine($"Restore status: {copyInfo.CopyStatus}"); }
public IActionResult DownloadFile(string userId, string fileName) { // Get a reference to a share and then create it ShareClient share = new ShareClient(Secret.AzureConnectionString, Secret.AzureFileShareName); if (!share.Exists()) { share.Create(); } // Get a reference to a directory and create it ShareDirectoryClient directory = share.GetDirectoryClient(Auth0Utils.GetUserFolder()); if (!directory.Exists()) { directory.Create(); } // Get a reference to a file and upload it ShareFileClient fileClient = directory.GetFileClient(fileName); if (fileClient.Exists()) { //ShareFileDownloadInfo download = file.Download(); return(File(fileClient.OpenRead(), "application/octet-stream")); } else { return(NotFound()); } }
public List <Metadata> GetMetadatas() { List <Metadata> metadatas = new List <Metadata>(); MetadataParser parser = new MetadataParser( new MetadataConverter()); try { var remaining = new Queue <ShareDirectoryClient>(); remaining.Enqueue(shareClient.GetDirectoryClient(this.path)); while (remaining.Count > 0) { ShareDirectoryClient dir = remaining.Dequeue(); foreach (ShareFileItem item in dir.GetFilesAndDirectories()) { if (item.IsDirectory) { remaining.Enqueue(dir.GetSubdirectoryClient(item.Name)); } else if (item.Name.Contains(FILE_EXTENSION)) { Console.WriteLine($" In {dir.Uri.AbsolutePath} found {item.Name}"); ShareFileClient file = dir.GetFileClient(item.Name); ShareFileDownloadInfo fileContents = file.Download(); string json; using (MemoryStream ms = new MemoryStream()) { fileContents.Content.CopyTo(ms); json = Encoding.UTF8.GetString(ms.ToArray()); } // Parse json string Metadata metadata = parser.Parse(json); // Sets the dataset path relative to the Uri and Path specified in constructor var filePath = Path.GetRelativePath(this.path, file.Path) .Replace(FILE_EXTENSION, ""); metadata.Dataset.DatasetPath = filePath; metadatas.Add(metadata); } } } Console.WriteLine($"Found a total of {metadatas.Count} files"); } catch (Exception e) { Console.WriteLine($"An error ocurred: {e}"); } return(metadatas); }
public async Task <string> SaveFileUri(string fileShare, string fileName, string fileContent) { ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { share.Create(); } ShareDirectoryClient rootDir = share.GetRootDirectoryClient(); ShareFileClient file = rootDir.GetFileClient(fileName); if (!file.Exists()) { file.Create(fileContent.Length); } byte[] outBuff = Encoding.ASCII.GetBytes(fileContent); ShareFileOpenWriteOptions options = new ShareFileOpenWriteOptions { MaxSize = outBuff.Length }; var stream = await file.OpenWriteAsync(true, 0, options); stream.Write(outBuff, 0, outBuff.Length); stream.Flush(); return(file.Uri.ToString()); }
public static ShareFileClient GetAzureFile(string folderName, string fileName) { string shareName = MyWebUtils.Application.ToLower(); string connectionString = Properties.Settings.Default.StorageConnectionString; ShareClient share = new ShareClient(connectionString, shareName); // Create the share if it doesn't already exist share.CreateIfNotExists(); if (share.Exists()) { ShareDirectoryClient subFolder = share.GetRootDirectoryClient(); foreach (string subFolderName in folderName.Split('\\')) { subFolder = subFolder.GetSubdirectoryClient(subFolderName); subFolder.CreateIfNotExists(); } return(subFolder.GetFileClient(fileName)); } return(null); }
public string Download(string connectionString, string shareName, string directory, string fileName) { // Get a reference to the file ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directoryClient = share.GetDirectoryClient(directory); ShareFileClient file = directoryClient.GetFileClient(fileName); string localFilePath = @"C:\audio\sales\trusted\Sales\" + file.Name; try { // Download the file ShareFileDownloadInfo download = file.Download(); using (FileStream stream = File.OpenWrite(localFilePath)) { download.Content.CopyTo(stream); } } catch (Exception e) { _errors.Add(fileName + ": " + e.Message); } return(localFilePath); }
public async Task <IActionResult> GetLogo(string fileName) { var connectionString = _configuration.GetSection("StorageAccount:ConnectionString").Value; var shareName = _configuration.GetSection("StorageAccount:ShareName").Value; if (string.IsNullOrEmpty(fileName)) { return(NotFound()); } var extension = GetExtensionFileName(fileName); var contentType = GetContentTypeForResponse(extension); ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetDirectoryClient("logos"); var file = directory.GetFileClient(fileName); if (!file.Exists()) { return(NotFound()); } Stream stream = await file.OpenReadAsync(); return(File(stream, contentType)); }
private static async Task MoveFileAsync(ShareClient share, ShareDirectoryClient directory, ShareFileClient file, string outputFolder) { try { ShareDirectoryClient outputDirectory = share.GetDirectoryClient(outputFolder); await outputDirectory.CreateIfNotExistsAsync(); if (outputDirectory.Exists()) { ShareFileClient outputFile = outputDirectory.GetFileClient(file.Name); await outputFile.StartCopyAsync(file.Uri); if (await outputFile.ExistsAsync()) { Log($"{file.Uri} copied to {outputFile.Uri}"); await DeleteFileAsync(file); } } } catch (Exception ex) { Log(ex); } }
public async Task <string> ReadFile(string fileShare, string fileName) { string json = ""; ShareClient share = new ShareClient(connectionString, fileShare); if (!share.Exists()) { Exception error = new Exception($"Fileshare {fileName} does not exist "); throw error; } ShareDirectoryClient directory = share.GetRootDirectoryClient(); ShareFileClient file = directory.GetFileClient(fileName); if (file.Exists()) { using (Stream fileStream = await file.OpenReadAsync()) { using (StreamReader reader = new StreamReader(fileStream)) { json = reader.ReadToEnd(); } } } else { Exception error = new Exception($"File {fileName} does not exist in Azure storage "); throw error; } return(json); }
public IActionResult DeleteFile(string userId, string fileName) { // Get a reference to a share and then create it ShareClient share = new ShareClient(Secret.AzureConnectionString, Secret.AzureFileShareName); if (!share.Exists()) { share.Create(); } // Get a reference to a directory and create it ShareDirectoryClient directory = share.GetDirectoryClient(Auth0Utils.GetUserFolder()); if (!directory.Exists()) { directory.Create(); } // Get a reference to a file and upload it ShareFileClient fileClient = directory.GetFileClient(fileName); fileClient.DeleteIfExists(); return(Ok()); }
public static FoundFile ScanForANewFile() { ShareClient share = new ShareClient(CONNECTIONSTRING, SHARENAME); foreach (ShareFileItem item in share.GetRootDirectoryClient().GetFilesAndDirectories()) // loop through all plants { if (item.Name == "System") { continue; } if (item.IsDirectory) { var subDirectory = share.GetRootDirectoryClient().GetSubdirectoryClient(item.Name); ShareDirectoryClient dir = subDirectory.GetSubdirectoryClient("immediateScan"); if (!dir.Exists()) { continue; } foreach (var file in dir.GetFilesAndDirectories()) { if (!file.IsDirectory) { string tempFileName = Path.GetTempFileName(); DownloadFile(dir.GetFileClient(file.Name), tempFileName); return(new FoundFile(/*item.Name, */ file.Name, dir.Path + "/" + file.Name, tempFileName)); } } } } return(null); }
#pragma warning disable CA1806 // Do not ignore method results public override void Run(CancellationToken cancellationToken) { var serviceClient = new ShareServiceClient(s_connectionString); new ShareServiceClient(s_serviceUri); new ShareServiceClient(s_serviceUri, s_azureSasCredential); new ShareServiceClient(s_serviceUri, s_storageSharedKey); var shareClient = new ShareClient(s_connectionString, "foo"); new ShareClient(s_shareUri); new ShareClient(s_shareUri, s_azureSasCredential); new ShareClient(s_shareUri, s_storageSharedKey); var directoryClient = new ShareDirectoryClient(s_connectionString, "foo", "bar"); new ShareDirectoryClient(s_directoryUri); new ShareDirectoryClient(s_directoryUri, s_azureSasCredential); new ShareDirectoryClient(s_directoryUri, s_storageSharedKey); new ShareFileClient(s_connectionString, "foo", "bar/baz"); new ShareFileClient(s_fileUri); new ShareFileClient(s_fileUri, s_azureSasCredential); new ShareFileClient(s_fileUri, s_storageSharedKey); serviceClient.GetShareClient("foo"); shareClient.GetDirectoryClient("bar"); directoryClient.GetFileClient("baz"); }
private static (ShareClient, ShareDirectoryClient, ShareFileClient) GetFileShareClients(string connectionString, string shareName, string dirName, string fileName) { ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetDirectoryClient(dirName); ShareFileClient file = directory.GetFileClient(fileName); return(share, directory, file); }
/// <summary>Creates a wrapper around the file so that you can perform actions on it (doesn't do anything to the server).</summary> /// <param name="directoryName">The directory of interest or empty/null if you want the root directory</param> /// <param name="fileName">The file name without a path</param> public ShareFileClient CreateClient(string directoryName, string fileName) { ShareDirectoryClient directory = string.IsNullOrWhiteSpace(directoryName) ? _share.GetRootDirectoryClient() : _share.GetDirectoryClient(directoryName); return(directory.GetFileClient(fileName)); }
public async Task UploadFileAsync(String filename, Stream stream) { ShareDirectoryClient raiz = this.cliente.GetRootDirectoryClient(); ShareFileClient file = raiz.GetFileClient(filename); await file.CreateAsync(stream.Length); await file.UploadAsync(stream); }
// <snippet_CreateShare> //------------------------------------------------- // Create a file share //------------------------------------------------- public async Task CreateShareAsync(string shareName) { // <snippet_CreateShareClient> // Get the connection string from app settings string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; // Instantiate a ShareClient which will be used to create and manipulate the file share ShareClient share = new ShareClient(connectionString, shareName); // </snippet_CreateShareClient> // Create the share if it doesn't already exist await share.CreateIfNotExistsAsync(); // Ensure that the share exists if (await share.ExistsAsync()) { Console.WriteLine($"Share created: {share.Name}"); // Get a reference to the sample directory ShareDirectoryClient directory = share.GetDirectoryClient("CustomLogs"); // Create the directory if it doesn't already exist await directory.CreateIfNotExistsAsync(); // Ensure that the directory exists if (await directory.ExistsAsync()) { // Get a reference to a file object ShareFileClient file = directory.GetFileClient("Log1.txt"); // Ensure that the file exists if (await file.ExistsAsync()) { Console.WriteLine($"File exists: {file.Name}"); // Download the file ShareFileDownloadInfo download = await file.DownloadAsync(); // Save the data to a local file, overwrite if the file already exists using (FileStream stream = File.OpenWrite(@"downloadedLog1.txt")) { await download.Content.CopyToAsync(stream); await stream.FlushAsync(); stream.Close(); // Display where the file was saved Console.WriteLine($"File downloaded: {stream.Name}"); } } } } else { Console.WriteLine($"CreateShareAsync failed"); } }
static void Main(string[] args) { string downloadDirectory = args[0]; // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(AZURE_STORAGE_CONNECTION_STRING); // Create a unique name for the container string containerName = "startupfiles"; // Create the container and return a container client object BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName); List <BlobItem> blobs = containerClient.GetBlobs().ToList(); // Download the blob files in parallel - maximum of 10 at a time } Parallel.ForEach(blobs, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, blob => { string downloadFilePath = Path.Combine(downloadDirectory, blob.Name); BlobClient blobClient = containerClient.GetBlobClient(blob.Name); BlobDownloadInfo download = blobClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } }); string shareName = "startupfiles"; ShareClient shareClient = new ShareClient(AZURE_FILES_CONNECTION_STRING, shareName); if (shareClient.Exists()) { ShareDirectoryClient shareDirectoryClient = shareClient.GetRootDirectoryClient(); List <ShareFileItem> items = shareDirectoryClient.GetFilesAndDirectories().ToList(); foreach (ShareFileItem item in items) { if (!item.IsDirectory) { string downloadFilePath = Path.Combine(downloadDirectory, item.Name); ShareFileClient shareFileClient = shareDirectoryClient.GetFileClient(item.Name); ShareFileDownloadInfo download = shareFileClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } } } } }
/// <summary> /// Uploads the asynchronous. /// </summary> /// <param name="storageFile">The storage file.</param> /// <param name="overwrite">if set to <c>true</c> [overwrite].</param> /// <exception cref="System.ArgumentNullException">storageFile</exception> /// <exception cref="System.ArgumentException">storageFile</exception> /// <exception cref="CloudFileSystem.Core.V1.FileManagement.Storage.StorageException"> /// rootDirectoryExists - UploadAsync or fileExists - UploadAsync or Path - UploadAsync /// </exception> public async Task UploadAsync(StorageFile storageFile, bool overwrite = false) { if (storageFile is null) { throw new ArgumentNullException(nameof(storageFile)); } if (string.IsNullOrWhiteSpace(storageFile.SafeName) && string.IsNullOrWhiteSpace(storageFile.FileName)) { throw new ArgumentException(nameof(storageFile)); } ShareDirectoryClient rootDirectory = this._shareClient.GetRootDirectoryClient(); bool rootDirectoryExists = await rootDirectory.ExistsAsync(); if (!rootDirectoryExists) { throw new StorageException(nameof(rootDirectoryExists), nameof(this.UploadAsync)); } string safeName = storageFile.SafeName ?? this.RemoveInvalidCharacters(storageFile.FileName); ShareFileClient file = rootDirectory.GetFileClient(safeName); bool fileExists = await file.ExistsAsync(); if (fileExists && !overwrite) { throw new StorageException(nameof(fileExists), nameof(this.UploadAsync)); } await file.CreateAsync(storageFile.Content.Length); using var reader = new BinaryReader(storageFile.Content); int blockSize = 1 * 1024 * 1024; // 1MB long offset = 0; while (true) { byte[] buffer = reader.ReadBytes(blockSize); if (buffer.Length == 0) { break; } using var uploadChunk = new MemoryStream(); uploadChunk.Write(buffer, 0, buffer.Length); uploadChunk.Position = 0; var httpRange = new HttpRange(offset, buffer.Length); await file.UploadRangeAsync(httpRange, uploadChunk); offset += buffer.Length; } if (string.IsNullOrWhiteSpace(file.Path)) { throw new StorageException(nameof(file.Path), nameof(this.UploadAsync)); } }
public async Task UploadRangeFromUriAsync_SourceBearerTokenFail() { // Arrange BlobServiceClient blobServiceClient = InstrumentClient(new BlobServiceClient( new Uri(Tenants.TestConfigOAuth.BlobServiceEndpoint), Tenants.GetOAuthCredential(Tenants.TestConfigOAuth), GetBlobOptions())); BlobContainerClient containerClient = InstrumentClient(blobServiceClient.GetBlobContainerClient(GetNewShareName())); try { await containerClient.CreateIfNotExistsAsync(); AppendBlobClient appendBlobClient = InstrumentClient(containerClient.GetAppendBlobClient(GetNewFileName())); await appendBlobClient.CreateAsync(); byte[] data = GetRandomBuffer(Constants.KB); using Stream stream = new MemoryStream(data); await appendBlobClient.AppendBlockAsync(stream); ShareServiceClient serviceClient = SharesClientBuilder.GetServiceClient_OAuthAccount_SharedKey(); await using DisposingShare test = await GetTestShareAsync( service : serviceClient, shareName : GetNewShareName()); ShareDirectoryClient directoryClient = InstrumentClient(test.Share.GetDirectoryClient(GetNewDirectoryName())); await directoryClient.CreateAsync(); ShareFileClient fileClient = InstrumentClient(directoryClient.GetFileClient(GetNewFileName())); await fileClient.CreateAsync(Constants.KB); HttpAuthorization sourceAuthHeader = new HttpAuthorization( "Bearer", "auth token"); ShareFileUploadRangeFromUriOptions options = new ShareFileUploadRangeFromUriOptions { SourceAuthentication = sourceAuthHeader }; HttpRange range = new HttpRange(0, Constants.KB); // Act await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>( fileClient.UploadRangeFromUriAsync( sourceUri: appendBlobClient.Uri, range: range, sourceRange: range, options: options), e => Assert.AreEqual("CannotVerifyCopySource", e.ErrorCode)); } finally { await containerClient.DeleteIfExistsAsync(); } }
public async Task UploadRangeFromUriAsync_SourceBearerToken() { // Arrange BlobServiceClient blobServiceClient = InstrumentClient(new BlobServiceClient( new Uri(TestConfigOAuth.BlobServiceEndpoint), GetOAuthCredential(TestConfigOAuth), GetBlobOptions())); BlobContainerClient containerClient = InstrumentClient(blobServiceClient.GetBlobContainerClient(GetNewShareName())); try { await containerClient.CreateIfNotExistsAsync(); AppendBlobClient appendBlobClient = InstrumentClient(containerClient.GetAppendBlobClient(GetNewFileName())); await appendBlobClient.CreateAsync(); byte[] data = GetRandomBuffer(Constants.KB); using Stream stream = new MemoryStream(data); await appendBlobClient.AppendBlockAsync(stream); ShareServiceClient serviceClient = GetServiceClient_OAuth_SharedKey(); await using DisposingShare test = await GetTestShareAsync( service : serviceClient, shareName : GetNewShareName()); ShareDirectoryClient directoryClient = InstrumentClient(test.Share.GetDirectoryClient(GetNewDirectoryName())); await directoryClient.CreateAsync(); ShareFileClient fileClient = InstrumentClient(directoryClient.GetFileClient(GetNewFileName())); await fileClient.CreateAsync(Constants.KB); string sourceBearerToken = await GetAuthToken(); HttpAuthorization sourceAuthHeader = new HttpAuthorization( "Bearer", sourceBearerToken); ShareFileUploadRangeFromUriOptions options = new ShareFileUploadRangeFromUriOptions { SourceAuthentication = sourceAuthHeader }; HttpRange range = new HttpRange(0, Constants.KB); // Act await fileClient.UploadRangeFromUriAsync( sourceUri : appendBlobClient.Uri, range : range, sourceRange : range, options : options); } finally { await containerClient.DeleteIfExistsAsync(); } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log) { string connectionString = "DefaultEndpointsProtocol=https;AccountName=m10l2;AccountKey=jKxmGhpm9FWua8lWReXyt9gft5xConbXInXr8IRQj2Z1lWVL6YIWNl/pmqm3EQkdh7YgJlTRPakW8w2GiSfswg==;EndpointSuffix=core.windows.net"; string containerName = "test"; string queueName = "test"; string shareName = "test"; string blobName = $"{Guid.NewGuid().ToString()}.json"; string fileName = $"{Guid.NewGuid().ToString()}.json"; BlobContainerClient container = new BlobContainerClient(connectionString, containerName); BlobClient blob = container.GetBlobClient(blobName); Stream uploadStream = new MemoryStream(); req.Body.CopyTo(uploadStream); uploadStream.Position = 0; blob.Upload(uploadStream); Stream result = (await blob.DownloadAsync()).Value.Content; QueueClient queue = new QueueClient(connectionString, queueName); Stream messageStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(messageStream); using (StreamReader sr = new StreamReader(messageStream)) { queue.SendMessage(sr.ReadToEnd()); } QueueMessage[] messages = (await queue.ReceiveMessagesAsync()).Value; ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetRootDirectoryClient(); Stream fileStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(fileStream); fileStream.Position = 0; ShareFileClient file = directory.GetFileClient(fileName); await file.CreateAsync(fileStream.Length); file.UploadRange(new HttpRange(0, fileStream.Length), fileStream); var downloadedFile = file.Download(); using (StreamReader sr = new StreamReader(downloadedFile.Value.Content)) { string uploadedFile = await sr.ReadToEndAsync(); return(new OkObjectResult(uploadedFile)); } }
public IActionResult UploadAzure() { try { var file = Request.Form.Files[0]; var folderName = Path.Combine("StaticFiles", "Images"); var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName); if (file.Length > 0) { var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"'); var fullPath = Path.Combine(pathToSave, fileName); var dbPath = Path.Combine(folderName, fileName); using (var stream = new FileStream(fullPath, FileMode.Create)) { file.CopyTo(stream); } // Get a reference to a share and then create it ShareClient share = new ShareClient("DefaultEndpointsProtocol=https;AccountName=faceidentity;AccountKey=N/gO9IA0exmgv4yH+ZISlxc0wxv2haDMWi2fZoL2/ErfqM/KHAePM4qkwMjnWEXesDvDidDVYJqKAtv3FvaXnQ==;EndpointSuffix=core.windows.net", "employeesimages"); // share.Create(); // Get a reference to a directory and create it ShareDirectoryClient directory = share.GetDirectoryClient("auth"); // directory.Create(); // Get a reference to a file and upload it ShareFileClient fileAzure = directory.GetFileClient(fileName); using (FileStream stream = System.IO.File.OpenRead(fullPath)) { fileAzure.Create(stream.Length); fileAzure.UploadRange( new HttpRange(0, stream.Length), stream); } string fileAzurePath = fileAzure.Uri.ToString(); //System.IO.File.Delete(fullPath); return(Ok(new { fileAzurePath })); } else { return(BadRequest()); } } catch (Exception ex) { return(StatusCode(500, $"Internal server error: {ex}")); } }
public async Task Sample01b_HelloWorldAsync_TraverseAsync() { // Create a temporary Lorem Ipsum file on disk that we can upload string originalPath = CreateTempFile(SampleFileContent); // Get a reference to a share named "sample-share" and then create it string shareName = Randomize("sample-share"); ShareClient share = new ShareClient(ConnectionString, shareName); await share.CreateAsync(); try { // Create a bunch of directories ShareDirectoryClient first = await share.CreateDirectoryAsync("first"); await first.CreateSubdirectoryAsync("a"); await first.CreateSubdirectoryAsync("b"); ShareDirectoryClient second = await share.CreateDirectoryAsync("second"); await second.CreateSubdirectoryAsync("c"); await second.CreateSubdirectoryAsync("d"); await share.CreateDirectoryAsync("third"); ShareDirectoryClient fourth = await share.CreateDirectoryAsync("fourth"); ShareDirectoryClient deepest = await fourth.CreateSubdirectoryAsync("e"); // Upload a file named "file" ShareFileClient file = deepest.GetFileClient("file"); using (FileStream stream = File.OpenRead(originalPath)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync( ShareFileRangeWriteType.Update, new HttpRange(0, stream.Length), stream); } await Sample01b_HelloWorldAsync.TraverseAsync(ConnectionString, shareName); } finally { await share.DeleteAsync(); } }