public static ResourceGroupExtended CreateResourceGroup( SubscriptionCloudCredentials creds, string name, string location ) { var resourceMgmtClient = new ResourceManagementClient( creds ); var resourceGroupsResponse = resourceMgmtClient.ResourceGroups.CreateOrUpdate( name, new ResourceGroup { Location = location } ); return resourceGroupsResponse.ResourceGroup; }
public ResourceGroupHelper(SubscriptionCloudCredentials credentials) { _client = new ResourceManagementClient(credentials); if (!IsProviderRegistered(_client.Providers.List(null), "Micorsoft.Network")) { _client.Providers.Register("Microsoft.Network"); } }
private static SubscriptionCloudCredentials GetCreds() { if (Creds == null) { X509Certificate2 cert = new X509Certificate2(certName, certPassword); Creds = new CertificateCloudCredentials(testSubscription, cert); ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => { return true; }; } return Creds; }
public void CreateCloudService(SubscriptionCloudCredentials credentials,string cloudServiceName) { var cloudServiceClient = new CloudServiceManagementClient(credentials); var cloudServiceCreateParameters = new CloudServiceCreateParameters { Description = cloudServiceParameters.Description, GeoRegion = cloudServiceParameters.GeoRegion, Label = cloudServiceParameters.Label }; cloudServiceClient.CloudServices.Create(cloudServiceName, cloudServiceCreateParameters); }
public static string[] GetRegions( SubscriptionCloudCredentials creds ) { var sbMgmt = new ServiceBusManagementClient( creds ); var regionsResponse = sbMgmt.GetServiceBusRegionsAsync( ).Result; int currentRegion = 0, regionsCount = regionsResponse.Count( ); string[] regions = new string[ regionsCount ]; foreach( var region in regionsResponse ) { regions[ currentRegion++ ] = region.FullName; } return regions; }
public static ServiceBusNamespace[] GetNamespaces( SubscriptionCloudCredentials creds ) { var sbMgmt = new ServiceBusManagementClient( creds ); var regionsResponse = sbMgmt.Namespaces.List( ); int currentNamespace = 0, namespaceCount = regionsResponse.Count( ); ServiceBusNamespace[] namespaces = new ServiceBusNamespace[ namespaceCount ]; foreach( var region in regionsResponse ) { namespaces[ currentNamespace++ ] = region; } return namespaces; }
public static ResourceGroupExtended[] GetResourceGroups( SubscriptionCloudCredentials creds ) { var resourceMgmtClient = new ResourceManagementClient( creds ); var resourceGroupsResponse = resourceMgmtClient.ResourceGroups.ListAsync( new ResourceGroupListParameters( ) ).Result; int currentGroup = 0, resourceGroupsCount = resourceGroupsResponse.ResourceGroups.Count; ResourceGroupExtended[] resourceGroups = new ResourceGroupExtended[ resourceGroupsCount ]; foreach( var group in resourceGroupsResponse.ResourceGroups ) { resourceGroups[ currentGroup++ ] = group; } return resourceGroups; }
GetSubscriptionList( SubscriptionCloudCredentials credentials ) { IList<SubscriptionListOperationResponse.Subscription> ret = null; using( var subscriptionClient = new SubscriptionClient( credentials ) ) { var listSubscriptionResults = await subscriptionClient.Subscriptions.ListAsync( ); var subscriptions = listSubscriptionResults.Subscriptions; ret = subscriptions; } return ret; }
public static RecoveryServicesManagementClient CreateRecoveryServicesManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials, Uri baseUri) { return(new RecoveryServicesManagementClient(credentials, baseUri)); }
/// <summary> /// Gets deployment response from MS azure using API call. /// </summary> /// <param name="credentials">Subscription Cloud Credentials</param> /// <param name="serviceUrl">ServiceUrl of subscription</param> /// <param name="serviceName">Name of azure service</param> /// <param name="deploymentName">Name of azure service deployment</param> /// <returns>Deployment response for subscription </returns> private DeploymentGetResponse GetDeploymentResponseFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl, string serviceName, string deploymentName) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetDeploymentFromMSAzureStarted, ResourceType.CloudService.ToString()); using (var client = new ComputeManagementClient(credentials, serviceUrl)) { // Call management API to get list of CloudServices. DeploymentGetResponse deploymentResponse = Retry.RetryOperation(() => client.Deployments.GetByName(serviceName, deploymentName), (BaseParameters)importParameters, ResourceType.Deployment, deploymentName); Logger.Info(methodName, ProgressResources.GetDeploymentFromMSAzureCompleted, ResourceType.CloudService.ToString()); return deploymentResponse; } }
public DnsZoneHelper(SubscriptionCloudCredentials credentials) { _client = new DnsManagementClient(credentials); }
public static GalleryClient CreateGalleryClient(this CloudClients clients, SubscriptionCloudCredentials credentials) { return(new GalleryClient(credentials)); }
public static AutomationManagementClient CreateCloudServiceManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials) { return(new AutomationManagementClient(credentials)); }
public static ResourceManagementClient CreateResourceManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials) { return(new ResourceManagementClient(credentials)); }
public static EventHubDescription SelectEventHub( NamespaceManager nsManager, SubscriptionCloudCredentials credentials ) { Console.WriteLine( "Retrieving a list of created Event Hubs..." ); EventHubDescription[ ] eventHubs = nsManager.GetEventHubs( ).ToArray( ); int eventHubCount = eventHubs.Length; Console.WriteLine( "Created Event Hubs: " ); for( int currentNamespace = 1; currentNamespace <= eventHubCount; ++currentNamespace ) { Console.WriteLine( currentNamespace + ": " + eventHubs[ currentNamespace - 1 ].Path ); } for( ;; ) { Console.WriteLine( "Please select Event Hub you want to use: " ); string answer = Console.ReadLine( ); int selection; if( !int.TryParse( answer, out selection ) || selection > eventHubCount || selection < -1 ) { Console.WriteLine( "Incorrect Event Hub number." ); continue; } if( ConsoleHelper.Confirm( "Are you sure you want to select " + eventHubs[ selection - 1 ].Path + " Event Hub?" ) ) { return eventHubs[ selection - 1 ]; } } }
/// <summary> /// Refreshes the token used to access azure automation. /// This is currently called from a timer that runs on the Constants.tokenRefreshInterval /// If it is about to expire (2 minutes from the next refresh, it will renew) /// </summary> public void RefreshAutomationClientwithNewToken() { // Get the token for the tenant on this subscription and check if it is about to expire. // If it is, refresh it if possible. if (currSubscription == null) return; if (azureARMAuthResult.ExpiresOn.ToLocalTime() < DateTime.Now.AddMinutes(Constants.tokenRefreshInterval + 2)) { azureARMAuthResult = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.ActiveDirectoryTenantId); subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, azureARMAuthResult.AccessToken); automationManagementClient = new AutomationManagementClient(subscriptionCreds); // Add user agent string to indicate this is coming from the ISE automation client. ProductInfoHeaderValue ISEClientAgent = new ProductInfoHeaderValue(Constants.ISEUserAgent, Constants.ISEVersion); automationManagementClient.UserAgent.Add(ISEClientAgent); } }
/// <summary> /// Checks for storage account name availability /// </summary> /// <param name="storageAccountName">Destination storage account name</param> /// <param name="credentials">Destination subscription credentials</param> /// <returns>false if storage account name is reserved</returns> private bool CheckStorageNameAvailability(string storageAccountName, SubscriptionCloudCredentials credentials) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, String.Format(ProgressResources.CheckStorageNameAvailabilityFromMSAzureStarted, storageAccountName), ResourceType.StorageAccount.ToString(), storageAccountName); using (var client = new StorageManagementClient(credentials)) { CheckNameAvailabilityResponse storageResponse = Retry.RetryOperation(() => client.StorageAccounts.CheckNameAvailability( storageAccountName), (BaseParameters)importParameters, ResourceType.StorageAccount, storageAccountName); Logger.Info(methodName, String.Format(ProgressResources.CheckStorageNameAvailabilityFromMSAzureCompleted, storageAccountName), ResourceType.StorageAccount.ToString(), storageAccountName); return storageResponse.IsAvailable; } }
/// <summary> /// Gets network configuration from MS azure using management API call. /// Changed in v2.0 /// </summary> /// <param name="credentials">Source subscription credentials</param> /// <param name="serviceUrl">Subscription service Url</param> /// <returns>Network configuration for subscription</returns> private NetworkGetConfigurationResponse GetNetworkConfigurationFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted, ResourceType.VirtualNetwork.ToString()); dcMigration.ReportProgress(ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted); NetworkGetConfigurationResponse ventConfig = null; using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl)) { try { ventConfig = vnetClient.Networks.GetConfiguration(); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureCompleted, ResourceType.VirtualNetwork.ToString()); return ventConfig; } catch (CloudException cex) { if (ventConfig == null) { return ventConfig; } if (string.Compare(cex.Error.ToString(), Constants.ResourceNotFound, StringComparison.CurrentCultureIgnoreCase) == 0) { return null; } else { Logger.Error(methodName, cex, ResourceType.VirtualNetwork.ToString()); throw; } } } }
/// <summary> /// Gets list of storage account operation response from MS azure using API call. /// </summary> /// <param name="credentials">Source Subscription Credentials</param> /// <returns>list of storage account</returns> internal StorageAccountListResponse GetStorageAccountListResponseFromMSAzure(SubscriptionCloudCredentials credentials) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; dcMigration.ReportProgress(ProgressResources.GetStorageAccountsFromMSAzureStarted); try { Logger.Info(methodName, ProgressResources.GetStorageAccountsFromMSAzureStarted, ResourceType.StorageAccount.ToString()); using (var client = new StorageManagementClient(credentials)) { // Call management API to get list of storage accounts. StorageAccountListResponse storageResponse = Retry.RetryOperation(() => client.StorageAccounts.List(),(BaseParameters)exportParameters,ResourceType.StorageAccount); Logger.Info(methodName, ProgressResources.GetStorageAccountsFromMSAzureCompleted, ResourceType.StorageAccount.ToString()); return storageResponse; } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.StorageAccount.ToString()); throw; } }
/// <summary> /// Gets list of affinity group operation response from MS azure using API call. /// </summary> /// <param name="credentials">credentials</param> /// <returns>List of affinity group operation response for subscription </returns> private AffinityGroupListResponse GetAffinityGroupListResponseFromMSAzure(SubscriptionCloudCredentials credentials) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetAffinityGroupsFromMSAzureStarted, ResourceType.AffinityGroup.ToString()); dcMigration.ReportProgress(ProgressResources.GetAffinityGroupsFromMSAzureStarted); try { using (var client = new ManagementClient(credentials)) { //// Call management API to get list of affinity groups. AffinityGroupListResponse agResponse = Retry.RetryOperation(() => client.AffinityGroups.List(),(BaseParameters)exportParameters,ResourceType.AffinityGroup); Logger.Info(methodName, ProgressResources.GetAffinityGroupsFromMSAzureCompleted, ResourceType.AffinityGroup.ToString()); return agResponse; } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.AffinityGroup.ToString()); throw; } }
/// <summary> /// Gets list of hosted service operation response from MS azure using API call. /// </summary> /// <param name="credentials">credentials</param> /// <param name="serviceUrl">serviceUrl</param> /// <returns>List of hosted service operation response for subscription </returns> private HostedServiceListResponse GetCloudServiceListResponseFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetServicesFromMSAzureStarted, ResourceType.CloudService.ToString()); dcMigration.ReportProgress(ProgressResources.GetServicesFromMSAzureStarted); try { using (var client = new ComputeManagementClient(credentials, serviceUrl)) { ////Call management API to get list of CloudServices. ////HostedServiceListResponse serviceResponse = Retry.RetryOperation(() => client.HostedServices.List(), exportParameters.RetryCount, exportParameters.MinBackOff, exportParameters.MaxBackOff, exportParameters.DeltaBackOff, ResourceType.CloudService); HostedServiceListResponse serviceResponse = Retry.RetryOperation(() => client.HostedServices.List(), (BaseParameters)exportParameters, ResourceType.CloudService); Logger.Info(methodName, ProgressResources.GetServicesFromMSAzureCompleted, ResourceType.CloudService.ToString()); return serviceResponse; } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.CloudService.ToString()); throw; } }
private StorageAccountGetKeysResponse GetStorageAccountKeysFromMSAzure(SubscriptionCloudCredentials credentials, string storageAccountName) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; using (var client = new StorageManagementClient(credentials)) { Logger.Info(methodName, string.Format(ProgressResources.GetStorageAccountKeysStarted, storageAccountName),ResourceType.StorageAccount.ToString(),storageAccountName); ////Call management API to get keys of storage account. StorageAccountGetKeysResponse storageKeyResponse = Retry.RetryOperation(() => client.StorageAccounts.GetKeys(storageAccountName), (BaseParameters)exportParameters, ResourceType.StorageAccount, storageAccountName); Logger.Info(methodName, string.Format(ProgressResources.GetStorageAccountKeysCompleted, storageAccountName), ResourceType.StorageAccount.ToString(), storageAccountName); return storageKeyResponse; } }
public static GalleryClient CreateCloudServiceManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials, Uri baseUri) { return(new GalleryClient(credentials, baseUri)); }
/// <summary> /// Gets network configuration from MS azure using management API call. /// </summary> /// <param name="credentials">Subscription Cloud Credentials</param> /// <param name="serviceUrl">service url of subscription</param> /// <returns>Network configuration for subscription</returns> private NetworkGetConfigurationResponse GetNetworkConfigurationFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.VirtualNetwork.ToString()); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted); using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl)) { try { NetworkGetConfigurationResponse ventConfig = vnetClient.Networks.GetConfiguration(); Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureCompleted, ResourceType.VirtualNetwork.ToString()); Logger.Info(methodName, ProgressResources.ExecutionCompleted, ResourceType.VirtualNetwork.ToString()); return ventConfig; } catch (CloudException cex) { if (cex.Error.ToString() == Constants.ResourceNotFound) { return null; } else { Logger.Error(methodName, cex); throw cex; } } } }
public async Task<IList<ResourceGroupExtended>> GetResourceGroups() { if (currSubscription == null) throw new Exception(Properties.Resources.SubscriptionNotSet); // Get the token for the tenant on this subscription. var cloudtoken = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.ActiveDirectoryTenantId); subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, cloudtoken.AccessToken); resourceManagementClient = new ResourceManagementClient(subscriptionCreds); ResourceGroupListResult resourceGroupResult = await resourceManagementClient.ResourceGroups.ListAsync(null); return resourceGroupResult.ResourceGroups; }
private static void ValidateClientWithCredentials( DataFactoryManagementClient client, SubscriptionCloudCredentials expectedCredentials, Mock<TokenCloudCredentials> mockCredentials) { ValidateDefaultClientProperties(client); Assert.Equal(expectedCredentials, client.Credentials); Assert.Equal(expectedCredentials, client.InternalClient.Credentials); Assert.NotNull(client.InternalClient.BaseUri); Assert.NotNull(client.BaseUri); ValidateCredentialMock(mockCredentials, client); }
public async Task<IList<AutomationAccount>> GetAutomationAccounts() { if(currSubscription == null) throw new Exception(Properties.Resources.SubscriptionNotSet); // Get the token for the tenant on this subscription. azureARMAuthResult = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.ActiveDirectoryTenantId); subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, azureARMAuthResult.AccessToken); automationManagementClient = new AutomationManagementClient(subscriptionCreds); // Add user agent string to indicate this is coming from the ISE automation client. ProductInfoHeaderValue ISEClientAgent = new ProductInfoHeaderValue(Constants.ISEUserAgent, Constants.ISEVersion); automationManagementClient.UserAgent.Add(ISEClientAgent); //TODO: does this belong here? if (accountResourceGroups == null) accountResourceGroups = new Dictionary<AutomationAccount, ResourceGroupExtended>(); else accountResourceGroups.Clear(); IList<AutomationAccount> result = new List<AutomationAccount>(); IList<ResourceGroupExtended> resourceGroups = await this.GetResourceGroups(); foreach (ResourceGroupExtended resourceGroup in resourceGroups) { AutomationAccountListResponse accountListResponse = await automationManagementClient.AutomationAccounts.ListAsync(resourceGroup.Name); foreach (AutomationAccount account in accountListResponse.AutomationAccounts) { result.Add(account); accountResourceGroups.Add(account, resourceGroup); } } return result; }
public static ManagedCacheClient CreateManagedCacheManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials, Uri baseUri) { return(new ManagedCacheClient(credentials, baseUri)); }
public static AutomationManagementClient CreateAutomationManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials, Uri baseUri) { return(new AutomationManagementClient(credentials, baseUri)); }
/// <summary> /// Checks for service name availability /// </summary> /// <param name="serviceName"> Service Name</param> /// <param name="credentials"> Destination subscription credentials</param> /// <param name="serviceUrl"> Destination subscription service Url</param> /// <returns>false if service name is reserved</returns> private bool CheckServiceNameAvailability(string serviceName, SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, string.Format(ProgressResources.CheckServiceNameAvailabilityFromMSAzureStarted, serviceName), ResourceType.CloudService.ToString(), serviceName); using (var client = new ComputeManagementClient(credentials, serviceUrl)) { HostedServiceCheckNameAvailabilityResponse availabilityResponse = Retry.RetryOperation(() => client.HostedServices.CheckNameAvailability(serviceName), (BaseParameters)importParameters, ResourceType.CloudService, serviceName); Logger.Info(methodName, String.Format(ProgressResources.CheckServiceNameAvailabilityFromMSAzureCompleted, serviceName), ResourceType.CloudService.ToString(), serviceName); return availabilityResponse.IsAvailable; } }
/// <summary> /// Exports list of SubscriptionId specific dataCenters. /// </summary> /// <param name="credentials"> Subscription credentials</param> /// <param name="retryCount"> No. of times to retry in case of exception</param> /// <param name="minBackOff">Minimum backoff in seconds</param> /// <param name="maxBackOff">Maximum backoff in seconds</param> /// <param name="deltaBackOff">Delta Backoff in seconds</param> /// <returns>List of SubscriptionId specific dataCenters.</returns> private static List<string> ExportDataCenterLocations(SubscriptionCloudCredentials credentials, int retryCount, double minBackOff, double maxBackOff, double deltaBackOff) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted); try { using (var client = new ManagementClient(credentials)) { BaseParameters baseParams = new BaseParameters() { RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff) }; // Call management API to get list of locations. var locations = Retry.RetryOperation(() => client.Locations.List(), baseParams, ResourceType.None); Logger.Info(methodName, ProgressResources.ExecutionCompleted); return locations.Select(l => l.Name).ToList(); } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.None.ToString()); throw; } }
/// <summary> /// Checks that the provided reserved ip name is present in destination and also it is not allocated to any service. /// </summary> /// <param name="credentials">Subscription credentials</param> /// <param name="serviceUrl">Subscription service url</param> /// <param name="reservedIPName">Reserved ip name</param> /// <param name="serviceName">Service name</param> /// <returns>Returns true if ReservedIPName is present in destination and it is not allocated to any deployment / /// returns <see cref="ValidationException"/> if the ReservedIPName is not available in destination subscription or it is available but already assigned to any service. /// </returns> private bool CheckReservedIPNameAvailability(SubscriptionCloudCredentials credentials, Uri serviceUrl, string reservedIPName, string serviceName) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetVirtualNetworkConfigFromMSAzureStarted, ResourceType.VirtualNetwork.ToString()); using (var vnetClient = new NetworkManagementClient(credentials, serviceUrl)) { var reservedIPLists = vnetClient.ReservedIPs.List(); NetworkReservedIPListResponse.ReservedIP reservedIpPresent = (from ri in reservedIPLists where (ri.Name == reservedIPName) select ri).FirstOrDefault(); if (reservedIpPresent == null) { throw new ValidationException(string.Format(ProgressResources.MissingReservedIPName, reservedIPName)); } else if (reservedIpPresent.ServiceName != null && !(serviceName.Equals(reservedIpPresent.ServiceName, StringComparison.InvariantCultureIgnoreCase))) { throw new ValidationException(string.Format(ProgressResources.OccupiedReservedIpName, reservedIPName, reservedIpPresent.ServiceName)); } } return true; }
public static ServiceBusNamespace SelectNamespace( SubscriptionCloudCredentials credentials, string requestMessageText = "Please select namespace you want to use: ", string manualOption = null ) { Console.WriteLine( "Retrieving a list of created namespaces..." ); ServiceBusNamespace[] namespaces = AzureProvider.GetNamespaces( credentials ); int namespaceCount = namespaces.Length; Console.WriteLine( "Created namespaces: " ); for( int currentNamespace = 1; currentNamespace <= namespaceCount; ++currentNamespace ) { Console.WriteLine( currentNamespace + ": " + namespaces[ currentNamespace - 1 ].Name + " (" + namespaces[currentNamespace - 1].Region+ ")" ); } if( manualOption != null ) { Console.WriteLine( "*: " + manualOption ); } Console.WriteLine( "0: Exit without processing" ); for( ;; ) { Console.WriteLine( requestMessageText ); string answer = Console.ReadLine( ); if( answer.StartsWith( "*" ) ) { if( manualOption == null ) { Console.WriteLine( "Incorrect namespace number." ); continue; } if( !ConsoleHelper.Confirm( "Are you sure you want to enter name prefix manually?" ) ) { continue; } for( ;; ) { Console.WriteLine( "Enter a name prefix: " ); string namePrefix = Console.ReadLine( ); if( string.IsNullOrEmpty( namePrefix ) ) { Console.WriteLine( "Incorrect namespace prefix." ); continue; } if( ConsoleHelper.Confirm( "Are you sure you want to use namespace prefix " + namePrefix + "?" ) ) { return new ServiceBusNamespace { Name = namePrefix }; } } } int selection; if( !int.TryParse( answer, out selection ) || selection > namespaceCount || selection < -1 ) { Console.WriteLine( "Incorrect namespace number." ); continue; } if( selection == 0 ) { return null; } if( ConsoleHelper.Confirm( "Are you sure you want to select " + namespaces[ selection - 1 ].Name + " namespace?" ) ) { if( namespaces[ selection - 1 ].Name.EndsWith( "-ns" ) ) { namespaces[ selection - 1 ].Name = namespaces[ selection - 1 ].Name.Substring( 0, namespaces[ selection - 1 ].Name.Length - 3 ); } return namespaces[ selection - 1 ]; } } }
public static SiteRecoveryManagementClient CreateSiteRecoveryManagementClient(this CloudClients clients, SubscriptionCloudCredentials credentials, Uri baseUri) { return(new SiteRecoveryManagementClient("", "", credentials, baseUri)); }