/// <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); }
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 }
/// <summary> /// Initializes a new instance of the <see cref="PSAsrFabricDiscoveryClient" /> class. /// </summary> /// <param name="azureProfile">Azure context.</param> public PSAsrFabricDiscoveryClient(IAzureContextContainer azureProfile) { AzureContext = (AzureContext)azureProfile.DefaultContext; if (endPointUri == null) { endPointUri = azureProfile.DefaultContext.Environment.GetEndpointAsUri( AzureEnvironment.Endpoint.ResourceManager); } this.DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = DateTimeZoneHandling.Utc, NullValueHandling = NullValueHandling.Ignore, ReferenceLoopHandling = ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter(), new PolymorphicDeserializeJsonConverter <VMwareRunAsAccount>("type"), new PolymorphicDeserializeJsonConverter <VMwareMachine>("type") } }; }
public static void SetTokenCache(this IAzureContextContainer container, IAzureTokenCache cache) { if (container != null && container.DefaultContext != null) { container.DefaultContext.TokenCache = cache; } }
/// <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 IAzureContextContainer profile, IAzureContext newContext, string name = null) { if (profile == null) { throw new ArgumentNullException("profile", Resources.ProfileCannotBeNull); } if (newContext == null) { throw new ArgumentNullException("newContext", Resources.ContextCannotBeNull); } if (newContext.TokenCache != null && newContext.TokenCache.CacheData != null && newContext.TokenCache.CacheData.Length > 0) { AzureSession.Instance.TokenCache.CacheData = newContext.TokenCache.CacheData; } newContext.TokenCache = AzureSession.Instance.TokenCache; var rmProfile = profile as AzureRmProfile; if (rmProfile != null) { rmProfile.TrySetDefaultContext(name, newContext); } else { profile.DefaultContext = newContext; } }
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)); }
/// <summary> /// Registers resource providers for Sparta. /// </summary> /// <typeparam name="T">The client type</typeparam> private void RegisterResourceManagerProviders <T>(IAzureContextContainer profile) { var providersToRegister = RequiredResourceLookup.RequiredProvidersForResourceManager <T>(); var registeredProviders = profile.DefaultContext.Subscription.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders); var unregisteredProviders = providersToRegister.Where(p => !registeredProviders.Contains(p)).ToList(); var successfullyRegisteredProvider = new List <string>(); SubscriptionCloudCredentials creds = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(profile.DefaultContext); if (unregisteredProviders.Count > 0) { using (var client = ClientFactory.CreateCustomClient <ResourceManagementClient>( creds, profile.DefaultContext.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager))) { foreach (string provider in unregisteredProviders) { try { client.Providers.Register(provider); successfullyRegisteredProvider.Add(provider); } catch { // Ignore this as the user may not have access to service management endpoint or the provider is already registered } } } } }
public static bool HasTokenCache(this IAzureContextContainer container) { return(container != null && container.DefaultContext != null && container.DefaultContext.TokenCache != null && container.DefaultContext.TokenCache.CacheData != null && container.DefaultContext.TokenCache.CacheData.Length > 0); }
public void ApplyArm <TClient>(TClient client, IAzureContextContainer container, string endpoint) where TClient : Rest.ServiceClient <TClient> { Debug.Assert(ClientFactory != null); if (endpoint == AzureEnvironment.Endpoint.ResourceManager) { RegisterResourceManagerProviders <TClient>(container); } }
public override void SetTokenCacheForProfile(IAzureContextContainer profile) { base.SetTokenCacheForProfile(profile); if (profile.HasTokenCache()) { var cache = TokenCache.DefaultShared; cache.Deserialize(profile.GetTokenCache().CacheData); AzureSession.Instance.TokenCache = new AuthenticationStoreTokenCache(cache); } }
/// <summary> /// Initializes a new instance of the <see cref="PSRecoveryServicesClient" /> class with /// required current subscription. /// </summary> /// <param name="azureSubscription">Azure Subscription</param> public PSAsrComputeManagementClient( IAzureContextContainer azureProfile) { AzureContext = (AzureContext)azureProfile.DefaultContext; this.computeManagementClient = AzureSession.Instance.ClientFactory .CreateArmClient <Common.Compute.Version2016_04_preview.ComputeManagementClient>( AzureContext, AzureEnvironment.Endpoint.ResourceManager); }
public virtual TClient CreateClient <TClient>(IAzureContextContainer container, string endpoint) where TClient : ServiceClient <TClient> { TClient client = CreateClient <TClient>(container.DefaultContext, endpoint); foreach (IClientAction action in GetActions()) { action.Apply <TClient>(client, container, endpoint); } return(client); }
public static IAzureTokenCache GetTokenCache(this IAzureContextContainer container) { IAzureTokenCache result = null; if (HasTokenCache(container)) { result = container.DefaultContext.TokenCache; } return(result); }
public override void SetTokenCacheForProfile(IAzureContextContainer profile) { base.SetTokenCacheForProfile(profile); var session = AzureSession.Instance; var cache = new ProtectedFileTokenCache(Path.Combine(session.TokenCacheDirectory, session.TokenCacheFile), session.DataStore); session.TokenCache = cache; if (profile.HasTokenCache()) { cache.Deserialize(profile.GetTokenCache().CacheData); } profile.SetTokenCache(cache); }
/// <summary> /// Get the current storage account /// </summary> /// <returns>True if it need to init the service channel, otherwise false</returns> internal virtual bool TryGetStorageAccount(IAzureContextContainer profile, out string account) { account = null; bool result = false; //Storage Context is empty and have already set the current storage account in subscription if (Context == null && profile != null && profile.DefaultContext != null && profile.DefaultContext.Subscription != null && profile.DefaultContext.Subscription != null) { account = profile.DefaultContext.Subscription.GetProperty(AzureSubscription.Property.StorageAccount); result = !string.IsNullOrWhiteSpace(account); } return(result); }
/// <summary> /// Get the current storage account /// </summary> /// <returns>True if it need to init the service channel, otherwise false</returns> internal virtual bool TryGetStorageAccount(IAzureContextContainer profile, out string account) { account = null; //Storage Context is empty and have already set the current storage account in subscription if (Context != null || profile?.DefaultContext?.Subscription == null) { return(false); } account = profile.DefaultContext.GetCurrentStorageAccountConnectionString(); var result = !string.IsNullOrWhiteSpace(account); return(result); }
public void Apply <TClient>(TClient client, IAzureContextContainer container, string endpoint) where TClient : ServiceClient <TClient> { var profile = container as AzureSMProfile; Debug.Assert(ClientFactory != null); if (endpoint == AzureEnvironment.Endpoint.ServiceManagement) { RegisterServiceManagementProviders <TClient>(profile); } else if (endpoint == AzureEnvironment.Endpoint.ResourceManager) { RegisterResourceManagerProviders <TClient>(profile); } }
private static void RunDataProfileTest(IAzureContextContainer rmProfile, IAzureContextContainer smProfile, Action testAction) { AzureSession.Instance.DataStore = new MemoryDataStore(); var savedRmProfile = AzureRmProfileProvider.Instance.Profile; try { AzureRmProfileProvider.Instance.Profile = rmProfile; testAction(); } finally { AzureRmProfileProvider.Instance.Profile = savedRmProfile; } }
public AzKeyStore(IAzureContextContainer profile) { if (profile != null && profile.Accounts != null) { foreach (var account in profile.Accounts) { if (account != null && account.ExtendedProperties.ContainsKey(AzureAccount.Property.ServicePrincipalSecret)) { IKeyStoreKey keyStoreKey = new ServicePrincipalKey(AzureAccount.Property.ServicePrincipalSecret, account.Id , account.GetTenants().FirstOrDefault()); var servicePrincipalSecret = account.ExtendedProperties[AzureAccount.Property.ServicePrincipalSecret]; _credentials[keyStoreKey] = servicePrincipalSecret.ConvertToSecureString(); } } } }
public IAzureContextContainer CopyForContextOverriding(IAzureContextContainer contextContainer) { var profile = contextContainer as AzureRmProfile; return(new AzureRmProfile() { DefaultContextKey = profile.DefaultContextKey, EnvironmentTable = profile.EnvironmentTable, // Contexts need a new instance else any change to DefaultContext will affect the original profile Contexts = new ConcurrentDictionary <string, IAzureContext>(profile.Contexts, StringComparer.CurrentCultureIgnoreCase), ShouldRefreshContextsFromCache = profile.ShouldRefreshContextsFromCache, // ProfilePath is not copied because // 1. it's protected setter // 2. copy won't be written back to disk, so it's not useful ExtendedProperties = profile.ExtendedProperties }); }
public AzureRmServicePrincipalKeyStore(IAzureContextContainer profile) { _credentials = new Dictionary <string, SecureString>(); if (profile != null && profile.Accounts != null) { foreach (var account in profile.Accounts) { if (account != null && account.ExtendedProperties.ContainsKey(AzureAccount.Property.ServicePrincipalSecret)) { var appId = account.Id; var tenantId = account.GetTenants().FirstOrDefault(); var key = CreateKey(appId, tenantId); var servicePrincipalSecret = account.ExtendedProperties[AzureAccount.Property.ServicePrincipalSecret]; _credentials[key] = ConvertToSecureString(servicePrincipalSecret); } } } }
/// <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 IAzureContextContainer profile, IAzureContext newContext) { if (profile == null) { throw new ArgumentNullException("profile", Resources.ProfileCannotBeNull); } if (newContext == null) { throw new ArgumentNullException("newContext", Resources.ContextCannotBeNull); } if (newContext.TokenCache != null && newContext.TokenCache.CacheData != null && newContext.TokenCache.CacheData.Length > 0) { AzureSession.Instance.TokenCache.CacheData = newContext.TokenCache.CacheData; } newContext.TokenCache = AzureSession.Instance.TokenCache; profile.DefaultContext = newContext; }
/// <summary> /// Set the context for the current profile, preserving token cache information. /// After MSAL, token cache is no longer stored in contexts. So this method roughly equals to TrySetDefaultContext(). /// </summary> /// <param name="profile">The profile to change the context for</param> /// <param name="newContext">The new context, with no token cache information.</param> /// <param name="name"></param> public static void SetContextWithCache(this IAzureContextContainer profile, IAzureContext newContext, string name = null) { if (profile == null) { throw new ArgumentNullException("profile", Resources.ProfileCannotBeNull); } if (newContext == null) { throw new ArgumentNullException("newContext", Resources.ContextCannotBeNull); } var rmProfile = profile as AzureRmProfile; if (rmProfile != null) { rmProfile.TrySetDefaultContext(name, newContext); } else { profile.DefaultContext = newContext; } }
/// <summary> /// Initializes a new instance of the <see cref="PSRecoveryServicesClient" /> class with /// required current subscription. /// </summary> /// <param name="azureSubscription">Azure Subscription</param> public PSRecoveryServicesClient( IAzureContextContainer azureProfile) { AzureContext = (AzureContext)azureProfile.DefaultContext; var resourceNamespace = ARMResourceTypeConstants .RecoveryServicesResourceProviderNameSpace; var resourceType = ARMResourceTypeConstants.RecoveryServicesVault; // Get Resource provider namespace and type from config only if Vault context is not set // (hopefully it is required only for Vault related cmdlets) if (string.IsNullOrEmpty(asrVaultCreds.ResourceNamespace) || string.IsNullOrEmpty(asrVaultCreds.ARMResourceType)) { Utilities.UpdateCurrentVaultContext( new ASRVaultCreds { ResourceNamespace = resourceNamespace, ARMResourceType = resourceType }); } if (null == endPointUri) { endPointUri = azureProfile.DefaultContext.Environment.GetEndpointAsUri( AzureEnvironment.Endpoint.ResourceManager); } cloudCredentials = AzureSession.Instance.AuthenticationFactory .GetSubscriptionCloudCredentials(azureProfile.DefaultContext); this.recoveryServicesVaultClient = AzureSession.Instance.ClientFactory .CreateArmClient <RecoveryServicesClient>( AzureContext, AzureEnvironment.Endpoint.ResourceManager); }
private static void RunDataProfileTest(IAzureContextContainer rmProfile, IAzureContextContainer smProfile, Action testAction) { AzureSession.Instance.DataStore = new MemoryDataStore(); var savedRmProfile = AzureRmProfileProvider.Instance.Profile; #if !NETSTANDARD var savedSmProfile = AzureSMProfileProvider.Instance.Profile; #endif try { AzureRmProfileProvider.Instance.Profile = rmProfile; #if !NETSTANDARD AzureSMProfileProvider.Instance.Profile = smProfile; #endif testAction(); } finally { AzureRmProfileProvider.Instance.Profile = savedRmProfile; #if !NETSTANDARD AzureSMProfileProvider.Instance.Profile = savedSmProfile; #endif } }
public TClient CreateClient <TClient>(IAzureContextContainer profile, string endpoint) where TClient : ServiceClient <TClient> { return(CreateClient <TClient>(profile, profile.DefaultContext.Subscription, endpoint)); }
public TClient CreateClient <TClient>(IAzureContextContainer profile, IAzureSubscription subscription, string endpoint) where TClient : Hyak.Common.ServiceClient <TClient> { throw new NotImplementedException(); }
public abstract void SetTokenCacheForProfile(IAzureContextContainer profile);
/// <summary> /// Initializes a new instance of the <see cref="PSRecoveryServicesClient" /> class with /// required current subscription. /// </summary> /// <param name="azureSubscription">Azure Subscription</param> public PSRecoveryServicesClient(IAzureContextContainer azureProfile) { System.Configuration.Configuration siteRecoveryConfig = ConfigurationManager.OpenExeConfiguration(System.Reflection.Assembly.GetExecutingAssembly().Location); System.Configuration.AppSettingsSection appSettings = (System.Configuration.AppSettingsSection)siteRecoveryConfig.GetSection("appSettings"); string resourceNamespace = string.Empty; string resourceType = string.Empty; // Get Resource provider namespace and type from config only if Vault context is not set // (hopefully it is required only for Vault related cmdlets) if (string.IsNullOrEmpty(asrVaultCreds.ResourceNamespace) || string.IsNullOrEmpty(asrVaultCreds.ARMResourceType)) { if (appSettings.Settings.Count == 0) { resourceNamespace = "Microsoft.SiteRecovery"; // ProviderNameSpace for Production is taken as default resourceType = ARMResourceTypeConstants.SiteRecoveryVault; } else { resourceNamespace = null == appSettings.Settings["ProviderNamespace"] ? "Microsoft.SiteRecovery" : appSettings.Settings["ProviderNamespace"].Value; resourceType = null == appSettings.Settings["ResourceType"] ? ARMResourceTypeConstants.SiteRecoveryVault : appSettings.Settings["ResourceType"].Value; } Utilities.UpdateCurrentVaultContext(new ASRVaultCreds() { ResourceNamespace = resourceNamespace, ARMResourceType = resourceType }); } if (null == endPointUri) { if (appSettings.Settings.Count == 0) { endPointUri = azureProfile.DefaultContext.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager); } else { if (null == appSettings.Settings["RDFEProxy"]) { endPointUri = azureProfile.DefaultContext.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager); } else { // Setting Endpoint to RDFE Proxy if (null == ServicePointManager.ServerCertificateValidationCallback) { ServicePointManager.ServerCertificateValidationCallback = IgnoreCertificateErrorHandler; } endPointUri = new Uri(appSettings.Settings["RDFEProxy"].Value); } } } cloudCredentials = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(azureProfile.DefaultContext); this.recoveryServicesClient = AzureSession.Instance.ClientFactory.CreateCustomClient <SiteRecoveryVaultManagementClient>( asrVaultCreds.ResourceNamespace, asrVaultCreds.ARMResourceType, cloudCredentials, azureProfile.DefaultContext.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager)); }
/// <summary> /// Get the list of subscriptions associated with the given account /// </summary> /// <param name="account">The account to look for</param> /// <param name="profile">The profile to search</param> /// <returns>A list of subscriptions available to the given account</returns> public static List <IAzureSubscription> GetSubscriptions(this IAzureAccount account, IAzureContextContainer profile) { string[] subscriptions = new string[0]; List <IAzureSubscription> subscriptionsList = new List <IAzureSubscription>(); if (account.IsPropertySet(AzureAccount.Property.Subscriptions)) { subscriptions = account.GetSubscriptions(); } foreach (var subscription in subscriptions) { var foundSubscription = profile.Subscriptions.FirstOrDefault((s) => string.Equals(s.Id, subscription, StringComparison.OrdinalIgnoreCase)); if (foundSubscription != null) { subscriptionsList.Add(foundSubscription); } } return(subscriptionsList); }