/// <summary>
/// Constructs a database activation adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlDatabaseActivationAdapter(AzureContext context)
{
Context = context;
_subscription = context.Subscription;
Communicator = new AzureSqlDatabaseActivationCommunicator(Context);
}
/// <summary>
/// Creates new BatchClient
/// </summary>
/// <param name="context">Context with subscription containing a batch account to manipulate</param>
public BatchClient(AzureContext context)
: this(AzureSession.ClientFactory.CreateClient <BatchManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager),
AzureSession.ClientFactory.CreateClient <ResourceManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager))
{
}
public AvailabilitySet(AzureContext azureContext)
{
_AzureContext = azureContext;
}
private async Task MigrationSourceControl_AfterAzureTenantChange(AzureContext sender)
{
targetAzureContextViewer.ExistingContext = sender;
}
private async Task MigrationSourceControl_UserAuthenticated(AzureContext sender)
{
targetAzureContextViewer.ExistingContext = sender;
this.targetTreeView1.Enabled = true;
}
/// <summary>
/// Constructs adapter
/// </summary>
public AzureSqlElasticPoolAdvisorAdapter(AzureContext context)
{
Context = context;
Communicator = new AzureSqlElasticPoolAdvisorCommunicator(Context);
}
public Microsoft.Rest.ServiceClientCredentials GetServiceClientCredentials(AzureContext context)
{
return(new Microsoft.Rest.TokenCredentials(Token.AccessToken));
}
/// <summary>
/// Constructs a recommended elastic pool adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlElasticPoolRecommendationAdapter(AzureContext context)
{
_subscription = context.Subscription;
Context = context;
RecommendationCommunicator = new AzureSqlElasticPoolRecommendationCommunicator(Context);
}
/// <summary>
/// Constructs adapter
/// </summary>
public AzureSqlDatabaseAdvisorAdapter(AzureContext context)
{
Context = context;
Communicator = new AzureSqlDatabaseAdvisorCommunicator(Context);
}
/// <summary>
/// Creates a communicator for Azure Sql Elastic Pool Recommended Actions
/// </summary>
public AzureSqlElasticPoolRecommendedActionCommunicator(AzureContext context)
: base(context)
{
}
/// <summary>
/// Constructs a Azure SQL Server Active Directory administrator adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlServerActiveDirectoryAdministratorAdapter(AzureContext context)
{
Context = context;
_subscription = context.Subscription;
Communicator = new AzureSqlServerActiveDirectoryAdministratorCommunicator(Context);
}
/// <summary>
/// AzureContext based ctor
/// </summary>
/// <param name="context">Azure context</param>
public ServiceClientAdapter(AzureContext context)
{
BmsAdapter = new ClientProxy <RecoveryServicesNS.RecoveryServicesBackupClient>(context);
}
public async Task <bool> CheckNameAvailability(AzureSubscription targetSubscription)
{
const String checkNameAvailability = "checkNameAvailability";
if (targetSubscription == null)
{
throw new ArgumentException("Target Subscription must be specified to check Storage Account Name Availability.");
}
if (targetSubscription.SubscriptionId == Guid.Empty)
{
this.IsNameAvailable = true;
return(this.IsNameAvailable);
}
AzureContext azureContext = targetSubscription.AzureTenant.AzureContext;
if (targetSubscription.ExistsProviderResourceType(ArmConst.MicrosoftStorage, checkNameAvailability))
{
if (azureContext != null && azureContext.LogProvider != null)
{
azureContext.LogProvider.WriteLog("CheckNameAvailability", "Storage Account '" + this.ToString());
}
if (azureContext != null && azureContext.StatusProvider != null)
{
azureContext.StatusProvider.UpdateStatus("Checking Name Availabilty for target Storage Account '" + this.ToString() + "'");
}
// https://docs.microsoft.com/en-us/rest/api/storagerp/storageaccounts/checknameavailability
string url = "/subscriptions/" + targetSubscription.SubscriptionId + ArmConst.ProviderStorage + checkNameAvailability + "?api-version=" + targetSubscription.GetProviderMaxApiVersion(ArmConst.MicrosoftStorage, checkNameAvailability);
AuthenticationResult authenticationResult = await azureContext.TokenProvider.GetToken(azureContext.AzureEnvironment.ResourceManagerEndpoint, azureContext.AzureSubscription.AzureAdTenantId);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authenticationResult.AccessToken);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.BaseAddress = new Uri(azureContext.AzureEnvironment.ResourceManagerEndpoint);
if (azureContext != null && azureContext.LogProvider != null)
{
azureContext.LogProvider.WriteLog("CheckNameAvailability", "Storage Account '" + this.ToString() + "' PostAsync " + url);
}
using (var response = await client.PostAsJsonAsync(url,
new
{
name = this.ToString(),
type = ArmConst.TypeStorageAccount
})
)
{
String strResponse = response.Content.ReadAsStringAsync().Result.ToString();
azureContext.LogProvider.WriteLog("CheckNameAvailability", "HttpStatusCode: '" + response.StatusCode);
azureContext.LogProvider.WriteLog("CheckNameAvailability", "Response: '" + strResponse);
JObject responseJson = JObject.Parse(strResponse);
this.IsNameAvailable = (response.StatusCode == System.Net.HttpStatusCode.OK &&
responseJson != null &&
responseJson["nameAvailable"] != null &&
String.Compare(responseJson["nameAvailable"].ToString(), "True", true) == 0);
}
}
if (azureContext != null && azureContext.StatusProvider != null)
{
azureContext.StatusProvider.UpdateStatus("Ready");
}
}
else
{
azureContext.LogProvider.WriteLog("CheckNameAvailability", "Provider Resource Type does not exist. Unable to check if storage account name is available.");
this.IsNameAvailable = true;
}
return(this.IsNameAvailable);
}
private Tuple <IAccessToken, string> GetToken(IAuthenticationFactory authFactory, AzureContext context)
{
if (context.Subscription == null)
{
throw new ArgumentException(KeyVaultProperties.Resources.InvalidCurrentSubscription);
}
if (context.Account == null)
{
throw new ArgumentException(KeyVaultProperties.Resources.InvalidSubscriptionState);
}
if (context.Account.Type != AzureAccount.AccountType.User)
{
throw new ArgumentException(string.Format(KeyVaultProperties.Resources.UnsupportedAccountType, context.Account.Type));
}
var tenant = context.Subscription.GetPropertyAsArray(AzureSubscription.Property.Tenants)
.Intersect(context.Account.GetPropertyAsArray(AzureAccount.Property.Tenants))
.FirstOrDefault();
if (tenant == null)
{
throw new ArgumentException(KeyVaultProperties.Resources.InvalidSubscriptionState);
}
try
{
var accesstoken = authFactory.Authenticate(context.Account, context.Environment, tenant, null, ShowDialog.Auto,
ResourceIdEndpoint);
return(Tuple.Create(accesstoken, context.Environment.Endpoints[ResourceIdEndpoint]));
}
catch (Exception ex)
{
throw new ArgumentException(KeyVaultProperties.Resources.InvalidSubscriptionState, ex);
}
}
/// <summary>
/// Constructs a firewall rule adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlCapabilitiesAdapter(AzureContext context)
{
Context = context;
_communicator = new AzureSqlCapabilitiesCommunicator(Context);
}
public VaultManagementClient(AzureContext context)
{
KeyVaultManagementClient = AzureSession.ClientFactory.CreateClient <KeyVaultManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public Logout(AzureContext context) : base(context)
{
}
/// <summary>
/// Constructs adapter
/// </summary>
public AzureSqlElasticPoolRecommendedActionAdapter(AzureContext context)
{
Context = context;
Communicator = new AzureSqlElasticPoolRecommendedActionCommunicator(Context);
}
public SubscriptionCloudCredentials GetSubscriptionCloudCredentials(AzureContext context)
{
return(new AccessTokenCredential(context.Subscription.Id, Token));
}
public WebsitesClient(AzureContext context)
{
this.WrappedWebsitesClient = AzureSession.ClientFactory.CreateArmClient <WebSiteManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public SubscriptionCloudCredentials GetSubscriptionCloudCredentials(AzureContext context, AzureEnvironment.Endpoint targetEndpoint)
{
return(new AccessTokenCredential(context.Subscription.Id, Token));
}
public RedisCacheClient(AzureContext context)
{
_client = AzureSession.ClientFactory.CreateClient <RedisManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
private async Task MigrationSourceControl_BeforeAzureSubscriptionChange(AzureContext sender)
{
targetAzureContextViewer.ExistingContext = sender;
}
public ManagedDisk(AzureContext azureContext, VirtualMachine virtualMachine, JToken resourceToken) : base(resourceToken)
{
_VirtualMachine = virtualMachine;
_AzureContext = azureContext;
}
private async Task MigrationSourceControl_AzureEnvironmentChanged(AzureContext sender)
{
targetAzureContextViewer.ExistingContext = sender;
}
public ManagedDisk(AzureContext azureContext, JToken resourceToken) : base(resourceToken)
{
_AzureContext = azureContext;
}
/// <summary>
/// Creates PoliciesClient using WindowsAzureSubscription instance.
/// </summary>
/// <param name="subscription">The WindowsAzureSubscription instance</param>
public AuthorizationClient(AzureContext context)
{
ActiveDirectoryClient = new ActiveDirectoryClient(context);
AuthorizationManagementClient = AzureSession.ClientFactory.CreateClient <AuthorizationManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager);
}
public new async Task InitializeChildrenAsync(AzureContext azureContext)
{
await base.InitializeChildrenAsync(azureContext);
}
public AvailabilitySet(AzureContext azureContext, String targetName)
{
_AzureContext = azureContext;
this.TargetName = targetName;
}
public Rest.ServiceClientCredentials GetServiceClientCredentials(AzureContext context, AzureEnvironment.Endpoint targetEndpoint)
{
throw new System.NotImplementedException();
}
