// Creates container and blobs within a storage account to populate changefeed and add example events
static void Main(string[] args)
{
count = 0;
// Create clients
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
try
{
BlobContainerClient blobContainerClient = blobServiceClient.CreateBlobContainer(containerName);
}
catch
{
BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient(containerName);
}
// Create Timer
Timer timer = null;
Console.WriteLine("Press Space to start the timer. Press Enter to stop the timer. Press any other key to exit/not run the timer");
if (Console.ReadKey().Key == ConsoleKey.Spacebar)
{
Console.WriteLine("Starting timer...");
// Timer calls CreateEvents function every 30 minutes, to edit the interval change the last value in the call to the number of milliseconds
timer = new Timer(new TimerCallback(CreateEvents), null, 0, 1800000);
while (Console.ReadKey().Key != ConsoleKey.Enter)
{
if (Console.ReadKey().Key == ConsoleKey.Enter)
{
Console.WriteLine("Stopping timer...");
timer.Change(
Timeout.Infinite,
Timeout.Infinite);
break;
}
}
Console.WriteLine("Timer Stopped");
}
else
{
Console.WriteLine("\nTimer was not run, program exited");
}
}
public async Task Step3_attempt_to_upload_a_new_version_of_blob_using_stream_workaround_that_works()
{
// Download the blob
var serviceClient = new BlobServiceClient(connectionString);
var containerClient = serviceClient.GetBlobContainerClient("repro");
var blobClient = containerClient.GetBlobClient("aabbccdd-1122-3344-5566-778899aabbcc.txt");
var response = await blobClient.DownloadAsync();
// upload to the destination - first two characters and then the original blob
var uploadClient = containerClient.GetBlobClient("aa/aabbccdd-1122-3344-5566-778899aabbcc.txt");
// The code set the LocalId in case this is an insert and verifies the blob tag value is lesser value in case it's an update
var options = new BlobUploadOptions
{
Tags = new Dictionary <string, string> {
{ "LocalId", "456" }
},
Conditions = new BlobRequestConditions
{
TagConditions = $@"""LocalId"" < '456'"
}
};
// Workaround for https://github.com/Azure/azure-sdk-for-net/issues/20931
await using var memoryStreamFix = new MemoryStream();
await response.Value.Content.CopyToAsync(memoryStreamFix).ConfigureAwait(false);
memoryStreamFix.Position = 0;
// End Workaround
try
{
await uploadClient.UploadAsync(memoryStreamFix, options);
}
catch (RequestFailedException exception) when(exception.ErrorCode == BlobErrorCode.ConditionNotMet)
{
output.WriteLine("Failed to copy 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' to 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' despite workaround.");
output.WriteLine("Reason: 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' reported as existing and condition not met (412) despite 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' absense.");
output.WriteLine($"Exception: {exception.Message}");
}
}
public async Task <IActionResult> GetAlerts(int id)
{
var currentUser = CurrentUser();
var organization = _context.Organizations.Find(id);
// Ensure that object was found.
if (organization == null)
{
return(NotFound());
}
// Ensure that user is authorized.
if (!currentUser.CanViewPunches ||
currentUser.OrganizationId != id)
{
return(BadRequest());
}
try
{
// Download and deserialize the json.
var azureConnectionString = _configuration["AlertsAzureStorageConnectionString"];
BlobServiceClient blobServiceClient = new BlobServiceClient(azureConnectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient("alerts");
BlobClient blobClient = containerClient.GetBlobClient($"{organization.Id}.json");
List <Alert> result;
using (var stream = await blobClient.OpenReadAsync())
{
result = JsonSerializer.Deserialize <List <Alert> >(stream);
}
return(Ok(result));
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
return(BadRequest(ex.Message));
}
}
public async Task AppendBlobSample()
{
// Instantiate a new BlobServiceClient using a connection string.
BlobServiceClient blobServiceClient = new BlobServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString);
// Instantiate a new BlobContainerClient
BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient("mycontainer4");
try
{
// Create new Container in the Service
await blobContainerClient.CreateAsync();
// Instantiate a new PageBlobClient
AppendBlobClient appendBlobClient = blobContainerClient.GetAppendBlobClient("appendblob");
// Create PageBlob in the Service
await appendBlobClient.CreateAsync();
// Append content to AppendBlob
using (FileStream fileStream = File.OpenRead("Samples/SampleSource.txt"))
{
await appendBlobClient.AppendBlockAsync(fileStream);
}
// Download PageBlob
using (FileStream fileStream = File.Create("AppendDestination.txt"))
{
Response <BlobDownloadInfo> downloadResponse = await appendBlobClient.DownloadAsync();
await downloadResponse.Value.Content.CopyToAsync(fileStream);
}
// Delete PageBlob in the Service
await appendBlobClient.DeleteAsync();
}
finally
{
// Delete Container in the Service
await blobContainerClient.DeleteAsync();
}
}
public void FineGrainedBatching()
{
string connectionString = ConnectionString;
string containerName = Randomize("sample-container");
#region Snippet:SampleSnippetsBatch_FineGrainedBatching
// Get a connection string to our Azure Storage account.
//@@ string connectionString = "<connection_string>";
//@@ string containerName = "sample-container";
// Get a reference to a container named "sample-container" and then create it
BlobServiceClient service = new BlobServiceClient(connectionString);
BlobContainerClient container = service.GetBlobContainerClient(containerName);
container.Create();
// Create three blobs named "foo", "bar", and "baz"
BlobClient foo = container.GetBlobClient("foo");
BlobClient bar = container.GetBlobClient("bar");
BlobClient baz = container.GetBlobClient("baz");
foo.Upload(BinaryData.FromString("Foo!"));
foo.CreateSnapshot();
bar.Upload(BinaryData.FromString("Bar!"));
bar.CreateSnapshot();
baz.Upload(BinaryData.FromString("Baz!"));
// Create a batch with three deletes
BlobBatchClient batchClient = service.GetBlobBatchClient();
BlobBatch batch = batchClient.CreateBatch();
batch.DeleteBlob(foo.Uri, DeleteSnapshotsOption.IncludeSnapshots);
batch.DeleteBlob(bar.Uri, DeleteSnapshotsOption.OnlySnapshots);
batch.DeleteBlob(baz.Uri);
// Submit the batch
batchClient.SubmitBatch(batch);
#endregion
Pageable <BlobItem> blobs = container.GetBlobs(states: BlobStates.Snapshots);
Assert.AreEqual(1, blobs.Count());
Assert.AreEqual("bar", blobs.FirstOrDefault().Name);
// Clean up after the test when we're finished
container.Delete();
}
private async Task <Stream> GetFileStream(string blobKey)
{
var blobServiceClient = new BlobServiceClient(_options.StorageConnectionString);
var containerClient = blobServiceClient.GetBlobContainerClient(_options.StorageContainerName);
await containerClient.CreateIfNotExistsAsync(PublicAccessType.Blob);
var blobClient = containerClient.GetBlobClient(blobKey);
if (blobClient.Exists())
{
var stream = new MemoryStream();
await blobClient.DownloadToAsync(stream);
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
return(new MemoryStream());
}
/// <summary>
/// Initializes the Azure storage container and creates it if it doesn't exist.
/// </summary>
/// <param name="containerName">Name of the container.</param>
private async Task <BlobContainerClient> InitializeContainer(string containerName, CancellationToken cancellationToken)
{
if (_client == null)
{
throw new InvalidOperationException("CloudBlobClient has not been initialized");
}
var container = _client.GetBlobContainerClient(containerName);
var containerExists = await container.ExistsAsync(cancellationToken).ConfigureAwait(false);
if (containerExists)
{
return(container);
}
await container.CreateIfNotExistsAsync(Azure.Storage.Blobs.Models.PublicAccessType.None, null, cancellationToken).ConfigureAwait(false);
return(container);
}
/// <summary>
/// Saves data in blob storage defined in configuration.
/// </summary>
/// <param name="config">Configuration.</param>
/// <param name="name">Blob name.</param>
/// <param name="data">Blob data.</param>
public static async Task SaveBlob(IConfiguration config, string name, string data)
{
BlobClient client;
StorageSharedKeyCredential storageCredentials = new StorageSharedKeyCredential(config["AccountName"], config["AccountKey"]);
BlobServiceClient serviceClient = new BlobServiceClient(new Uri(config["BlobEndPoint"]), storageCredentials);
BlobContainerClient blobContainerClient = serviceClient.GetBlobContainerClient(config["StorageContainer"]);
client = blobContainerClient.GetBlobClient(name);
Stream stream = new MemoryStream();
StreamWriter writer = new StreamWriter(stream);
writer.Write(data);
writer.Flush();
stream.Position = 0;
await client.UploadAsync(stream, true);
stream.Dispose();
}
public void TestSendStreamToStorage(Action setupFunction, string firstFile)
{
try
{
setupFunction();
Telegraph.Instance.Ask((System.IO.Stream)System.IO.File.OpenRead(firstFile)).Wait();
var acct = new BlobServiceClient(Connections.StorageConnectionString);
var container = acct.GetBlobContainerClient(StorageContainerName);
var blob = container.GetBlobClient(System.IO.Path.GetFileName(firstFile));
Assert.IsTrue(blob.Exists());
blob.Delete();
}
finally
{
Telegraph.Instance.UnRegisterAll();
}
}
private List <Models.EmailMetrics> ProcessBlobFiles()
{
var emailMetrics = new List <Models.EmailMetrics>();
// connect to the storage account
_storageAccount = new BlobServiceClient(ConfigurationManager.AppSettings["arm:AzureStorageConnectionString"]);
_storageContainer = _storageAccount.GetBlobContainerClient("mgdccontainer");
// get a list of all emails
var blobResults = _storageContainer.GetBlobs();
// process each email
foreach (Azure.Storage.Blobs.Models.BlobItem blob in blobResults)
{
BlobClient blobClient = _storageContainer.GetBlobClient(blob.Name);
ProcessBlobEmails(emailMetrics, blobClient);
}
// emailMetrics.Sort((p1, p2) => p1.RecipientsToEmail.CompareTo(p2.RecipientsToEmail));
return(emailMetrics);
}
public HomeController()
{
if (!containerCreated)
{
string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"].ToString();
// Create a client to interact with blob service.
BlobServiceClient client = new BlobServiceClient(connectionString);
// Create a container named "webappstoragedotnet-imagecontainer" in this storage account first if you want interact with truly Azure service.
blobContainer = client.GetBlobContainerClient(BlobContainerName);
blobContainer.CreateIfNotExists();
// To view the uploaded blob in a browser, you have two options. The first option is to use a Shared Access Signature (SAS) token to delegate
// access to the resource. The second approach is to set permissions to allow public access to blobs in this container.Then you can view the image.
blobContainer.SetAccessPolicy(PublicAccessType.Blob);
containerCreated = true;
}
}
public JobApplicationsController(HRPotterContext context, BlobServiceClient blobService)
{
_context = context;
blobContainerClient = blobService.GetBlobContainerClient("job-applications");
s3Client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1);
var storageService = Environment.GetEnvironmentVariable("StorageService");
if (storageService == "S3")
{
storageType = StorageType.S3;
}
else
{
// By default use BlobStorage
storageType = StorageType.BlobStorage;
}
bucketName = Environment.GetEnvironmentVariable("BucketName");
}
public async Task RenameBlobContainerAsync()
{
// Arrange
BlobServiceClient service = GetServiceClient_SharedKey();
string oldContainerName = GetNewContainerName();
string newContainerName = GetNewContainerName();
BlobContainerClient container = InstrumentClient(service.GetBlobContainerClient(oldContainerName));
await container.CreateAsync();
// Act
BlobContainerClient newContainer = await service.RenameBlobContainerAsync(
sourceContainerName : oldContainerName,
destinationContainerName : newContainerName);
// Assert
await newContainer.GetPropertiesAsync();
// Cleanup
await newContainer.DeleteAsync();
}
public async Task <bool> WriteStreamAsBlobToStorageAsync(Stream content, string containerName, string filename)
{
var connectionString = Environment.GetEnvironmentVariable("FileStorAcc");
var blobClient = new BlobServiceClient(connectionString);
var containerClient = blobClient.GetBlobContainerClient(containerName);
await containerClient.CreateIfNotExistsAsync();
// Get a reference to a blob
var blob = containerClient.GetBlobClient(filename);
// Open the file and upload its data
await blob.UploadAsync(content, true);
content.Close();
return(true);
}
public SalaryCsvBlobService(IConfiguration configuration, ILogger <SalaryCsvBlobService> logger)
{
_logger = logger;
if (string.IsNullOrWhiteSpace(configuration["AzureStorageConnectionString"]))
{
throw new ArgumentException("Azure Storage connection string is null");
}
if (string.IsNullOrWhiteSpace(configuration["SalaryCsvContainer"]))
{
throw new ArgumentException("Salary CSV Container Name is null");
}
_logger.LogInformation("Instantiating service client...");
var blobServiceClient = new BlobServiceClient(configuration["AzureStorageConnectionString"]);
_blobContainerClient = blobServiceClient.GetBlobContainerClient(configuration["SalaryCsvContainer"]);
_logger.LogInformation("Service client successfully instantiated!");
}
public async Task <IActionResult> LinkPage()
{
// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
// Create the container and return a container client object
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
BlobLists blobLists = new BlobLists();
blobLists.Links = new List <string>();
// List all blobs in the container
await foreach (BlobItem blobItem in containerClient.GetBlobsAsync())
{
blobLists.Links.Add(blobItem.Name);
}
ViewData["id"] = "result" + Globals.ContainerName + ".txt";
return(View(blobLists));
}
public async Task <long> GetBanFileSizeForGame(GameType gameType)
{
var blobKey = $"{gameType}-bans.txt";
_logger.LogInformation($"Retrieving ban file size for {gameType} using blob key {blobKey}");
var blobServiceClient = new BlobServiceClient(_options.StorageConnectionString);
var containerClient = blobServiceClient.GetBlobContainerClient(_options.StorageContainerName);
await containerClient.CreateIfNotExistsAsync(PublicAccessType.Blob);
var blobClient = containerClient.GetBlobClient(blobKey);
if (blobClient.Exists())
{
return((await blobClient.GetPropertiesAsync()).Value.ContentLength);
}
return(0);
}
private BlobContainerClient GetContainerClient(params string[] path)
{
if (path.Length < 2)
{
throw new Exception($"Path is not complete, it needs to consist of at least 2 parts, but only has {path.Length}.");
}
var blobServiceClient = new BlobServiceClient(_configuration.AzureStorageConnectionString);
var container = path.First();
var client = blobServiceClient.GetBlobContainerClient(container);
if (_configuration.AutomaticallyCreateDirectories && !client.Exists())
{
client.Create();
}
return(client);
}
public static async Task Main()
{
BlobClientOptions options = new BlobClientOptions();
options.Retry.MaxRetries = 10;
options.Retry.Delay = TimeSpan.FromSeconds(3);
options.Diagnostics.IsLoggingEnabled = true;
options.AddPolicy(new SimpleTracingPolicy(), HttpPipelinePosition.PerCall);
BlobServiceClient serviceClient = new BlobServiceClient(BlobServiceUri, new DefaultAzureCredential(), options);
await foreach (ContainerItem container in serviceClient.GetContainersAsync())
{
BlobContainerClient containerClient = serviceClient.GetBlobContainerClient(container.Name);
await containerClient.DeleteAsync();
}
}
public IActionResult Index()
{
//This for Azure App Configuration
//BlobServiceClient blobServiceClient = new BlobServiceClient(_configuration["TestApp:Settings:StgConnString"]);
//BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(_configuration["TestApp:Settings:StgContainerName"]);
//This for Azure Key Vault
BlobServiceClient blobServiceClient = new BlobServiceClient(_configuration["DemoStoreConnectionString"]);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(_configuration["DemoStoreContainerName"]);
BlobList blobList = new BlobList();
blobList.AccountName = containerClient.Uri.ToString();
blobList.ContainerName = containerClient.Name.ToString();
blobList.Blobs = new List <string>();
foreach (var blob in containerClient.GetBlobs())
{
blobList.Blobs.Add(blob.Name);
}
ViewData["blobs"] = blobList;
return(View());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
string storageAccount = data.storageAccount;
string container = data.container;
string folderPath = data.folderPath; // with no leading slash
var uri = $"https://{storageAccount}.blob.core.windows.net/";
var serviceClient = new BlobServiceClient(new Uri(uri), new DefaultAzureCredential());
var containerClient = serviceClient.GetBlobContainerClient(container);
var files = new List <BlobFilePath>();
await GetFiles(containerClient, folderPath, files);
return(new OkObjectResult("{\"childItems\":" + JsonConvert.SerializeObject(files) + "}"));
}
public async Task Execute(FileRequest request)
{
_validator.ValidateAndThrow(request);
var containerClient = _blobServiceClient.GetBlobContainerClient("code");
// Clearing the metadata field
containerClient.SetMetadata(new Dictionary <string, string>());
if (!File.Exists(request.Path))
{
throw new FileNotFoundException("asd");
}
var blobClient = containerClient.GetBlobClient(Guid.NewGuid().ToString());
var metaData = new Dictionary <string, string>(1);
metaData.Add("Project", request.ProjectName);
//blobClient.SetMetadata(metaData);
await blobClient.UploadAsync(request.Path, new BlobHttpHeaders { ContentType = request.Path.GetContentType() });
blobClient.SetMetadata(metaData);
}
public AzureBlobStorageService(IConfiguration configuration)
{
var storageConnectionString = configuration["Azure:Blob:StorageConnectionString"];
var containerName = configuration["Azure:Blob:ContainerName"];
_publicEndpoint = configuration["Azure:Blob:PublicEndpoint"];
Contract.Requires(string.IsNullOrWhiteSpace(storageConnectionString));
Contract.Requires(string.IsNullOrWhiteSpace(containerName));
var blobClient = new BlobServiceClient(storageConnectionString);
_blobContainer = blobClient.GetBlobContainerClient(containerName);
if (string.IsNullOrWhiteSpace(_publicEndpoint))
{
_publicEndpoint = _blobContainer.Uri.AbsoluteUri;
}
}
public static async Task <List <string> > GetEventPictures(IConfiguration configuration)
{
var connectionString = configuration?.GetAzureStorageSettings("ConnectionString");
var imageContainer = configuration?.GetAzureStorageSettings("ImageContainer");
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
// Create the container and return a container client object
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(imageContainer);
List <string> eventPictures = new List <string>();
await foreach (BlobItem blobItem in containerClient.GetBlobsAsync())
{
if (blobItem.Name.Contains("events", StringComparison.OrdinalIgnoreCase))
{
eventPictures.Add(blobItem.Name);
}
}
return(eventPictures);
}
public async Task <List <BlobClient> > BlobGetterAsync(string containerName)
{
string connectionString = Environment.GetEnvironmentVariable("BlobEndPoint");
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
var containerClient = blobServiceClient.GetBlobContainerClient(containerName);
AsyncPageable <BlobItem> blobs = containerClient.GetBlobsAsync();
var blobClients = new List <BlobClient>();
await foreach (var blob in blobs)
{
var blobClient = containerClient.GetBlobClient(blob.Name);
blobClients.Add(blobClient);
}
return(blobClients);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("FunctionKeyVault.displayBlobs function processed a request.");
BlobServiceClient blobServiceClient = new BlobServiceClient(Configuration["TestApp:Settings:StgConnString"]);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(Configuration["TestApp:Settings:StgContainerName"]);
int blobCount = 0;
foreach (var blob in containerClient.GetBlobs())
{
blobCount++;
}
string responseMessage = "Found " + blobCount.ToString() + " blobs in storage account " + containerClient.Uri.ToString() +
" in container " + containerClient.Name.ToString();
return(new OkObjectResult(responseMessage));
}
public async Task <DisposingContainer> GetTestContainerAsync(
BlobServiceClient service = default,
string containerName = default,
IDictionary <string, string> metadata = default,
PublicAccessType?publicAccessType = default,
bool premium = default)
{
containerName ??= GetNewContainerName();
service ??= GetServiceClient_SharedKey();
if (publicAccessType == default)
{
publicAccessType = premium ? PublicAccessType.None : PublicAccessType.BlobContainer;
}
BlobContainerClient container = InstrumentClient(service.GetBlobContainerClient(containerName));
await container.CreateAsync(metadata : metadata, publicAccessType : publicAccessType.Value);
return(new DisposingContainer(container));
}
public async Task <string> Upload(IFormFile file)
{
var connectionString = _configuration["StorageAccount:ConnectionString"];
var containerName = _configuration["StorageContainer:BookCover:Name"];
var blobServiceClient = new BlobServiceClient(connectionString);
var containerClient = blobServiceClient.GetBlobContainerClient(containerName);
var blobName = $"{Guid.NewGuid()}-{file.FileName}";
var blobClient = containerClient.GetBlobClient(blobName);
using var stream = file.OpenReadStream();
await blobClient.UploadAsync(stream);
return(blobName);
}
private RequestDelegate EnsureUserIdAndContainer(RequestDelegate next)
{
return(async ctx =>
{
// Get the UserId from our Cookies or create it and save it for this request
if (!ctx.Request.Cookies.TryGetValue("UserId", out string userId))
{
userId = Guid.NewGuid().ToString();
}
ctx.Items["UserId"] = userId;
ctx.Response.Cookies.Append("UserId", userId);
// Create a container for the user if it doesn't already exist
BlobServiceClient serviceClient = ctx.RequestServices.GetService <BlobServiceClient>();
await serviceClient.GetBlobContainerClient(userId).CreateIfNotExistsAsync();
// Continue processing
await next(ctx);
});
}
public async Task <List <ImpactStats> > GetAsync()
{
// Get a reference to a blob
if (blobContainerClient == null)
{
// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClient(AzureStorageConfig.AccountKey);
blobContainerClient = blobServiceClient.GetBlobContainerClient(AzureStorageConfig.ContainerName);
}
var blobClient = blobContainerClient.GetBlobClient(statsFileName);
BlobDownloadInfo blobDownloadInfo = await blobClient.DownloadAsync();
using (StreamReader reader = new StreamReader(blobDownloadInfo.Content))
{
string text = reader.ReadToEnd();
List <ImpactStats> stats = JsonSerializer.Deserialize <List <ImpactStats> >(text);
return(stats);
}
}
