Exemplo n.º 1
0
        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);
        }
Exemplo n.º 3
0
        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)));
 }
Exemplo n.º 9
0
 public async ValueTask <ISqlDatabase> CreateSqlDatabaseAsync(
     string sqlDatabaseName,
     ISqlServer sqlServer)
 {
     return(await this.azure.SqlServers.Databases
            .Define(sqlDatabaseName)
            .WithExistingSqlServer(sqlServer)
            .CreateAsync());
 }
Exemplo n.º 10
0
 ///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);
 }
Exemplo n.º 11
0
 ///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);
 }
Exemplo n.º 12
0
        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();
            }
        }
Exemplo n.º 13
0
        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;
        }
Exemplo n.º 14
0
        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);
            }
        }
Exemplo n.º 19
0
        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);
            }
        }
Exemplo n.º 20
0
        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)
            });
        }
Exemplo n.º 21
0
        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);
            }
        }
Exemplo n.º 23
0
 /// <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));
 }
Exemplo n.º 26
0
 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));
 }
Exemplo n.º 28
0
 /// <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());
        }
Exemplo n.º 30
0
 /// <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));
 }
Exemplo n.º 32
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UserDb"/> class.
 /// </summary>
 /// <param name="database">The database.</param>
 public UserDb(ISqlServer database)
 {
     _database = database;
 }
Exemplo n.º 33
0
        /**
         * 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);
                }
            }
        }
Exemplo n.º 34
0
 /// <summary>
 /// Initializes a new instance of the <see cref="GalleryDb"/> class.
 /// </summary>
 /// <param name="database">The database.</param>
 public GalleryDb(ISqlServer database)
 {
     _database = database;
 }