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); }