protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpResponseMessage responseMessage = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (IsProviderNotRegistereError(responseMessage))
{
var providerName = GetProviderName(request.RequestUri);
if (!string.IsNullOrEmpty(providerName) && !registeredProviders.Contains(providerName))
{
// Force dispose for response messages to reclaim the used socket connection.
responseMessage.Dispose();
registeredProviders.Add(providerName);
try
{
ResourceManagementClient = createClient();
writeDebug(string.Format(Resources.ResourceProviderRegisterAttempt, providerName));
ResourceManagementClient.Providers.Register(providerName);
Provider provider = null;
short retryCount = 0;
do
{
if (retryCount++ > RetryCount)
{
throw new TimeoutException();
}
provider = ResourceManagementClient.Providers.Get(providerName).Provider;
TestMockSupport.Delay(1000);
} while (provider.RegistrationState != RegistrationState.Registered.ToString());
writeDebug(string.Format(Resources.ResourceProviderRegisterSuccessful, providerName));
}
catch (Exception e)
{
writeDebug(string.Format(Resources.ResourceProviderRegisterFailure, providerName, e.Message));
// Ignore RP registration errors.
}
responseMessage = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
}
return responseMessage;
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation", "Name");
var deploymentName = request.DataStore.GetValue("DeploymentName");
var storageAccountName = request.DataStore.GetValue("StorageAccountName");
var logicAppName = request.DataStore.GetValue("LogicAppName");
var apiKeyTopics = request.DataStore.GetAllValues("AzureMLKey")[0];
var apiKeyImages = request.DataStore.GetAllValues("AzureMLKey")[1];;
var apiKeyEntities = request.DataStore.GetAllValues("AzureMLKey")[2];;
var apiUrlTopics = request.DataStore.GetAllValues("AzureMLUrl")[0];
var apiUrlImages = request.DataStore.GetAllValues("AzureMLUrl")[1];
var apiUrlEntities = request.DataStore.GetAllValues("AzureMLUrl")[2];
var param = new AzureArmParameterGenerator();
param.AddStringParam("resourcegroup", resourceGroup);
param.AddStringParam("subscription", subscription);
//param.AddStringParam("storageaccountname", storageAccountName);
param.AddStringParam("logicappname", logicAppName);
param.AddStringParam("apikeytopics", apiKeyTopics);
param.AddStringParam("apikeyimages", apiKeyImages);
param.AddStringParam("apikeyentities", apiKeyEntities);
param.AddStringParam("apiurltopics", apiUrlTopics);
param.AddStringParam("apiurlentities", apiUrlEntities);
param.AddStringParam("apiurlimages", apiUrlImages);
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/AzureArm/AzureMLSchedulerLogicApp.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = await client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = await client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
return(new ActionResponse(ActionStatus.Success, deploymentItem));
}
public void DatabaseAccountCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = CosmosDBTestUtilities.CreateResourceGroup(resourcesClient);
string databaseAccountName = "db993812";
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: "East US"));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = "EAST US",
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = locations,
IpRangeFilter = "192.168.1.0/24,10.0.0.0/24",
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = false
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(databaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
DatabaseAccountGetResults readDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(readDatabaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, readDatabaseAccount.Name);
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = "EAST US",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = locations,
IpRangeFilter = "192.168.3.0/24,110.0.0.0/24",
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = true
};
DatabaseAccountGetResults updatedDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(updatedDatabaseAccount, databaseAccountUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
IEnumerable <DatabaseAccountGetResults> databaseAccounts = cosmosDBManagementClient.DatabaseAccounts.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccounts);
IEnumerable <DatabaseAccountGetResults> databaseAccountsByResourceGroupName = cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountsByResourceGroupName);
DatabaseAccountListKeysResult databaseAccountListKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListKeysResult.PrimaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.PrimaryReadonlyMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryReadonlyMasterKey);
DatabaseAccountListConnectionStringsResult databaseAccountListConnectionStringsResult = cosmosDBManagementClient.DatabaseAccounts.ListConnectionStringsWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListConnectionStringsResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountGetReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.GetReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountGetReadOnlyKeysResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountListReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListReadOnlyKeysResult);
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primaryReadonly"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondaryReadonly"
});
DatabaseAccountListKeysResult databaseAccountListRegeneratedKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
bool isNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
Assert.True(isNameExists);
cosmosDBManagementClient.DatabaseAccounts.DeleteWithHttpMessagesAsync(resourceGroupName, databaseAccountName);
}
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string azureToken = request.DataStore.GetJson("AzureTokenKV", "access_token");
string refreshToken = request.DataStore.GetJson("AzureTokenKV", "refresh_token");
string crmToken = request.DataStore.GetJson("MsCrmToken", "access_token");
string resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string vaultName = request.DataStore.GetValue("VaultName") ?? "bpstv-" + RandomGenerator.GetRandomLowerCaseCharacters(12);
string secretName = request.DataStore.GetValue("SecretName") ?? "bpst-mscrm-secret";
string connectionString = request.DataStore.GetAllValues("SqlConnectionString")[0];
string organizationId = request.DataStore.GetValue("OrganizationId");
_subscriptionId = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
RetrieveKVToken(refreshToken, request.Info.WebsiteRootUrl, request.DataStore);
RetrieveGraphToken(refreshToken, request.Info.WebsiteRootUrl, request.DataStore);
SubscriptionCloudCredentials credentials = new TokenCloudCredentials(_subscriptionId, azureToken);
// Get user's object ID and tenant ID (in the Azure subscription where the vault is created)
string oid = null;
int propCount = 0;
foreach (var c in new JwtSecurityToken(azureToken).Claims)
{
switch (c.Type.ToLowerInvariant())
{
case "oid":
oid = c.Value;
propCount++;
break;
case "tid":
_tenantId = c.Value;
propCount++;
break;
}
if (propCount >= 2)
{
break;
}
}
// Get user's tenant ID in the CRM implicit subscription
string crmtenantId = null;
foreach (var c in new JwtSecurityToken(crmToken).Claims)
{
if (c.Type.EqualsIgnoreCase("tid"))
{
crmtenantId = c.Value;
break;
}
}
try
{
TokenCredentials credentialsKv = new TokenCredentials(azureToken);
using (KeyVaultManagementClient client = new KeyVaultManagementClient(credentialsKv))
{
client.SubscriptionId = _subscriptionId;
// Check if a vault already exists
var vaults = client.Vaults.ListByResourceGroup(resourceGroup);
foreach (var v in client.Vaults.ListByResourceGroup(resourceGroup))
{
if (v.Name.EqualsIgnoreCase(vaultName))
{
client.Vaults.Delete(resourceGroup, vaultName);
break;
}
}
// Create the vault
string vaultUrl = null;
using (ResourceManagementClient resourceClient = new ResourceManagementClient(credentials))
{
// Set properties
VaultProperties p = new VaultProperties()
{
Sku = new Sku(SkuName.Standard),
TenantId = new Guid(_tenantId),
AccessPolicies = new List <AccessPolicyEntry>()
};
// Access policy for the owner
AccessPolicyEntry apeOwner = new AccessPolicyEntry();
apeOwner.Permissions = new Permissions(new[] { "get", "create", "delete", "list", "update", "import", "backup", "restore" }, new[] { "all" }, new[] { "all" });
apeOwner.TenantId = p.TenantId;
apeOwner.ObjectId = oid;
p.AccessPolicies.Add(apeOwner);
// Access policy for the CRM exporter
AccessPolicyEntry ape = new AccessPolicyEntry();
ape.Permissions = new Permissions(null, new[] { "get" });
ape.TenantId = p.TenantId;
ape.ObjectId = GetCrmConnectorObjectID(_graphToken, _tenantId).Result;
p.AccessPolicies.Add(ape);
VaultCreateOrUpdateParameters vaultParams = new VaultCreateOrUpdateParameters()
{
Location = resourceClient.ResourceGroups.Get(resourceGroup).ResourceGroup.Location,
Properties = p
};
Vault vault = client.Vaults.CreateOrUpdate(resourceGroup, vaultName, vaultParams);
vaultUrl = vault.Properties.VaultUri;
Thread.Sleep(15000); // The vault DNS entry isn't there immediatly
}
// Create the secret
KeyVaultClient kvClient = new KeyVaultClient(new TokenCredentials(_kvToken));
SecretBundle secret = await kvClient.SetSecretAsync(vaultUrl,
secretName,
connectionString,
new Dictionary <string, string>() { { organizationId, crmtenantId } },
null /* Do I need to set a content type? */,
new SecretAttributes()
{
Enabled = true
});
request.DataStore.AddToDataStore("KeyVault", secret.Id, DataStoreType.Private);
}
}
catch (Exception)
{
throw;
}
//Log kv name
request.Logger.LogResource(request.DataStore, vaultName,
DeployedResourceType.KeyVault, CreatedBy.BPST, DateTime.UtcNow.ToString("o"));
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject(), true));
}
public DSResource convertToDSResource(ResourceManagementClient client, ResourceObject resource,
string[] loadedAttributes, bool includePermission, ResourceOption option, bool deepResolve = true)
{
DSResource dsResource = new DSResource
{
DisplayName = resource.DisplayName,
ObjectID = resource.ObjectID.Value,
ObjectType = resource.ObjectTypeName,
HasPermissionHints = resource.HasPermissionHints
};
List <RmAttribute> attributeDef = getAttributeDefinition(resource.ObjectTypeName, option.CultureKey, option.ConnectionInfo.EncryptionKey);
Dictionary <string, DSAttribute> attributes = new Dictionary <string, DSAttribute>();
foreach (string attributeName in loadedAttributes)
{
if (resource.Attributes.ContainsAttribute(attributeName))
{
AttributeValue attValue = resource.Attributes[attributeName];
if (attValue.Attribute.SystemName.Equals("ObjectID") || attValue.Attribute.SystemName.Equals("ObjectType"))
{
continue;
}
DSAttribute dsAttribute = new DSAttribute
{
Description = attValue.Attribute.Description,
DisplayName = attValue.Attribute.DisplayName,
IsMultivalued = attValue.Attribute.IsMultivalued,
IsReadOnly = attValue.Attribute.IsReadOnly,
IsRequired = attValue.Attribute.IsRequired,
Regex = attValue.Attribute.Regex,
SystemName = attValue.Attribute.SystemName,
Type = attValue.Attribute.Type.ToString(),
IsNull = attValue.IsNull,
PermissionHint = attValue.PermissionHint.ToString(),
Value = attValue.Value,
Values = attValue.Values.ToList()
};
if (attributeDef != null)
{
RmAttribute attr = attributeDef.FirstOrDefault(a => a.Name.Equals(attValue.AttributeName));
if (attr != null)
{
dsAttribute.DisplayName = attr.DisplayName;
dsAttribute.Description = attr.Description;
}
}
if (!dsAttribute.IsNull && dsAttribute.Type.Equals("Reference"))
{
dsAttribute.Value = attValue.Attribute.IsMultivalued ?
attValue.StringValues.FirstOrDefault() : attValue.StringValue;
dsAttribute.Values = attValue.Attribute.IsMultivalued ?
attValue.StringValues.ToList <object>() : new List <object>()
{
attValue.StringValue
};
if (!string.IsNullOrEmpty(dsAttribute.Value.ToString()) && deepResolve && option.ResolveID)
{
if (dsAttribute.IsMultivalued)
{
foreach (string value in attValue.StringValues)
{
ResourceObject resolvedObject = client.GetResource(
value, option.AttributesToResolve, includePermission);
dsAttribute.ResolvedValues.Add(convertToDSResource(client,
resolvedObject, option.AttributesToResolve, includePermission, option, option.DeepResolve));
}
}
else
{
ResourceObject resolvedObject = client.GetResource(
attValue.StringValue, option.AttributesToResolve, includePermission);
dsAttribute.ResolvedValue = convertToDSResource(client,
resolvedObject, option.AttributesToResolve, includePermission, option, option.DeepResolve);
}
}
}
attributes.Add(attValue.AttributeName, dsAttribute);
}
}
dsResource.Attributes = attributes;
return(dsResource);
}
public static string GetLocationFromProvider(this ResourceManagementClient resourceManagementClient)
{
return("westus2");
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetValue("SqlLocation") ?? "westus";
var databaseTier = request.DataStore.GetValue("SqlSku") ?? "S1";
string server = request.DataStore.GetJson("SqlCredentials").SelectToken("Server")?.ToString();
string user = request.DataStore.GetJson("SqlCredentials").SelectToken("User")?.ToString();
string password = request.DataStore.GetJson("SqlCredentials").SelectToken("Password")?.ToString();
var database = request.DataStore.GetJson("SqlCredentials").SelectToken("Database")?.ToString();
string serverWithoutExtension = server.Replace(".database.windows.net", string.Empty);
var param = new AzureArmParameterGenerator();
param.AddStringParam("SqlServerName", serverWithoutExtension);
param.AddStringParam("SqlDatabaseName", database);
param.AddStringParam("Username", user);
param.AddParameter("Password", "securestring", password);
param.AddStringParam("Sku", databaseTier);
param.AddStringParam("SqlLocation", location);
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.ControllerModel.SiteCommonFilePath, "Service/Arm/sqlserveranddatabase.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
string deploymentName = "SqlDatabaseDeployment";
var validate = await client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
if (!validate.IsValid)
{
return(new ActionResponse(
ActionStatus.Failure,
JsonUtility.GetJObjectFromObject(validate),
null,
DefaultErrorCodes.DefaultErrorCode,
$"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = await client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
// Wait for deployment
while (true)
{
Thread.Sleep(5000);
var status = await client.Deployments.GetAsync(resourceGroup, deploymentName, new CancellationToken());
var operations = await client.DeploymentOperations.ListAsync(resourceGroup, deploymentName, new DeploymentOperationsListParameters());
var provisioningState = status.Deployment.Properties.ProvisioningState;
if (provisioningState == "Accepted" || provisioningState == "Running")
{
continue;
}
if (provisioningState == "Succeeded")
{
break;
}
var operation = operations.Operations.First(p => p.Properties.ProvisioningState == ProvisioningState.Failed);
var operationFailed = await client.DeploymentOperations.GetAsync(resourceGroup, deploymentName, operation.OperationId);
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(operationFailed), null, DefaultErrorCodes.DefaultErrorCode, operationFailed.Operation.Properties.StatusMessage));
}
SqlCredentials credentials = new SqlCredentials()
{
Server = server,
Username = user,
Password = password,
Authentication = SqlAuthentication.SQL,
Database = database
};
var connectionStringResponse = SqlUtility.GetConnectionString(credentials);
return(new ActionResponse(ActionStatus.Success, JsonUtility.CreateJObjectWithValueFromObject(connectionStringResponse), true));
}
/// <summary>
/// Lazy creation of a single instance of a resoures client
/// </summary>
private ResourceManagementClient GetCurrentResourcesClient()
{
ResourceManagementClient resourcesClient = AzureSession.Instance.ClientFactory.CreateArmClient <ResourceManagementClient>(Context, AzureEnvironment.Endpoint.ResourceManager);
return(resourcesClient);
}
public RedisCacheClient(IAzureContext context)
{
_client = AzureSession.Instance.ClientFactory.CreateArmClient <RedisManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_insightsClient = AzureSession.Instance.ClientFactory.CreateClient <InsightsManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_resourceManagementClient = AzureSession.Instance.ClientFactory.CreateClient <ResourceManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public async Task RestorableSqlTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler1);
DatabaseAccountGetResults databaseAccount = await cosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, sourceDatabaseAccountName);
RestorableDatabaseAccountGetResult restorableDatabaseAccount = (await cosmosDBManagementClient.RestorableDatabaseAccounts.GetByLocationAsync(location, sourceDatabaseAccountInstanceId));
Assert.Equal(databaseAccount.InstanceId, restorableDatabaseAccount.Name);
Assert.Equal(databaseAccount.Name, restorableDatabaseAccount.AccountName);
Assert.Equal(ApiType.Sql, restorableDatabaseAccount.ApiType);
Assert.Equal(3, restorableDatabaseAccount.RestorableLocations.Count);
foreach (var location in restorableDatabaseAccount.RestorableLocations)
{
Assert.NotNull(location.CreationTime);
// Assert.Null(location.DeletionTime);
Assert.False(string.IsNullOrEmpty(location.LocationName));
Assert.False(string.IsNullOrEmpty(location.RegionalDatabaseAccountInstanceId));
}
List <RestorableSqlDatabaseGetResult> restorableSqlDatabases =
(await cosmosDBManagementClient.RestorableSqlDatabases.ListAsync(location, restorableDatabaseAccount.Name)).ToList();
RestorableSqlDatabaseGetResult restorableSqlDatabase = restorableSqlDatabases.First();
Assert.Equal(2, restorableSqlDatabases.Count());
string dbRid = restorableSqlDatabase.Resource.OwnerResourceId;
List <RestorableSqlContainerGetResult> restorableSqlContainers =
(await cosmosDBManagementClient.RestorableSqlContainers.ListAsync(location, restorableDatabaseAccount.Name, dbRid)).ToList();
Assert.Equal(2, restorableSqlContainers.Count());
List <DatabaseRestoreResource> restorableSqlResources =
(await cosmosDBManagementClient.RestorableSqlResources.ListAsync(location, restorableDatabaseAccount.Name, location, restoreTimestamp.ToString())).ToList();
DatabaseRestoreResource databaseRestoreResource1 = new DatabaseRestoreResource()
{
DatabaseName = "database1",
CollectionNames = new List <string>()
{
"container1", "container2"
}
};
DatabaseRestoreResource databaseRestoreResource2 = new DatabaseRestoreResource()
{
DatabaseName = "databaseA",
CollectionNames = new List <string>()
};
List <DatabaseRestoreResource> resources = new List <DatabaseRestoreResource>()
{
databaseRestoreResource1,
databaseRestoreResource2
};
ValidateDatabaseRestoreResource(resources, restorableSqlResources);
}
}
public static async Task RunSample(string tenantId, string clientId, string secret, string subscriptionId)
{
// Build the service credentials and Azure Resource Manager clients
var serviceCreds = await ApplicationTokenProvider.LoginSilentAsync(tenantId, clientId, secret);
var resourceClient = new ResourceManagementClient(serviceCreds);
resourceClient.SubscriptionId = subscriptionId;
var resourceGroupName = "sdktestrg";
var location = "northeurope";
var templateFileLocation = Path.GetFullPath("template.json");
// Create the resource group
Write("Creating resource group: {0}", resourceGroupName);
resourceClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup {
Location = location
});
Write(Environment.NewLine);
var templateString = File.ReadAllText(Path.GetFullPath("template_params.json"));
var templateParamsObj = JObject.Parse(templateString)["parameters"];
var templateParams = templateParamsObj.ToObject <Dictionary <string, Dictionary <string, object> > >();
Write("{0}", JsonConvert.SerializeObject(templateParams));
Write("Building the deployment from a json file template from parameters");
var deployParams = new Deployment
{
Properties = new DeploymentProperties
{
Template = JObject.Parse(File.ReadAllText(templateFileLocation)),
Parameters = templateParams,
Mode = DeploymentMode.Incremental
}
};
var sshPubLocation = Path.Combine(@"c:\users", Environment.GetEnvironmentVariable("USERNAME"), ".ssh", "id_rsa.pub");
if (File.Exists(sshPubLocation))
{
Write("Found SSH public key in {0}.", sshPubLocation);
var pubKey = File.ReadAllText(sshPubLocation);
Write("Using public key: {0}", pubKey);
templateParams.Add("sshKeyData", new Dictionary <string, object> {
{ "value", pubKey }
});
}
else
{
Write("We could not find a RSA public key in {0}. Please create a public key and place it there.", sshPubLocation);
return;
}
Write("Creating deployment named {0} in {1} with template {2}", resourceGroupName, location, templateFileLocation);
var groupParams = new ResourceGroup {
Location = location
};
var deployResult = resourceClient.Deployments.CreateOrUpdate(resourceGroupName, "sample-deploy", deployParams);
Write(Environment.NewLine);
Write("Press any key to continue and delete the sample resources");
Console.ReadLine();
Write("Deleting resource group {0}", resourceGroupName);
resourceClient.ResourceGroups.Delete(resourceGroupName);
}
public void InitializeClient()
{
this.client = new ResourceManagementClient();
}
public void InitializeClientWithCredentials()
{
// Set the credentials that this specific instance of the resource management client will use
System.Net.NetworkCredential creds = new System.Net.NetworkCredential("username2", "password2");
this.specifiedCredentialClient = new ResourceManagementClient(creds);
}
public ActionResponse WaitForDeployment(string resourceGroup, string deploymentName, ResourceManagementClient client)
{
while (true)
{
Thread.Sleep(5000);
var status = client.Deployments.GetAsync(resourceGroup, deploymentName, new CancellationToken()).Result;
var operations = client.DeploymentOperations.ListAsync(resourceGroup, deploymentName, new DeploymentOperationsListParameters(), new CancellationToken()).Result;
var provisioningState = status.Deployment.Properties.ProvisioningState;
if (provisioningState == "Accepted" || provisioningState == "Running")
{
continue;
}
if (provisioningState == "Succeeded")
{
return(new ActionResponse(ActionStatus.Success, operations));
}
var operation = operations.Operations.First(p => p.Properties.ProvisioningState == ProvisioningState.Failed);
var operationFailed = client.DeploymentOperations.GetAsync(resourceGroup, deploymentName, operation.OperationId, new CancellationToken()).Result;
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(operationFailed), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{operationFailed.Operation.Properties.StatusMessage} Details:{operationFailed.Operation.Properties.Response.Content}"));
}
}
//public static string storageAccountName = "yustorageaccount";
static void Main(string[] args)
{
AUTH auth = new AUTH();
IAzure azure = auth.azure;
IEnumerable <IResourceGroup> resourceLsits = azure.ResourceGroups.List();
//输出全部资源组信息
foreach (IResourceGroup rs in resourceLsits)
{
Console.WriteLine("资源组信息：" + rs.Name);
}
//创建存储账户
//string storageAccountName = "yustorageaccount"
//azure.StorageAccounts.Define(storageAccountName)
// .WithRegion(Region.ChinaNorth)
// .WithExistingResourceGroup(resourceGroupName)
// .WithTag("key", "value")
// .WithSku(StorageAccountSkuType.Standard_LRS)
// .Create();
//创建服务总线命名空间
//string servicebusNamespace = "yuservicebusnamespace";
//azure.ServiceBusNamespaces.Define(servicebusNamespace)
// .WithRegion(Region.ChinaNorth)
// .WithNewResourceGroup(resourceGroupName)
// .WithTag("key", "value")
// .WithSku(NamespaceSku.Standard)
// .Create();
//删除资源组下服务总线的命名空间
//IEnumerable<IServiceBusNamespace> namespaces = azure.ServiceBusNamespaces.ListByResourceGroup(resourceGroupName);
//string serviceNamespaceId = null;
//foreach (IServiceBusNamespace i in namespaces)
//{
// Console.WriteLine(i.Id);
// serviceNamespaceId = i.Id;
// if (serviceNamespaceId != null)
// {
// //删除命名空间
// //azure.ServiceBusNamespaces.DeleteById(serviceNamespaceId);
// //Console.WriteLine("Delete service bus namespace success!");
// //删除具体的queue
// IQueues queues = i.Queues;
// IEnumerable<IQueue> listQueue = queues.List();
// foreach (IQueue queue in listQueue)
// {
// queues.DeleteByName(queue.Name);
// }
// }
//}
//azure.ServiceBusNamespaces.Define(servicebusNamespace)
// .WithRegion(Region.ChinaNorth)
// .WithExistingResourceGroup(resourceGroupName)
// .WithNewQueue("yuqueuetest", 1024)
// .WithSku(NamespaceSku.Basic)
// .Create();
//创建虚拟机
//Console.WriteLine("Creating a Windows VM");
//var windowsVM = azure.VirtualMachines.Define("myWindowsVM")
// .WithRegion(Region.ChinaNorth)
// .WithNewResourceGroup(resourceGroupName)
// .WithNewPrimaryNetwork("10.0.0.0/28")
// .WithPrimaryPrivateIPAddressDynamic()
// .WithNewPrimaryPublicIPAddress("yutest1")
// .WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012R2Datacenter)
// .WithAdminUsername("tirekicker")
// .WithAdminPassword(password)
// .WithSize(VirtualMachineSizeTypes.BasicA0)
// .Create();
//Console.WriteLine("Created a Windows VM: " + windowsVM.Id);
//azure resource manager test
ResourceManagementClient resourceManagerClient = new ResourceManagementClient(new Uri("https://management.chinacloudapi.cn"), auth.azureCredentials)
{
SubscriptionId = azure.SubscriptionId
};
resourceManagerClient.Resources.DeleteByIdAsync("/subscriptions/e0fbea86-6cf2-4b2d-81e2-9c59f4f96bcb/resourceGroups/armtest", "2016-06-01").GetAwaiter();
//resourceManagerClient.Resources.ListAsync();
Console.WriteLine("Hello World!");
Console.ReadKey(true);
}
public RedisCacheManagementHelper(TestBase testBase)
{
_client = RedisCacheManagementTestUtilities.GetResourceManagementClient(testBase);
_testBase = testBase;
}
public string GetMySqlLocation(ResourceManagementClient client)
{
return(ResourcesManagementTestUtilities.GetResourceLocation(client, "SuccessBricks.ClearDB/databases"));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var cognitiveServiceKey = request.DataStore.GetValue("CognitiveServiceKey");
if (!string.IsNullOrEmpty(cognitiveServiceKey))
{
return(new ActionResponse(ActionStatus.Success));
}
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation", "Name");
var deploymentName = request.DataStore.GetValue("DeploymentName");
var cognitiveServiceName = request.DataStore.GetValue("CognitiveServiceName");
var skuName = request.DataStore.GetValue("CognitiveSkuName");
var param = new AzureArmParameterGenerator();
param.AddStringParam("CognitiveServiceName", cognitiveServiceName);
param.AddStringParam("skuName", skuName);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
var registeration = await client.Providers.RegisterAsync("Microsoft.CognitiveServices");
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/AzureArm/sentimentCognitiveService.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = await client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken());
while (true)
{
Thread.Sleep(5000);
var status = client.Deployments.GetAsync(resourceGroup, deploymentName, new CancellationToken()).Result;
var operations = client.DeploymentOperations.ListAsync(resourceGroup, deploymentName, new DeploymentOperationsListParameters(), new CancellationToken()).Result;
var provisioningState = status.Deployment.Properties.ProvisioningState;
if (provisioningState == "Accepted" || provisioningState == "Running")
{
continue;
}
if (provisioningState == "Succeeded")
{
return(new ActionResponse(ActionStatus.Success, operations));
}
var operation = operations.Operations.First(p => p.Properties.ProvisioningState == ProvisioningState.Failed);
var operationFailed = client.DeploymentOperations.GetAsync(resourceGroup, deploymentName, operation.OperationId, new CancellationToken()).Result;
return(new ActionResponse(ActionStatus.Failure, operationFailed));
}
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
List <Task <ActionResponse> > task = new List <Task <ActionResponse> >();
var token = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
string connString = request.DataStore.GetValue("SqlConnectionString");
string schema = "dbo";
string sfUsername = request.DataStore.GetValue("SalesforceUser");
string sfPassword = request.DataStore.GetValue("SalesforcePassword");
string sfToken = request.DataStore.GetValue("SalesforceToken");
string postDeploymentPipelineType = request.DataStore.GetValue("postDeploymentPipelineType");
string pipelineFrequency = request.DataStore.GetValue("pipelineFrequency");
string pipelineInterval = request.DataStore.GetValue("pipelineInterval");
string pipelineType = request.DataStore.GetValue("pipelineType");
string pipelineStart = request.DataStore.GetValue("pipelineStart");
string pipelineEnd = request.DataStore.GetValue("pipelineEnd");
bool historicalOnly = Convert.ToBoolean(request.DataStore.GetValue("historicalOnly"));
string dataFactoryName = resourceGroup + "SalesforceCopyFactory";
if (!string.IsNullOrWhiteSpace(postDeploymentPipelineType))
{
pipelineFrequency = request.DataStore.GetValue("postDeploymentPipelineFrequency");
pipelineType = postDeploymentPipelineType;
pipelineInterval = request.DataStore.GetValue("postDeploymentPipelineInterval");
pipelineStart = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
pipelineEnd = new DateTime(9999, 12, 31, 23, 59, 59).ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
if (string.IsNullOrWhiteSpace(pipelineStart))
{
pipelineStart = DateTime.UtcNow.AddYears(-3).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
if (string.IsNullOrWhiteSpace(pipelineEnd))
{
pipelineEnd = DateTime.UtcNow.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture);
}
var adfJsonData = request.DataStore.GetValue("ADFPipelineJsonData");
var obj = JsonConvert.DeserializeObject(adfJsonData, typeof(DeserializedADFPayload)) as DeserializedADFPayload;
obj = ReorderObjects(obj);
for (int i = 0; i < obj.fields.Count(); i++)
{
var o = obj.fields[i];
string deploymentName = string.Concat("ADFPipeline", pipelineType, o.Item1);
var sqlCreds = SqlUtility.GetSqlCredentialsFromConnectionString(connString);
var param = new AzureArmParameterGenerator();
param.AddStringParam("dataFactoryName", dataFactoryName);
param.AddStringParam("sqlServerName", sqlCreds.Server.Split('.')[0]);
param.AddStringParam("sqlServerUsername", sqlCreds.Username);
param.AddStringParam("targetDatabaseName", sqlCreds.Database);
param.AddStringParam("targetSqlSchema", schema);
param.AddStringParam("targetSqlTable", o.Item1);
param.AddStringParam("salesforceUsername", sfUsername);
param.AddStringParam("targetSalesforceTable", o.Item1);
param.AddStringParam("pipelineName", o.Item1 + "_CopyPipeline");
param.AddStringParam("sqlWritableTypeName", o.Item1 + "Type");
param.AddStringParam("sqlWriterStoredProcedureName", "spMerge" + o.Item1);
param.AddStringParam("pipelineStartDate", pipelineStart);
param.AddStringParam("pipelineEndDate", pipelineEnd);
param.AddStringParam("sliceFrequency", pipelineFrequency);
param.AddStringParam("sliceInterval", pipelineInterval);
param.AddStringParam("pipelineType", pipelineType);
param.AddParameter("salesforcePassword", "securestring", sfPassword);
param.AddParameter("sqlServerPassword", "securestring", sqlCreds.Password);
param.AddParameter("salesforceSecurityToken", "securestring", sfToken);
var armTemplate = JsonUtility.GetJsonObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/ADF/pipeline.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
if (i >= 1)
{
armTemplate = CreatePipelineDependency(pipelineType, obj, armTemplate, i - 1);
}
string tableFields = JsonConvert.SerializeObject(o.Item2);
StringBuilder query;
if (o.Item1 != "Opportunity" &&
o.Item1 != "Lead" &&
o.Item1 != "OpportunityLineItem" &&
pipelineType == "PreDeployment")
{
query = CreateQuery(o, tableFields, true, pipelineStart, pipelineEnd);
armTemplate = CreateOneTimePipeline(armTemplate);
}
else
{
query = CreateQuery(o, tableFields, false);
}
if (historicalOnly && pipelineType == "PostDeployment")
{
armTemplate = this.PausePipeline(armTemplate);
}
string stringTemplate = ReplaceTableFieldsAndQuery(tableFields, query, armTemplate);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, token);
ResourceManagementClient client = new ResourceManagementClient(creds);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = stringTemplate,
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
task.Add(new Task <ActionResponse>(() =>
{
var deploymentItem = client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
var helper = new DeploymentHelper();
return(helper.WaitForDeployment(resourceGroup, deploymentName, client));
}));
}
foreach (var t in task)
{
t.Start();
}
Task.WaitAll(task.ToArray());
foreach (var t in task)
{
if (t.Result.Status != ActionStatus.Success)
{
return(new ActionResponse(ActionStatus.Failure, t.Result.ExceptionDetail.FriendlyErrorMessage));
}
}
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetJObjectFromStringValue(dataFactoryName)));
}
private void RunAMLWebServiceTestScenario(AMLWebServiceTestDelegate actualTest,
[System.Runtime.CompilerServices.CallerMemberName]
string methodName = "testframework_failed")
{
using (var context = MockContext.Start(this.GetType().FullName, methodName))
{
bool testIsSuccessfull = true;
string cpRpApiVersion = string.Empty;
ResourceManagementClient resourcesClient = null;
StorageManagementClient storageManagementClient = null;
var amlServiceName = TestUtilities.GenerateName(WebServiceTests.TestServiceNamePrefix);
var resourceGroupName = TestUtilities.GenerateName(WebServiceTests.TestResourceGroupNamePrefix);
var commitmentPlanName = TestUtilities.GenerateName(WebServiceTests.TestCommitmentPlanNamePrefix);
var cpDeploymentName = "depl" + commitmentPlanName;
var storageAccountName = TestUtilities.GenerateName(WebServiceTests.TestStorageAccountPrefix);
try
{
// Create a resource group for the AML service
resourcesClient = context.GetServiceClient <ResourceManagementClient>();
var resourceGroupDefinition = new ResourceGroup
{
Location = WebServiceTests.DefaultLocation
};
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, resourceGroupDefinition);
// Create a support storage account for the service in this resource group
storageManagementClient = context.GetServiceClient <StorageManagementClient>();
var accountParameters = new StorageAccountCreateParameters
{
AccountType = AccountType.StandardLRS,
Location = WebServiceTests.DefaultLocation
};
storageManagementClient.StorageAccounts.Create(resourceGroupName, storageAccountName, accountParameters);
StorageAccountKeys accountKeys = storageManagementClient.StorageAccounts.ListKeys(resourceGroupName, storageAccountName);
var storageAccountInfo = new StorageAccount(storageAccountName, accountKeys.Key1);
// Create an AML commitment plan resource to associate with the services
cpRpApiVersion = ResourceProvidersHelper.GetRPApiVersion(resourcesClient, WebServiceTests.MLResourceProviderNamespace, WebServiceTests.CPResourceType);
var cpDeploymentItems = WebServiceTests.CreateCommitmentPlanResource(resourceGroupName, commitmentPlanName, cpDeploymentName, resourcesClient, cpRpApiVersion);
var cpResource = cpDeploymentItems.Item2;
// Create a client for the AML RP and run the actual test
var webServicesClient = context.GetServiceClient <AzureMLWebServicesManagementClient>();
// Run the actual test
actualTest(amlServiceName, resourceGroupName, resourcesClient, webServicesClient, cpResource.Id, storageAccountInfo);
}
catch (CloudException cloudEx)
{
Trace.TraceError("Caught unexpected exception: ");
Trace.TraceError(BaseScenarioTests.GenerateCloudExceptionReport(cloudEx));
testIsSuccessfull = false;
}
finally
{
if (resourcesClient != null)
{
// Delete the deployment with the commitment plan
if (cpRpApiVersion != string.Empty)
{
BaseScenarioTests.DisposeOfTestResource(() => resourcesClient.Resources.Delete(resourceGroupName, WebServiceTests.MLResourceProviderNamespace, string.Empty, WebServiceTests.CPResourceType, commitmentPlanName, cpRpApiVersion));
BaseScenarioTests.DisposeOfTestResource(() => resourcesClient.Deployments.Delete(resourceGroupName, cpDeploymentName));
}
// Delete the created storage account
BaseScenarioTests.DisposeOfTestResource(() => storageManagementClient.StorageAccounts.Delete(resourceGroupName, storageAccountName));
// Delete the created resource group
BaseScenarioTests.DisposeOfTestResource(() => resourcesClient.ResourceGroups.Delete(resourceGroupName));
}
}
Assert.True(testIsSuccessfull);
}
}
public static IEnumerable <ResourceGroupExtended> GetResourceGroups(this ResourceManagementClient resourceManagementClient)
{
return(resourceManagementClient.ResourceGroups.List(new ResourceGroupListParameters()).ResourceGroups);
}
private static Tuple <DeploymentExtended, GenericResource> CreateCommitmentPlanResource(string resourceGroupName, string commitmentPlanName, string deploymentName, ResourceManagementClient resourcesClient, string cpApiVersion)
{
string deploymentParams = @"{'planName': {'value': '" + commitmentPlanName + "'}, 'planSkuName': {'value': 'S1'}, 'planSkuTier': {'value': 'Standard'}, 'apiVersion': {'value': '" + cpApiVersion + "'}}";
var deploymentProperties = new DeploymentProperties
{
Template = JObject.Parse(File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(), "TestData", "DeployCommitmentPlanTemplate.json"))),
Parameters = JObject.Parse(deploymentParams),
Mode = DeploymentMode.Incremental
};
var deployment = resourcesClient.Deployments.CreateOrUpdate(resourceGroupName, deploymentName, new Deployment(deploymentProperties));
var cpResource = resourcesClient.Resources.Get(resourceGroupName, WebServiceTests.MLResourceProviderNamespace, string.Empty, WebServiceTests.CPResourceType, commitmentPlanName, cpApiVersion);
return(Tuple.Create(deployment, cpResource));
}
public static void TryRegisterResourceGroup(this ResourceManagementClient resourceManagementClient, string location, string resourceGroupName)
{
resourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup(location));
}
static void Main(string[] args)
{
try
{
string filter = args.Length > 0 ? args[0] : "/*[starts-with(DisplayName,'%')]";
int index = args.Length > 1 ? Convert.ToInt32(args[1]) : -1;
string token = args.Length > 2 ? args[2] : null;
int pageSize = 100;
ResourceManagementClient client = new ResourceManagementClient();
client.RefreshSchema();
ResourceObject resourceObject = client.GetResource(
"418fc8b4-d5b3-4a0a-87c6-0984812a6781",
new string[] { "DisplayName", "CreatedTime", "Manager" },
new CultureInfo("de-DE"), true);
SearchResultPager p = getSearchResultPager(client, filter, pageSize, token);
token = token ?? Guid.NewGuid().ToString();
if (index >= 0)
{
p.CurrentIndex = index;
}
p.PageSize = pageSize;
int oldIndex = p.CurrentIndex;
PagedResultSet results = new PagedResultSet
{
Results = p.GetNextPage().ToList(),
};
results.TotalCount = p.TotalCount;
results.HasMoreItems = index + pageSize < p.TotalCount;
searchCache.Add(buildCacheKey(token), p, new CacheItemPolicy()
{
SlidingExpiration = new TimeSpan(0, 5, 0)
});
foreach (ResourceObject resource in results.Results)
{
Console.WriteLine(resource.DisplayName);
}
Console.WriteLine("Total Count: " + results.TotalCount);
Console.WriteLine("More Items to Load: " + results.HasMoreItems);
//Uri nextPageUri;
//Uri previousPageUri;
//ResourceManagementWebServicev2.GetPageUris(context, oldIndex, pageSize, token, p, out previousPageUri, out nextPageUri);
//results.NextPage = nextPageUri?.ToString();
//results.PreviousPage = previousPageUri?.ToString();
//results.TotalCount = p.TotalCount;
//results.HasMoreItems = results.NextPage != null;
//ResourceManagementWebServicev2.searchCache.Add(ResourceManagementWebServicev2.BuildCacheKey(token), p, new CacheItemPolicy() { SlidingExpiration = new TimeSpan(0, 5, 0) });
//return WebResponseHelper.GetResponse(results, false);
}
catch (Exception ex)
{
throw ex;
}
}
protected Cluster CreateCluster(
ResourceManagementClient resouceClient,
ServiceFabricManagementClient serviceFabricClient,
string rg,
string rgLocation,
string clusterName)
{
var clusterId = string.Format(
clusterIdFormat,
resouceClient.SubscriptionId,
rg,
clusterName);
var newCluster = new Cluster(
location: rgLocation,
reliabilityLevel: "Silver",
managementEndpoint: "http://testCluster.southcentralus.cloudapp.azure.com:19080",
nodeTypes: new List <NodeTypeDescription>()
{
new NodeTypeDescription()
{
ApplicationPorts = new EndpointRangeDescription()
{
StartPort = 1000,
EndPort = 3000
},
DurabilityLevel = "Bronze",
EphemeralPorts = new EndpointRangeDescription()
{
StartPort = 4000,
EndPort = 6000
},
IsPrimary = true,
Name = "n1",
ClientConnectionEndpointPort = 19000,
Capacities = null,
HttpGatewayEndpointPort = 19080,
PlacementProperties = null,
VmInstanceCount = 5,
ReverseProxyEndpointPort = null
}
},
clusterId: clusterId,
name: clusterName,
type: "Microsoft.ServiceFabric/clusters",
vmImage: "Windows"
)
{
};
resouceClient.ResourceGroups.CreateOrUpdate(
rg,
new ResourceGroup(rgLocation));
var cluster = serviceFabricClient.Clusters.CreateOrUpdate(rg, clusterName, newCluster);
Assert.NotNull(cluster);
cluster = serviceFabricClient.Clusters.Get(rg, clusterName);
Assert.NotNull(cluster);
return(cluster);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation", "Name");
var connectorName = request.DataStore.GetValue("ConnectorName");
var requiresConsent = request.DataStore.GetValue("RequiresConsent");
//Needs to be changed once Logic Apps makes it available
if (connectorName == "bingsearch")
{
location = "brazilsouth";
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
var registeration = await client.Providers.RegisterAsync("Microsoft.Web");
dynamic payload = new ExpandoObject();
payload.properties = new ExpandoObject();
payload.properties.parameterValues = new ExpandoObject();
payload.properties.parameterValues.sku = "Enterprise";
payload.properties.displayName = connectorName;
payload.properties.api = new ExpandoObject();
payload.properties.api.id = $"subscriptions/{subscription}/providers/Microsoft.Web/locations/{location}/managedApis/{connectorName}";
payload.location = location;
HttpResponseMessage connection = await new AzureHttpClient(azureToken, subscription, resourceGroup).ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Put,
$"/providers/Microsoft.Web/connections/{connectorName}", "2016-06-01", JsonUtility.GetJsonStringFromObject(payload));
if (!connection.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromJsonString(await connection.Content.ReadAsStringAsync()),
null, DefaultErrorCodes.DefaultErrorCode, "Failed to create connection"));
}
var redirectRoot = request.Info.WebsiteRootUrl;
if (requiresConsent != null && requiresConsent.ToLowerInvariant() == "true")
{
// Get Consent links for auth
payload = new ExpandoObject();
payload.parameters = new ExpandoObject[1];
payload.parameters[0] = new ExpandoObject();
payload.parameters[0].objectId = null;
payload.parameters[0].tenantId = null;
payload.parameters[0].parameterName = "token";
payload.parameters[0].redirectUrl = redirectRoot + Constants.WebsiteRedirectPath;
HttpResponseMessage consent = await new AzureHttpClient(azureToken, subscription, resourceGroup).ExecuteWithSubscriptionAndResourceGroupAsync(HttpMethod.Post,
$"/providers/Microsoft.Web/connections/{connectorName}/listConsentLinks", "2016-06-01", JsonUtility.GetJsonStringFromObject(payload));
if (!consent.IsSuccessStatusCode)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromJsonString(await connection.Content.ReadAsStringAsync()),
null, DefaultErrorCodes.DefaultErrorCode, "Failed to get consent"));
}
var connectiondata = JsonUtility.GetJObjectFromJsonString(await connection.Content.ReadAsStringAsync());
var consentdata = JsonUtility.GetJObjectFromJsonString(await consent.Content.ReadAsStringAsync());
dynamic objectToReturn = new ExpandoObject();
objectToReturn.Consent = consentdata;
objectToReturn.Connection = connectiondata;
objectToReturn.UniqueId = payload.parameters[0].objectId;
return(new ActionResponse(ActionStatus.Success, objectToReturn));
}
return(new ActionResponse(ActionStatus.Success));
}
static async Task CreateOrUpdateResourceGroup(IServicePrincipal serverApplication)
{
Console.WriteLine("Add or update Key Vault Resource Group (required once)? [y/N] to continue: ");
var key = Console.ReadLine()
.ToUpperInvariant()
.Trim();
if (key != "Y")
{
return;
}
Console.Write("SubscriptionId: ");
var subscriptionId = Console.ReadLine();
Console.Write("Resource Group Name (blank for default 'SignService-KeyVaults'): ");
var name = Console.ReadLine();
if (string.IsNullOrWhiteSpace(name))
{
name = "SignService-KeyVaults";
}
Console.WriteLine("Location (eastus, westus, etc): ");
var location = Console.ReadLine();
var accessToken = await authContext.AcquireTokenSilentAsync(azureRmResourceId, clientId);
var rgc = new ResourceManagementClient(new TokenCredentials(accessToken.AccessToken))
{
SubscriptionId = subscriptionId,
BaseUri = new Uri(configuration["AzureRM:Instance"])
};
var rg = new ResourceGroup(location, name: name);
rg = await rgc.ResourceGroups.CreateOrUpdateAsync(name, rg);
var ac = new AuthorizationManagementClient(new TokenCredentials(accessToken.AccessToken))
{
SubscriptionId = subscriptionId,
BaseUri = new Uri(configuration["AzureRM:Instance"])
};
// See if the resource group has the reader role
// Get the reader role
var roleFilter = new ODataQuery <RoleDefinitionFilter>(f => f.RoleName == "Reader");
var roleDefinitions = await ac.RoleDefinitions.ListAsync(rg.Id, roleFilter);
var roleDefinition = roleDefinitions.First();
var roleId = roleDefinition.Id;
var spid = serverApplication.ObjectId;
var raps = await ac.RoleAssignments.ListForScopeAsync(rg.Id, new ODataQuery <RoleAssignmentFilter>(f => f.PrincipalId == spid));
if (raps.All(ra => ra.Properties.RoleDefinitionId != roleId))
{
// none found, add one
var rap = new RoleAssignmentProperties
{
PrincipalId = spid,
RoleDefinitionId = roleId
};
var ra = await ac.RoleAssignments.CreateAsync(rg.Id, Guid.NewGuid().ToString(), rap);
}
}
public void DeleteResourceGroup(string resourceGroupName)
{
ResourceManagementClient resourceClient = GetClient <ResourceManagementClient>();
resourceClient.ResourceGroups.BeginDelete(resourceGroupName);
}
public void GraphCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = "CosmosDBResourceGroup2510";
string databaseAccountName = "db1002";
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
//DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
return;
// SDK doesnt support creation of Cassandra, Table, Gremlin Accounts, use accounts created using Azure portal
// List<Location> locations = new List<Location>();
// locations.Add(new Location(locationName: "East US"));
// DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
// {
// Location = "EAST US",
// Locations = locations
// };
//databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
}
string databaseName = "databaseName1002";
string databaseName2 = "databaseName21002";
GremlinDatabaseCreateUpdateParameters gremlinDatabaseCreateUpdateParameters = new GremlinDatabaseCreateUpdateParameters
{
Resource = new GremlinDatabaseResource {
Id = databaseName
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
GremlinDatabaseGetResults gremlinDatabaseGetResults = cosmosDBManagementClient.GremlinResources.CreateUpdateGremlinDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, gremlinDatabaseCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinDatabaseGetResults);
Assert.Equal(databaseName, gremlinDatabaseGetResults.Name);
GremlinDatabaseGetResults gremlinDatabaseGetResults1 = cosmosDBManagementClient.GremlinResources.GetGremlinDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinDatabaseGetResults1);
Assert.Equal(databaseName, gremlinDatabaseGetResults1.Name);
VerifyEqualGremlinDatabases(gremlinDatabaseGetResults, gremlinDatabaseGetResults1);
GremlinDatabaseCreateUpdateParameters gremlinDatabaseCreateUpdateParameters2 = new GremlinDatabaseCreateUpdateParameters
{
Location = "EAST US",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
Resource = new GremlinDatabaseResource {
Id = databaseName2
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
GremlinDatabaseGetResults gremlinDatabaseGetResults2 = cosmosDBManagementClient.GremlinResources.CreateUpdateGremlinDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2, gremlinDatabaseCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinDatabaseGetResults2);
Assert.Equal(databaseName2, gremlinDatabaseGetResults2.Name);
IEnumerable <GremlinDatabaseGetResults> gremlinDatabases = cosmosDBManagementClient.GremlinResources.ListGremlinDatabasesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinDatabases);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.GremlinResources.GetGremlinDatabaseThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/gremlinDatabases/throughputSettings", throughputSettingsGetResults.Type);
string gremlinGraphName = "gremlinGraphName1002";
GremlinGraphCreateUpdateParameters gremlinGraphCreateUpdateParameters = new GremlinGraphCreateUpdateParameters
{
Resource = new GremlinGraphResource
{
Id = gremlinGraphName,
PartitionKey = new ContainerPartitionKey
{
Kind = "Hash",
Paths = new List <string> {
"/address"
}
}
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
GremlinGraphGetResults gremlinGraphGetResults = cosmosDBManagementClient.GremlinResources.CreateUpdateGremlinGraphWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraphName, gremlinGraphCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinGraphGetResults);
IEnumerable <GremlinGraphGetResults> gremlinGraphs = cosmosDBManagementClient.GremlinResources.ListGremlinGraphsWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName).GetAwaiter().GetResult().Body;
Assert.NotNull(gremlinGraphs);
foreach (GremlinGraphGetResults gremlinGraph in gremlinGraphs)
{
cosmosDBManagementClient.GremlinResources.DeleteGremlinGraphWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseName, gremlinGraph.Name);
}
foreach (GremlinDatabaseGetResults gremlinDatabase in gremlinDatabases)
{
cosmosDBManagementClient.GremlinResources.DeleteGremlinDatabaseWithHttpMessagesAsync(resourceGroupName, databaseAccountName, gremlinDatabase.Name);
}
}
}
public void CassandraCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = "CosmosDBResourceGroup2510";
string databaseAccountName = "db2725";
bool isDatabaseNameExists = cosmosDBManagementClient.DatabaseAccounts.CheckNameExistsWithHttpMessagesAsync(databaseAccountName).GetAwaiter().GetResult().Body;
//DatabaseAccountGetResults databaseAccount = null;
if (!isDatabaseNameExists)
{
return;
// SDK doesnt support creation of Cassandra, Table, Gremlin Accounts, use accounts created using Azure portal
// List<Location> locations = new List<Location>();
// locations.Add(new Location(locationName: "East US"));
// DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
// {
// Location = "EAST US",
// Locations = locations
// };
//databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
}
string keyspaceName = "keyspaceName2510";
string keyspaceName2 = "keyspaceName22510";
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters = new CassandraKeyspaceCreateUpdateParameters
{
Resource = new CassandraKeyspaceResource {
Id = keyspaceName
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
CassandraKeyspaceGetResults cassandraKeyspaceGetResults = cosmosDBManagementClient.CassandraResources.CreateUpdateCassandraKeyspaceWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraKeyspaceCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraKeyspaceGetResults);
Assert.Equal(keyspaceName, cassandraKeyspaceGetResults.Name);
CassandraKeyspaceGetResults cassandraKeyspaceGetResults1 = cosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraKeyspaceGetResults1);
Assert.Equal(keyspaceName, cassandraKeyspaceGetResults1.Name);
VerifyEqualCassandraDatabases(cassandraKeyspaceGetResults, cassandraKeyspaceGetResults1);
CassandraKeyspaceCreateUpdateParameters cassandraKeyspaceCreateUpdateParameters2 = new CassandraKeyspaceCreateUpdateParameters
{
Location = "EAST US",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
Resource = new CassandraKeyspaceResource {
Id = keyspaceName2
},
Options = new Dictionary <string, string>()
{
{ "Throughput", "700" }
}
};
CassandraKeyspaceGetResults cassandraKeyspaceGetResults2 = cosmosDBManagementClient.CassandraResources.CreateUpdateCassandraKeyspaceWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName2, cassandraKeyspaceCreateUpdateParameters2).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraKeyspaceGetResults2);
Assert.Equal(keyspaceName2, cassandraKeyspaceGetResults2.Name);
IEnumerable <CassandraKeyspaceGetResults> cassandraKeyspaces = cosmosDBManagementClient.CassandraResources.ListCassandraKeyspacesWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraKeyspaces);
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.CassandraResources.GetCassandraKeyspaceThroughputWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName2).GetAwaiter().GetResult().Body;
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Name);
Assert.Equal("Microsoft.DocumentDB/databaseAccounts/cassandraKeyspaces/throughputSettings", throughputSettingsGetResults.Type);
string tableName = "tableName2510";
CassandraTableCreateUpdateParameters cassandraTableCreateUpdateParameters = new CassandraTableCreateUpdateParameters
{
Resource = new CassandraTableResource
{
Id = tableName,
Schema = new CassandraSchema
{
Columns = new List <Column> {
new Column {
Name = "columnA", Type = "int"
}, new Column {
Name = "columnB", Type = "ascii"
}
},
ClusterKeys = new List <ClusterKey> {
new ClusterKey {
Name = "columnB", OrderBy = "Asc"
}
},
PartitionKeys = new List <CassandraPartitionKey> {
new CassandraPartitionKey {
Name = "columnA"
}
}
}
},
Options = new Dictionary <string, string>()
{
{ "foo", "bar" }
}
};
CassandraTableGetResults cassandraTableGetResults = cosmosDBManagementClient.CassandraResources.CreateUpdateCassandraTableWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName, tableName, cassandraTableCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraTableGetResults);
IEnumerable <CassandraTableGetResults> cassandraTables = cosmosDBManagementClient.CassandraResources.ListCassandraTablesWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName).GetAwaiter().GetResult().Body;
Assert.NotNull(cassandraTables);
foreach (CassandraTableGetResults cassandraTable in cassandraTables)
{
cosmosDBManagementClient.CassandraResources.DeleteCassandraTableWithHttpMessagesAsync(resourceGroupName, databaseAccountName, keyspaceName, cassandraTable.Name);
}
foreach (CassandraKeyspaceGetResults cassandraKeyspace in cassandraKeyspaces)
{
cosmosDBManagementClient.CassandraResources.DeleteCassandraKeyspaceWithHttpMessagesAsync(resourceGroupName, databaseAccountName, cassandraKeyspace.Name);
}
}
}
public string GetWebsiteLocation(ResourceManagementClient client)
{
return(ResourcesManagementTestUtilities.GetResourceLocation(client, "Microsoft.Web/sites"));
}
public RedisCacheClient(AzureContext context)
{
_client = AzureSession.ClientFactory.CreateClient<RedisManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_insightsClient = AzureSession.ClientFactory.CreateClient<InsightsManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
_resourceManagementClient = AzureSession.ClientFactory.CreateClient<ResourceManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
private static async Task MainAsync()
{
// Obtain an access token using the "common" AAD resource. This allows the application
// to query AAD for information that lies outside the application's tenant (such as for
// querying subscription information in your Azure account).
AuthenticationContext authContext = new AuthenticationContext(AuthorityUri);
AuthenticationResult authResult = authContext.AcquireToken(ResourceUri,
ClientId,
new Uri(RedirectUri),
PromptBehavior.Auto);
// The first credential object is used when querying for subscriptions, and is therefore
// not associated with a specific subscription.
ServiceClientCredentials subscriptionCreds = new TokenCredentials(authResult.AccessToken);
string subscriptionId = String.Empty;
using (SubscriptionClient subClient = new SubscriptionClient(subscriptionCreds))
{
// Ask the user to select a subscription. We'll use the selected subscription's
// ID when constructing another credential object used in initializing the management
// clients for the remainder of the sample.
subscriptionId = await SelectSubscriptionAsync(subClient);
}
// These credentials are associated with a subscription, and can therefore be used when
// creating Resource and Batch management clients for use in manipulating entities within
// the subscription (e.g. resource groups and Batch accounts).
ServiceClientCredentials creds = new TokenCredentials(authResult.AccessToken);
// With the ResourceManagementClient, we create a resource group in which to create the Batch account.
using (ResourceManagementClient resourceManagementClient = new ResourceManagementClient(creds))
{
resourceManagementClient.SubscriptionId = subscriptionId;
// Register with the Batch resource provider; this only needs to be performed once per subscription.
resourceManagementClient.Providers.Register(BatchNameSpace);
string location = await PromptUserForLocationAsync(resourceManagementClient);
await CreateResourceGroupAsync(resourceManagementClient, location);
await PerformBatchAccountOperationsAsync(authResult.AccessToken, subscriptionId, location);
await DeleteResourceGroupAsync(resourceManagementClient);
}
}
