public IAzureSubscription AddOrSetSubscription(IAzureSubscription subscription)
{
if (subscription == null)
{
throw new ArgumentNullException("subscription", Resources.SubscriptionNeedsToBeSpecified);
}
if (subscription.GetEnvironment() == null)
{
throw new ArgumentNullException("subscription.Environment", Resources.EnvironmentNeedsToBeSpecified);
}
// Validate environment
GetEnvironmentOrDefault(subscription.GetEnvironment());
if (Profile.SubscriptionTable.ContainsKey(subscription.GetId()))
{
Profile.SubscriptionTable[subscription.GetId()] = MergeSubscriptionProperties(subscription, Profile.SubscriptionTable[subscription.GetId()]);
}
else
{
Debug.Assert(!string.IsNullOrEmpty(subscription.GetAccount()));
if (!Profile.AccountTable.ContainsKey(subscription.GetAccount()))
{
throw new KeyNotFoundException(string.Format("The specified account {0} does not exist in profile accounts", subscription.GetAccount()));
}
Profile.SubscriptionTable[subscription.GetId()] = subscription;
}
return(Profile.SubscriptionTable[subscription.GetId()]);
}
public TClient CreateClient <TClient>(IAzureContextContainer profile, IAzureSubscription subscription, string endpoint) where TClient : ServiceClient <TClient>
{
#if !NETSTANDARD
if (subscription == null)
{
throw new ArgumentException(Microsoft.Azure.Commands.ResourceManager.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile as AzureSMProfile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.GetAccount()),
profileClient.GetEnvironmentOrDefault(subscription.GetEnvironment())
);
creds = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.Environments.FirstOrDefault((e) => e.Name.Equals(subscription.GetEnvironment(), StringComparison.OrdinalIgnoreCase)).GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
#else
throw new NotSupportedException("AzureSMProfile is not supported in Azure PS on .Net Core.");
#endif
}
public static IHDInsightSubscriptionCredentials GetSubscriptionCredentials(
this IAzureHDInsightCommonCommandBase command,
IAzureSubscription currentSubscription,
IAzureEnvironment environment,
AzureSMProfile profile)
{
var accountId = currentSubscription.GetAccount();
Debug.Assert(profile.AccountTable.ContainsKey(accountId));
if (profile.AccountTable[accountId].Type == AzureAccount.AccountType.Certificate)
{
return(GetSubscriptionCertificateCredentials(command, currentSubscription, profile.AccountTable[accountId], environment));
}
else if (profile.AccountTable[accountId].Type == AzureAccount.AccountType.User)
{
return(GetAccessTokenCredentials(command, currentSubscription, profile.AccountTable[accountId], environment));
}
else if (profile.AccountTable[accountId].Type == AzureAccount.AccountType.ServicePrincipal)
{
return(GetAccessTokenCredentials(command, currentSubscription, profile.AccountTable[accountId], environment));
}
throw new NotSupportedException();
}
public TClient CreateClient <TClient>(IAzureContextContainer container, IAzureSubscription subscription, string endpoint) where TClient : ServiceClient <TClient>
{
var profile = container as AzureSMProfile;
if (subscription == null)
{
throw new ArgumentException(Commands.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.GetAccount()),
profileClient.GetEnvironmentOrDefault(subscription.GetEnvironment())
);
creds = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.EnvironmentTable[subscription.GetEnvironment()].GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
}
public static IHDInsightSubscriptionCredentials GetSubscriptionCertificateCredentials(this IAzureHDInsightCommonCommandBase command,
IAzureSubscription currentSubscription, IAzureAccount azureAccount, IAzureEnvironment environment)
{
return(new HDInsightCertificateCredential
{
SubscriptionId = currentSubscription.GetId(),
Certificate = AzureSession.Instance.DataStore.GetCertificate(currentSubscription.GetAccount()),
Endpoint = environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ServiceManagement),
});
}
public PSAzureSubscription(IAzureSubscription subscription, AzureSMProfile profile)
{
SubscriptionId = subscription.Id.ToString();
SubscriptionName = subscription.Name;
Environment = subscription.GetEnvironment();
DefaultAccount = subscription.GetAccount();
Accounts = profile.AccountTable.Values.Where(a => a.HasSubscription(subscription.GetId())).ToArray();
IsDefault = subscription.IsPropertySet(AzureSubscription.Property.Default);
IsCurrent = profile.Context != null && profile.Context.Subscription.Id == subscription.Id;
CurrentStorageAccountName = subscription.GetProperty(AzureSubscription.Property.StorageAccount);
TenantId = subscription.GetTenant();
}
internal Subscription(IAzureSubscription azureSubscription)
{
if (azureSubscription == null)
{
throw new ArgumentNullException();
}
ProfileClient client = new ProfileClient(new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile)));
var environment = client.GetEnvironmentOrDefault(azureSubscription.GetEnvironment());
this.SubscriptionName = azureSubscription.Name;
this.SubscriptionId = azureSubscription.Id.ToString();
this.ServiceEndpoint = new Uri(String.Format("{0}/{1}/services/systemcenter/vmm", environment.GetEndpoint(AzureEnvironment.Endpoint.ServiceManagement).TrimEnd(new[] { '/' }), SubscriptionId));
this.Certificate = FileUtilities.DataStore.GetCertificate(azureSubscription.GetAccount());
this.CredentialType = CredentialType.UseCertificate;
}
/// <summary>
/// Returns Account specified in the parameter or current account of the subscription
/// </summary>
/// <returns></returns>
private string GetAccount()
{
if (!string.IsNullOrEmpty(Account))
{
return(Account);
}
IAzureSubscription subscription = ProfileClient.Profile.SubscriptionTable.Values
.Where(s => !string.IsNullOrWhiteSpace(s.Name))
.FirstOrDefault(s => s.Name.Equals(SubscriptionName, StringComparison.InvariantCultureIgnoreCase) ||
s.Id.ToString().Equals(SubscriptionId, StringComparison.InvariantCultureIgnoreCase));
if (subscription != null)
{
return(subscription.GetAccount());
}
else
{
return(null);
}
}
private PSAzureSubscriptionExtended ConstructPsAzureSubscriptionExtended(IAzureSubscription subscription, IClientFactory clientFactory)
{
using (var client = clientFactory.CreateClient <ManagementClient>(Profile, subscription, AzureEnvironment.Endpoint.ServiceManagement))
{
var response = client.Subscriptions.Get();
var environment = ProfileClient.GetEnvironmentOrDefault(subscription.GetEnvironment());
var account = ProfileClient.Profile.AccountTable[subscription.GetAccount()];
bool isCert = account.Type == AzureAccount.AccountType.Certificate;
var psAzureSubscription = new PSAzureSubscription(subscription, ProfileClient.Profile);
PSAzureSubscriptionExtended result = new PSAzureSubscriptionExtended(psAzureSubscription)
{
AccountAdminLiveEmailId = response.AccountAdminLiveEmailId,
ActiveDirectoryUserId = subscription.GetAccount(),
CurrentCoreCount = response.CurrentCoreCount,
CurrentHostedServices = response.CurrentHostedServices,
CurrentDnsServers = response.CurrentDnsServers,
CurrentLocalNetworkSites = response.CurrentLocalNetworkSites,
CurrentStorageAccounts = response.CurrentStorageAccounts,
CurrentVirtualNetworkSites = response.CurrentVirtualNetworkSites,
MaxCoreCount = response.MaximumCoreCount,
MaxDnsServers = response.MaximumDnsServers,
MaxHostedServices = response.MaximumHostedServices,
MaxLocalNetworkSites = response.MaximumLocalNetworkSites,
MaxStorageAccounts = response.MaximumStorageAccounts,
MaxVirtualNetworkSites = response.MaximumVirtualNetworkSites,
ServiceAdminLiveEmailId = response.ServiceAdminLiveEmailId,
SubscriptionRealName = response.SubscriptionName,
SubscriptionStatus = response.SubscriptionStatus.ToString(),
ServiceEndpoint = environment.GetEndpoint(AzureEnvironment.Endpoint.ServiceManagement),
ResourceManagerEndpoint = environment.GetEndpoint(AzureEnvironment.Endpoint.ResourceManager),
IsDefault = subscription.GetProperty(AzureSubscription.Property.Default) != null,
Account = account,
Certificate = isCert ? AzureSession.Instance.DataStore.GetCertificate(subscription.GetAccount()) : null,
CurrentStorageAccountName = subscription.GetProperty(AzureSubscription.Property.StorageAccount)
};
return(result);
}
}
/// <summary>
/// Creates the client.
/// </summary>
/// <typeparam name="TClient">The type of the client.</typeparam>
/// <param name="profile">The profile.</param>
/// <param name="subscription">The subscription.</param>
/// <param name="endpoint">The endpoint.</param>
/// <returns></returns>
/// <exception cref="System.ApplicationException"></exception>
/// <exception cref="System.ArgumentException">
/// accountName
/// or
/// environment
/// </exception>
public virtual TClient CreateClient <TClient>(IAzureContextContainer profile, IAzureSubscription subscription, string endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ApplicationException(Resources.InvalidDefaultSubscription);
}
var account = profile.Accounts.FirstOrDefault((a) => string.Equals(a.Id, (subscription.GetAccount()), StringComparison.OrdinalIgnoreCase));
if (null == account)
{
throw new ArgumentException(string.Format("Account with name '{0}' does not exist.", subscription.GetAccount()), "accountName");
}
var environment = profile.Environments.FirstOrDefault((e) => string.Equals(e.Name, subscription.GetEnvironment(), StringComparison.OrdinalIgnoreCase));
if (null == environment)
{
throw new ArgumentException(string.Format(Resources.EnvironmentNotFound, subscription.GetEnvironment()));
}
AzureContext context = new AzureContext(subscription, account, environment);
var client = CreateClient <TClient>(context, endpoint);
foreach (IClientAction action in GetActions())
{
action.Apply <TClient>(client, profile, endpoint);
}
return(client);
}
