public async Task <TerraModuleCollection> GetAllModulesAsync()
{
var modules = new List <TerraModule>();
var segments = await blobClient.ListContainersSegmentedAsync(default(BlobContinuationToken));
foreach (var bc in segments.Results)
{
var blobSegs = await bc.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All,
100, default(BlobContinuationToken), null, null);
// Loop over items within the container and output the length and URI.
foreach (var item in blobSegs.Results)
{
if (item.GetType() == typeof(CloudBlockBlob))
{
var blob = (CloudBlockBlob)item;
// azure/api-app/0.0.44176.zip
var parts = blob.Name.Split("/".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var @namespace = blob.Container.Name;
var name = "Unknown";
var provider = "Unknown";
var version = "Unknown";
if (parts.Length == 3)
{
name = parts[1];
provider = parts[0];
version = $"{parts[2]}".ToLowerInvariant().Replace(".zip", string.Empty);
}
modules.Add(new TerraModule
{
Id = $"{@namespace}/{name}/{provider}/{version}",
Owner = string.Empty,
Namespace = @namespace,
Name = name,
Version = version,
Provider = provider,
Description = $"{@namespace}/{name}/{provider}/{version}",
Downloads = new Random().Next(10, 30),
Published_at = DateTime.Now.Subtract(new TimeSpan(22, 0, 0, 0)),
Source = $"https://github.com/{ @namespace }/{ name }/{ provider }/{ version }",
Verified = true
});
}
}
}
return(await Task.FromResult(new TerraModuleCollection
{
Meta = new TerraMetaData
{
Current_offset = 0,
Limit = modules.Count,
Next_offset = -1,
Next_url = string.Empty
},
Modules = modules
}));
}
internal async Task AddContainersToRoot(DirectoryBlock directory)
{
var items = await client.ListContainersSegmentedAsync(null, new ContainerListingDetails(),
maxListResults,
new BlobContinuationToken(),
new BlobRequestOptions(),
new OperationContext());
var list_continue = false;
do
{
if (items != null)
{
foreach (var item in items.Results)
{
AddToParentDirectoryObject(directory, item);
}
}
if (items.ContinuationToken != null)
{
items = await client.ListContainersSegmentedAsync(null, new ContainerListingDetails(), maxListResults, items.ContinuationToken, new BlobRequestOptions(), new OperationContext());
list_continue = true;
}
else
{
list_continue = false;
}
} while (list_continue);
}
internal static async Task <string> CreateBlobItem(string blobPath)
{
storageConnectionString = BaseConfiguration.Configuration["appsettings:storageConnectionString"];
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
string tempBlobPath = blobPath.ToLower();
if (File.Exists(tempBlobPath))
{
ContainerResultSegment containers = await blobClient.ListContainersSegmentedAsync(null);
CloudBlobContainer selectedContainer = containers.Results.Where(x => x.Name == "deeplibcontainer").FirstOrDefault();
if (selectedContainer != null)
{
CloudBlockBlob blob = selectedContainer.GetBlockBlobReference((DateTime.Now.Day.ToString("X") +
DateTime.Now.Month.ToString("X") + DateTime.Now.Year.ToString("X") +
DateTime.Now.Hour.ToString("X") + DateTime.Now.Minute.ToString("X") +
DateTime.Now.Second.ToString("X") + Path.GetExtension(blobPath)).ToLower());
await blob.UploadFromFileAsync(blobPath);
return(blob.Uri.ToString());
}
}
return(null);
}
public async Task <IEnumerable <IStorageBucket> > ListBucketsAsync()
{
var segmentedResult = await _blobClient.ListContainersSegmentedAsync(
string.Empty, ContainerListingDetails.Metadata, null, null, null, null);
return(segmentedResult.Results.Select(c => new AzureBlobStorageContainer(this, c)));
}
public async Task <IReadOnlyList <IUnixFileSystemEntry> > GetEntriesAsync(IUnixDirectoryEntry directoryEntry, CancellationToken cancellationToken)
{
var ret = new List <IUnixFileSystemEntry>();
//handle container listing
if (directoryEntry.IsRoot == true)
{
var containers = _blobClient.ListContainersSegmentedAsync(null).Result;
ret.AddRange(containers.Results.Select(c => new AzureStorageDirectoryEntry(c)));
}
//handle a url inside a container
else
{
var split = directoryEntry.Name.Split('/').Where(s => string.IsNullOrEmpty(s) == false).ToArray();
if (split != null && split.Length > 0)
{
var container = _blobClient.GetContainerReference(split.FirstOrDefault());
var subdir = split.Length > 1 ? string.Join("/", split.Skip(1).Take(split.Length - 1)) : "";
var directoryReference = container.GetDirectoryReference(subdir);
//get blobs in dir
var blobs = await directoryReference.ListBlobsSegmentedAsync(false, BlobListingDetails.Copy, 10000, null, null, null);
ret.AddRange(blobs.Results.Where(b => b.GetType() == typeof(CloudBlobDirectory)).Select(b => new AzureStorageDirectoryEntry(b as CloudBlobDirectory)));
ret.AddRange(blobs.Results.Where(b => b.GetType() != typeof(CloudBlobDirectory)).Select(b => new AzureStorageFileEntry(b as CloudBlockBlob)));
}
}
return(ret);
}
private async Task <JArray> GetContainersAsync(string storageAccountConnectionString)
{
CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(storageAccountConnectionString);
// Create a blob client for interacting with the blob service.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
BlobContinuationToken continuationToken = null;
var array = new JArray();
do
{
var response = await blobClient.ListContainersSegmentedAsync(continuationToken);
foreach (var container in response.Results)
{
JObject containerObject = new JObject
{
{ "Name", container.Name }
};
array.Add(containerObject);
}
}while (continuationToken != null);
return(array);
}
private static async Task <TResult> FindAllContainersAsync <TResult>(this CloudBlobClient sourceClient, Func <bool> stopCalled, Func <CloudBlobContainer[], TResult> onSuccess, Func <string, TResult> onFailure)
{
var context = new OperationContext();
BlobContinuationToken token = null;
var containers = new List <CloudBlobContainer>();
while (true)
{
if (stopCalled())
{
return(onFailure($"listing containers stopped on {sourceClient.Credentials.AccountName}"));
}
try
{
var segment = await sourceClient.ListContainersSegmentedAsync(null, ContainerListingDetails.All,
null, token, BlobCopyOptions.requestOptions, context);
var results = segment.Results.ToArray();
containers.AddRange(results);
token = segment.ContinuationToken;
if (null == token)
{
return(onSuccess(containers.ToArray()));
}
}
catch (Exception e)
{
return(onFailure($"Exception listing all containers, Detail: {e.Message}"));
}
}
}
static async System.Threading.Tasks.Task Main(string[] args)
{
string storageConnectionString = "DefaultEndpointsProtocol=https;AccountName=strrdm;AccountKey=jykbgp7GhLpHiqZIMtstB+tTLx+EtfELlrOHhPbNV4PUHDySga97Rv/jK68v9mSrFx6INL/jVFJpzv51uyWvqQ==;EndpointSuffix=core.windows.net";
CloudStorageAccount storageAccount;
if (CloudStorageAccount.TryParse(storageConnectionString, out storageAccount))
{// Create the CloudBlobClient that represents the Blob storage endpoint for the storage account.
CloudBlobClient cbc = storageAccount.CreateCloudBlobClient();
var conroot = cbc.GetRootContainerReference();
Console.WriteLine(conroot.Name);
BlobContinuationToken token = null;
var listcon = new List <CloudBlobContainer>();
do
{
var respon = await cbc.ListContainersSegmentedAsync(token);
listcon.AddRange(respon.Results);
token = respon.ContinuationToken;
} while (token != null);
foreach (var c in listcon)
{
Console.WriteLine(c.Name);
}
Console.WriteLine(listcon.Count);
}
}
public async Task <List <string> > ListFolders(string shareName)
{
List <string> toReturn = new List <string>();
try
{
CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(this.ConnectionString);
CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
BlobContinuationToken token = null;
do
{
ContainerResultSegment resultSegment = await cloudBlobClient.ListContainersSegmentedAsync(token);
token = resultSegment.ContinuationToken;
foreach (var item in resultSegment.Results)
{
toReturn.Add(item.Name);
}
} while (token != null);
}
catch (StorageException exStorage)
{
this.ErrorMessage = exStorage.ToString();
}
catch (Exception ex)
{
this.ErrorMessage = ex.ToString();
}
return(toReturn);
}
public async Task <List <AzureStorageContainer> > GetContainers()
{
var list = new List <AzureStorageContainer>();
var prefix = string.Empty;
var continuationToken = new BlobContinuationToken();
var requestOptions = new BlobRequestOptions();
var cancelToken = new CancellationToken();
var opContext = new OperationContext();
var operationOutcome = await blobClient.ListContainersSegmentedAsync(prefix, ContainerListingDetails.All, 1000, continuationToken, requestOptions, opContext, cancelToken);
foreach (var item in operationOutcome.Results)
{
var container = new AzureStorageContainer();
container.Name = item.Name;
var accessLevel = await GetAccessLevel(container);
container.AccessLevel = new ContainerAccessLevel()
{
Code = accessLevel
};
list.Add(container);
}
return(list);
}
public static async Task <IEnumerable <CloudBlobContainer> > ListContainersAsync(string connectionString)
{
CloudStorageAccount.TryParse(connectionString, out CloudStorageAccount storageAccount);
if (storageAccount == null)
{
return(null);
}
CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
if (storageAccount == null)
{
Console.WriteLine("Connection string did not work");
}
BlobContinuationToken continuationToken = null;
var containers = new List <CloudBlobContainer>();
do
{
ContainerResultSegment response = await cloudBlobClient.ListContainersSegmentedAsync(continuationToken);
continuationToken = response.ContinuationToken;
containers.AddRange(response.Results);
} while (continuationToken != null);
return(containers);
}
public async Task UpdateDwhSchemaAsync()
{
BlobContinuationToken token = null;
while (true)
{
ContainerResultSegment containersResult = await _blobClient.ListContainersSegmentedAsync(token);
if (containersResult?.Results != null)
{
foreach (var container in containersResult.Results)
{
await ProcessContainerAsync(container);
}
}
token = containersResult?.ContinuationToken;
if (token == null)
{
break;
}
}
if (_forcedUpdate)
{
_forcedUpdate = false;
}
_log.Info("Dwh structure update is finished");
}
public async Task <CloudContainersModel> ListContainers()
{
CloudContainersModel containersList = new CloudContainersModel();
try
{
var member = User.Identity.Name;
MemberLicense ml = this.iMemberLicenseRepository.MyLicense(member);
if (CloudStorageAccount.TryParse(ml?.AzureSaConnectionString, out CloudStorageAccount storageAccount))
{
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
BlobContinuationToken continuationToken = null;
do
{
ContainerResultSegment resultSegment = await blobClient.ListContainersSegmentedAsync(continuationToken);
continuationToken = resultSegment.ContinuationToken;
containersList.AddRange(resultSegment.Results);
}while (continuationToken != null);
}
}
catch
{
}
return(containersList);
}
private async Task ClearOldContainers(CloudBlobClient client)
{
var token = new BlobContinuationToken();
var containers = await client.ListContainersSegmentedAsync(ContainerPrefix, token)
.ConfigureAwait(false);
var validContainerNames = GetContainerNames();
if (containers?.Results == null)
{
return;
}
// loop through all containers
var results = containers.Results.ToList();
foreach (var container in results)
{
if (container.Name.StartsWith(ContainerPrefix, StringComparison.OrdinalIgnoreCase))
{
if (validContainerNames.NextName != container.Name &&
validContainerNames.CurrentName != container.Name &&
validContainerNames.PreviousName != container.Name)
{
// Delete the container if it doesn't match the current container or padding windows
await container.DeleteAsync().ConfigureAwait(false);
}
}
}
}
private static async Task DownloadFilesAsync()
{
CloudBlobClient blobClient = GetCloudBlobClient();
// Retrieve the list of containers in the storage account. Create a directory and configure variables for use later.
BlobContinuationToken continuationToken = null;
List <CloudBlobContainer> containers = new List <CloudBlobContainer>();
do
{
var listingResult = await blobClient.ListContainersSegmentedAsync(continuationToken);
continuationToken = listingResult.ContinuationToken;
containers.AddRange(listingResult.Results);
}while (continuationToken != null);
var directory = Directory.CreateDirectory("download");
BlobResultSegment resultSegment = null;
Stopwatch time = Stopwatch.StartNew();
// download thee blob
try
{
List <Task> Tasks = new List <Task>();
// Iterate throung the containers
foreach (CloudBlobContainer container in containers)
{
do
{
// Return the blobs from the container lazily 10 at a time.
resultSegment = await container.ListBlobsSegmentedAsync("", true, BlobListingDetails.All, 10, continuationToken, null, null);
{
foreach (var blobItem in resultSegment.Results)
{
if (((CloudBlob)blobItem).Properties.BlobType == BlobType.BlockBlob)
{
// Get the blob and add a task to download the blob asynchronously from the storage account.
CloudBlockBlob blockBlob = container.GetBlockBlobReference(((CloudBlockBlob)blobItem).Name);
Console.WriteLine("Starting download of {0} from container {1}", blockBlob.Name, container.Name);
Tasks.Add(blockBlob.DownloadToFileAsync(directory.FullName + "\\" + blockBlob.Name, FileMode.Create, null, new BlobRequestOptions()
{
DisableContentMD5Validation = true, StoreBlobContentMD5 = false
}, null));
}
}
}
}while (continuationToken != null);
}
// Creates an asynchonous task that completes when all the downloads complete.
await Task.WhenAll(Tasks);
}
catch (Exception e)
{
Console.WriteLine("\nThe transfer is canceled: {0}", e.Message);
}
time.Stop();
Console.WriteLine("Download has been completed in {0} seconds. Press any key to continue", time.Elapsed.TotalSeconds.ToString());
Console.ReadLine();
}
public void Dispose()
{
CloudBlobClient blobClient = _storageAccount.CreateCloudBlobClient();
foreach (var testContainer in blobClient.ListContainersSegmentedAsync(TestArtifactPrefix, null).Result.Results)
{
testContainer.DeleteAsync();
}
}
private static async Task <CloudBlobContainer> GetContainerAsync(CloudBlobClient cloudBlobClient)
{
var containers = new List <CloudBlobContainer>();
ContainerResultSegment response = await cloudBlobClient.ListContainersSegmentedAsync(null);
containers.AddRange(response.Results);
return(containers.FirstOrDefault());
}
private async Task Clear(CloudBlobClient target, CancellationToken token)
{
var response = await target.ListContainersSegmentedAsync(null);
do
{
foreach (var sourceItem in response.Results.Where(x => string.IsNullOrWhiteSpace(Options.Object) || x.Name.EqualsCi(Options.Object)).Where(x => !x.Name.StartsWith("azure-")))
{
var targetItem = target.GetContainerReference(sourceItem.Name);
_logger.LogInformation($"Deleting {sourceItem.GetType().Name} '{sourceItem.Name}'...");
await targetItem.DeleteAsync();
}
response = await target.ListContainersSegmentedAsync(response.ContinuationToken);
}while (response.ContinuationToken != null && !token.IsCancellationRequested);
}
static async Task ListarContainers(CloudBlobClient blobClient)
{
var containers = await blobClient.ListContainersSegmentedAsync(null);
foreach (var item in containers.Results)
{
Console.WriteLine(item.Name);
}
}
static async Task ListaContainers(CloudBlobClient blobClient)
{
//listar containers
var containers = await blobClient.ListContainersSegmentedAsync(null);
//retorna paginado entao nesse caso poderia passar um novo token para retornar as demais informações
foreach (var container in containers.Results)
{
System.Console.WriteLine(container.Name);
}
}
protected override async Task <LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
var next = await client.ListContainersSegmentedAsync(continuationToken as BlobContinuationToken);
var result = new LoadMoreResult(next.Results.Where
(r =>
query.Filter == null ||
(r.Name.IndexOf(query.Filter, StringComparison.InvariantCultureIgnoreCase) >= 0)
).Select(r => new ContainerRecord(r) as object).ToList(), next.ContinuationToken);
return(result);
}
private async Task <List <CloudBlobContainer> > GetCloudBlobContainersAsync(CancellationToken cancellationToken)
{
var result = new List <CloudBlobContainer>();
ContainerResultSegment firstPage = await _client.ListContainersSegmentedAsync(null);
result.AddRange(firstPage.Results);
//todo: list more containers
return(result);
}
public void Dispose()
{
Host.Stop();
VerifyLockState("WebJobs.Internal.Blobs.Listener", LeaseState.Available, LeaseStatus.Unlocked).Wait();
CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient();
foreach (var testContainer in blobClient.ListContainersSegmentedAsync(TestArtifactPrefix, null).Result.Results)
{
testContainer.DeleteAsync().Wait();
}
}
public async Task <bool> IsAvailableAsync()
{
try
{
BlobContinuationToken continuationToken = null;
await blobClient.ListContainersSegmentedAsync(continuationToken);
return(true);
}
catch
{
return(false);
}
}
private async Task <IEnumerable <CloudBlobContainer> > ListContainersAsync()
{
BlobContinuationToken continuationToken = null;
var response = new List <CloudBlobContainer>();
do
{
var segment = await CloudBlobClient.ListContainersSegmentedAsync(continuationToken);
continuationToken = segment.ContinuationToken;
response.AddRange(segment.Results);
}while (continuationToken != null);
return(response.Where(o => o.Properties.PublicAccess == BlobContainerPublicAccessType.Container));
}
// list containers in storage account
public IEnumerable <CloudBlobContainer> ListContainers()
{
var blobContainers = new List <CloudBlobContainer>();
BlobContinuationToken blobContinuationToken = null;
do
{
var containerSegment = _blobClient.ListContainersSegmentedAsync(blobContinuationToken).GetAwaiter().GetResult();
blobContainers.AddRange(containerSegment.Results);
blobContinuationToken = containerSegment.ContinuationToken;
} while (blobContinuationToken != null);
return(blobContainers);
}
public async Task <IViewComponentResult> InvokeAsync()
{
CloudStorageAccount cloudStorageAccount = _storageUtility.Value.StorageAccount;
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();
var currentToken = new BlobContinuationToken();
List <string> categoriesContainerList = new List <string>();
var result = await cloudBlobClient.ListContainersSegmentedAsync(currentToken);
if (result.Results.Count() != 0)
{
categoriesContainerList = result.Results.Select(c => c.Name).ToList();
}
return(await Task.FromResult <IViewComponentResult>(View("Default", categoriesContainerList)));
}
public static async Task <List <CloudBlobContainer> > ListContainersAsync(this CloudBlobClient client)
{
BlobContinuationToken continuationToken = null;
List <CloudBlobContainer> results = new List <CloudBlobContainer>();
do
{
var response = await client.ListContainersSegmentedAsync(continuationToken);
continuationToken = response.ContinuationToken;
results.AddRange(response.Results);
}while (continuationToken != null);
return(results);
}
public async Task DisposeAsync()
{
await Host.StopAsync();
// $$$ reenalbe this
// VerifyLockState("WebJobs.Internal.Blobs.Listener", LeaseState.Available, LeaseStatus.Unlocked).Wait();
CloudBlobClient blobClient = StorageAccount.CreateCloudBlobClient();
foreach (var testContainer in (await blobClient.ListContainersSegmentedAsync(TestArtifactPrefix, null)).Results)
{
await testContainer.DeleteAsync();
}
}
protected override async Task Execute()
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(StorageConnectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
string blobPath = "";
Console.Clear();
Console.WriteLine("-----Add Blob-----");
Console.WriteLine($"Blob path:");
do
{
blobPath = Console.ReadLine().ToLower();
if (System.IO.File.Exists(blobPath))
{
Console.WriteLine();
Console.WriteLine("Select target container:");
ContainerResultSegment containers = await blobClient.ListContainersSegmentedAsync(null);
int counter = 1;
foreach (var container in containers.Results)
{
Console.WriteLine($"{counter++}) {container.Name}");
}
Console.Write("Selected container: ");
string itemNumberInput = Console.ReadLine();
if (int.TryParse(itemNumberInput, out int itemNumber) && itemNumber > 0 && itemNumber < containers.Results.Count() + 1)
{
var selectedContainer = containers.Results.ElementAt(itemNumber - 1);
CloudBlockBlob blob = selectedContainer.GetBlockBlobReference(Path.GetFileName(blobPath));
await blob.UploadFromFileAsync((blobPath));
Console.WriteLine($"Blob uri: {blob.Uri}");
await TextCopy.Clipboard.SetTextAsync(blob.Uri.ToString());
}
}
else
{
Console.WriteLine("File does not exist. Try again");
Console.SetCursorPosition(0, Console.CursorTop - 2);
}
} while (!System.IO.File.Exists(blobPath));
}