public void CloudStorageAccountDefaultStorageAccountWithHttp()
{
StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, false);
Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
new Uri(String.Format("http://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
new Uri(String.Format("http://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableEndpoint,
new Uri(String.Format("http://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.FileEndpoint,
new Uri(String.Format("http://{0}.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.BlobStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.FileStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
AccountsAreEqual(testAccount, cloudStorageAccount);
}
/// <inheritdoc />
public async Task <(Uri verifyUploadUri, Uri?displayUploadUri)> GenerateImageUploadUris(string entrantId,
bool generateDisplayUri, string verifyContainerName = "photos-verification",
string displayContainerName = "photos-display")
{
if (string.IsNullOrWhiteSpace(entrantId))
{
throw new ArgumentNullException(nameof(entrantId));
}
//Generate containers
var blobClient = new BlobContainerClient(_storageAccount.ToString(true), displayContainerName);
await blobClient.CreateIfNotExistsAsync(PublicAccessType.Blob).ConfigureAwait(false);
blobClient = new BlobContainerClient(_storageAccount.ToString(true), verifyContainerName);
await blobClient.CreateIfNotExistsAsync(PublicAccessType.None).ConfigureAwait(false);
var sasBuilder = new BlobSasBuilder
{
BlobContainerName = verifyContainerName,
BlobName = entrantId,
Resource = @"b",
ExpiresOn = DateTimeOffset.UtcNow.AddMinutes(5)
};
//Sets the permissions for the SAS token
sasBuilder.SetPermissions(BlobSasPermissions.Create | BlobSasPermissions.Write | BlobSasPermissions.Delete);
var credentials = new StorageSharedKeyCredential(_storageAccount.Credentials.AccountName,
_storageAccount.Credentials.ExportBase64EncodedKey());
//The constructed sas token
var verifyUploadSas = sasBuilder.ToSasQueryParameters(credentials);
//Uri builder for verify blob
var builder = new BlobUriBuilder(_storageAccount.BlobEndpoint)
{
BlobName = entrantId,
BlobContainerName = verifyContainerName,
AccountName = _storageAccount.Credentials.AccountName,
Sas = verifyUploadSas
};
var verifyUploadUri = builder.ToUri();
sasBuilder.BlobContainerName = displayContainerName;
builder.BlobContainerName = displayContainerName;
if (generateDisplayUri)
{
builder.Sas = sasBuilder.ToSasQueryParameters(credentials);
var displayUploadUri = builder.ToUri();
return(verifyUploadUri, displayUploadUri);
}
return(verifyUploadUri, null);
}
public void StartCrossAccountCopyWithMetaAndPropertiesTest()
{
if (lang == Language.PowerShell)
{
blobUtil.SetupTestContainerAndBlob();
}
else
{
blobUtil.SetupTestContainerAndBlob(blobNamePrefix: "blob");
}
try
{
CloudStorageAccount secondaryAccount = TestBase.GetCloudStorageAccountFromConfig("Secondary");
object destContext = null;
if (lang == Language.PowerShell)
{
destContext = PowerShellAgent.GetStorageContext(secondaryAccount.ToString(true));
}
else
{
destContext = secondaryAccount;
}
CloudBlobUtil destBlobUtil = new CloudBlobUtil(secondaryAccount);
string destContainerName = Utility.GenNameString("secondary");
CloudBlobContainer destContainer = destBlobUtil.CreateContainer(destContainerName);
AssertCopyBlobCrossContainer(blobUtil.Blob, destContainer, string.Empty, destContext);
destBlobUtil.RemoveContainer(destContainer.Name);
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
}
}
// GET: api/ToDoItemList
public IEnumerable <ToDoItem> Get(string owner)
{
CheckCallerId();
System.Diagnostics.Trace.TraceInformation("This is a specific trace message at the method level ToDoListController::Get(string owner)");
string accountName = "bobjacsilkroad2";
string keyValue = "7JSPQio+N6pSYGU2JKVcfqNbVMrmRVBSMPY14h36Vvb4IjG8Tvzw1vx1RkzYxOCjhubvFIx5volG/TJjfiGA3A==";
bool useHttps = true;
bool exportSecrets = true;
var storageCredentials = new StorageCredentials(accountName, keyValue);
var storageAccount = new CloudStorageAccount(storageCredentials, useHttps);
var connectionString = storageAccount.ToString(exportSecrets);
var tableClient = storageAccount.CreateCloudTableClient();
var cloudTable = tableClient.GetTableReference("insightsTest");
cloudTable.CreateIfNotExists();
System.Diagnostics.Trace.TraceInformation("Created reference to cloud storage table in ToDoListController::Get(string owner)");
var testEntity = new TestEntity("This is a test entity with value of " + Guid.NewGuid().ToString(), "bobjac");
var tableOperation = TableOperation.Insert(testEntity);
cloudTable.Execute(tableOperation);
System.Diagnostics.Trace.TraceInformation("Successfully executed insert operation in ToDoListController::Get(string owner)");
return(mockData.Values.Where(m => m.Owner == owner || owner == "*"));
}
public void GetContainerFromValidAndInvalidStorageContext()
{
CloudStorageAccount account1 = TestBase.GetCloudStorageAccountFromConfig();
string connectionString1 = account1.ToString(true);
string randomAccountName = Utility.GenNameString("account");
string randomAccountKey = Utility.GenNameString("key");
randomAccountKey = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(randomAccountKey));
string containerName = Utility.GenNameString("container");
try
{
CloudBlobContainer container1 = blobUtil.CreateContainer(containerName);
string cmd = String.Format("$context1 = new-azurestoragecontext -connectionstring '{0}';$context2 = new-azurestoragecontext -StorageAccountName '{1}' -StorageAccountKey '{2}';($context1, $context2)",
connectionString1, randomAccountName, randomAccountKey);
agent.UseContextParam = false;
((PowerShellAgent)agent).AddPipelineScript(cmd);
Test.Assert(!agent.GetAzureStorageContainer(containerName), Utility.GenComparisonData("Get-AzureStorageContainer using valid and invalid storage contexts", false));
Test.Assert(agent.Output.Count == 1, "valid storage context should return 1 container");
Test.Assert(agent.ErrorMessages.Count == 1, "invalid storage context should return error");
//the same error may output different error messages in different environments
bool expectedError = agent.ErrorMessages[0].StartsWith("The remote server returned an error: (502) Bad Gateway") ||
agent.ErrorMessages[0].StartsWith("The remote name could not be resolved") || agent.ErrorMessages[0].StartsWith("The operation has timed out");
Test.Assert(expectedError, "use invalid storage account should return 502 or could not be resolved exception or The operation has timed out, actully {0}", agent.ErrorMessages[0]);
}
finally
{
//TODO test the invalid storage account in subscription
blobUtil.RemoveContainer(containerName);
}
}
public static void TestClassInitialize(TestContext testContext)
{
Test.Info(string.Format("{0} Class Initialize", testContext.FullyQualifiedTestClassName));
Test.FullClassName = testContext.FullyQualifiedTestClassName;
StorageAccount = GetCloudStorageAccountFromConfig();
//init the blob helper for blob related operations
blobUtil = new CloudBlobUtil(StorageAccount);
queueUtil = new CloudQueueUtil(StorageAccount);
tableUtil = new CloudTableUtil(StorageAccount);
// import module
string moduleFilePath = Test.Data.Get("ModuleFilePath");
PowerShellAgent.ImportModule(moduleFilePath);
//set the default storage context
PowerShellAgent.SetStorageContext(StorageAccount.ToString(true));
random = new Random();
ContainerInitCount = blobUtil.GetExistingContainerCount();
QueueInitCount = queueUtil.GetExistingQueueCount();
TableInitCount = tableUtil.GetExistingTableCount();
}
public void GetCopyStateFromCrossAccountCopyTest()
{
CloudStorageAccount secondaryAccount = TestBase.GetCloudStorageAccountFromConfig("Secondary");
object destContext = PowerShellAgent.GetStorageContext(secondaryAccount.ToString(true));
CloudBlobUtil destBlobUtil = new CloudBlobUtil(secondaryAccount);
string destContainerName = Utility.GenNameString("secondary");
CloudBlobContainer destContainer = destBlobUtil.CreateContainer(destContainerName);
blobUtil.SetupTestContainerAndBlob();
//remove the same name container in source storage account, so we could avoid some conflicts.
blobUtil.RemoveContainer(destContainer.Name);
try
{
Test.Assert(agent.StartAzureStorageBlobCopy(blobUtil.Blob, destContainer.Name, string.Empty, destContext), "Start cross account copy should successed");
int expectedBlobCount = 1;
Test.Assert(agent.Output.Count == expectedBlobCount, String.Format("Expected get {0} copy blob, and actually it's {1}", expectedBlobCount, agent.Output.Count));
ICloudBlob destBlob = (ICloudBlob)agent.Output[0]["ICloudBlob"];
//make sure this context is different from the PowerShell.Context
object context = agent.Output[0]["Context"];
Test.Assert(PowerShellAgent.Context != context, "make sure you are using different context for cross account copy");
Test.Assert(agent.GetAzureStorageBlobCopyState(destBlob, context, true), "Get copy state in dest container should be successed.");
AssertFinishedCopyState(blobUtil.Blob.Uri);
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
destBlobUtil.RemoveContainer(destContainer.Name);
}
}
public static void TestClassInitialize(TestContext testContext)
{
Test.Info(string.Format("{0} Class Initialize", testContext.FullyQualifiedTestClassName));
Test.FullClassName = testContext.FullyQualifiedTestClassName;
//add the common initialization
if (StorageAccount == null)
{
StorageAccount = GetCloudStorageAccountFromConfig(useHttps: useHttps);
Test.Info("Got storage account from config: {0}", StorageAccount.ToString(true));
}
//init the blob helper for blob related operations
blobUtil = new CloudBlobUtil(StorageAccount);
queueUtil = new CloudQueueUtil(StorageAccount);
tableUtil = new CloudTableUtil(StorageAccount);
fileUtil = new CloudFileUtil(StorageAccount);
random = new Random();
SetCLIEnv(testContext);
if (null == CommandAgent)
{
CommandAgent = AgentFactory.CreateAgent(testContext.Properties);
}
}
public void CloudStorageAccountEndpointSuffixWithHttps()
{
const string TestEndpointSuffix = "fake.endpoint.suffix";
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(
string.Format(
"DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1};EndpointSuffix={2};",
TestBase.TargetTenantConfig.AccountName,
TestBase.TargetTenantConfig.AccountKey,
TestEndpointSuffix));
Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
new Uri(String.Format("https://{0}.blob.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
new Uri(String.Format("https://{0}.queue.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.TableEndpoint,
new Uri(String.Format("https://{0}.table.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.FileEndpoint,
new Uri(String.Format("https://{0}.file.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.BlobStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.blob.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.QueueStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.queue.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.TableStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.table.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
Assert.AreEqual(cloudStorageAccount.FileStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.file.{1}", TestBase.TargetTenantConfig.AccountName, TestEndpointSuffix)));
string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
AccountsAreEqual(testAccount, cloudStorageAccount);
}
/// <summary>
/// Gets connection string of the given storage service name.
/// </summary>
/// <param name="name">The storage service name</param>
/// <returns>The connection string</returns>
public string GetStorageServiceConnectionString(string name)
{
StorageServiceGetResponse storageService;
StorageAccountGetKeysResponse storageKeys;
try
{
storageService = StorageClient.StorageAccounts.Get(name);
storageKeys = StorageClient.StorageAccounts.GetKeys(name);
}
catch
{
throw new Exception(string.Format(Resources.StorageAccountNotFound, name));
}
Debug.Assert(storageService.ServiceName != null);
Debug.Assert(storageKeys != null);
StorageCredentials credentials = new StorageCredentials(
storageService.ServiceName,
storageKeys.PrimaryKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(
credentials,
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[0].ToString()),
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[1].ToString()),
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[2].ToString())
);
return(cloudStorageAccount.ToString(true));
}
public static void MyClassInitialize(TestContext testContext)
{
Trace.WriteLine("ClassInit");
Test.FullClassName = testContext.FullyQualifiedTestClassName;
StorageAccount = TestBase.GetCloudStorageAccountFromConfig();
//init the blob helper for blob related operations
BlobHelper = new CloudBlobHelper(StorageAccount);
// import module
string moduleFilePath = Test.Data.Get("ModuleFilePath");
if (moduleFilePath.Length > 0)
PowerShellAgent.ImportModule(moduleFilePath);
// $context = New-AzureStorageContext -ConnectionString ...
PowerShellAgent.SetStorageContext(StorageAccount.ToString(true));
BlockFilePath = Path.Combine(Test.Data.Get("TempDir"), FileUtil.GetSpecialFileName());
PageFilePath = Path.Combine(Test.Data.Get("TempDir"), FileUtil.GetSpecialFileName());
FileUtil.CreateDirIfNotExits(Path.GetDirectoryName(BlockFilePath));
FileUtil.CreateDirIfNotExits(Path.GetDirectoryName(PageFilePath));
// Generate block file and page file which are used for uploading
Helper.GenerateMediumFile(BlockFilePath, 1);
Helper.GenerateMediumFile(PageFilePath, 1);
}
public void GetCopyStateFromCrossAccountCopyTest()
{
CloudStorageAccount secondaryAccount = TestBase.GetCloudStorageAccountFromConfig("Secondary");
object destContext;
if (lang == Language.PowerShell)
{
destContext = PowerShellAgent.GetStorageContext(secondaryAccount.ToString(true));
}
else
{
destContext = secondaryAccount;
}
CloudBlobUtil destBlobUtil = new CloudBlobUtil(secondaryAccount);
string destContainerName = Utility.GenNameString("secondary");
CloudBlobContainer destContainer = destBlobUtil.CreateContainer(destContainerName);
if (lang == Language.PowerShell)
{
blobUtil.SetupTestContainerAndBlob();
}
else
{
blobUtil.SetupTestContainerAndBlob(blobNamePrefix: "blob");
}
//remove the same name container in source storage account, so we could avoid some conflicts.
if (!blobUtil.Blob.ServiceClient.BaseUri.Host.Equals(destContainer.ServiceClient.BaseUri.Host))
{
blobUtil.RemoveContainer(destContainer.Name);
}
try
{
Test.Assert(CommandAgent.StartAzureStorageBlobCopy(blobUtil.Blob, destContainer.Name, string.Empty, destContext), "Start cross account copy should succeed");
int expectedBlobCount = 1;
Test.Assert(CommandAgent.Output.Count == expectedBlobCount, String.Format("Expected get {0} copy blob, and actually it's {1}", expectedBlobCount, CommandAgent.Output.Count));
CloudBlob destBlob;
object context;
if (lang == Language.PowerShell)
{
destBlob = (CloudBlob)CommandAgent.Output[0]["ICloudBlob"];
//make sure this context is different from the PowerShell.Context
context = CommandAgent.Output[0]["Context"];
Test.Assert(PowerShellAgent.Context != context, "make sure you are using different context for cross account copy");
}
else
{
destBlob = StorageExtensions.GetBlobReferenceFromServer(destContainer, (string)CommandAgent.Output[0]["name"]);
context = destContext;
}
Test.Assert(CommandAgent.GetAzureStorageBlobCopyState(destBlob, context, true), "Get copy state in dest container should succeed.");
AssertFinishedCopyState(blobUtil.Blob.Uri);
}
finally
{
blobUtil.CleanupTestContainerAndBlob();
destBlobUtil.RemoveContainer(destContainer.Name);
}
}
private void AccountsAreEqual(CloudStorageAccount a, CloudStorageAccount b)
{
// endpoints are the same
Assert.AreEqual(a.BlobEndpoint, b.BlobEndpoint);
Assert.AreEqual(a.QueueEndpoint, b.QueueEndpoint);
Assert.AreEqual(a.TableEndpoint, b.TableEndpoint);
Assert.AreEqual(a.FileEndpoint, b.FileEndpoint);
// storage uris are the same
Assert.AreEqual(a.BlobStorageUri, b.BlobStorageUri);
Assert.AreEqual(a.QueueStorageUri, b.QueueStorageUri);
Assert.AreEqual(a.TableStorageUri, b.TableStorageUri);
Assert.AreEqual(a.FileStorageUri, b.FileStorageUri);
// seralized representatons are the same.
string aToStringNoSecrets = a.ToString();
string aToStringWithSecrets = a.ToString(true);
string bToStringNoSecrets = b.ToString(false);
string bToStringWithSecrets = b.ToString(true);
Assert.AreEqual(aToStringNoSecrets, bToStringNoSecrets, false);
Assert.AreEqual(aToStringWithSecrets, bToStringWithSecrets, false);
// credentials are the same
if (a.Credentials != null && b.Credentials != null)
{
Assert.AreEqual(a.Credentials.IsAnonymous, b.Credentials.IsAnonymous);
Assert.AreEqual(a.Credentials.IsSAS, b.Credentials.IsSAS);
Assert.AreEqual(a.Credentials.IsSharedKey, b.Credentials.IsSharedKey);
// make sure
if (!a.Credentials.IsAnonymous &&
a.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials &&
b.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials)
{
Assert.AreNotEqual(aToStringWithSecrets, bToStringNoSecrets, true);
}
}
else if (a.Credentials == null && b.Credentials == null)
{
return;
}
else
{
Assert.Fail("credentials mismatch");
}
}
private void connectionStringRoundtripHelper(string accountString)
{
CloudStorageAccount originalAccount = CloudStorageAccount.Parse(accountString);
CloudStorageAccount copiedAccount = CloudStorageAccount.Parse(originalAccount.ToString(true));
// make sure it round trips
this.AccountsAreEqual(originalAccount, copiedAccount);
}
public void CloudStorageAccountDefaultStorageAccountWithHttps()
{
StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, true);
Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
new Uri(String.Format("https://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
new Uri(String.Format("https://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableEndpoint,
new Uri(String.Format("https://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
// make sure it round trips
AccountsAreEqual(testAccount, cloudStorageAccount);
}
protected static void SetCLIEnv(TestContext testContext)
{
//add the language specific initialization
lang = AgentFactory.GetLanguage(testContext.Properties);
isMooncake = Utility.GetTargetEnvironment().Name == "AzureChinaCloud";
string mode = Test.Data.Get("IsResourceMode");
if (!string.IsNullOrEmpty(mode))
{
isResourceMode = bool.Parse(mode);
}
if (lang == Language.PowerShell)
{
if (isResourceMode)
{
PowerShellAgent.ImportModules(Constants.ResourceModulePaths);;
}
else
{
PowerShellAgent.ImportModules(Constants.ServiceModulePaths);
}
string snapInName = Test.Data.Get("PSSnapInName");
if (!string.IsNullOrWhiteSpace(snapInName))
{
PowerShellAgent.AddSnapIn(snapInName);
}
//set the default storage context
PowerShellAgent.SetStorageContext(StorageAccount.ToString(true));
}
else if (lang == Language.NodeJS)
{
NodeJSAgent.GetOSConfig(Test.Data);
// use ConnectionString parameter by default in function test
NodeJSAgent.AgentConfig.ConnectionString = StorageAccount.ToString(true);
FileUtil.GetOSConfig(Test.Data);
}
}
public void CloudStorageAccountAnonymousRoundtrip()
{
string accountString = "BlobEndpoint=http://blobs/";
Assert.AreEqual(accountString, CloudStorageAccount.Parse(accountString).ToString(true));
CloudStorageAccount account = new CloudStorageAccount(null, new Uri("http://blobs/"), null, null);
AccountsAreEqual(account, CloudStorageAccount.Parse(account.ToString(true)));
}
public void CloudStorageAccountDevelopmentStorageAccount()
{
CloudStorageAccount devstoreAccount = CloudStorageAccount.DevelopmentStorageAccount;
Assert.AreEqual(devstoreAccount.BlobEndpoint, new Uri("http://127.0.0.1:10000/devstoreaccount1"));
Assert.AreEqual(devstoreAccount.QueueEndpoint, new Uri("http://127.0.0.1:10001/devstoreaccount1"));
Assert.AreEqual(devstoreAccount.TableEndpoint, new Uri("http://127.0.0.1:10002/devstoreaccount1"));
string devstoreAccountToStringNoSecrets = devstoreAccount.ToString();
string devstoreAccountToStringWithSecrets = devstoreAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(devstoreAccountToStringWithSecrets);
// make sure it round trips
AccountsAreEqual(testAccount, devstoreAccount);
CloudStorageAccount acct;
if (!CloudStorageAccount.TryParse(devstoreAccountToStringWithSecrets, out acct))
{
Assert.Fail("Expected TryParse success.");
}
}
private void SetApplicationDiagnosticsSettings(
string name,
WebsiteDiagnosticOutput output,
bool setFlag,
Dictionary <DiagnosticProperties, object> properties = null)
{
Site website = GetWebsite(name);
using (HttpClient client = CreateHttpClient(website.Name))
{
DiagnosticsSettings diagnosticsSettings = GetApplicationDiagnosticsSettings(website.Name);
switch (output)
{
case WebsiteDiagnosticOutput.FileSystem:
diagnosticsSettings.AzureDriveTraceEnabled = setFlag;
diagnosticsSettings.AzureDriveTraceLevel = setFlag ?
(LogEntryType)properties[DiagnosticProperties.LogLevel] :
diagnosticsSettings.AzureDriveTraceLevel;
break;
case WebsiteDiagnosticOutput.StorageTable:
diagnosticsSettings.AzureTableTraceEnabled = setFlag;
if (setFlag)
{
const string storageTableName = "CLOUD_STORAGE_ACCOUNT";
string storageAccountName = (string)properties[DiagnosticProperties.StorageAccountName];
StorageService storageService = ServiceManagementChannel.GetStorageKeys(
SubscriptionId,
storageAccountName);
StorageCredentials credentials = new StorageCredentials(
storageAccountName,
storageService.StorageServiceKeys.Primary);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(credentials, false);
string connectionString = cloudStorageAccount.ToString(true);
AddAppSetting(website.Name, storageTableName, connectionString);
diagnosticsSettings.AzureTableTraceLevel = setFlag ?
(LogEntryType)properties[DiagnosticProperties.LogLevel] :
diagnosticsSettings.AzureTableTraceLevel;
}
break;
default:
throw new ArgumentException();
}
JObject json = new JObject();
json[UriElements.AzureDriveTraceEnabled] = diagnosticsSettings.AzureDriveTraceEnabled;
json[UriElements.AzureDriveTraceLevel] = JToken.FromObject(diagnosticsSettings.AzureDriveTraceLevel);
json[UriElements.AzureTableTraceEnabled] = diagnosticsSettings.AzureTableTraceEnabled;
json[UriElements.AzureTableTraceLevel] = JToken.FromObject(diagnosticsSettings.AzureTableTraceLevel);
client.PostAsJsonAsync(UriElements.DiagnosticsSettings, json, Logger);
}
}
protected CloudFileClient GetCloudFileClient(CloudStorageAccount cloudStorageAccount)
{
try
{
return(cloudStorageAccount.CreateCloudFileClient());
}
catch (Exception oExeption)
{
oExeption.Log($"GetCloudFileClient [refSD64] - {cloudStorageAccount.ToString()}");
return(null);
}
}
static Functions()
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("IoTStorageConnectionString"));
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
//DataPointTable = tableClient.GetTableReference("SumpPumpMonitorData");
string tableStorageConnectionString = storageAccount.ToString(true);
DataPointRepository = new DataPointRepository(tableStorageConnectionString);
DutyCycleRepository = new DutyCycleRepository(tableStorageConnectionString);
AlertRepository = new AlertRepository(tableStorageConnectionString);
}
/// <summary>
/// Create a storage context usign cloud storage account
/// </summary>
/// <param name="account">cloud storage account</param>
public AzureStorageContext(CloudStorageAccount account, string accountName = null, IAzureContext DefaultContext = null, DebugLogWriter logWriter = null)
{
StorageAccount = account;
TableStorageAccount = XTable.CloudStorageAccount.Parse(StorageAccount.ToString(true));
if (account.BlobEndpoint != null)
{
BlobEndPoint = account.BlobEndpoint.ToString();
}
if (account.TableEndpoint != null)
{
TableEndPoint = account.TableEndpoint.ToString();
}
if (account.QueueEndpoint != null)
{
QueueEndPoint = account.QueueEndpoint.ToString();
}
if (account.FileEndpoint != null)
{
FileEndPoint = account.FileEndpoint.ToString();
}
StorageAccountName = string.IsNullOrEmpty(accountName) ?
(account.Credentials is null ? null : account.Credentials.AccountName)
: accountName;
Context = this;
Name = String.Empty;
if (string.IsNullOrEmpty(StorageAccountName))
{
if (account.Credentials != null && account.Credentials.IsSAS)
{
StorageAccountName = "[SasToken]";
}
else if (account.Credentials != null && account.Credentials.IsToken)
{
StorageAccountName = "[AccessToken]";
}
else
{
StorageAccountName = "[Anonymous]";
}
}
if (account.Credentials != null && account.Credentials.IsToken)
{
Track2OauthToken = new AzureSessionCredential(DefaultContext, logWriter);
}
}
public ImageStore(string blobConnectionString, string containerName)
{
Console.WriteLine("Connection string: {0}", blobConnectionString);
Console.WriteLine("Container Connection string: {0}", containerName);
Console.WriteLine("library Connection string: {0}", libraryContainer);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(blobConnectionString);
Console.WriteLine("Connection string: {0}", blobConnectionString);
Console.WriteLine("Storage account: {0}", storageAccount.ToString());
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
libraryContainer = blobClient.GetContainerReference(containerName);
}
/// <summary>
/// Create a storage context usign cloud storage account
/// </summary>
/// <param name="account">cloud storage account</param>
public AzureStorageContext(CloudStorageAccount account, string accountName = null)
{
StorageAccount = account;
TableStorageAccount = XTable.CloudStorageAccount.Parse(StorageAccount.ToString(true));
if (account.BlobEndpoint != null)
{
BlobEndPoint = account.BlobEndpoint.ToString();
}
if (account.TableEndpoint != null)
{
TableEndPoint = account.TableEndpoint.ToString();
}
if (account.QueueEndpoint != null)
{
QueueEndPoint = account.QueueEndpoint.ToString();
}
if (account.FileEndpoint != null)
{
FileEndPoint = account.FileEndpoint.ToString();
}
StorageAccountName = string.IsNullOrEmpty(accountName) ? account.Credentials.AccountName : accountName;
Context = this;
Name = String.Empty;
if (string.IsNullOrEmpty(StorageAccountName))
{
if (account.Credentials.IsSAS)
{
StorageAccountName = "[SasToken]";
}
else if (account.Credentials.IsToken)
{
StorageAccountName = "[AccessToken]";
}
else
{
StorageAccountName = "[Anonymous]";
}
}
}
public static void MyClassInitialize(TestContext testContext)
{
Trace.WriteLine("ClassInit");
Test.FullClassName = testContext.FullyQualifiedTestClassName;
_StorageAccount = TestBase.GetCloudStorageAccountFromConfig();
// import module
string moduleFilePath = Test.Data.Get("ModuleFilePath");
if (moduleFilePath.Length > 0)
{
PowerShellAgent.ImportModule(moduleFilePath);
}
// $context = New-AzureStorageContext -ConnectionString ...
PowerShellAgent.SetStorageContext(_StorageAccount.ToString(true));
}
private async Task RegisterEventProcessorFactoryWithBlobCheckpointingAsync()
{
var storageCredentials = new StorageCredentials(
config.IoTHubConfig.CheckpointingConfig.StorageConfig.AzureBlobConfig.Account,
config.IoTHubConfig.CheckpointingConfig.StorageConfig.AzureBlobConfig.Key);
var storageAccount = new CloudStorageAccount(
storageCredentials,
config.IoTHubConfig.CheckpointingConfig.StorageConfig.AzureBlobConfig.EndpointSuffix,
config.IoTHubConfig.CheckpointingConfig.StorageConfig.AzureBlobConfig.Protocol == "https");
var iotHubConnectionBuilder = IotHubConnectionStringBuilder.Create(config.IoTHubConfig.ConnectionConfig.AccessConnString);
if (!Uri.TryCreate(config.IoTHubConfig.ConnectionConfig.HubEndpoint, UriKind.Absolute, out Uri endpoint))
{
if (!Uri.TryCreate($"sb://{config.IoTHubConfig.ConnectionConfig.HubEndpoint}/", UriKind.Absolute, out endpoint))
{
throw new InvalidConfigurationException($"Invalid IoTHub endpoint {config.IoTHubConfig.ConnectionConfig.HubEndpoint}");
}
}
var eventHubConntionStringBuilder = new EventHubsConnectionStringBuilder(
endpoint,
config.IoTHubConfig.ConnectionConfig.HubName,
iotHubConnectionBuilder.SharedAccessKeyName,
iotHubConnectionBuilder.SharedAccessKey);
eventProcessorHost = new EventProcessorHost(
config.IoTHubConfig.ConnectionConfig.HubName,
config.IoTHubConfig.StreamingConfig.ConsumerGroup,
eventHubConntionStringBuilder.ToString(),
storageAccount.ToString(true),
config.IoTHubConfig.CheckpointingConfig.StorageConfig.Namespace);
var options = new EventProcessorOptions
{
InitialOffsetProvider = InitialOffset,
MaxBatchSize = config.IoTHubConfig.StreamingConfig.ReceiveBatchSize,
ReceiveTimeout = config.IoTHubConfig.StreamingConfig.ReceiveTimeout,
InvokeProcessorAfterReceiveTimeout = true
};
await eventProcessorHost.RegisterEventProcessorFactoryAsync(processorFactory, options);
}
public void CloudStorageAccountEndpointSuffixWithBlob()
{
const string TestEndpointSuffix = "fake.endpoint.suffix";
const string AlternateBlobEndpoint = "http://blob.other.endpoint/";
CloudStorageAccount testAccount =
CloudStorageAccount.Parse(
string.Format(
"DefaultEndpointsProtocol=http;AccountName={0};AccountKey={1};EndpointSuffix={2};BlobEndpoint={3}",
TestBase.TargetTenantConfig.AccountName,
TestBase.TargetTenantConfig.AccountKey,
TestEndpointSuffix,
AlternateBlobEndpoint));
CloudStorageAccount cloudStorageAccount = CloudStorageAccount.Parse(testAccount.ToString(true));
// make sure it round trips
this.AccountsAreEqual(testAccount, cloudStorageAccount);
}
/// <summary>
/// Gets connection string of the given storage service name.
/// </summary>
/// <param name="name">The storage service name</param>
/// <returns>The connection string</returns>
public string GetStorageServiceConnectionString(string name)
{
StorageService storageService = GetStorageService(name);
Debug.Assert(storageService.StorageServiceKeys != null);
Debug.Assert(storageService.ServiceName != null);
StorageCredentials credentials = new StorageCredentials(
storageService.ServiceName,
storageService.StorageServiceKeys.Primary);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(
credentials,
General.CreateHttpsEndpoint(storageService.StorageServiceProperties.Endpoints[0]),
General.CreateHttpsEndpoint(storageService.StorageServiceProperties.Endpoints[1]),
General.CreateHttpsEndpoint(storageService.StorageServiceProperties.Endpoints[2])
);
return(cloudStorageAccount.ToString(true));
}
public void GetContainerFromMultipleStorageContext()
{
PowerShellAgent psAgent = (PowerShellAgent)CommandAgent;
CloudStorageAccount account1 = TestBase.GetCloudStorageAccountFromConfig();
CloudStorageAccount account2 = TestBase.GetCloudStorageAccountFromConfig("Secondary");
string connectionString1 = account1.ToString(true);
string connectionString2 = account2.ToString(true);
Test.Assert(connectionString1 != connectionString2, "Use two different connection string {0} != {1}", connectionString1, connectionString2);
CloudBlobUtil blobUtil1 = new CloudBlobUtil(account1);
CloudBlobUtil blobUtil2 = new CloudBlobUtil(account2);
string containerName = Utility.GenNameString("container");
bool savedParamValue = psAgent.UseContextParam;
try
{
CloudBlobContainer container1 = blobUtil1.CreateContainer(containerName);
CloudBlobContainer container2 = blobUtil2.CreateContainer(containerName);
int containerCount = 2;
string cmd = String.Format("$context1 = new-azurestoragecontext -connectionstring '{0}';$context2 = new-azurestoragecontext -connectionstring '{1}';($context1, $context2)", connectionString1, connectionString2);
psAgent.UseContextParam = false;
psAgent.AddPipelineScript(cmd);
Test.Assert(CommandAgent.GetAzureStorageContainer(containerName), Utility.GenComparisonData("Get-AzureStorageContainer using multiple storage contexts", true));
Test.Assert(CommandAgent.Output.Count == containerCount, String.Format("Want to retrieve {0} page blob, but retrieved {1} page blobs", containerCount, CommandAgent.Output.Count));
CommandAgent.OutputValidation(new List <CloudBlobContainer>()
{
container1, container2
});
}
finally
{
psAgent.UseContextParam = savedParamValue;
blobUtil1.RemoveContainer(containerName);
blobUtil2.RemoveContainer(containerName);
}
}
public string ToString(bool exportSecrets)
{
return(_cloudStorageAccount.ToString(exportSecrets));
}
public void CloudStorageAccountAnonymousRoundtrip()
{
string accountString = "BlobEndpoint=http://blobs/";
Assert.AreEqual(accountString, CloudStorageAccount.Parse(accountString).ToString(true));
CloudStorageAccount account = new CloudStorageAccount(null, new Uri("http://blobs/"), null, null);
AccountsAreEqual(account, CloudStorageAccount.Parse(account.ToString(true)));
}
public void CloudStorageAccountDefaultStorageAccountWithHttps()
{
StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, true);
Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
new Uri(String.Format("https://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
new Uri(String.Format("https://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableEndpoint,
new Uri(String.Format("https://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
// make sure it round trips
AccountsAreEqual(testAccount, cloudStorageAccount);
}
private void AccountsAreEqual(CloudStorageAccount a, CloudStorageAccount b)
{
// endpoints are the same
Assert.AreEqual(a.BlobEndpoint, b.BlobEndpoint);
Assert.AreEqual(a.QueueEndpoint, b.QueueEndpoint);
Assert.AreEqual(a.TableEndpoint, b.TableEndpoint);
// seralized representatons are the same.
string aToStringNoSecrets = a.ToString();
string aToStringWithSecrets = a.ToString(true);
string bToStringNoSecrets = b.ToString(false);
string bToStringWithSecrets = b.ToString(true);
Assert.AreEqual(aToStringNoSecrets, bToStringNoSecrets, false);
Assert.AreEqual(aToStringWithSecrets, bToStringWithSecrets, false);
// credentials are the same
if (a.Credentials != null && b.Credentials != null)
{
Assert.AreEqual(a.Credentials.IsAnonymous, b.Credentials.IsAnonymous);
Assert.AreEqual(a.Credentials.IsSAS, b.Credentials.IsSAS);
Assert.AreEqual(a.Credentials.IsSharedKey, b.Credentials.IsSharedKey);
// make sure
if (!a.Credentials.IsAnonymous &&
a.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials &&
b.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials)
{
Assert.AreNotEqual(aToStringWithSecrets, bToStringNoSecrets, true);
}
}
else if (a.Credentials == null && b.Credentials == null)
{
return;
}
else
{
Assert.Fail("credentials mismatch");
}
}
public void StorageCredentialsEmptyKeyValue()
{
string accountName = TestBase.TargetTenantConfig.AccountName;
string keyValue = TestBase.TargetTenantConfig.AccountKey;
string emptyKeyValueAsString = string.Empty;
string emptyKeyConnectionString = string.Format(CultureInfo.InvariantCulture, "DefaultEndpointsProtocol=https;AccountName={0};AccountKey=", accountName);
StorageCredentials credentials1 = new StorageCredentials(accountName, emptyKeyValueAsString);
Assert.AreEqual(accountName, credentials1.AccountName);
Assert.IsFalse(credentials1.IsAnonymous);
Assert.IsFalse(credentials1.IsSAS);
Assert.IsTrue(credentials1.IsSharedKey);
Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(credentials1.ExportKey()));
CloudStorageAccount account1 = new CloudStorageAccount(credentials1, true);
Assert.AreEqual(emptyKeyConnectionString, account1.ToString(true));
Assert.IsNotNull(account1.Credentials);
Assert.AreEqual(accountName, account1.Credentials.AccountName);
Assert.IsFalse(account1.Credentials.IsAnonymous);
Assert.IsFalse(account1.Credentials.IsSAS);
Assert.IsTrue(account1.Credentials.IsSharedKey);
Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account1.Credentials.ExportKey()));
CloudStorageAccount account2 = CloudStorageAccount.Parse(emptyKeyConnectionString);
Assert.AreEqual(emptyKeyConnectionString, account2.ToString(true));
Assert.IsNotNull(account2.Credentials);
Assert.AreEqual(accountName, account2.Credentials.AccountName);
Assert.IsFalse(account2.Credentials.IsAnonymous);
Assert.IsFalse(account2.Credentials.IsSAS);
Assert.IsTrue(account2.Credentials.IsSharedKey);
Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account2.Credentials.ExportKey()));
CloudStorageAccount account3;
bool isValidAccount3 = CloudStorageAccount.TryParse(emptyKeyConnectionString, out account3);
Assert.IsTrue(isValidAccount3);
Assert.IsNotNull(account3);
Assert.AreEqual(emptyKeyConnectionString, account3.ToString(true));
Assert.IsNotNull(account3.Credentials);
Assert.AreEqual(accountName, account3.Credentials.AccountName);
Assert.IsFalse(account3.Credentials.IsAnonymous);
Assert.IsFalse(account3.Credentials.IsSAS);
Assert.IsTrue(account3.Credentials.IsSharedKey);
Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account3.Credentials.ExportKey()));
StorageCredentials credentials2 = new StorageCredentials(accountName, keyValue);
Assert.AreEqual(accountName, credentials2.AccountName);
Assert.IsFalse(credentials2.IsAnonymous);
Assert.IsFalse(credentials2.IsSAS);
Assert.IsTrue(credentials2.IsSharedKey);
Assert.AreEqual(keyValue, Convert.ToBase64String(credentials2.ExportKey()));
credentials2.UpdateKey(emptyKeyValueAsString, null);
Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(credentials2.ExportKey()));
#if !WINDOWS_RT
byte[] emptyKeyValueAsByteArray = new byte[0];
StorageCredentials credentials3 = new StorageCredentials(accountName, keyValue);
Assert.AreEqual(accountName, credentials3.AccountName);
Assert.IsFalse(credentials3.IsAnonymous);
Assert.IsFalse(credentials3.IsSAS);
Assert.IsTrue(credentials3.IsSharedKey);
Assert.AreEqual(keyValue, Convert.ToBase64String(credentials3.ExportKey()));
credentials3.UpdateKey(emptyKeyValueAsByteArray, null);
Assert.AreEqual(Convert.ToBase64String(emptyKeyValueAsByteArray), Convert.ToBase64String(credentials3.ExportKey()));
#endif
}
public void CloudStorageAccountDefaultStorageAccountWithHttp()
{
StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, false);
Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
new Uri(String.Format("http://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
new Uri(String.Format("http://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableEndpoint,
new Uri(String.Format("http://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.FileEndpoint,
new Uri(String.Format("http://{0}.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.BlobStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.QueueStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.TableStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
Assert.AreEqual(cloudStorageAccount.FileStorageUri.SecondaryUri,
new Uri(String.Format("http://{0}-secondary.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
AccountsAreEqual(testAccount, cloudStorageAccount);
}
/// <summary>
/// Gets connection string of the given storage service name.
/// </summary>
/// <param name="name">The storage service name</param>
/// <returns>The connection string</returns>
public string GetStorageServiceConnectionString(string name)
{
StorageServiceGetResponse storageService;
StorageAccountGetKeysResponse storageKeys;
try
{
storageService = StorageClient.StorageAccounts.Get(name);
storageKeys = StorageClient.StorageAccounts.GetKeys(name);
}
catch
{
throw new Exception(string.Format(Resources.StorageAccountNotFound, name));
}
Debug.Assert(storageService.ServiceName != null);
Debug.Assert(storageKeys != null);
StorageCredentials credentials = new StorageCredentials(
storageService.ServiceName,
storageKeys.PrimaryKey);
CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(
credentials,
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[0].ToString()),
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[1].ToString()),
General.CreateHttpsEndpoint(storageService.Properties.Endpoints[2].ToString())
);
return cloudStorageAccount.ToString(true);
}
