private void DeleteDatabase(ProvisionedService provisionedService)
{
string name = provisionedService.Name;
string user = provisionedService.User;
try
{
this.DeleteDatabaseUser(user);
Logger.Info(Strings.SqlNodeDeletingDatabaseInfoMessage, name);
using (TransactionScope ts = new TransactionScope())
{
using (SqlCommand takeOfflineCommand = new SqlCommand(string.Format(CultureInfo.InvariantCulture, Strings.SqlNodeTakeDBOfflineSQL, name), this.connection))
{
takeOfflineCommand.ExecuteNonQuery();
}
using (SqlCommand bringOnlineCommand = new SqlCommand(string.Format(CultureInfo.InvariantCulture, Strings.SqlNodeBringDBOnlineSQL, name), this.connection))
{
bringOnlineCommand.ExecuteNonQuery();
}
using (SqlCommand dropDatabaseCommand = new SqlCommand(string.Format(CultureInfo.InvariantCulture, Strings.SqlNodeDropDatabaseSQL, name), this.connection))
{
dropDatabaseCommand.ExecuteNonQuery();
}
ts.Complete();
}
}
catch (Exception ex)
{
Logger.Fatal(Strings.SqlNodeCannotDeleteDBFatalMessage, ex.ToString());
}
}
private DragDropEffects GetApplicationServicesDropEffects(ProvisionedService provisionedService)
{
ProvisionedService existingService =
ApplicationServices.SingleOrDefault(
i => i.Name.Equals(provisionedService.Name, StringComparison.InvariantCultureIgnoreCase));
return((existingService != null) ? DragDropEffects.None : DragDropEffects.Move);
}
/// <summary>
/// Returns storage capacity based on billing plan.
/// </summary>
/// <param name="provisionedService">The provisioned service.</param>
/// <returns>The storage quota in bytes.</returns>
private long StorageForService(ProvisionedService provisionedService)
{
switch (provisionedService.Plan)
{
case ProvisionedServicePlanType.Free: return(this.maxDbSize);
default: throw new MSSqlErrorException(MSSqlErrorException.MSSqlInvalidPlan, provisionedService.Plan.ToString());
}
}
public void TC003_3Secquential()
{
List <string> serviceNames = new List <string>();
for (int i = 0; i < 3; i++)
{
string serviceName = Guid.NewGuid().ToString();
bool serviceProvisioned = false;
try
{
cloudConnection.CreateProvisionedService(cloudConnection.SystemServices.FirstOrDefault(ss => ss.Vendor == "mssql"), serviceName, true);
Thread.Sleep(10000);
ICollection <ProvisionedService> services = cloudConnection.ProvisionedServices;
foreach (ProvisionedService svc in services)
{
if (svc.Name == serviceName)
{
serviceProvisioned = true;
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
Assert.IsTrue(serviceProvisioned);
serviceNames.Add(serviceName);
}
for (int i = 0; i < 3; i++)
{
string serviceName = serviceNames[i];
bool serviceDeleted = true;
try
{
ProvisionedService provService = cloudConnection.ProvisionedServices.FirstOrDefault(ps => ps.Name == serviceName);
provService.Delete();
Thread.Sleep(10000);
ICollection <ProvisionedService> services = cloudConnection.ProvisionedServices;
foreach (ProvisionedService svc in services)
{
if (svc.Name == serviceName)
{
serviceDeleted = false;
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
Assert.IsTrue(serviceDeleted);
}
}
private void DropApplicationServices(ProvisionedService provisionedService)
{
ApplicationServices.Add(provisionedService);
foreach (ProvisionedService service in ApplicationServices)
{
if (!SelectedApplication.Services.Contains(service.Name))
{
SelectedApplication.Services.Add(service.Name);
RaisePropertyChanged("ApplicationServices");
}
}
}
private void CreateDatabase(ProvisionedService provisionedService)
{
string databaseName = provisionedService.Name;
string databasePassword = provisionedService.Password;
string databaseUser = provisionedService.User;
try
{
DateTime start = DateTime.Now;
Logger.Debug(Strings.SqlNodeCreateDatabaseDebugMessage, provisionedService.SerializeToJson());
this.createDBScript = this.ExtractSqlScriptFromTemplate(databaseName);
// split script on GO command
IEnumerable <string> commandStrings = Regex.Split(this.createDBScript, "^\\s*GO\\s*$", RegexOptions.Multiline);
using (TransactionScope ts = new TransactionScope())
{
foreach (string commandString in commandStrings)
{
if (!string.IsNullOrEmpty(commandString.Trim()) && !commandString.Contains("[master]"))
{
using (SqlCommand cmd = new SqlCommand(commandString, this.connection))
{
if (commandString.Contains("CREATE DATABASE"))
{
cmd.CommandTimeout = 0;
}
cmd.ExecuteNonQuery();
}
}
}
}
this.CreateDatabaseUser(databaseName, databaseUser, databasePassword);
long storage = this.StorageForService(provisionedService);
if (this.availableStorageBytes < storage)
{
throw new MSSqlErrorException(MSSqlErrorException.MSSqlDiskFull);
}
this.availableStorageBytes -= storage;
Logger.Debug(Strings.SqlNodeDoneCreatingDBDebugMessage, provisionedService.SerializeToJson(), (start - DateTime.Now).TotalSeconds);
}
catch (Exception ex)
{
Logger.Warning(Strings.SqlNodeCouldNotCreateDBWarningMessage, ex.ToString());
throw;
}
}
protected override bool Unprovision(string name, ServiceCredentials[] bindings)
{
if (string.IsNullOrEmpty(name))
{
return(false);
}
Logger.Debug(Strings.SqlNodeUnprovisionDatabaseDebugMessage, name, JsonConvertibleObject.SerializeToJson(bindings.Select(binding => binding.ToJsonIntermediateObject()).ToArray()));
ProvisionedService provisioned_service = ProvisionedService.GetService(name);
if (provisioned_service == null)
{
throw new MSSqlErrorException(MSSqlErrorException.MSSqlConfigNotFound, name);
}
// TODO: validate that database files are not lingering
// Delete all bindings, ignore not_found error since we are unprovision
try
{
if (bindings != null)
{
foreach (ServiceCredentials credential in bindings)
{
this.Unbind(credential);
}
}
}
catch (Exception)
{
// ignore
}
this.DeleteDatabase(provisioned_service);
long storage = this.StorageForService(provisioned_service);
this.availableStorageBytes += storage;
this.availableCapacity += this.CapacityUnit();
if (!provisioned_service.Destroy())
{
Logger.Error(Strings.SqlNodeDeleteServiceErrorMessage, provisioned_service.Name);
throw new MSSqlErrorException(MSSqlErrorException.MSSqlLocalDBError);
}
Logger.Debug(Strings.SqlNodeUnprovisionSuccessDebugMessage, name);
return(true);
}
public void TC002_DatabaseDelete()
{
string serviceName = Guid.NewGuid().ToString();
bool serviceProvisioned = false;
bool serviceDeleted = true;
try
{
RawSystemService systemService = cloudConnection.SystemServices.First(ss => ss.Vendor == "mssql");
cloudConnection.CreateProvisionedService(systemService, serviceName, true);
Thread.Sleep(10000);
ICollection <ProvisionedService> services = cloudConnection.ProvisionedServices;
foreach (ProvisionedService svc in services)
{
if (svc.Name == serviceName)
{
serviceProvisioned = true;
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
Assert.IsTrue(serviceProvisioned);
try
{
ProvisionedService provisionedService = cloudConnection.ProvisionedServices.FirstOrDefault(ps => ps.Name == serviceName);
provisionedService.Delete();
Thread.Sleep(10000);
ICollection <ProvisionedService> services = cloudConnection.ProvisionedServices;
foreach (ProvisionedService svc in services)
{
if (svc.Name == serviceName)
{
serviceDeleted = false;
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
Assert.IsTrue(serviceDeleted);
}
/// <summary>
/// Binds a SQL Server database to an app.
/// </summary>
/// <param name="name">The name of the service.</param>
/// <param name="bindOptions">Binding options.</param>
/// <param name="credentials">Already existing credentials.</param>
/// <returns>
/// A new set of credentials used for binding.
/// </returns>
protected override ServiceCredentials Bind(string name, Dictionary <string, object> bindOptions, ServiceCredentials credentials)
{
Logger.Debug(Strings.SqlNodeBindServiceDebugMessage, name, JsonConvertibleObject.SerializeToJson(bindOptions));
Dictionary <string, object> binding = null;
try
{
ProvisionedService service = ProvisionedService.GetService(name);
if (service == null)
{
throw new MSSqlErrorException(MSSqlErrorException.MSSqlConfigNotFound, name);
}
// create new credential for binding
binding = new Dictionary <string, object>();
if (credentials != null)
{
binding["user"] = credentials.User;
binding["password"] = credentials.Password;
}
else
{
binding["user"] = "******" + Credentials.GenerateCredential();
binding["password"] = "******" + Credentials.GenerateCredential();
}
binding["bind_opts"] = bindOptions;
this.CreateDatabaseUser(name, binding["user"] as string, binding["password"] as string);
ServiceCredentials response = this.GenerateCredential(name, binding["user"] as string, binding["password"] as string);
Logger.Debug(Strings.SqlNodeBindResponseDebugMessage, response.SerializeToJson());
this.bindingServed += 1;
return(response);
}
catch (Exception)
{
if (binding != null)
{
this.DeleteDatabaseUser(binding["user"] as string);
}
throw;
}
}
protected override Dictionary <string, string> HealthzDetails()
{
Dictionary <string, string> healthz = new Dictionary <string, string>()
{
{ "self", "ok" }
};
try
{
using (SqlCommand readDatabases = new SqlCommand("SELECT name FROM master..sysdatabases", this.connection))
{
using (SqlDataReader reader = readDatabases.ExecuteReader())
{
reader.Read();
}
}
}
catch (Exception ex)
{
Logger.Error(Strings.ErrorGettingDBListErrorMessage, ex.ToString());
healthz["self"] = "fail";
return(healthz);
}
try
{
foreach (ProvisionedService instance in ProvisionedService.GetInstances())
{
healthz[instance.Name] = this.GetInstanceHealthz(instance);
}
}
catch (Exception ex)
{
Logger.Error(Strings.ErrorGettingInstanceListErrorMessage, ex.ToString());
healthz["self"] = "fail";
}
return(healthz);
}
/// <summary>
/// Provisions an MS Sql Server database.
/// </summary>
/// <param name="planRequest">The payment plan for the service.</param>
/// <param name="credentials">Existing credentials for the service.</param>
/// <returns>
/// Credentials for the provisioned service.
/// </returns>
protected override ServiceCredentials Provision(ProvisionedServicePlanType planRequest, ServiceCredentials credentials)
{
//// todo: chek for plan
ProvisionedService provisioned_service = new ProvisionedService();
if (credentials == null)
{
throw new ArgumentNullException("credentials");
}
try
{
string name = credentials.Name;
string user = credentials.User;
string password = credentials.Password;
provisioned_service.Name = name;
provisioned_service.User = user;
provisioned_service.Password = password;
provisioned_service.Plan = planRequest;
this.CreateDatabase(provisioned_service);
if (!ProvisionedService.Save())
{
Logger.Error(Strings.SqlNodeCannotSaveProvisionedServicesErrorMessage, provisioned_service.SerializeToJson());
throw new MSSqlErrorException(MSSqlErrorException.MSSqlLocalDBError);
}
ServiceCredentials response = this.GenerateCredential(provisioned_service.Name, provisioned_service.User, provisioned_service.Password);
this.provisionServed += 1;
return(response);
}
catch (Exception)
{
this.DeleteDatabase(provisioned_service);
throw;
}
}
private string GetInstanceHealthz(ProvisionedService instance)
{
string res = "ok";
try
{
string instanceConnectionString = string.Format(
CultureInfo.InvariantCulture,
Strings.SqlNodeConnectionString,
this.mssqlConfig.Host,
this.mssqlConfig.Port,
instance.User,
instance.Password);
using (SqlConnection databaseConnection = new SqlConnection(instanceConnectionString))
{
databaseConnection.Open();
databaseConnection.ChangeDatabase(instance.Name);
using (SqlCommand readDatabases = new SqlCommand("SELECT name from sys.tables", this.connection))
{
using (SqlDataReader reader = readDatabases.ExecuteReader())
{
reader.Read();
}
}
}
}
catch (Exception ex)
{
Logger.Warning(Strings.ErrorGettingDBTablesWarningMessage, instance.Name, ex.ToString());
res = "fail";
}
return(res);
}
private bool ValidateServices(CloudFoundryClient client, string CFServices)
{
List<ProvisionedService> servicesList = new List<ProvisionedService>();
try
{
string[] provServs = CFServices.Split(';');
foreach (string service in provServs)
{
if (string.IsNullOrWhiteSpace(service) == false)
{
string[] serviceInfo = service.Split(',');
if (serviceInfo.Length != 3)
{
logger.LogError("Invalid service information in {0}", service);
continue;
}
ProvisionedService serviceDetails = new ProvisionedService();
serviceDetails.Name = serviceInfo[0].Trim();
serviceDetails.Type = serviceInfo[1].Trim();
serviceDetails.Plan = serviceInfo[2].Trim();
servicesList.Add(serviceDetails);
}
}
}
catch (Exception ex)
{
logger.LogErrorFromException(ex);
logger.LogWarning("Error trying to obtain service information, trying to deserialize as xml");
servicesList = Utils.Deserialize<List<ProvisionedService>>(CFServices);
}
foreach (ProvisionedService service in servicesList)
{
logger.LogMessage("Validating {0} service {1}", service.Type, service.Name);
PagedResponseCollection<ListAllServicesResponse> allServicesList = client.Services.ListAllServices(new RequestOptions() { Query = "label:" + service.Type }).Result;
if (allServicesList.Count() < 1)
{
logger.LogError("Invalid service type {0}", service.Type);
return false;
}
foreach (var serviceInfo in allServicesList)
{
var planList = client.Services.ListAllServicePlansForService(new Guid(serviceInfo.EntityMetadata.Guid)).Result;
var plan = planList.Where(o => o.Name == service.Plan).FirstOrDefault();
if (plan != null)
{
break;
}
else
{
logger.LogError("Invalid plan {2} for service {0} - {1}", service.Name, service.Type, service.Plan);
return false;
}
}
}
return true;
}
public override bool Execute()
{
logger = new Microsoft.Build.Utilities.TaskLoggingHelper(this);
CloudFoundryClient client = InitClient();
Guid? spaceGuid = null;
if (CFSpace.Length > 0 && CFOrganization.Length > 0)
{
spaceGuid = Utils.GetSpaceGuid(client, logger, CFOrganization, CFSpace);
if (spaceGuid == null)
{
return false;
}
}
List<ProvisionedService> servicesList = new List<ProvisionedService>();
try
{
string[] provServs = CFServices.Split(';');
foreach (string service in provServs)
{
if (string.IsNullOrWhiteSpace(service) == false)
{
string[] serviceInfo = service.Split(',');
if (serviceInfo.Length != 3)
{
logger.LogError("Invalid service information in {0}", service);
continue;
}
ProvisionedService serviceDetails = new ProvisionedService();
serviceDetails.Name = serviceInfo[0].Trim();
serviceDetails.Type = serviceInfo[1].Trim();
serviceDetails.Plan = serviceInfo[2].Trim();
servicesList.Add(serviceDetails);
}
}
}
catch(Exception ex)
{
logger.LogErrorFromException(ex);
logger.LogWarning("Error trying to obtain service information, trying to deserialize as xml");
servicesList = Utils.Deserialize<List<ProvisionedService>>(CFServices);
}
List<string> serviceGuids = new List<string>();
foreach (ProvisionedService service in servicesList)
{
logger.LogMessage("Creating {0} service {1}", service.Type, service.Name);
Guid? planGuid = null;
PagedResponseCollection<ListAllServicesResponse> allServicesList = client.Services.ListAllServices(new RequestOptions() { Query = "label:" + service.Type }).Result;
foreach (var serviceInfo in allServicesList)
{
var planList = client.Services.ListAllServicePlansForService(new Guid(serviceInfo.EntityMetadata.Guid)).Result;
var plan = planList.Where(o => o.Name == service.Plan).FirstOrDefault();
if (plan != null)
{
planGuid = new Guid(plan.EntityMetadata.Guid);
break;
}
}
Guid? serviceInstanceGuid=null;
if ((serviceInstanceGuid=Utils.CheckForExistingService(service.Name, planGuid, client)) != null)
{
logger.LogMessage("Service {0} - {1} already exists -> skipping", service.Name, service.Type);
serviceGuids.Add(serviceInstanceGuid.Value.ToString());
continue;
}
CreateServiceInstanceRequest request = new CreateServiceInstanceRequest();
request.Name = service.Name;
request.ServicePlanGuid = planGuid;
request.SpaceGuid = spaceGuid;
CreateServiceInstanceResponse result = client.ServiceInstances.CreateServiceInstance(request).Result;
serviceGuids.Add(result.EntityMetadata.Guid);
}
CFServicesGuids = serviceGuids.ToArray();
return true;
}
private object GetBindProvisionedServicesData(ProvisionedService provisionedService)
{
return provisionedService;
}
private void DropApplicationServices(ProvisionedService provisionedService)
{
ApplicationServices.Add(provisionedService);
foreach (ProvisionedService service in ApplicationServices)
{
if (!SelectedApplication.Services.Contains(service.Name))
{
SelectedApplication.Services.Add(service.Name);
RaisePropertyChanged("ApplicationServices");
}
}
}
private DragDropEffects GetBindProvisionedServicesDragEffects(ProvisionedService provisionedService)
{
return(Cloud.Services.Any() ? DragDropEffects.Move : DragDropEffects.None);
}
private DragDropEffects GetApplicationServicesDropEffects(ProvisionedService provisionedService)
{
ProvisionedService existingService =
ApplicationServices.SingleOrDefault(
i => i.Name.Equals(provisionedService.Name, StringComparison.InvariantCultureIgnoreCase));
return (existingService != null) ? DragDropEffects.None : DragDropEffects.Move;
}
/// <summary>
/// Starts the node.
/// </summary>
/// <param name="options">The configuration options for the node.</param>
/// <param name="sqlOptions">The MS SQL Server options.</param>
public void Start(Options options, MSSqlOptions sqlOptions)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (sqlOptions == null)
{
throw new ArgumentNullException("sqlOptions");
}
this.mssqlConfig = sqlOptions;
this.maxDbSize = options.MaxDBSize * 1024 * 1024;
this.maxLongQuery = options.MaxLengthyQuery;
this.maxLongTx = options.MaxLengthTX;
this.localIp = NetworkInterface.GetLocalIPAddress(options.LocalRoute);
this.connection = this.ConnectMSSql();
TimerHelper.RecurringCall(
KeepAliveInterval,
delegate
{
this.KeepAliveMSSql();
});
if (this.maxLongQuery > 0)
{
TimerHelper.RecurringCall(
this.maxLongQuery / 2,
delegate
{
this.KillLongTransactions();
});
}
if (this.maxLongTx > 0)
{
TimerHelper.RecurringCall(
this.maxLongTx / 2,
delegate
{
this.KillLongQueries();
});
}
else
{
Logger.Info(Strings.LongTXKillerDisabledInfoMessage);
}
TimerHelper.RecurringCall(
StorageQuotaInterval,
delegate
{
this.EnforceStorageQuota();
});
this.baseDir = options.BaseDir;
if (!string.IsNullOrEmpty(this.baseDir))
{
Directory.CreateDirectory(this.baseDir);
}
ProvisionedService.Initialize(options.LocalDB);
this.CheckDBConsistency();
this.availableStorageBytes = options.AvailableStorage * 1024 * 1024;
this.availableCapacity = options.Capacity;
foreach (ProvisionedService provisioned_service in ProvisionedService.GetInstances())
{
this.availableStorageBytes -= this.StorageForService(provisioned_service);
this.availableCapacity -= this.CapacityUnit();
}
this.queriesServed = 0;
this.qpsLastUpdated = DateTime.Now;
// initialize qps counter
this.GetQPS();
this.longQueriesKilled = 0;
this.longTxKilled = 0;
this.provisionServed = 0;
this.bindingServed = 0;
this.Start(options);
}
private DragDropEffects GetBindProvisionedServicesDragEffects(ProvisionedService provisionedService)
{
return Cloud.Services.Any() ? DragDropEffects.Move : DragDropEffects.None;
}
private System.Windows.DragDropEffects GetBindProvisionedServicesDragEffects(ProvisionedService provisionedService)
{
return this.Cloud.Services.Any() ? System.Windows.DragDropEffects.Move : System.Windows.DragDropEffects.None;
}
private object GetBindProvisionedServicesData(ProvisionedService provisionedService)
{
return(provisionedService);
}
private System.Windows.DragDropEffects GetBindProvisionedServicesDragEffects(ProvisionedService provisionedService)
{
return(this.Cloud.Services.Any() ? System.Windows.DragDropEffects.Move : System.Windows.DragDropEffects.None);
}
public void CreateDatabaseTest()
{
try
{
Node node = new Node();
Node_Accessor target = new Node_Accessor(new PrivateObject(node));
target.mssqlConfig = new MSSqlOptions();
UhuruSection config = (UhuruSection)ConfigurationManager.GetSection("uhuru");
var po = new PrivateObject(node, new PrivateType(typeof(NodeBase)));
NodeBase_Accessor nodebase = new NodeBase_Accessor(po);
nodebase.capacity = config.Service.Capacity;
target.mssqlConfig.Host = config.Service.MSSql.Host;
target.mssqlConfig.User = config.Service.MSSql.User;
target.mssqlConfig.Password = config.Service.MSSql.Password;
target.mssqlConfig.Port = config.Service.MSSql.Port;
target.maxLongQuery = config.Service.MSSql.MaxLengthyQuery;
target.mssqlConfig.LogicalStorageUnits = config.Service.MSSql.LogicalStorageUnits;
target.mssqlConfig.InitialDataSize = config.Service.MSSql.InitialDataSize;
target.mssqlConfig.InitialLogSize = config.Service.MSSql.InitialLogSize;
target.mssqlConfig.MaxDataSize = config.Service.MSSql.MaxDataSize;
target.mssqlConfig.MaxLogSize = config.Service.MSSql.MaxLogSize;
target.mssqlConfig.DataFileGrowth = config.Service.MSSql.DataFileGrowth;
target.mssqlConfig.LogFileGrowth = config.Service.MSSql.LogFileGrowth;
target.connection = target.ConnectMSSql();
ProvisionedService provisionedService = new ProvisionedService();
DateTime now = DateTime.Now;
string decoration = string.Format(
"{0}_{1}_{2}",
now.Hour,
now.Minute,
now.Second);
provisionedService.Name = "CreateDatabaseTest_" + decoration;
provisionedService.User = "******" + decoration;
provisionedService.Password = "******";
provisionedService.Plan = "free";
//////////////////////////////////////////////////////////////////////////
// create the provisioned service db and user
//////////////////////////////////////////////////////////////////////////
target.CreateDatabase(provisionedService);
Thread.Sleep(500);
//////////////////////////////////////////////////////////////////////////
// assert the existence of the db files
//////////////////////////////////////////////////////////////////////////
string dbScript = target.createDBScript;
Regex fnRegex = new Regex(@"FILENAME = N'(.*)'");
MatchCollection matches = fnRegex.Matches(dbScript);
foreach (Match m in matches)
{
string fileName = m.Value.Substring(m.Value.IndexOf('\'')).Trim(new char[] { '\'' });
Assert.IsTrue(File.Exists(fileName), string.Format("File '{0}' does not exist", fileName));
}
//////////////////////////////////////////////////////////////////////////
// try to connect as the newly created user
//////////////////////////////////////////////////////////////////////////
string sqlTestConnString = string.Format(
CultureInfo.InvariantCulture,
"Data Source={0},{1};User Id={2};Password={3};MultipleActiveResultSets=true;Pooling=false",
target.mssqlConfig.Host,
target.mssqlConfig.Port,
provisionedService.User,
provisionedService.Password);
SqlConnection sqlTest = new SqlConnection(sqlTestConnString);
sqlTest.Open();
//////////////////////////////////////////////////////////////////////////
// try to connect create a table as the newly created user
//////////////////////////////////////////////////////////////////////////
SqlCommand cmdTest = new SqlCommand(
string.Format("CREATE TABLE [{0}].[dbo].[TestTable]([Command] [varchar](100) NULL, [Description] [varchar](50) NULL) ON [DATA]", provisionedService.Name),
sqlTest);
cmdTest.ExecuteNonQuery();
sqlTest.Close();
//////////////////////////////////////////////////////////////////////////
// try to operate on the service db as a different user
//////////////////////////////////////////////////////////////////////////
// connect as sa
sqlTest.ConnectionString = string.Format(
CultureInfo.InvariantCulture,
"Data Source={0},{1};User Id={2};Password={3};MultipleActiveResultSets=true;Pooling=false",
target.mssqlConfig.Host,
target.mssqlConfig.Port,
target.mssqlConfig.User,
target.mssqlConfig.Password);
sqlTest.Open();
string dummyUser = "******" + decoration;
string dummyPwd = "password1234!";
//create a dummy user
string createLoginString = string.Format(@"CREATE LOGIN {0} WITH PASSWORD = '******'", dummyUser, dummyPwd);
cmdTest = new SqlCommand(createLoginString, sqlTest);
cmdTest.ExecuteNonQuery();
sqlTest.Close();
// connect as the dummy user
sqlTest.ConnectionString = string.Format(
CultureInfo.InvariantCulture,
"Data Source={0},{1};User Id={2};Password={3};MultipleActiveResultSets=true;Pooling=false",
target.mssqlConfig.Host,
target.mssqlConfig.Port,
dummyUser,
dummyPwd);
sqlTest.Open();
// try to drop the service db
try
{
cmdTest.CommandText = string.Format("CREATE TABLE [{0}].[dbo].[DummyTable]([Command] [varchar](100) NULL, [Description] [varchar](50) NULL) ON [DATA]", provisionedService.Name);
cmdTest.ExecuteNonQuery();
Assert.Fail("Other users have read/write access to the service db");
}
catch (SqlException sex)
{
}
//////////////////////////////////////////////////////////////////////////
//Remove database
//////////////////////////////////////////////////////////////////////////
ServiceCredentials sc = new ServiceCredentials();
sc.UserName = provisionedService.User;
sc.Password = provisionedService.Password;
sc.Name = provisionedService.Name;
sc.User = provisionedService.User;
target.DeleteDatabase(provisionedService);
//target.Unprovision(provisionedService.Name, new ServiceCredentials[] { sc });
sqlTest.Close();
target.connection.Close();
}
catch (System.Exception ex)
{
Assert.Fail(ex.Message);
}
}
public static void PushApp(string appName, string sourceDir, string url, List <string> directoriesCreated, CloudConnection cloudConnection, string vendor, string serviceName, string path)
{
if (path == null)
{
path = TestUtil.CopyFolderToTemp(sourceDir);
}
directoriesCreated.Add(path);
if (serviceName == null)
{
serviceName = appName + "svc";
}
if (vendor != null)
{
cloudConnection.CreateProvisionedService(cloudConnection.SystemServices.FirstOrDefault(ss => ss.Vendor == vendor), serviceName, true);
Thread.Sleep(10000);
}
CloudApplication cloudApp = new CloudApplication()
{
Name = appName,
Urls = new string[1] {
url
},
DeploymentPath = path,
Deployable = true,
Framework = "dotNet",
InstanceCount = 1,
Memory = 128,
Runtime = "iis",
};
PushTracker pushTracker = new PushTracker();
Guid tracker = Guid.NewGuid();
pushTracker.TrackId = tracker;
currentJobs.Add(tracker);
cloudConnection.PushJob.Start(pushTracker, cloudApp);
cloudConnection.PushJob.JobCompleted += new EventHandler <global::System.ComponentModel.AsyncCompletedEventArgs>(PushJob_JobCompleted);
while (currentJobs.Contains(tracker))
{
Thread.Sleep(1000);
}
App currentApp = cloudConnection.Apps.FirstOrDefault(app => app.Name == cloudApp.Name);
ProvisionedService provisionedService = cloudConnection.ProvisionedServices.FirstOrDefault(ps => ps.Name == serviceName);
if (vendor != null)
{
currentApp.BindService(provisionedService);
Thread.Sleep(1000);
}
currentApp.Start();
int retryCount = 10;
while (true)
{
App pushedApp = cloudConnection.Apps.FirstOrDefault(app => app.Name == cloudApp.Name);
if (pushedApp.State == AppState.RUNNING)
{
break;
}
Thread.Sleep(1000);
retryCount--;
if (retryCount == 0)
{
break;
}
}
}
