private static void CreateDatabaseFromRestorePoint(IAzure azure) { ISqlServer sqlServer = azure.SqlServers.GetById(sqlSubscriptionId); ISqlDatabase database = sqlServer.Databases.Get(sourceDatabase); // Let the user know something is happening Console.WriteLine("Starting creation of new database from restore point of existing item"); Console.WriteLine("This can take a long time..."); // There only ever seems to be one come back...? IRestorePoint restorePoint = database.ListRestorePoints()[0]; // Select the Elastic Pool to deploy too ISqlElasticPool elasticPool = sqlServer.ElasticPools.Get(sqlElasticPoolName); // Restore the database from 5 minutes ago to a random name prefixed with Example_ string dbName = SdkContext.RandomResourceName("Example_", 20); ISqlDatabase newDatabase = sqlServer.Databases .Define(dbName) .WithExistingElasticPool(elasticPool) .FromRestorePoint(restorePoint, DateTime.UtcNow.AddMinutes(-5)) .Create(); // The process is finished... Console.WriteLine($"Database {newDatabase.Name} deployed to pool {elasticPool.Name}"); }
public void DeleteAzureSqlServer(ISqlServer sqlServer) { var rgName = sqlServer.ResourceGroupName; var firewallRules = sqlServer.FirewallRules.List(); foreach (var firewallRule in firewallRules) { Console.WriteLine($"Firewall rule '{firewallRule.Name}' was deleted"); firewallRule.Delete(); } var sqlDatabases = sqlServer.Databases.List().Where(x => !IsMaster(x)); foreach (var sqlDatabase in sqlDatabases) { Console.WriteLine($"Sql database '{sqlDatabase.Name}' was deleted"); sqlDatabase.Delete(); } Console.WriteLine($"Sql server '{sqlServer.Name}' was deleted"); _azure.SqlServers.DeleteById(sqlServer.Id); Console.WriteLine($"Resource group '{rgName}' was deleted"); _azure.ResourceGroups.DeleteByName(rgName); }
private static HaISqlServerModel LoadSqlServerCoreProperties(IAzure azure, ISqlServer sqlServer) { var myObject = new HaISqlServerModel(); string myId = sqlServer.Id; //Id, Type, Name, ResourceGroupName, SubscriptionId, Region, RegionName, Type myObject.Id = myId; myObject.Type = azure.GenericResources.GetById(myId).Type; myObject.Name = azure.GenericResources.GetById(myId).Name; myObject.ResourceGroupName = azure.GenericResources.GetById(myId).ResourceGroupName; myObject.SubscriptionId = azure.GenericResources.GetById(myId).Id.Split('/')[2]; myObject.Region = azure.GenericResources.GetById(myId).Region; myObject.RegionName = azure.GenericResources.GetById(myId).RegionName; myObject.Tags = azure.GenericResources.GetById(myId).Tags; //Specifics myObject.Version = sqlServer.Version; myObject.SystemAssignedManagedServiceIdentityPrincipalId = sqlServer.SystemAssignedManagedServiceIdentityPrincipalId; myObject.SystemAssignedManagedServiceIdentityTenantId = sqlServer.SystemAssignedManagedServiceIdentityTenantId; myObject.Kind = sqlServer.Kind; myObject.FullyQualifiedDomainName = sqlServer.FullyQualifiedDomainName; myObject.IsManagedServiceIdentityEnabled = sqlServer.IsManagedServiceIdentityEnabled; myObject.AdministratorLogin = sqlServer.AdministratorLogin; myObject.State = sqlServer.State; myObject.ManagedServiceIdentityType = sqlServer.ManagedServiceIdentityType; return(myObject); }
private void SqlDatabases(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting SqlDatabases for {0}", sqlServer.Name); var _sqlServerDatabases = sqlServer.Databases.List(); Log.Information("{0} SqlDatabases for server {1}", _sqlServerDatabases.Count, sqlServer.Name); foreach (var item in _sqlServerDatabases) { SqlDatabase _sqlServerDatabase = new SqlDatabase(); _sqlServerDatabase.ParentId = item.ParentId; _sqlServerDatabase.SqlServerName = item.SqlServerName; _sqlServerDatabase.Collation = item.Collation; _sqlServerDatabase.CreationDate = item.CreationDate; _sqlServerDatabase.CurrentServiceObjectiveId = item.CurrentServiceObjectiveId; _sqlServerDatabase.DatabaseId = item.DatabaseId; _sqlServerDatabase.DefaultSecondaryLocation = item.DefaultSecondaryLocation; _sqlServerDatabase.EarliestRestoreDate = item.EarliestRestoreDate; _sqlServerDatabase.Edition = item.Edition.Value; _sqlServerDatabase.ElasticPoolName = item.ElasticPoolName; _sqlServerDatabase.IsDataWarehouse = item.IsDataWarehouse; _sqlServerDatabase.MaxSizeBytes = item.MaxSizeBytes; _sqlServerDatabase.RegionName = item.RegionName; // _sqlServerDatabase.Tags = item.Tags.Values; sQLProps.sqlDatabases.Add(_sqlServerDatabase); } }
///GENMHASH:A0EEAA3D4BFB322B5036FE92D9F0F641:29E97F88060ECB7FAB4757A4A7DF3007 public SqlFailoverGroupImpl WithExistingSqlServer(ISqlServer sqlServer) { this.resourceGroupName = sqlServer.ResourceGroupName; this.sqlServerName = sqlServer.Name; this.sqlServerLocation = sqlServer.RegionName; return(this); }
private void PrepareResource(AzureSQLDatabase resource) { var serverLogin = "******"; var serverPass = "******"; if (_sqlServer == null) { Console.WriteLine("Making sql server"); _sqlServer = _azure.SqlServers.Define(Guid.NewGuid().ToString("N").Substring(0, 16)) .WithRegion(ConfigProvider.GetValue("AzureRegion")) .WithExistingResourceGroup(_resourceGroup) .WithAdministratorLogin("sqladmin3423") .WithAdministratorPassword("myS3cureP@ssword") .WithNewFirewallRule("0.0.0.0", "255.255.255.255", "shady") .Create(); } Console.WriteLine("Making sql db: " + resource.Name); _databases.Add(resource, _sqlServer.Databases.Define(resource.Name) .WithEdition(resource.PerformanceTier).WithServiceObjective(resource.ServiceObjective) .Create()); PreparedResources.Add(resource); resource.ConnectionString = "Server=tcp:" + _sqlServer.Name + ".database.windows.net,1433;Initial Catalog=" + _databases[resource].Name + ";Persist Security Info=False;User ID=" + serverLogin + ";Password="******";MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"; Console.WriteLine("Done: " + resource.Name); }
private static void ValidateSqlServer(ISqlServer sqlServer) { Assert.NotNull(sqlServer); Assert.Equal(GroupName, sqlServer.ResourceGroupName); Assert.NotNull(sqlServer.FullyQualifiedDomainName); Assert.Equal(ServerVersion.OneTwoFullStopZero, sqlServer.Version); Assert.Equal("userName", sqlServer.AdministratorLogin); }
///GENMHASH:3B0B15606AA6CA4AD0624C5561BF19C5:CFF20C10280FB1AA49F458E638101338 public ISqlDatabase GetBySqlServer(ISqlServer sqlServer, string name) { if (sqlServer == null) { throw new ArgumentNullException("sqlServer"); } return(Extensions.Synchronize(() => this.GetBySqlServerAsync(sqlServer.ResourceGroupName, sqlServer.Name, name))); }
public async ValueTask <ISqlDatabase> CreateSqlDatabaseAsync( string sqlDatabaseName, ISqlServer sqlServer) { return(await this.azure.SqlServers.Databases .Define(sqlDatabaseName) .WithExistingSqlServer(sqlServer) .CreateAsync()); }
///GENMHASH:A0EEAA3D4BFB322B5036FE92D9F0F641:29B0399E75CADE64EBE14362E52E6A76 public SqlFirewallRuleImpl WithExistingSqlServer(ISqlServer sqlServer) { if (sqlServer == null) { throw new ArgumentNullException("sqlServer"); } this.resourceGroupName = sqlServer.ResourceGroupName; this.sqlServerName = sqlServer.Name; return(this); }
///GENMHASH:A0EEAA3D4BFB322B5036FE92D9F0F641:1913C8F57081FC6BA71CCA1646434B22 public SqlDatabaseImpl WithExistingSqlServer(ISqlServer sqlServer) { if (sqlServer == null) { throw new ArgumentNullException("sqlServer"); } this.resourceGroupName = sqlServer.ResourceGroupName; this.sqlServerName = sqlServer.Name; this.sqlServerLocation = sqlServer.RegionName; return(this); }
public async Task BackupDatabase(Backup backup) { _logger.LogInformation("Authenticating Azure Management object"); AzureCredentials credentials = SdkContext.AzureCredentialsFactory.FromFile(Directory.GetCurrentDirectory() + "\\Azure_Credentials.txt"); IAzure azure = Azure .Configure() .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .Authenticate(credentials) .WithDefaultSubscription(); _logger.LogInformation("Get SQL database reference"); ISqlServer sqlServer = await azure.SqlServers.GetByResourceGroupAsync(backup.Source.SqlServerResourceGroup, backup.Source.SqlServerName); ISqlDatabase sqlDatabase = await sqlServer.Databases.GetAsync(backup.Source.SqlDatabaseName); _logger.LogInformation("Get storage account reference"); IStorageAccount storageAccount = azure.StorageAccounts.GetByResourceGroup(backup.Destination.StorageAccountResourceGroup, backup.Destination.StorageAccountName); _logger.LogInformation("Export database to storage account"); string blobPath = backup.Source.SqlDatabaseName + "_" + DateTime.Now.ToString("yyyyMMdd") + ".bacpac"; ISqlDatabaseImportExportResponse exportedSqlDatabase = sqlDatabase.ExportTo(storageAccount, backup.Destination.StorageContainerName, blobPath) .WithSqlAdministratorLoginAndPassword(backup.Source.SqlAdminUsername, backup.Source.SqlAdminPassword) .Execute(); _logger.LogInformation("Get reference to storage account"); CloudBlobContainer container = new CloudBlobContainer(new Uri(backup.Destination.StorageContainerConnectionString)); _logger.LogInformation("Get reference to blob"); CloudBlockBlob blockBlob = container.GetBlockBlobReference(blobPath); _logger.LogInformation("Download blob"); if (await blockBlob.ExistsAsync()) { string filePath = backup.Destination.LocalDirectory + blobPath; await blockBlob.DownloadToFileAsync(filePath, FileMode.Create); } else { throw new FileNotFoundException("Target blob not found in storage account"); } if (backup.Destination.DeleteFromStorageAfterDownload) { _logger.LogInformation("Removing file from storage"); await blockBlob.DeleteAsync(); } }
private static void LoadSqlDatabases(IAzure azure, ISqlServer sqlServer, HaISqlServerModel objSqlServer) { List <HaISqlDatabase> objSqlDatabase = new List <HaISqlDatabase>(); foreach (var sqlDatabase in sqlServer.Databases.List()) { string myId = sqlDatabase.Id; objSqlDatabase.Add(new HaISqlDatabase() { //Generics: //Name, ResourceGroupName, SubscriptionId, Region, RegionName, Type, Id, Tags //Note, not all resources can have their attributes accessed in this manner. Name = azure.GenericResources.GetById(myId).Name, ResourceGroupName = azure.GenericResources.GetById(myId).ResourceGroupName, SubscriptionId = sqlDatabase.Id.Split('/')[2], Region = azure.GenericResources.GetById(myId).Region, RegionName = azure.GenericResources.GetById(myId).RegionName, ParentId = azure.GenericResources.GetById(myId).ParentResourceId, Type = azure.GenericResources.GetById(myId).Type, Id = myId, Tags = azure.GenericResources.GetById(sqlDatabase.Id).Tags, //Specifics Collation = sqlDatabase.Collation, CreationDate = sqlDatabase.CreationDate, CurrentServiceObjectiveId = sqlDatabase.CurrentServiceObjectiveId, DatabaseId = sqlDatabase.DatabaseId, DefaultSecondaryLocation = sqlDatabase.DefaultSecondaryLocation, EarliestRestoreDate = sqlDatabase.EarliestRestoreDate, Edition = sqlDatabase.Edition, ElasticPoolName = sqlDatabase.ElasticPoolName, IsDataWarehouse = sqlDatabase.IsDataWarehouse, MaxSizeBytes = sqlDatabase.MaxSizeBytes, RequestedServiceObjectiveId = sqlDatabase.RequestedServiceObjectiveId, RequestedServiceObjectiveName = sqlDatabase.RequestedServiceObjectiveName, ServiceLevelObjective = sqlDatabase.ServiceLevelObjective, Status = sqlDatabase.Status, SyncGroups = sqlDatabase.SyncGroups, SqlServerName = sqlDatabase.SqlServerName } ); } objSqlServer.sqlDatabases = objSqlDatabase; }
public async ValueTask <ISqlServer> ProvisionSqlServerAsync( string projectName, string environment, IResourceGroup resourceGroup) { string sqlServerName = $"{projectName}-dbserver-{environment}".ToLower(); this.loggingBroker.LogActivity(message: $"Provisioning {sqlServerName}..."); ISqlServer sqlServer = await this.cloudBroker.CreateSqlServerAsync( sqlServerName, resourceGroup); this.loggingBroker.LogActivity(message: $"{sqlServer} Provisioned"); return(sqlServer); }
private void SqlServerDnsAliases(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting SqlServerDnsAliases for {0}", sqlServer.Name); var _sqlServerDnsAliases = sqlServer.DnsAliases.List(); Log.Information("{0} SqlServerDnsAliases for server {1}", _sqlServerDnsAliases.Count, sqlServer.Name); foreach (var item in _sqlServerDnsAliases) { SqlServerDnsAlias _sqlServerDnsAlias = new SqlServerDnsAlias(); _sqlServerDnsAlias.ParentId = item.ParentId; _sqlServerDnsAlias.AzureDnsRecord = item.AzureDnsRecord; _sqlServerDnsAlias.SqlServerName = item.SqlServerName; sQLProps.sqlServerDnsAliases.Add(_sqlServerDnsAlias); } }
private void SqlVirtualNetworkRules(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting SqlVirtualNetworkRule for {0}", sqlServer.Name); var _sqlVirtualNetworkRules = sqlServer.VirtualNetworkRules.List(); Log.Information("{0} SqlVirtualNetworkRule for server {1}", _sqlVirtualNetworkRules.Count, sqlServer.Name); foreach (var item in _sqlVirtualNetworkRules) { SqlVirtualNetworkRule _sqlVirtualNetworkRule = new SqlVirtualNetworkRule(); _sqlVirtualNetworkRule.ParentId = item.ParentId; _sqlVirtualNetworkRule.SqlServerName = item.SqlServerName; _sqlVirtualNetworkRule.SubnetId = item.SubnetId; _sqlVirtualNetworkRule.State = item.State; sQLProps.sqlVirtualNetworkRules.Add(_sqlVirtualNetworkRule); } }
private void FirewallRules(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting FirewallRules for {0}", sqlServer.Name); var _firewallRules = sqlServer.FirewallRules.List(); Log.Information("{0} FirewallRules for server {1}", _firewallRules.Count, sqlServer.Name); foreach (var item in _firewallRules) { SqlFirewallRule _sqlFirewallRule = new SqlFirewallRule(); _sqlFirewallRule.ParentId = item.ParentId; _sqlFirewallRule.SqlServerName = item.SqlServerName; _sqlFirewallRule.StartIPAddress = item.StartIPAddress; _sqlFirewallRule.EndIPAddress = item.EndIPAddress; _sqlFirewallRule.Kind = item.Kind; sQLProps.SqlFirewallRule.Add(_sqlFirewallRule); } }
private void Encryptionprotector(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting Encryptionprotector for {0}", sqlServer.Name); var _sqlEncryptionProtectors = sqlServer.EncryptionProtectors.List(); Log.Information("{0} Encryptionprotector for server {1}", _sqlEncryptionProtectors.Count, sqlServer.Name); foreach (var item in _sqlEncryptionProtectors) { SqlEncryptionProtector _sqlEncryptionProtector = new SqlEncryptionProtector(); _sqlEncryptionProtector.Kind = item.Kind; _sqlEncryptionProtector.ParentId = item.ParentId; _sqlEncryptionProtector.ServerKeyName = item.ServerKeyName; _sqlEncryptionProtector.SqlServerName = item.SqlServerName; _sqlEncryptionProtector.Thumbprint = item.Thumbprint; sQLProps.sqlEncryptionProtectors.Add(_sqlEncryptionProtector); } }
private async ValueTask ProvisionAsync( string projectName, CloudAction cloudAction) { List <string> environments = RetrieveEnvironments(cloudAction); foreach (string environmentName in environments) { IResourceGroup resourceGroup = await this.cloudManagementService .ProvisionResourceGroupAsync( projectName, environmentName); IAppServicePlan appServicePlan = await this.cloudManagementService .ProvisionPlanAsync( projectName, environmentName, resourceGroup); ISqlServer sqlServer = await this.cloudManagementService .ProvisionSqlServerAsync( projectName, environmentName, resourceGroup); SqlDatabase sqlDatabase = await this.cloudManagementService .ProvisionSqlDatabaseAsync( projectName, environmentName, sqlServer); IWebApp webApp = await this.cloudManagementService .ProvisionWebAppAsync( projectName, environmentName, sqlDatabase.ConnectionString, resourceGroup, appServicePlan); } }
public async ValueTask <SqlDatabase> ProvisionSqlDatabaseAsync( string projectname, string environment, ISqlServer sqlServer) { string sqlDatabaseName = $"{projectname}-db-{environment}".ToLower(); this.loggingBroker.LogActivity(message: $"Provisioning {sqlDatabaseName}..."); ISqlDatabase sqlDatabase = await this.cloudBroker.CreateSqlDatabaseAsync( sqlDatabaseName, sqlServer); this.loggingBroker.LogActivity(message: $"{sqlDatabaseName} Provisioned"); return(new SqlDatabase { Database = sqlDatabase, ConnectionString = GenerateConnectionString(sqlDatabase) }); }
static void Main(string[] args) { var credentials = new AzureCredentialsFactory() .FromServicePrincipal(SecretConstants.ApplicationId, SecretConstants.Password, SecretConstants.Tenant, AzureEnvironment.AzureGlobalCloud); IAzure azure = Azure.Authenticate(credentials).WithDefaultSubscription(); Console.WriteLine($"Subscription ID : {azure.SubscriptionId}"); foreach (IDeployment deployment in azure.Deployments.List()) { Console.WriteLine($"{deployment.Name}"); } IEnumerable <ISqlServer> servers = azure.SqlServers.List(); foreach (ISqlServer server in servers) { Console.WriteLine($"{server.Id} - {server.Name} - {server.RegionName}"); } ISqlServer sqlServer = azure.SqlServers.List().FirstOrDefault(); IEnumerable <IStorageAccount> storageAccounts = azure.StorageAccounts.List(); foreach (IStorageAccount storageAccount in storageAccounts) { Console.WriteLine($"{storageAccount.Id} - {storageAccount.Name}"); } try { CreateNewDatabase(azure, sqlServer.Id); } catch (Exception ex) { Console.WriteLine($"{ex.Message}"); } Console.ReadLine(); }
private void SqlFailoverGroup(ISqlServer sqlServer, AzureSqlProps sQLProps) { Log.Information("Collecting SqlFailoverGroup for {0}", sqlServer.Name); var _sqlFailoverGroups = sqlServer.FailoverGroups.List(); Log.Information("{0} SqlFailoverGroup for server {1}", _sqlFailoverGroups.Count, sqlServer.Name); foreach (var item in _sqlFailoverGroups) { SqlFailoverGroup _sqlFailoverGroup = new SqlFailoverGroup(); _sqlFailoverGroup.ParentId = item.ParentId; // _sqlFailoverGroup.Databases = item.Databases; _sqlFailoverGroup.ReadWriteEndpointDataLossGracePeriodMinutes = item.ReadWriteEndpointDataLossGracePeriodMinutes; _sqlFailoverGroup.ReplicationState = item.ReplicationState; _sqlFailoverGroup.SqlServerName = item.SqlServerName; sQLProps.sqlFailoverGroups.Add(_sqlFailoverGroup); } }
/// <summary> /// Initializes a new instance of the <see cref="GalleryDb"/> class. /// </summary> /// <param name="database">The database.</param> public GalleryDb(ISqlServer database) { _database = database; }
///GENMHASH:48B8354F9A8656B355FBB651D3743037:75423D6C2145189317E4FA9AA37DD8DE public IReadOnlyList <Microsoft.Azure.Management.Sql.Fluent.ISqlDatabase> ListBySqlServer(ISqlServer sqlServer) { if (sqlServer == null) { throw new ArgumentNullException("sqlServer"); } return(Extensions.Synchronize(() => this.ListBySqlServerAsync(sqlServer.ResourceGroupName, sqlServer.Name))); }
/// <summary> /// Sets the parent SQL server for the new Firewall rule. /// </summary> /// <param name="sqlServer">The parent SQL server.</param> /// <return>The next stage of the definition.</return> SqlFirewallRuleOperations.Definition.IWithIPAddressRange SqlFirewallRuleOperations.Definition.IWithSqlServer.WithExistingSqlServer(ISqlServer sqlServer) { return(this.WithExistingSqlServer(sqlServer)); }
public App(ISettings settings, ISqlServer sqlServer, IScripter scripter) { this.settings = settings; this.sqlServer = sqlServer; this.scripter = scripter; }
private static void ValidateSqlElasticPoolNotFound(ISqlServer sqlServer, string elasticPoolName) { Assert.Null(sqlServer.ElasticPools.Get(elasticPoolName)); }
/// <summary> /// Sets the parent SQL server for the new Elastic Pool. /// </summary> /// <param name="sqlServer">The parent SQL server.</param> /// <return>The next stage of the definition.</return> SqlElasticPoolOperations.Definition.IWithEdition SqlElasticPoolOperations.Definition.IWithSqlServer.WithExistingSqlServer(ISqlServer sqlServer) { return(this.WithExistingSqlServer(sqlServer)); }
private static void ValidateMultiCreation( ISqlManager sqlServerManager, string database2Name, string database1InEPName, string database2InEPName, string elasticPool1Name, string elasticPool2Name, string elasticPool3Name, ISqlServer sqlServer, bool deleteUsingUpdate) { ValidateSqlServer(sqlServer); ValidateSqlServer(sqlServerManager.SqlServers.GetByResourceGroup(GroupName, SqlServerName)); ValidateSqlDatabase(sqlServer.Databases.Get(SqlDatabaseName), SqlDatabaseName); ValidateSqlFirewallRule(sqlServer.FirewallRules.Get(SqlFirewallRuleName), SqlFirewallRuleName); var firewalls = sqlServer.FirewallRules.List(); Assert.Equal(3, firewalls.Count()); var startIPAddress = 0; var endIPAddress = 0; foreach (ISqlFirewallRule firewall in firewalls) { if (!StringComparer.OrdinalIgnoreCase.Equals(firewall.Name, SqlFirewallRuleName)) { Assert.Equal(firewall.StartIPAddress, StartIPAddress); if (StringComparer.OrdinalIgnoreCase.Equals(firewall.EndIPAddress, StartIPAddress)) { startIPAddress++; } else if (StringComparer.OrdinalIgnoreCase.Equals(firewall.EndIPAddress, EndIPAddress)) { endIPAddress++; } } } Assert.Equal(1, startIPAddress); Assert.Equal(1, endIPAddress); Assert.NotNull(sqlServer.Databases.Get(database2Name)); Assert.NotNull(sqlServer.Databases.Get(database1InEPName)); Assert.NotNull(sqlServer.Databases.Get(database2InEPName)); var ep1 = sqlServer.ElasticPools.Get(elasticPool1Name); ValidateSqlElasticPool(ep1, elasticPool1Name); var ep2 = sqlServer.ElasticPools.Get(elasticPool2Name); Assert.NotNull(ep2); Assert.Equal(ep2.Edition, ElasticPoolEditions.Premium); Assert.Equal(2, ep2.ListDatabases().Count()); Assert.NotNull(ep2.GetDatabase(database1InEPName)); Assert.NotNull(ep2.GetDatabase(database2InEPName)); var ep3 = sqlServer.ElasticPools.Get(elasticPool3Name); Assert.NotNull(ep3); Assert.Equal(ep3.Edition, ElasticPoolEditions.Standard); if (!deleteUsingUpdate) { sqlServer.Databases.Delete(database2Name); sqlServer.Databases.Delete(database1InEPName); sqlServer.Databases.Delete(database2InEPName); sqlServer.Databases.Delete(SqlDatabaseName); Assert.Empty(ep1.ListDatabases()); Assert.Empty(ep2.ListDatabases()); Assert.Empty(ep3.ListDatabases()); sqlServer.ElasticPools.Delete(elasticPool1Name); sqlServer.ElasticPools.Delete(elasticPool2Name); sqlServer.ElasticPools.Delete(elasticPool3Name); firewalls = sqlServer.FirewallRules.List(); foreach (ISqlFirewallRule firewallRule in firewalls) { firewallRule.Delete(); } } else { sqlServer.Update() .WithoutDatabase(database2Name) .WithoutElasticPool(elasticPool1Name) .WithoutElasticPool(elasticPool2Name) .WithoutElasticPool(elasticPool3Name) .WithoutElasticPool(elasticPool1Name) .WithoutDatabase(database1InEPName) .WithoutDatabase(SqlDatabaseName) .WithoutDatabase(database2InEPName) .WithoutFirewallRule(SqlFirewallRuleName) .Apply(); Assert.Empty(sqlServer.ElasticPools.List()); firewalls = sqlServer.FirewallRules.List(); Assert.Equal(2, firewalls.Count()); foreach (ISqlFirewallRule firewallRule in firewalls) { firewallRule.Delete(); } } Assert.Empty(sqlServer.ElasticPools.List()); // Only master database is remaining in the SQLServer. Assert.Single(sqlServer.Databases.List()); }
/// <summary> /// Initializes a new instance of the <see cref="PhotoDb"/> class. /// </summary> /// <param name="database">The database.</param> public PhotoDb(ISqlServer database) { _database = database; }
private static void ValidateSqlServerNotFound(ISqlManager sqlServerManager, ISqlServer sqlServer) { Assert.Null(sqlServerManager.SqlServers.GetById(sqlServer.Id)); }
/// <summary> /// Initializes a new instance of the <see cref="UserDb"/> class. /// </summary> /// <param name="database">The database.</param> public UserDb(ISqlServer database) { _database = database; }
/** * Azure App Service basic sample for managing web apps. * - Create a SQL database in a new SQL server * - Create a web app deployed with Project Nami (WordPress's SQL Server variant) * that contains the app settings to connect to the SQL database * - Update the SQL server's firewall rules to allow the web app to access * - Clean up */ public static void RunSample(IAzure azure) { string appName = SdkContext.RandomResourceName("webapp1-", 20); string appUrl = appName + Suffix; string sqlServerName = SdkContext.RandomResourceName("jsdkserver", 20); string sqlDbName = SdkContext.RandomResourceName("jsdkdb", 20); string rgName = SdkContext.RandomResourceName("rg1NEMV_", 24); try { //============================================================ // Create a sql server Utilities.Log("Creating SQL server " + sqlServerName + "..."); ISqlServer server = azure.SqlServers.Define(sqlServerName) .WithRegion(Region.USWest) .WithNewResourceGroup(rgName) .WithAdministratorLogin(Admin) .WithAdministratorPassword(Password) .Create(); Utilities.Log("Created SQL server " + server.Name); //============================================================ // Create a sql database for the web app to use Utilities.Log("Creating SQL database " + sqlDbName + "..."); ISqlDatabase db = server.Databases.Define(sqlDbName) .Create(); Utilities.Log("Created SQL database " + db.Name); //============================================================ // Create a web app with a new app service plan Utilities.Log("Creating web app " + appName + "..."); IWebApp app = azure.WebApps .Define(appName) .WithRegion(Region.USWest) .WithExistingResourceGroup(rgName) .WithNewWindowsPlan(PricingTier.StandardS1) .WithPhpVersion(PhpVersion.V5_6) .DefineSourceControl() .WithPublicGitRepository("https://github.com/ProjectNami/projectnami") .WithBranch("master") .Attach() .WithAppSetting("ProjectNami.DBHost", server.FullyQualifiedDomainName) .WithAppSetting("ProjectNami.DBName", db.Name) .WithAppSetting("ProjectNami.DBUser", Admin) .WithAppSetting("ProjectNami.DBPass", Password) .Create(); Utilities.Log("Created web app " + app.Name); Utilities.Print(app); //============================================================ // Allow web app to access the SQL server Utilities.Log("Allowing web app " + appName + " to access SQL server..."); Microsoft.Azure.Management.Sql.Fluent.SqlServer.Update.IUpdate update = server.Update(); foreach (var ip in app.OutboundIPAddresses) { update = update.WithNewFirewallRule(ip); } server = update.Apply(); Utilities.Log("Firewall rules added for web app " + appName); Utilities.PrintSqlServer(server); Utilities.Log("Your WordPress app is ready."); Utilities.Log("Please navigate to http://" + appUrl + " to finish the GUI setup. Press enter to exit."); Utilities.ReadLine(); } finally { try { Utilities.Log("Deleting Resource Group: " + rgName); azure.ResourceGroups.DeleteByName(rgName); Utilities.Log("Deleted Resource Group: " + rgName); } catch (NullReferenceException) { Utilities.Log("Did not create any resources in Azure. No clean up is necessary"); } catch (Exception g) { Utilities.Log(g); } } }