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>
/// Determines the API version.
/// </summary>
/// <param name="context">The azure profile.</param>
/// <param name="providerNamespace">The provider namespace.</param>
/// <param name="resourceType">The resource type.</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param>
internal static Task<string> DetermineApiVersion(AzureContext context, string providerNamespace, string resourceType, CancellationToken cancellationToken, bool? pre = null, Dictionary<string, string> cmdletHeaderValues = null)
{
var cacheKey = ApiVersionCache.GetCacheKey(providerNamespace: providerNamespace, resourceType: resourceType);
var apiVersions = ApiVersionCache.Instance
.AddOrGetExisting(cacheKey: cacheKey, getFreshData: () => ApiVersionHelper.GetApiVersionsForResourceType(
context,
providerNamespace: providerNamespace,
resourceType: resourceType,
cancellationToken: cancellationToken,
cmdletHeaderValues: cmdletHeaderValues));
apiVersions = apiVersions.CoalesceEnumerable().ToArray();
var apiVersionsToSelectFrom = apiVersions;
if (pre == null || pre == false)
{
apiVersionsToSelectFrom = apiVersions
.Where(apiVersion => apiVersion.IsDecimal(NumberStyles.AllowDecimalPoint) || apiVersion.IsDateTime("yyyy-mm-dd", DateTimeStyles.None))
.ToArray();
}
var selectedApiVersion = apiVersionsToSelectFrom.OrderByDescending(apiVersion => apiVersion).FirstOrDefault();
if (string.IsNullOrWhiteSpace(selectedApiVersion) && apiVersions.Any())
{
// fall back on pre-release APIs if they're the only ones available.
selectedApiVersion = apiVersions.OrderByDescending(apiVersion => apiVersion).FirstOrDefault();
}
var result = string.IsNullOrWhiteSpace(selectedApiVersion)
? Constants.DefaultApiVersion
: selectedApiVersion;
return Task.FromResult(result);
}
private Tuple<IAccessToken, string> GetToken(IAuthenticationFactory authFactory, AzureContext context, AzureEnvironment.Endpoint resourceIdEndpoint)
{
if (context.Account == null)
throw new ArgumentException(KeyVaultProperties.Resources.ArmAccountNotFound);
if (context.Account.Type != AzureAccount.AccountType.User &&
context.Account.Type != AzureAccount.AccountType.ServicePrincipal )
throw new ArgumentException(string.Format(KeyVaultProperties.Resources.UnsupportedAccountType, context.Account.Type));
if (context.Subscription != null && context.Account != null)
TenantId = context.Subscription.GetPropertyAsArray(AzureSubscription.Property.Tenants)
.Intersect(context.Account.GetPropertyAsArray(AzureAccount.Property.Tenants))
.FirstOrDefault();
if (string.IsNullOrWhiteSpace(TenantId) && context.Tenant != null && context.Tenant.Id != Guid.Empty)
TenantId = context.Tenant.Id.ToString();
if (string.IsNullOrWhiteSpace(TenantId))
throw new ArgumentException(KeyVaultProperties.Resources.NoTenantInContext);
try
{
var accesstoken = authFactory.Authenticate(context.Account, context.Environment, TenantId, 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 database adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlDatabaseAdapter(AzureContext context)
{
Context = context;
_subscription = context.Subscription;
Communicator = new AzureSqlDatabaseCommunicator(Context);
ElasticPoolCommunicator = new AzureSqlElasticPoolCommunicator(Context);
}
private static RMProfileClient SetupTestEnvironment(List<string> tenants, params List<string>[] subscriptionLists)
{
AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(DefaultAccount,
Guid.NewGuid().ToString(), DefaultTenant.ToString());
var subscriptionList = new Queue<List<string>>(subscriptionLists);
var clientFactory = new MockSubscriptionClientFactory(tenants, subscriptionList);
var mock = new MockClientFactory(new List<object>
{
clientFactory.GetSubscriptionClient()
}, true);
mock.MoqClients = true;
AzureSession.ClientFactory = mock;
var context = new AzureContext(new AzureSubscription()
{
Account = DefaultAccount,
Environment = EnvironmentName.AzureCloud,
Id = DefaultSubscription,
Name = DefaultSubscriptionName
},
new AzureAccount() { Id = DefaultAccount, Type = AzureAccount.AccountType.User },
AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud],
new AzureTenant() { Domain = DefaultDomain, Id = DefaultTenant });
var profile = new AzureRMProfile();
profile.Context = context;
return new RMProfileClient(profile);
}
public SqlThreatDetectionAdapter(AzureContext context)
{
Context = context;
Subscription = context.Subscription;
ThreatDetectionCommunicator = new ThreatDetectionEndpointsCommunicator(Context);
AzureCommunicator = new AzureEndpointsCommunicator(Context);
AuditingAdapter = new SqlAuditAdapter(context);
}
/// <summary>
/// Creates new ActiveDirectoryClient using WindowsAzureSubscription.
/// </summary>
/// <param name="context"></param>
public ActiveDirectoryClient(AzureContext context)
{
AccessTokenCredential creds = (AccessTokenCredential)AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
GraphClient = AzureSession.ClientFactory.CreateCustomClient<GraphRbacManagementClient>(
creds.TenantID,
creds,
context.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.Graph));
}
public SqlAuditAdapter(AzureContext context)
{
Context = context;
Subscription = context.Subscription;
Communicator = new AuditingEndpointsCommunicator(Context);
AzureCommunicator = new AzureEndpointsCommunicator(Context);
IgnoreStorage = false;
}
/// <summary>
/// Creates new ResourceManagementClient
/// </summary>
/// <param name="context">Profile containing resources to manipulate</param>
public ResourcesClient(AzureContext context)
: this(
AzureSession.ClientFactory.CreateClient<ResourceManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager),
new GalleryTemplatesClient(context),
AzureSession.ClientFactory.CreateClient<AuthorizationManagementClient>(context, AzureEnvironment.Endpoint.ResourceManager))
{
}
/// <summary>
/// Initialize method
/// </summary>
public void Initialize(AzureContext defaultContext, string apiVersion)
{
if (!this.Initialized)
{
this.IntuneClient = IntuneBaseCmdlet.GetIntuneManagementClient(defaultContext, apiVersion);
this.Initialized = true;
}
}
/// <summary>
/// Constructs a database adapter
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureSqlDatabaseReplicationAdapter(AzureContext context)
{
Context = context;
_subscription = context.Subscription;
ReplicationCommunicator = new AzureSqlDatabaseReplicationCommunicator(Context);
DatabaseCommunicator = new AzureSqlDatabaseCommunicator(Context);
ServerCommunicator = new AzureSqlServerCommunicator(Context);
}
/// <summary>
/// Creates a communicator for Azure Sql Databases FirewallRules
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlCapabilitiesCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
public NotificationHubsManagementClient(AzureContext azureContext)
{
if (azureContext == null)
{
throw new ArgumentNullException("azureContext");
}
_context = azureContext;
}
public ThreatDetectionEndpointsCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure Sql Recommended Elastic Pool
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlElasticPoolRecommendationCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure Sql Databases TransparentDataEncryption
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlDatabaseTransparentDataEncryptionCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure SQL Server Active Directory administrator
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlServerActiveDirectoryAdministratorCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure Sql Databases
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlDatabaseActivationCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure Sql Service Tier Advisor
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlServiceTierAdvisorCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
public ApiManagementClient(AzureContext context)
{
if (context == null)
{
throw new ArgumentNullException("AzureProfile");
}
_context = context;
}
/// <summary>
/// Creates a communicator for Azure Sql Databases ServiceObjective
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlServerServiceObjectiveCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
public AuditingEndpointsCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
/// <summary>
/// Creates a communicator for Azure Sql Elastic Pool
/// </summary>
/// <param name="profile"></param>
/// <param name="subscription"></param>
public AzureSqlServerCommunicationLinkCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
SqlClient = null;
}
}
public DataServiceCredential(IAuthenticationFactory authFactory, AzureContext context, AzureEnvironment.Endpoint resourceIdEndpoint)
{
if (authFactory == null)
throw new ArgumentNullException("authFactory");
if (context == null)
throw new ArgumentNullException("context");
var bundle = GetToken(authFactory, context, resourceIdEndpoint);
this.token = bundle.Item1;
}
/// <summary>
/// Determines the API version.
/// </summary>
/// <param name="context">The azure profile.</param>
/// <param name="resourceId">The resource Id.</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param>
internal static Task<string> DetermineApiVersion(AzureContext context, string resourceId, CancellationToken cancellationToken, bool? pre = null, Dictionary<string, string> cmdletHeaderValues = null)
{
var providerNamespace = ResourceIdUtility.GetExtensionProviderNamespace(resourceId)
?? ResourceIdUtility.GetProviderNamespace(resourceId);
var resourceType = ResourceIdUtility.GetExtensionResourceType(resourceId: resourceId, includeProviderNamespace: false)
?? ResourceIdUtility.GetResourceType(resourceId: resourceId, includeProviderNamespace: false);
return ApiVersionHelper.DetermineApiVersion(context: context, providerNamespace: providerNamespace, resourceType: resourceType, cancellationToken: cancellationToken, pre: pre, cmdletHeaderValues: cmdletHeaderValues);
}
/// <summary>
/// Default Constructor.
/// </summary>
/// <param name="profile">The current azure profile</param>
/// <param name="subscription">The current azure subscription</param>
public AzureEndpointsCommunicator(AzureContext context)
{
Context = context;
if (context.Subscription != Subscription)
{
Subscription = context.Subscription;
StorageClient = null;
ResourcesClient = null;
StorageV2Client = null;
}
}
internal static AzureSubscription ToAzureSubscription(this Subscription other, AzureContext context)
{
var subscription = new AzureSubscription();
subscription.Account = context.Account != null ? context.Account.Id : null;
subscription.Environment = context.Environment != null ? context.Environment.Name : EnvironmentName.AzureCloud;
subscription.Id = new Guid(other.SubscriptionId);
subscription.Name = other.DisplayName;
subscription.SetProperty(AzureSubscription.Property.Tenants,
context.Tenant.Id.ToString());
return subscription;
}
public DataLakeStoreClient(AzureContext context)
{
if (context == null)
{
throw new ApplicationException(Resources.InvalidDefaultSubscription);
}
_subscriptionId = context.Subscription.Id;
_client = AzureSession.ClientFactory.CreateClient<DataLakeStoreManagementClient>(context,
AzureEnvironment.Endpoint.ResourceManager);
_client.UserAgentSuffix = " - PowerShell Client";
}
public DataLakeStoreFileSystemClient(AzureContext context)
{
if (context == null)
{
throw new ApplicationException(Resources.InvalidDefaultSubscription);
}
var creds = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
_client = AzureSession.ClientFactory.CreateCustomClient<DataLakeStoreFileSystemManagementClient>(creds,
context.Environment.GetEndpoint(AzureEnvironment.Endpoint.AzureDataLakeStoreFileSystemEndpointSuffix));
_client.UserAgentSuffix = " - PowerShell Client";
uniqueActivityIdGenerator = new Random();
}
/// <summary>
/// Set the context for the current profile, preserving token cache information
/// </summary>
/// <param name="profile">The profile to change the context for</param>
/// <param name="newContext">The new context, with no token cache information.</param>
public static void SetContextWithCache(this AzureRMProfile profile, AzureContext newContext)
{
if (profile == null)
{
throw new ArgumentNullException("profile", Resources.ProfileCannotBeNull);
}
if (newContext == null)
{
throw new ArgumentNullException("newContext", Resources.ContextCannotBeNull);
}
newContext.TokenCache = TokenCache.DefaultShared.Serialize();
profile.Context = newContext;
}