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)); }