public void ImportItem(int packageId, int itemTypeId,
Type itemType, ResourceGroupInfo group, string itemName)
{
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return;
}
// FTP provider
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, serviceId);
if (itemType == typeof(FtpAccount))
{
// load FTP account
FtpAccount account = ftp.GetAccount(itemName);
account.Folder = FilesController.GetFullPackagePath(packageId, "\\"); // root space folder
// update FTP account
ftp.UpdateAccount(account);
// save account
account.ServiceId = serviceId;
account.PackageId = packageId;
PackageController.AddPackageItem(account);
}
}
public static bool RemoteServerFolderWriteAccessible(int packageId, string path)
{
try
{
// copy to space folder
int osServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Os);
if (osServiceId > 0)
{
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osServiceId);
string remoteServerPathCheck = FilesController.GetFullPackagePath(packageId,
Path.Combine(path, "check.txt"));
//
os.CreateFile(remoteServerPathCheck);
os.AppendFileBinaryContent(remoteServerPathCheck, Encoding.UTF8.GetBytes(remoteServerPathCheck));
os.DeleteFile(remoteServerPathCheck);
}
//
return(true);
}
catch
{ //
return(false);
}
}
private static FtpAccount ConvertItemToFtpAccount(ServiceProviderItem item)
{
FtpAccount account = (FtpAccount)item;
string homeFolder = FilesController.GetHomeFolder(account.PackageId);
if (!String.IsNullOrEmpty(account.Folder) && account.Folder.IndexOf(":") != -1)
{
account.Folder = account.Folder.Substring(homeFolder.Length);
}
account.Folder = (account.Folder == "") ? "\\" : account.Folder;
// decode password
account.Password = CryptoUtils.Decrypt(account.Password);
return(account);
}
public static FtpAccount GetFtpAccount(int itemId)
{
// load meta item
FtpAccount item = (FtpAccount)PackageController.GetPackageItem(itemId);
// load service item
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, item.ServiceId);
FtpAccount account = ftp.GetAccount(item.Name);
// truncate home folder
account.Folder = FilesController.GetVirtualPackagePath(item.PackageId, account.Folder);
account.Id = item.Id;
account.PackageId = item.PackageId;
account.ServiceId = item.ServiceId;
account.Password = CryptoUtils.Decrypt(item.Password);
return(account);
}
public static SystemDSN GetOdbcSource(int itemId)
{
// load meta item
SystemDSN item = (SystemDSN)PackageController.GetPackageItem(itemId);
// load service item
OS.OperatingSystem os = GetOS(item.ServiceId);
SystemDSN dsn = os.GetDSN(item.Name);
// add common properties
dsn.Id = item.Id;
dsn.PackageId = item.PackageId;
dsn.ServiceId = item.ServiceId;
if (dsn.Driver == "MsAccess" || dsn.Driver == "Excel" || dsn.Driver == "Text")
{
dsn.DatabaseName = FilesController.GetVirtualPackagePath(item.PackageId, dsn.DatabaseName);
}
return(dsn);
}
public override void DoWork()
{
// Input parameters:
// - FOLDER
// - ZIP_FILE
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string filesList = (string)topTask.GetParamValue("FOLDER");
string zipFile = (string)topTask.GetParamValue("ZIP_FILE");
// check input parameters
if (String.IsNullOrEmpty(filesList))
{
TaskManager.WriteWarning("Specify 'Files List' task parameter");
return;
}
if (String.IsNullOrEmpty(zipFile))
{
TaskManager.WriteWarning("Specify 'Zip File' task parameter");
return;
}
// substitute parameters
DateTime d = DateTime.Now;
string date = d.ToString("yyyyMMdd");
string time = d.ToString("HHmm");
filesList = Utils.ReplaceStringVariable(filesList, "date", date);
filesList = Utils.ReplaceStringVariable(filesList, "time", time);
zipFile = Utils.ReplaceStringVariable(zipFile, "date", date);
zipFile = Utils.ReplaceStringVariable(zipFile, "time", time);
// zip files and folders
FilesController.ZipFiles(topTask.PackageId, new string[] { filesList }, zipFile);
}
private void RollbackInstallation(InstallationInfo inst)
{
// remove virtual dir
if (inst[PROPERTY_VDIR_CREATED] != null)
{
// delete virtual directory
WebServerController.DeleteVirtualDirectory(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 FolderGraph GetFolderGraph(int packageId, string path)
{
return(FilesController.GetFolderGraph(packageId, path));
}
public void ExecuteSyncActions(int packageId, FileSyncAction[] actions)
{
FilesController.ExecuteSyncActions(packageId, actions);
}
public static int UpdateFtpAccount(FtpAccount item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
FtpAccount origItem = (FtpAccount)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FTP_ACCOUNT", "UPDATE", origItem.Name, item.Id);
TaskManager.WriteParameter("Folder", item.Folder);
TaskManager.WriteParameter("CanRead", item.CanRead);
TaskManager.WriteParameter("CanWrite", item.CanWrite);
try
{
// get service
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, origItem.ServiceId);
// store original folder
string origFolder = item.Folder;
// convert folder
StringDictionary ftpSettings = ServerController.GetServiceSettings(origItem.ServiceId);
if (Utils.ParseBool(ftpSettings["BuildUncFilesPath"], false))
{
// UNC
// get OS service
int osServiceId = PackageController.GetPackageServiceId(origItem.PackageId, ResourceGroups.Os);
item.Folder = FilesController.GetFullUncPackagePath(origItem.PackageId, osServiceId, item.Folder);
}
else
{
// Absolute
item.Folder = FilesController.GetFullPackagePath(origItem.PackageId, item.Folder);
}
item.Enabled = true;
// add service item
ftp.UpdateAccount(item);
// save item
item.Password = String.IsNullOrEmpty(item.Password) ? origItem.Password : CryptoUtils.Encrypt(item.Password);
item.Folder = (origFolder == "") ? "\\" : origFolder;
PackageController.UpdatePackageItem(item);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public List <SystemFile> GetFilesByMask(int packageId, string path, string filesMask)
{
return(FilesController.GetFilesByMask(packageId, path, filesMask));
}
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 static int AddOdbcSource(SystemDSN item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// check quota
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.OS_ODBC);
if (quota.QuotaExhausted)
{
return(BusinessErrorCodes.ERROR_OS_DSN_RESOURCE_QUOTA_LIMIT);
}
// check if mail resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os);
if (serviceId == 0)
{
return(BusinessErrorCodes.ERROR_OS_RESOURCE_UNAVAILABLE);
}
// check package items
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SystemDSN)) != null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_EXISTS);
}
// place log record
TaskManager.StartTask("ODBC_DSN", "ADD", item.Name);
try
{
// check service items
OS.OperatingSystem os = GetOS(serviceId);
if (os.GetDSN(item.Name) != null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_SERVICE_ITEM_EXISTS);
}
string[] dbNameParts = item.DatabaseName.Split('|');
string groupName = null;
if (dbNameParts.Length > 1)
{
item.DatabaseName = dbNameParts[0];
groupName = dbNameParts[1];
}
// get database server address
item.DatabaseServer = GetDatabaseServerName(groupName, item.PackageId);
if (item.Driver == "MsAccess" || item.Driver == "Excel" || item.Driver == "Text")
{
item.DatabaseName = FilesController.GetFullPackagePath(item.PackageId, item.DatabaseName);
}
// add service item
os.CreateDSN(item);
// save item
item.DatabasePassword = CryptoUtils.Encrypt(item.DatabasePassword);
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
TaskManager.ItemId = itemId;
return(itemId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public int SetFilePermissions(int packageId, string path, UserPermission[] users, bool resetChildPermissions)
{
return(FilesController.SetFilePermissions(packageId, path, users, resetChildPermissions));
}
public static int AddSite(StatsSite item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// check quota
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.STATS_SITES);
if (quota.QuotaExhausted)
{
return(BusinessErrorCodes.ERROR_STATS_RESOURCE_QUOTA_LIMIT);
}
// check if stats resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Statistics);
if (serviceId == 0)
{
return(BusinessErrorCodes.ERROR_STATS_RESOURCE_UNAVAILABLE);
}
// check package items
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(StatsSite)) != null)
{
return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_EXISTS);
}
// place log record
TaskManager.StartTask("STATS_SITE", "ADD", item.Name);
try
{
// load web site
WebSite siteItem = (WebSite)PackageController.GetPackageItemByName(item.PackageId,
item.Name, typeof(WebSite));
if (siteItem == null)
{
return(BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE);
}
// get service web site
WebServer web = new WebServer();
ServiceProviderProxy.Init(web, siteItem.ServiceId);
WebSite site = web.GetSite(siteItem.SiteId);
List <DomainInfo> pointers = WebServerController.GetWebSitePointers(siteItem.Id);
List <string> aliases = new List <string>();
foreach (DomainInfo pointer in pointers)
{
aliases.Add(pointer.DomainName);
}
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, serviceId);
string siteNumber = (site.IIs7) ? site[WebSite.IIS7_SITE_ID] : siteItem.SiteId.Replace("/", "");
string logsCommonFolder = site.LogsPath;
string logsFolder = Path.Combine(logsCommonFolder, siteNumber);
// get service settings
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
if (Utils.ParseBool(settings["BuildUncLogsPath"], false))
{
logsFolder = FilesController.ConvertToUncPath(siteItem.ServiceId, logsFolder);
}
item.LogDirectory = logsFolder;
item.DomainAliases = aliases.ToArray();
// install statistics
item.SiteId = stats.AddSite(item);
// save statistics item
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
TaskManager.ItemId = itemId;
return(itemId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int InstallWebPartsPackage(int itemId, string uploadedFile, string packageFile)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("SHAREPOINT", "INSTALL_WEBPARTS", item.Name);
TaskManager.ItemId = itemId;
TaskManager.WriteParameter("Package file", packageFile);
try
{
SharePointServer sps = GetSharePoint(item.ServiceId);
string backupFile = null;
if (!String.IsNullOrEmpty(packageFile))
{
// copy package files to the remote SharePoint Server
string path = null;
byte[] buffer = null;
int offset = 0;
do
{
// read package file
buffer = FilesController.GetFileBinaryChunk(item.PackageId, packageFile, offset, FILE_BUFFER_LENGTH);
// write remote backup file
string tempPath = sps.AppendTempFileBinaryChunk(Path.GetFileName(packageFile), path, buffer);
if (path == null)
{
path = tempPath;
backupFile = path;
}
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
}
else if (!String.IsNullOrEmpty(uploadedFile))
{
// upladed files
backupFile = uploadedFile;
}
// restore
if (!String.IsNullOrEmpty(backupFile))
{
sps.InstallWebPartsPackage(item.Name, backupFile);
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public byte[] GetFileBinaryChunk(int packageId, string path, int offset, int length)
{
return(FilesController.GetFileBinaryChunk(packageId, path, offset, length));
}
public int UpdateFileBinaryContentUsingEncoding(int packageId, string path, byte[] content, string encoding)
{
return(FilesController.UpdateFileBinaryContentUsingEncoding(packageId, path, content, encoding));
}
public int UpdateFileBinaryContent(int packageId, string path, byte[] content)
{
return(FilesController.UpdateFileBinaryContent(packageId, path, content));
}
public byte[] GetFileBinaryContentUsingEncoding(int packageId, string path, string encoding)
{
return(FilesController.GetFileBinaryContentUsingEncoding(packageId, path, encoding));
}
public byte[] GetFileBinaryContent(int packageId, string path)
{
return(FilesController.GetFileBinaryContent(packageId, path));
}
public static int BackupInternal(string taskId, int userId, int packageId, int serviceId, int serverId,
string backupFileName, int storePackageId, string storePackageFolder, string storeServerFolder,
bool deleteTempBackup)
{
try
{
TaskManager.StartTask(taskId, "BACKUP", "BACKUP", backupFileName, SecurityContext.User.UserId);
// get the list of items to backup
TaskManager.Write("Calculate items to backup");
List <ServiceProviderItem> items = GetBackupItems(userId, packageId, serviceId, serverId);
if (items.Count == 0)
{
return(0);
}
// group items by item types
Dictionary <int, List <ServiceProviderItem> > groupedItems = new Dictionary <int, List <ServiceProviderItem> >();
// sort by groups
foreach (ServiceProviderItem item in items)
{
// add to group
if (!groupedItems.ContainsKey(item.TypeId))
{
groupedItems[item.TypeId] = new List <ServiceProviderItem>();
}
groupedItems[item.TypeId].Add(item);
}
// temp backup folder
string tempFolder = GetTempBackupFolder();
// create backup catalog file
StringWriter sw = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(sw);
// write backup file header
writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
writer.WriteStartElement("Backup");
writer.WriteStartElement("Info");
writer.WriteElementString("Name", backupFileName);
writer.WriteElementString("Created", DateTime.Now.ToString("r"));
writer.WriteElementString("User", GetLoggedUsername());
writer.WriteEndElement(); // Info
// determine the number of items to backup
int totalItems = 0;
foreach (int itemTypeId in groupedItems.Keys)
{
// load item type
ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId);
if (!itemType.Backupable)
{
continue;
}
totalItems += groupedItems[itemTypeId].Count;
}
TaskManager.IndicatorMaximum = totalItems + 2;
TaskManager.IndicatorCurrent = 0;
// backup grouped items
writer.WriteStartElement("Items");
foreach (int itemTypeId in groupedItems.Keys)
{
// load item type
ServiceProviderItemType itemType = PackageController.GetServiceItemType(itemTypeId);
if (!itemType.Backupable)
{
continue;
}
// load group
ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId);
// instantiate controller
IBackupController controller = null;
try
{
if (group.GroupController != null)
{
controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController;
}
if (controller != null)
{
// backup items
foreach (ServiceProviderItem item in groupedItems[itemTypeId])
{
TaskManager.Write(String.Format("Backup {0} of {1} - {2} '{3}'",
TaskManager.IndicatorCurrent + 1,
totalItems,
itemType.DisplayName,
item.Name));
try
{
int backupResult = BackupItem(tempFolder, writer, item, group, controller);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't backup item");
}
// increment progress
TaskManager.IndicatorCurrent += 1;
}
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
writer.WriteEndElement(); // Items
// close catalog writer
writer.WriteEndElement(); // Backup
writer.Close();
// convert to Xml document
XmlDocument doc = new XmlDocument();
doc.LoadXml(sw.ToString());
// sign XML document
//SignXmlDocument(doc);
// save signed doc to file
try
{
doc.Save(Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME));
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't save backup catalog file: "
+ Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME));
return(0);
}
TaskManager.Write("Packaging backup...");
// compress backup files
string[] zipFiles = Directory.GetFiles(tempFolder);
string[] zipFileNames = new string[zipFiles.Length];
for (int i = 0; i < zipFiles.Length; i++)
{
zipFileNames[i] = Path.GetFileName(zipFiles[i]);
}
string backupFileNamePath = Path.Combine(tempFolder, backupFileName);
try
{
FileUtils.ZipFiles(backupFileNamePath, tempFolder, zipFileNames);
// delete packed files
foreach (string zipFile in zipFiles)
{
File.Delete(zipFile);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't zip backed up files");
return(0);
}
TaskManager.IndicatorCurrent += 1;
TaskManager.Write("Copying backup...");
// move/copy backup file
if (!String.IsNullOrEmpty(storeServerFolder))
{
// copy to local folder or UNC
try
{
string destFile = Path.Combine(storeServerFolder, backupFileName);
File.Copy(backupFileNamePath, destFile, true);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't copy backup to destination location");
return(0);
}
}
else if (storePackageId > 0)
{
try
{
// copy to space folder
int osServiceId = PackageController.GetPackageServiceId(storePackageId, ResourceGroups.Os);
if (osServiceId > 0)
{
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osServiceId);
string remoteBackupPath = FilesController.GetFullPackagePath(storePackageId,
Path.Combine(storePackageFolder, backupFileName));
FileStream stream = new FileStream(backupFileNamePath, FileMode.Open, FileAccess.Read);
byte[] buffer = new byte[FILE_BUFFER_LENGTH];
int readBytes = 0;
do
{
// read package file
readBytes = stream.Read(buffer, 0, FILE_BUFFER_LENGTH);
if (readBytes < FILE_BUFFER_LENGTH)
{
// resize buffer
Array.Resize <byte>(ref buffer, readBytes);
}
// write remote backup file
os.AppendFileBinaryContent(remoteBackupPath, buffer);
}while (readBytes == FILE_BUFFER_LENGTH);
stream.Close();
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't copy backup to destination hosting space");
return(0);
}
}
TaskManager.IndicatorCurrent += 1;
// delete backup file if required
if (deleteTempBackup)
{
try
{
// delete backup folder and all its contents
Directory.Delete(tempFolder, true);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't delete temporary backup folder");
return(0);
}
}
BackgroundTask topTask = TaskManager.TopTask;
topTask.IndicatorCurrent = topTask.IndicatorMaximum;
TaskController.UpdateTask(topTask);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
return(0);
}
public static int RestoreInternal(string taskId, int userId, int packageId, int serviceId, int serverId,
int storePackageId, string storePackageBackupPath, string storeServerBackupPath)
{
try
{
// copy backup from remote or local server
string backupFileName = (storePackageId > 0)
? Path.GetFileName(storePackageBackupPath) : Path.GetFileName(storeServerBackupPath);
TaskManager.StartTask(taskId, "BACKUP", "RESTORE", backupFileName, SecurityContext.User.UserId);
// create temp folder
string tempFolder = GetTempBackupFolder();
string backupFileNamePath = Path.Combine(tempFolder, backupFileName);
if (storePackageId > 0)
{
try
{
int osServiceId = PackageController.GetPackageServiceId(storePackageId, ResourceGroups.Os);
if (osServiceId > 0)
{
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osServiceId);
string remoteBackupPath = FilesController.GetFullPackagePath(storePackageId,
storePackageBackupPath);
FileStream stream = new FileStream(backupFileNamePath, FileMode.Create, FileAccess.Write);
byte[] buffer = new byte[FILE_BUFFER_LENGTH];
int offset = 0;
do
{
// read remote content
buffer = os.GetFileBinaryChunk(remoteBackupPath, offset, FILE_BUFFER_LENGTH);
// write remote content
stream.Write(buffer, 0, buffer.Length);
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
stream.Close();
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't copy source backup set");
return(0);
}
}
else
{
backupFileNamePath = storeServerBackupPath;
}
try
{
// unpack archive
FileUtils.UnzipFiles(backupFileNamePath, tempFolder);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't unzip backup set");
return(0);
}
// load backup catalog
XmlDocument doc = new XmlDocument();
try
{
doc.Load(Path.Combine(tempFolder, BACKUP_CATALOG_FILE_NAME));
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't find/open backup catalog file");
return(0);
}
// validate XML document
//if (!ValidateXmlDocument(doc))
//{
// TaskManager.WriteError("Corrupted or altered backup catalog file has been read");
// return 0;
//}
// get the list of items to restore
string condition = "";
if (userId > 0)
{
// get user spaces
List <PackageInfo> packages = new List <PackageInfo>();
packages.AddRange(PackageController.GetMyPackages(userId));
packages.AddRange(PackageController.GetPackages(userId));
List <string> parts = new List <string>();
foreach (PackageInfo package in packages)
{
parts.Add("@packageId = " + package.PackageId.ToString());
}
condition = "[" + String.Join(" or ", parts.ToArray()) + "]";
}
else if (packageId > 0)
{
condition = "[@packageId = " + packageId + "]";
}
else if (serviceId > 0)
{
condition = "[@serviceId = " + serviceId + "]";
}
else if (serverId > 0)
{
// get server services
List <ServiceInfo> services = ServerController.GetServicesByServerId(serverId);
List <string> parts = new List <string>();
foreach (ServiceInfo service in services)
{
parts.Add("@serviceId = " + service.ServiceId.ToString());
}
condition = "[" + String.Join(" or ", parts.ToArray()) + "]";
}
XmlNodeList itemNodes = doc.SelectNodes("Backup/Items/Item" + condition);
TaskManager.IndicatorMaximum = itemNodes.Count;
TaskManager.IndicatorCurrent = 0;
// group items by item types
Dictionary <int, List <XmlNode> > groupedItems = new Dictionary <int, List <XmlNode> >();
// sort by groups
foreach (XmlNode itemNode in itemNodes)
{
int itemTypeId = Utils.ParseInt(itemNode.Attributes["itemTypeId"].Value, 0);
// add to group
if (!groupedItems.ContainsKey(itemTypeId))
{
groupedItems[itemTypeId] = new List <XmlNode>();
}
groupedItems[itemTypeId].Add(itemNode);
}
// restore grouped items
foreach (int itemTypeId in groupedItems.Keys)
{
// load item type
ServiceProviderItemType itemTypeInfo = PackageController.GetServiceItemType(itemTypeId);
if (!itemTypeInfo.Backupable)
{
continue;
}
Type itemType = Type.GetType(itemTypeInfo.TypeName);
// load group
ResourceGroupInfo group = ServerController.GetResourceGroup(itemTypeInfo.GroupId);
// instantiate controller
IBackupController controller = null;
try
{
controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController;
if (controller != null)
{
// backup items
foreach (XmlNode itemNode in groupedItems[itemTypeId])
{
int itemId = Utils.ParseInt(itemNode.Attributes["itemId"].Value, 0);
string itemName = itemNode.Attributes["itemName"].Value;
int itemPackageId = Utils.ParseInt(itemNode.Attributes["packageId"].Value, 0);
int itemServiceId = Utils.ParseInt(itemNode.Attributes["serviceId"].Value, 0);
TaskManager.Write(String.Format("Restore {0} '{1}'",
itemTypeInfo.DisplayName, itemName));
try
{
int restoreResult = controller.RestoreItem(tempFolder, itemNode,
itemId, itemType, itemName, itemPackageId, itemServiceId, group);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't restore item");
}
TaskManager.IndicatorCurrent++;
}
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
// delete backup folder and all its contents
try
{
Directory.Delete(tempFolder, true);
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Can't delete temporary backup folder");
return(0);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
return(0);
}
public static int RestoreSqlDatabase(int itemId, string[] uploadedFiles, string[] packageFiles)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SqlDatabase item = (SqlDatabase)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("SQL_DATABASE", "RESTORE", item.Name);
TaskManager.ItemId = itemId;
try
{
DatabaseServer sql = GetDatabaseServer(item.ServiceId);
List <string> backupFiles = new List <string>();
if (packageFiles != null && packageFiles.Length > 0)
{
// copy package files to the remote SQL Server
foreach (string packageFile in packageFiles)
{
string path = null;
byte[] buffer = null;
int offset = 0;
do
{
// read package file
buffer = FilesController.GetFileBinaryChunk(item.PackageId, packageFile, offset, FILE_BUFFER_LENGTH);
// write remote backup file
string tempPath = sql.AppendTempFileBinaryChunk(Path.GetFileName(packageFile), path, buffer);
if (path == null)
{
path = tempPath;
backupFiles.Add(path);
}
offset += FILE_BUFFER_LENGTH;
}while (buffer.Length == FILE_BUFFER_LENGTH);
}
}
else if (uploadedFiles != null && uploadedFiles.Length > 0)
{
// upladed files
backupFiles.AddRange(uploadedFiles);
}
// restore
if (backupFiles.Count > 0)
{
sql.RestoreDatabase(item.Name, backupFiles.ToArray());
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ApplyEnableHardQuotaFeature(int packageId)
{
if (SecurityContext.CheckAccount(DemandAccount.IsActive | DemandAccount.IsAdmin | DemandAccount.NotDemo) != 0)
{
throw new Exception("This method could be called by serveradmin only.");
}
// place log record
TaskManager.StartTask("FILES", "APPLY_ENABLEHARDQUOTAFEATURE");
try
{
// request OS service
//int osId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Os);
//if (osId == 0)
// return -1;
//OS.OperatingSystem os = new OS.OperatingSystem();
//ServiceProviderProxy.Init(os, osId);
////Get operating system settings
// StringDictionary osSesstings = ServerController.GetServiceSettings(osId);
// bool diskQuotaEnabled = (osSesstings["EnableHardQuota"] != null) ? bool.Parse(osSesstings["EnableHardQuota"]) : false;
//string driveName = osSesstings["LocationDrive"];
//if (!diskQuotaEnabled)
// return -1;
List <PackageInfo> allPackages = PackageController.GetPackagePackages(packageId, true);
foreach (PackageInfo childPackage in allPackages)
{
// request OS service
int osId = PackageController.GetPackageServiceId(childPackage.PackageId, ResourceGroups.Os);
if (osId == 0)
{
continue;
}
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osId);
//Get operating system settings
StringDictionary osSesstings = ServerController.GetServiceSettings(osId);
string driveName = osSesstings["LocationDrive"];
if (String.IsNullOrEmpty(driveName))
{
continue;
}
string homeFolder = FilesController.GetHomeFolder(childPackage.PackageId);
FilesController.SetFolderQuota(childPackage.PackageId, homeFolder, driveName, Quotas.OS_DISKSPACE);
}
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
return(0);
}
public static string GetHomeFolder(int packageId)
{
return(FilesController.GetHomeFolder(packageId));
}
public static int UpdateOdbcSource(SystemDSN item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SystemDSN origItem = (SystemDSN)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("ODBC_DSN", "UPDATE", origItem.Name);
TaskManager.ItemId = item.Id;
try
{
// get service
OS.OperatingSystem os = GetOS(origItem.ServiceId);
// password
item.Driver = origItem.Driver;
item.Name = origItem.Name;
if (item.DatabasePassword == "")
{
item.DatabasePassword = CryptoUtils.Decrypt(origItem.DatabasePassword);
}
string[] dbNameParts = item.DatabaseName.Split('|');
string groupName = null;
if (dbNameParts.Length > 1)
{
item.DatabaseName = dbNameParts[0];
groupName = dbNameParts[1];
}
// get database server address
item.DatabaseServer = GetDatabaseServerName(groupName, item.PackageId);
if (item.Driver == "MsAccess" || item.Driver == "Excel" || item.Driver == "Text")
{
item.DatabaseName = FilesController.GetFullPackagePath(origItem.PackageId, item.DatabaseName);
}
// update service item
os.UpdateDSN(item);
// update meta item
if (item.DatabasePassword != "")
{
item.DatabasePassword = CryptoUtils.Encrypt(item.DatabasePassword);
PackageController.UpdatePackageItem(item);
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int AddFtpAccount(FtpAccount item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// check quota
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.FTP_ACCOUNTS);
if (quota.QuotaExhausted)
{
return(BusinessErrorCodes.ERROR_FTP_RESOURCE_QUOTA_LIMIT);
}
// check if FTP account already exists
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Ftp);
if (serviceId == 0)
{
return(BusinessErrorCodes.ERROR_FTP_RESOURCE_UNAVAILABLE);
}
// place log record
TaskManager.StartTask("FTP_ACCOUNT", "ADD", item.Name);
TaskManager.WriteParameter("Folder", item.Folder);
TaskManager.WriteParameter("CanRead", item.CanRead);
TaskManager.WriteParameter("CanWrite", item.CanWrite);
try
{
// check package items
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(FtpAccount)) != null)
{
return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_EXISTS);
}
// check service items
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, serviceId);
if (ftp.AccountExists(item.Name))
{
return(BusinessErrorCodes.ERROR_FTP_SERVICE_ITEM_EXISTS);
}
// store original path
string origFolder = item.Folder;
// convert folder
StringDictionary ftpSettings = ServerController.GetServiceSettings(serviceId);
if (Utils.ParseBool(ftpSettings["BuildUncFilesPath"], false))
{
// UNC
// get OS service
int osServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os);
item.Folder = FilesController.GetFullUncPackagePath(item.PackageId, osServiceId, item.Folder);
}
else
{
// Absolute
item.Folder = FilesController.GetFullPackagePath(item.PackageId, item.Folder);
}
item.Enabled = true;
// add service item
ftp.CreateAccount(item);
// save item
item.Password = CryptoUtils.Encrypt(item.Password);
item.ServiceId = serviceId;
item.Folder = (origFolder == "") ? "\\" : origFolder;
int itemId = PackageController.AddPackageItem(item);
TaskManager.ItemId = itemId;
return(itemId);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
throw;
}
finally
{
TaskManager.CompleteTask();
}
}
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);
TaskManager.ItemId = 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 List <SystemFile> GetFiles(int packageId, string path, bool includeFiles)
{
return(FilesController.GetFiles(packageId, path, includeFiles));
}
