private void RollbackInstallation(InstallationInfo inst)
{
// remove virtual dir
if (inst[PROPERTY_VDIR_CREATED] != null)
{
// delete virtual directory
WebServerController.DeleteAppVirtualDirectory(inst.WebSiteId, inst.VirtualDir);
// delete folder
FilesController.DeleteFiles(inst.PackageId, new string[] { inst[PROPERTY_CONTENT_PATH] });
}
// remove database
if (inst[PROPERTY_DATABASE_CREATED] != null)
{
DatabaseServerController.DeleteSqlDatabase(inst.DatabaseId);
}
// remove database user
if (inst[PROPERTY_USER_CREATED] != null)
{
DatabaseServerController.DeleteSqlUser(inst.UserId);
}
}
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
{
if (item is HomeFolder)
{
// backup home folder files
string backupName = String.Format("SpaceFiles_{0}_{1}.zip",
item.Id, DateTime.Now.Ticks);
// get the list of remote files
List <SystemFile> files = FilesController.GetFiles(item.PackageId, "\\", true);
string[] zipFiles = new string[files.Count];
for (int i = 0; i < zipFiles.Length; i++)
{
zipFiles[i] = files[i].Name;
}
// zip remote files
FilesController.ZipFiles(item.PackageId, zipFiles, backupName);
// download zipped file
string localBackupPath = Path.Combine(tempFolder, backupName);
byte[] buffer = null;
FileStream stream = new FileStream(localBackupPath, FileMode.Create, FileAccess.Write);
int offset = 0;
long length = 0;
do
{
// read remote content
buffer = FilesController.GetFileBinaryChunk(item.PackageId, backupName, offset, FILE_BUFFER_LENGTH);
// write remote content
stream.Write(buffer, 0, buffer.Length);
length += buffer.Length;
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
stream.Close();
// delete zipped file
if (FilesController.FileExists(item.PackageId, backupName))
{
FilesController.DeleteFiles(item.PackageId, new string[] { backupName });
}
// add file pointer
BackupController.WriteFileElement(writer, "SpaceFiles", backupName, length);
// store meta item
XmlSerializer serializer = new XmlSerializer(typeof(HomeFolder));
serializer.Serialize(writer, item);
}
else if (item is SystemDSN)
{
// backup ODBC DSN
OS.OperatingSystem os = GetOS(item.ServiceId);
// read DSN info
SystemDSN itemDsn = item as SystemDSN;
SystemDSN dsn = os.GetDSN(item.Name);
dsn.DatabasePassword = itemDsn.DatabasePassword;
XmlSerializer serializer = new XmlSerializer(typeof(SystemDSN));
serializer.Serialize(writer, dsn);
}
return(0);
}
public int InstallWebApplication(InstallationInfo inst)
{
// place log record
TaskManager.StartTask("APP_INSTALLER", "INSTALL_APPLICATION", inst.PackageId);
TaskManager.WriteParameter("Virtual directory", inst.VirtualDir);
TaskManager.WriteParameter("Database group", inst.DatabaseGroup);
try
{
// get application info
app = GetApplication(inst.PackageId, inst.ApplicationId);
BackgroundTask topTask = TaskManager.TopTask;
topTask.ItemName = app.Name;
TaskController.UpdateTask(topTask);
// check web site for existance
WebSite webSite = WebServerController.GetWebSite(inst.WebSiteId);
if (webSite == null)
{
return(BusinessErrorCodes.ERROR_WEB_INSTALLER_WEBSITE_NOT_EXISTS);
}
TaskManager.WriteParameter("Web site", webSite.Name);
webSiteName = webSite.Name;
siteId = webSite.SiteId;
// change web site properties if required
if (String.IsNullOrEmpty(inst.VirtualDir))
{
ChangeAppVirtualDirectoryProperties(webSite, app.WebSettings);
WebServerController.UpdateWebSite(webSite);
}
// get OS service
int osId = PackageController.GetPackageServiceId(inst.PackageId, "os");
os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osId);
// get remote content path
contentPath = webSite.ContentPath;
// create virtual dir if required
if (!String.IsNullOrEmpty(inst.VirtualDir))
{
// check if the required virtual dir already exists
contentPath = Path.Combine(contentPath, inst.VirtualDir);
WebAppVirtualDirectory vdir = null;
int result = WebServerController.AddAppVirtualDirectory(inst.WebSiteId, inst.VirtualDir, contentPath);
if (result == BusinessErrorCodes.ERROR_VDIR_ALREADY_EXISTS)
{
// the directory alredy exists
vdir = WebServerController.GetAppVirtualDirectory(
inst.WebSiteId, inst.VirtualDir);
contentPath = vdir.ContentPath;
}
else
{
vdir = WebServerController.GetAppVirtualDirectory(
inst.WebSiteId, inst.VirtualDir);
inst[PROPERTY_VDIR_CREATED] = "True";
}
// change virtual directory properties if required
ChangeAppVirtualDirectoryProperties(vdir, app.WebSettings);
WebServerController.UpdateAppVirtualDirectory(inst.WebSiteId, vdir);
}
// deploy application codebase ZIP and then unpack it
string codebasePath = app.Codebase;
string remoteCodebasePath = Path.Combine(contentPath, Path.GetFileName(app.Codebase));
// make content path absolute
string absContentPath = FilesController.GetFullPackagePath(inst.PackageId, contentPath);
// save content path
inst[PROPERTY_CONTENT_PATH] = contentPath;
inst[PROPERTY_ABSOLUTE_CONTENT_PATH] = absContentPath;
// copy ZIP to the target server
FileStream stream = File.OpenRead(codebasePath);
int BUFFER_LENGTH = 5000000;
byte[] buffer = new byte[BUFFER_LENGTH];
int readBytes = 0;
while (true)
{
readBytes = stream.Read(buffer, 0, BUFFER_LENGTH);
if (readBytes < BUFFER_LENGTH)
{
Array.Resize <byte>(ref buffer, readBytes);
}
FilesController.AppendFileBinaryChunk(inst.PackageId, remoteCodebasePath, buffer);
if (readBytes < BUFFER_LENGTH)
{
break;
}
}
// unpack codebase
inst[PROPERTY_INSTALLED_FILES] = String.Join(";",
FilesController.UnzipFiles(inst.PackageId, new string[] { remoteCodebasePath }));
// delete codebase zip
FilesController.DeleteFiles(inst.PackageId, new string[] { remoteCodebasePath });
// check/create databases
if (!String.IsNullOrEmpty(inst.DatabaseGroup) &&
String.Compare(inst.DatabaseGroup, "None", true) != 0)
{
// database
if (inst.DatabaseId == 0)
{
TaskManager.WriteParameter("Database name", inst.DatabaseName);
// we should create a new database
SqlDatabase db = new SqlDatabase();
db.PackageId = inst.PackageId;
db.Name = inst.DatabaseName;
inst.DatabaseId = DatabaseServerController.AddSqlDatabase(db, inst.DatabaseGroup);
if (inst.DatabaseId < 0)
{
// rollback installation
RollbackInstallation(inst);
// return error
return(inst.DatabaseId); // there was an error when creating database
}
inst[PROPERTY_DATABASE_CREATED] = "True";
}
else
{
// existing database
SqlDatabase db = DatabaseServerController.GetSqlDatabase(inst.DatabaseId);
inst.DatabaseName = db.Name;
TaskManager.WriteParameter("Database name", inst.DatabaseName);
}
SqlUser user = null;
// database user
if (inst.UserId == 0)
{
TaskManager.WriteParameter("Database user", inst.Username);
// NEW USER
user = new SqlUser();
user.PackageId = inst.PackageId;
user.Name = inst.Username;
user.Databases = new string[] { inst.DatabaseName };
user.Password = inst.Password;
inst.UserId = DatabaseServerController.AddSqlUser(user, inst.DatabaseGroup);
if (inst.UserId < 0)
{
// rollback installation
RollbackInstallation(inst);
// return error
return(inst.UserId); // error while adding user
}
inst[PROPERTY_USER_CREATED] = "True";
}
else
{
// EXISTING USER
user = DatabaseServerController.GetSqlUser(inst.UserId);
inst.Username = user.Name;
TaskManager.WriteParameter("Database user", inst.Username);
List <string> databases = new List <string>();
databases.AddRange(user.Databases);
if (!databases.Contains(inst.DatabaseName))
{
databases.Add(inst.DatabaseName);
user.Databases = databases.ToArray();
DatabaseServerController.UpdateSqlUser(user);
}
}
// check connectivity with SQL Server and credentials provided
// load user item
int sqlServiceId = PackageController.GetPackageServiceId(inst.PackageId, inst.DatabaseGroup);
sql = new DatabaseServer();
ServiceProviderProxy.Init(sql, sqlServiceId);
if (!sql.CheckConnectivity(inst.DatabaseName, inst.Username,
inst.Password))
{
// can't connect to the database
RollbackInstallation(inst);
return(BusinessErrorCodes.ERROR_WEB_INSTALLER_CANT_CONNECT_DATABASE);
}
// read SQL server settings
StringDictionary settings = ServerController.GetServiceSettings(sqlServiceId);
serverIpAddressExternal = settings["ExternalAddress"];
if (settings.ContainsKey("InternalAddress"))
{
serverIpAddressInternal = settings["InternalAddress"];
}
}
// ********* RUN INSTALL SCENARIO ***********
int scriptResult = RunInstallScenario(inst);
if (scriptResult < 0)
{
// rollback installation
RollbackInstallation(inst);
// return error
return(scriptResult);
}
// add new installation to the database
return(0);
}
catch (Exception ex)
{
// rollback installation
RollbackInstallation(inst);
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public int DeleteFiles(int packageId, string[] files)
{
return(FilesController.DeleteFiles(packageId, files));
}
public static string BackupSqlDatabase(int itemId, string backupName,
bool zipBackup, bool download, string folderName)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(null);
}
// load original meta item
SqlDatabase item = (SqlDatabase)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(null);
}
// place log record
TaskManager.StartTask("SQL_DATABASE", "BACKUP", item.Name, itemId);
try
{
DatabaseServer sql = GetDatabaseServer(item.ServiceId);
string backFile = sql.BackupDatabase(item.Name, backupName, zipBackup);
if (!download)
{
// copy backup files to space folder
string relFolderName = FilesController.CorrectRelativePath(folderName);
if (!relFolderName.EndsWith("\\"))
{
relFolderName = relFolderName + "\\";
}
// create backup folder if not exists
if (!FilesController.DirectoryExists(item.PackageId, relFolderName))
{
FilesController.CreateFolder(item.PackageId, relFolderName);
}
string packageFile = relFolderName + Path.GetFileName(backFile);
// delete destination file if exists
if (FilesController.FileExists(item.PackageId, packageFile))
{
FilesController.DeleteFiles(item.PackageId, new string[] { packageFile });
}
byte[] buffer = null;
int offset = 0;
do
{
// read remote content
buffer = sql.GetTempFileBinaryChunk(backFile, offset, FILE_BUFFER_LENGTH);
// write remote content
FilesController.AppendFileBinaryChunk(item.PackageId, packageFile, buffer);
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
}
return(backFile);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public override void DoWork()
{
// Input parameters:
// - FILE_PATH
// - FTP_SERVER
// - FTP_USERNAME
// - FTP_PASSWORD
// - FTP_FOLDER
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string filePath = (string)topTask.GetParamValue("FILE_PATH");
string ftpServer = (string)topTask.GetParamValue("FTP_SERVER");
string ftpUsername = (string)topTask.GetParamValue("FTP_USERNAME");
string ftpPassword = (string)topTask.GetParamValue("FTP_PASSWORD");
string ftpFolder = (string)topTask.GetParamValue("FTP_FOLDER");
// check input parameters
if (String.IsNullOrEmpty(filePath))
{
TaskManager.WriteWarning("Specify 'File' task parameter");
return;
}
if (String.IsNullOrEmpty(ftpServer))
{
TaskManager.WriteWarning("Specify 'FTP Server' task parameter");
return;
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
filePath = Utils.ReplaceStringVariable(filePath, "date", date);
filePath = Utils.ReplaceStringVariable(filePath, "time", time);
// build FTP command file
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
// FTP server
writer.WriteLine("open " + ftpServer);
// check if anonymous mode
if (String.IsNullOrEmpty(ftpUsername))
{
ftpUsername = "******";
ftpPassword = "******";
}
// FTP username/password
writer.WriteLine(ftpUsername);
writer.WriteLine(ftpPassword);
// check if we need to change remote folder
if (!String.IsNullOrEmpty(ftpFolder))
{
writer.WriteLine("cd " + ftpFolder.Replace("\\", "/"));
}
// file to send
writer.WriteLine("binary");
writer.WriteLine("put " + FilesController.GetFullPackagePath(topTask.PackageId, filePath));
// bye
writer.WriteLine("bye");
string cmdBatch = sb.ToString();
// create temp file in user space
string cmdPath = Utils.GetRandomString(10) + ".txt";
string fullCmdPath = FilesController.GetFullPackagePath(topTask.PackageId, cmdPath);
// upload batch
FilesController.UpdateFileBinaryContent(topTask.PackageId, cmdPath, Encoding.UTF8.GetBytes(cmdBatch));
// execute system command
// load OS service
int serviceId = PackageController.GetPackageServiceId(topTask.PackageId, ResourceGroups.Os);
// load service
ServiceInfo service = ServerController.GetServiceInfo(serviceId);
if (service == null)
{
return;
}
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, service.ServerId);
TaskManager.Write(winServer.ExecuteSystemCommand("ftp.exe", "-s:" + fullCmdPath));
// delete batch file
FilesController.DeleteFiles(topTask.PackageId, new string[] { cmdPath });
}
