public static StatsServer[] GetServers(int serviceId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive | DemandAccount.IsAdmin); if (accountCheck < 0) { return(null); } StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, serviceId); return(stats.GetServers()); }
public static int DeleteAuditLogRecords(int userId, int itemId, string itemName, DateTime startDate, DateTime endDate, int severityId, string sourceName, string taskName) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } DataProvider.DeleteAuditLogRecords(SecurityContext.User.UserId, userId, itemId, itemName, GetStartDate(startDate), GetEndDate(endDate), severityId, sourceName, taskName); return(0); }
public static int DeleteSqlDatabase(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SqlDatabase origItem = (SqlDatabase)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SQL_DATABASE", "DELETE", origItem.Name); TaskManager.ItemId = itemId; TaskManager.WriteParameter("Provider", origItem.GroupName); try { // get service DatabaseServer sql = GetDatabaseServer(origItem.ServiceId); // delete service item sql.DeleteDatabase(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { TaskManager.WriteError(ex); // Return a generic error instead of re-throwing an exception return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION); } finally { TaskManager.CompleteTask(); } }
public static int DeleteSite(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item StatsSite origItem = (StatsSite)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("STATS_SITE", "DELETE", origItem.Name); TaskManager.ItemId = origItem.Id; try { // get service StatisticsServer stats = new StatisticsServer(); ServiceProviderProxy.Init(stats, origItem.ServiceId); // delete service item stats.DeleteSite(origItem.SiteId); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static GalleryApplicationsResult GetGalleryApplicationsByServiceId(int serviceId) { GalleryApplicationsResult result; // try { TaskManager.StartTask(TASK_MANAGER_SOURCE, GET_SRV_GALLERY_APPS_TASK); // if (SecurityContext.CheckAccount(DemandAccount.IsAdmin) != 0) { return(WAG_MODULE_NOT_AVAILABLE <GalleryApplicationsResult>()); } // WebServer webServer = WebServerController.GetWebServer(serviceId); // ERROR: WAG is unavailable if (!webServer.IsMsDeployInstalled()) { return(WAG_MODULE_NOT_AVAILABLE <GalleryApplicationsResult>()); } // result = webServer.GetGalleryApplications(String.Empty); // if (!result.IsSuccess) { foreach (string errorMessage in result.ErrorCodes) { TaskManager.WriteError(errorMessage); } // return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>()); } } catch (Exception ex) { TaskManager.WriteError(ex); // return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>()); } finally { TaskManager.CompleteTask(); } // return(result); }
public static int AddComment(string itemTypeId, int itemId, string commentText, int severityId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // add comment DataProvider.AddComment(SecurityContext.User.UserId, itemTypeId, itemId, commentText, severityId); return(0); }
public static int DeleteFtpAccount(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item FtpAccount origItem = (FtpAccount)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("FTP_ACCOUNT", "DELETE", origItem.Name); TaskManager.ItemId = itemId; try { // get service FTPServer ftp = new FTPServer(); ServiceProviderProxy.Init(ftp, origItem.ServiceId); // delete service item ftp.DeleteAccount(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteFiles(int packageId, string[] files) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("FILES", "DELETE_FILES", packageId); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { OS.OperatingSystem os = GetOS(packageId); for (int i = 0; i < files.Length; i++) { files[i] = GetFullPackagePath(packageId, files[i]); } // delete files os.DeleteFiles(files); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static int DeleteSharePointUser(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemUser origItem = (SystemUser)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SHAREPOINT", "DELETE_USER", origItem.Name); TaskManager.ItemId = itemId; try { // get service SharePointServer sps = GetSharePoint(origItem.ServiceId); // delete service item sps.DeleteUser(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int DeleteOdbcSource(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SystemDSN origItem = (SystemDSN)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("ODBC_DSN", "DELETE", origItem.Name); TaskManager.ItemId = itemId; try { // get service OS.OperatingSystem os = GetOS(origItem.ServiceId); // delete service item os.DeleteDSN(origItem.Name); // delete meta item PackageController.DeletePackageItem(origItem.Id); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static GalleryApplicationsResult GetGalleryApplicationsByServiceId(int serviceId) { GalleryApplicationsResult result; // try { TaskManager.StartTask(TASK_MANAGER_SOURCE, GET_SRV_GALLERY_APPS_TASK); int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin); if (accountCheck < 0) { return(Warning <GalleryApplicationsResult>((-accountCheck).ToString())); } // check if WAG is installed WebServer webServer = WebServerController.GetWebServer(serviceId); if (!webServer.IsMsDeployInstalled()) { return(Error <GalleryApplicationsResult>(GalleryErrors.MsDeployIsNotInstalled)); } // get applications result = webServer.GetGalleryApplications(String.Empty); if (!result.IsSuccess) { return(Error <GalleryApplicationsResult>(result, GalleryErrors.GetApplicationsError)); } } catch (Exception ex) { TaskManager.WriteError(ex); return(Error <GalleryApplicationsResult>(GalleryErrors.GeneralError, ex.Message)); } finally { TaskManager.CompleteTask(); } // return(result); }
public static int CreateFolder(int packageId, string path) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "CREATE_FOLDER", path); TaskManager.ItemId = packageId; try { OS.OperatingSystem os = GetOS(packageId); string fullPath = GetFullPackagePath(packageId, path); // create folder os.CreateDirectory(fullPath); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static int UpdateFileBinaryContentUsingEncoding(int packageId, string path, byte[] content, string encoding) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "UPDATE_BINARY_CONTENT", path); TaskManager.ItemId = packageId; try { OS.OperatingSystem os = GetOS(packageId); string fullPath = GetFullPackagePath(packageId, path); // create file os.UpdateFileBinaryContentUsingEncoding(fullPath, content, encoding); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int TruncateSqlDatabase(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // load original meta item SqlDatabase origItem = (SqlDatabase)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_NOT_FOUND); } // place log record TaskManager.StartTask("SQL_DATABASE", "TRUNCATE", origItem.Name); TaskManager.ItemId = itemId; try { // get service DatabaseServer sql = GetDatabaseServer(origItem.ServiceId); // truncate database sql.TruncateDatabase(origItem.Name); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int StopSchedule(int scheduleId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } SchedulerJob schedule = GetScheduleComplete(scheduleId); if (schedule == null) { return(0); } Scheduler.StopSchedule(schedule); return(0); }
public static int DeleteSchedule(int scheduleId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // stop schedule if active StopSchedule(scheduleId); // delete schedule DataProvider.DeleteSchedule(SecurityContext.User.UserId, scheduleId); // re-schedule tasks Scheduler.ScheduleTasks(); return(0); }
public static int DeleteDirectoryRecursive(int packageId, string rootPath) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "DELETE_DIRECTORY_RECURSIVE", rootPath, packageId); try { OS.OperatingSystem os = GetOS(packageId); os.DeleteDirectoryRecursive(rootPath); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static string[] GetInstalledWebParts(int itemId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(null); } // load original meta item SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId); if (item == null) { return(null); } SharePointServer sps = GetSharePoint(item.ServiceId); return(sps.GetInstalledWebParts(item.Name)); }
public static int InstallApplication(InstallationInfo inst) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(inst.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // install application WebApplicationsInstaller installer = new WebApplicationsInstaller(); return(installer.InstallWebApplication(inst)); }
public static int SetSystemSettings(string settingsName, SystemSettings settings) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } XmlDocument xmldoc = new XmlDocument(); XmlElement root = xmldoc.CreateElement("properties"); foreach (string[] pair in settings.SettingsArray) { string name = pair[0]; string val = pair[1]; if (name.ToLower().IndexOf("password") != -1) { val = CryptoUtils.Encrypt(val); } XmlElement property = xmldoc.CreateElement("property"); property.SetAttribute("name", name); property.SetAttribute("value", val); root.AppendChild(property); } DataProvider.SetSystemSettings(settingsName, root.OuterXml); return(0); }
public static int RenameFile(int packageId, string oldPath, string newPath) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("FILES", "RENAME_FILE", oldPath, packageId); TaskManager.WriteParameter("New name", newPath); try { OS.OperatingSystem os = GetOS(packageId); string oldFullPath = GetFullPackagePath(packageId, oldPath); string destFullPath = GetFullPackagePath(packageId, newPath); os.MoveFile(oldFullPath, destFullPath); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
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 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 static int ChangeUserStatus(string taskId, int userId, UserStatus status) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } int result = 0; // get user details UserInfo user = GetUserInternally(userId); // place log record TaskManager.StartTask(taskId, "USER", "CHANGE_STATUS", user.Username); TaskManager.ItemId = user.UserId; try { // change this account result = ChangeUserStatusInternal(userId, status); if (result < 0) { return(result); } // change peer accounts List <UserInfo> peers = GetUserPeers(userId); foreach (UserInfo peer in peers) { result = ChangeUserStatusInternal(peer.UserId, status); if (result < 0) { return(result); } } // change child accounts List <UserInfo> children = GetUsers(userId, true); foreach (UserInfo child in children) { result = ChangeUserStatusInternal(child.UserId, status); if (result < 0) { return(result); } } // update user packages List <PackageInfo> packages = new List <PackageInfo>(); // his packages packages.AddRange(PackageController.GetMyPackages(userId)); // children packages packages.AddRange(PackageController.GetPackages(userId)); PackageStatus packageStatus = PackageStatus.Active; switch (status) { case UserStatus.Active: packageStatus = PackageStatus.Active; break; case UserStatus.Cancelled: packageStatus = PackageStatus.Cancelled; break; case UserStatus.Pending: packageStatus = PackageStatus.New; break; case UserStatus.Suspended: packageStatus = PackageStatus.Suspended; break; } // change packages state result = PackageController.ChangePackagesStatus(packages, packageStatus, true); if (result < 0) { return(result); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int ZipRemoteFiles(int packageId, string rootFolder, string[] files, string archivePath) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "ZIP_FILES", archivePath, packageId); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { OS.OperatingSystem os = GetOS(packageId); string zipFilePath = GetFullPackagePath(packageId, archivePath); List <string> archFiles = new List <string>(); string root = String.IsNullOrEmpty(rootFolder) ? "" : GetFullPackagePath(packageId, rootFolder); foreach (string file in files) { string archFile = GetFullPackagePath(packageId, file); if (!String.IsNullOrEmpty(rootFolder)) { archFiles.Add(archFile.Substring(root.Length + 1)); } else { int idx = archFile.LastIndexOf("\\"); root = archFile.Substring(0, idx); archFiles.Add(archFile.Substring(idx + 1)); } } os.ZipFiles(zipFilePath, root, archFiles.ToArray()); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static int MoveFiles(int packageId, string[] files, string destFolder) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // check dest folder exists if (!DirectoryExists(packageId, destFolder)) { return(BusinessErrorCodes.ERROR_FILE_DEST_FOLDER_NONEXISTENT); } // place log record TaskManager.StartTask("FILES", "MOVE_FILES", packageId); TaskManager.WriteParameter("Destination folder", destFolder); if (files != null) { foreach (string file in files) { TaskManager.Write(file); } } try { OS.OperatingSystem os = GetOS(packageId); string destFullFolder = GetFullPackagePath(packageId, destFolder); for (int i = 0; i < files.Length; i++) { string srcFilePath = GetFullPackagePath(packageId, files[i]); string destFilePath = Path.Combine(destFullFolder, srcFilePath.Substring(srcFilePath.LastIndexOf("\\") + 1)); if (srcFilePath == destFilePath) { return(BusinessErrorCodes.ERROR_FILE_COPY_TO_SELF); } //Check that we're not trying to copy a folder into its own subfolder else if (destFilePath.StartsWith(srcFilePath + "\\")) { return(BusinessErrorCodes.ERROR_FILE_COPY_TO_OWN_SUBFOLDER); } else if (os.FileExists(destFilePath) || os.DirectoryExists(destFilePath)) { return(BusinessErrorCodes.ERROR_FILE_MOVE_PATH_ALREADY_EXISTS); } else { os.MoveFile(srcFilePath, destFilePath); } } return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }
public static int Restore(bool async, string taskId, int userId, int packageId, int serviceId, int serverId, int storePackageId, string storePackageBackupPath, string storeServerBackupPath) { // check demo account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // check admin account accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin); if ((serviceId > 0 || serverId > 0) && accountCheck < 0) { return(accountCheck); } // check if backup temp folder is available string tempFolder = GetTempBackupFolder(); if (!FolderWriteAccessible(tempFolder)) { return(BusinessErrorCodes.ERROR_BACKUP_TEMP_FOLDER_UNAVAILABLE); } // check server source path if required if (!String.IsNullOrEmpty(storeServerBackupPath)) { try { if (!File.Exists(storeServerBackupPath)) { return(BusinessErrorCodes.ERROR_RESTORE_BACKUP_SOURCE_NOT_FOUND); } } catch { return(BusinessErrorCodes.ERROR_RESTORE_BACKUP_SOURCE_UNAVAILABLE); } } if (async) { BackupAsyncWorker worker = new BackupAsyncWorker(); worker.threadUserId = SecurityContext.User.UserId; worker.taskId = taskId; worker.userId = userId; worker.packageId = packageId; worker.serviceId = serviceId; worker.serverId = serverId; worker.storePackageId = storePackageId; worker.storePackageBackupPath = storePackageBackupPath; worker.storeServerBackupPath = storeServerBackupPath; // run worker.RestoreAsync(); return(0); } else { return(RestoreInternal(taskId, userId, packageId, serviceId, serverId, storePackageId, storePackageBackupPath, storeServerBackupPath)); } }
public static int Backup(bool async, string taskId, int userId, int packageId, int serviceId, int serverId, string backupFileName, int storePackageId, string storePackageFolder, string storeServerFolder, bool deleteTempBackup) { // check demo account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check admin account accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin); if ((serviceId > 0 || serverId > 0) && accountCheck < 0) { return(accountCheck); } if (accountCheck < 0) { deleteTempBackup = true; } // check if backup temp folder is available string tempFolder = GetTempBackupFolder(); if (!FolderWriteAccessible(tempFolder)) { return(BusinessErrorCodes.ERROR_BACKUP_TEMP_FOLDER_UNAVAILABLE); } // check destination folder if required if (!String.IsNullOrEmpty(storePackageFolder) && !RemoteServerFolderWriteAccessible(storePackageId, storePackageFolder)) { return(BusinessErrorCodes.ERROR_BACKUP_DEST_FOLDER_UNAVAILABLE); } // check server folder if required if (!String.IsNullOrEmpty(storeServerFolder) && !FolderWriteAccessible(storeServerFolder)) { return(BusinessErrorCodes.ERROR_BACKUP_SERVER_FOLDER_UNAVAILABLE); } // check/reset delete flag accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin); if (accountCheck < 0 && !deleteTempBackup) { deleteTempBackup = true; } if (async) { BackupAsyncWorker worker = new BackupAsyncWorker(); worker.threadUserId = SecurityContext.User.UserId; worker.taskId = taskId; worker.userId = userId; worker.packageId = packageId; worker.serviceId = serviceId; worker.serverId = serverId; worker.backupFileName = backupFileName; worker.storePackageId = storePackageId; worker.storePackageFolder = storePackageFolder; worker.storeServerFolder = storeServerFolder; worker.deleteTempBackup = deleteTempBackup; // run worker.BackupAsync(); return(0); } else { return(BackupInternal(taskId, userId, packageId, serviceId, serverId, backupFileName, storePackageId, storePackageFolder, storeServerFolder, deleteTempBackup)); } }
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 int SetFolderQuota(int packageId, string path, string driveName, string quotas) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // check package int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("FILES", "SET_QUOTA_ON_FOLDER", path, packageId); try { // disk space quota // This gets all the disk space allocated for a specific customer // It includes the package Add Ons * Quatity + Hosting Plan System disk space value. //Quotas.OS_DISKSPACE QuotaValueInfo diskSpaceQuota = PackageController.GetPackageQuota(packageId, quotas); #region figure Quota Unit // Quota Unit string unit = String.Empty; if (diskSpaceQuota.QuotaDescription.ToLower().Contains("gb")) { unit = "GB"; } else if (diskSpaceQuota.QuotaDescription.ToLower().Contains("mb")) { unit = "MB"; } else { unit = "KB"; } #endregion OS.OperatingSystem os = GetOS(packageId); os.SetQuotaLimitOnFolder(path, driveName, QuotaType.Hard, diskSpaceQuota.QuotaAllocatedValue.ToString() + unit, 0, String.Empty, String.Empty); return(0); } catch (Exception ex) { //Log and return a generic error rather than throwing an exception TaskManager.WriteError(ex); return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED); } finally { TaskManager.CompleteTask(); } }