public void CalculatePackage(int packageId)
{
DateTime since = PackageController.GetPackageBandwidthUpdate(packageId);
DateTime nextUpdate = DateTime.Now;
try
{
// get all package items
List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics(
0, packageId, false, true, false, false);
// order items by service
Dictionary <int, List <ServiceProviderItem> > orderedItems =
PackageController.OrderServiceItemsByServices(items);
// calculate statistics for each service set
List <ServiceProviderItemBandwidth> itemsBandwidth = new List <ServiceProviderItemBandwidth>();
foreach (int serviceId in orderedItems.Keys)
{
ServiceProviderItemBandwidth[] serviceBandwidth = CalculateItems(serviceId,
orderedItems[serviceId], since);
if (serviceBandwidth != null)
{
itemsBandwidth.AddRange(serviceBandwidth);
}
}
// update info in the database
string xml = BuildDiskBandwidthStatisticsXml(itemsBandwidth.ToArray());
PackageController.UpdatePackageBandwidth(packageId, xml);
// if everything is OK
// update date
PackageController.UpdatePackageBandwidthUpdate(packageId, nextUpdate);
// suspend package if requested
if (suspendOverused)
{
// disk space
QuotaValueInfo dsQuota = PackageController.GetPackageQuota(packageId, Quotas.OS_BANDWIDTH);
if (dsQuota.QuotaExhausted)
{
PackageController.ChangePackageStatus(null, packageId, PackageStatus.Suspended, false);
}
}
}
catch (Exception ex)
{
// load package details
PackageInfo package = PackageController.GetPackage(packageId);
// load user details
UserInfo user = PackageController.GetPackageOwner(package.PackageId);
// log error
TaskManager.WriteError(String.Format("Error calculating bandwidth for '{0}' space of user '{1}': {2}",
package.PackageName, user.Username, ex.ToString()));
}
}
public static int SetFilePermissions(int packageId, string path, UserPermission[] users, bool resetChildPermissions)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// place log record
TaskManager.StartTask("FILES", "SET_PERMISSIONS", path, packageId);
try
{
OS.OperatingSystem os = GetOS(packageId);
string fullPath = GetFullPackagePath(packageId, path);
// get users OU defined on web server
string usersOU = WebServerController.GetWebUsersOU(packageId);
os.GrantGroupNtfsPermissions(fullPath, users, usersOU, resetChildPermissions);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int CloseTerminalServicesSession(int serverId, int sessionId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load server info
ServerInfo server = ServerController.GetServerById(serverId, false);
// place log record
TaskManager.StartTask("SERVER", "RESET_TERMINAL_SESSION", sessionId, serverId);
try
{
GetServerService(serverId).CloseTerminalServicesSession(sessionId);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static ResultObject RemoveStorageSpaceLevelInternal(int id)
{
var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "REMOVE_STORAGE_SPACE_LEVEL");
try
{
if (id < 1)
{
throw new ArgumentException("Id must be greater than 0");
}
DataProvider.RemoveStorageSpaceLevel(id);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error removing Storage Space Level", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
private static int BackupItem(string tempFolder, XmlWriter writer,
ServiceProviderItem item, ResourceGroupInfo group, IBackupController controller)
{
writer.WriteStartElement("Item");
writer.WriteAttributeString("itemId", item.Id.ToString());
writer.WriteAttributeString("itemTypeId", item.TypeId.ToString());
writer.WriteAttributeString("itemName", item.Name);
writer.WriteAttributeString("packageId", item.PackageId.ToString());
writer.WriteAttributeString("serviceId", item.ServiceId.ToString());
try
{
return(controller.BackupItem(tempFolder, writer, item, group));
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
finally
{
writer.WriteEndElement(); // Item
}
return(0);
}
public static int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item)
{
// load item type
ServiceProviderItemType itemType = PackageController.GetServiceItemType(item.TypeId);
if (!itemType.Backupable)
{
return(-1);
}
// load group
ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId);
// create controller
IBackupController controller = null;
try
{
controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController;
if (controller != null)
{
return(BackupItem(tempFolder, writer, item, group, controller));
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
return(-2);
}
private static ResultObject DeleteStorageSpaceFolderInternal(int storageSpaceId, int storageSpaceFolderId)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "DELETE_STORAGE_SPACE_FOLDER");
try
{
if (storageSpaceId < 0)
{
throw new ArgumentException("Storage Space iD must be greater than 0");
}
var storage = GetStorageSpaceById(storageSpaceId);
if (storage == null)
{
throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId));
}
var storageFolder = GetStorageSpaceFolderById(storageSpaceFolderId);
if (storageFolder == null)
{
throw new Exception(string.Format("Storage Space folder with id={0} not found", storageSpaceFolderId));
}
var ss = GetStorageSpaceService(storage.ServiceId);
if (storageFolder.IsShared)
{
ss.RemoveShare(storageFolder.Path);
}
ss.DeleteFolder(storageFolder.Path);
DataProvider.RemoveStorageSpaceFolder(storageSpaceFolderId);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error removing Storage Space folder", exception);
if (result.Value > 0)
{
DataProvider.RemoveStorageSpaceFolder(result.Value);
}
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
public ResultObject DeleteFolders(int itemId)
{
var result = TaskManager.StartResultTask <ResultObject>("ORGANIZATION_FOLDERS", "DELETE_ALL_FOLDERS");
try
{
foreach (var storageSpaceFolderType in Enum.GetValues(typeof(StorageSpaceFolderTypes)))
{
DeleteFolders(itemId, storageSpaceFolderType.ToString());
}
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error deleting organization folders", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
private static void RunBackgroundTask(BackgroundTask backgroundTask)
{
UserInfo user = PackageController.GetPackageOwner(backgroundTask.PackageId);
SecurityContext.SetThreadPrincipal(user.UserId);
var schedule = SchedulerController.GetScheduleComplete(backgroundTask.ScheduleId);
backgroundTask.Guid = TaskManager.Guid;
backgroundTask.Status = BackgroundTaskStatus.Run;
TaskController.UpdateTask(backgroundTask);
try
{
var objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(schedule.Task.TaskType));
objTask.DoWork();
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Error executing scheduled task");
}
finally
{
try
{
TaskManager.CompleteTask();
}
catch (Exception)
{
}
}
}
public static int TerminateWindowsProcess(int serverId, int pid)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load server info
ServerInfo server = ServerController.GetServerById(serverId);
// place log record
TaskManager.StartTask("SERVER", "TERMINATE_SYSTEM_PROCESS", pid);
TaskManager.ItemId = serverId;
try
{
GetServerService(serverId).TerminateWindowsProcess(pid);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static void SetStorageSpaceFolderEncryptDataAccessStatusInternal(int storageSpaceFolderId, bool enabled)
{
TaskManager.StartTask("STORAGE_SPACES", "SET_ENCRYPT_DATA_ACCESS_STATUS");
try
{
var folder = GetStorageSpaceFolderById(storageSpaceFolderId);
if (folder == null)
{
throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId));
}
var storageSpace = StorageSpacesController.GetStorageSpaceById(folder.StorageSpaceId);
if (storageSpace == null)
{
throw new Exception(string.Format("Storage space with id={0} not found", folder.StorageSpaceId));
}
var ss = GetStorageSpaceService(storageSpace.ServiceId);
ss.ShareSetEncyptDataAccess(folder.Path, enabled);
}
catch (Exception exception)
{
throw TaskManager.WriteError(exception);
}
finally
{
TaskManager.CompleteTask();
}
}
private static bool GetStorageSpaceFolderEncryptDataAccessStatusInternal(int storageSpaceFolderId)
{
try
{
var folder = GetStorageSpaceFolderById(storageSpaceFolderId);
if (folder == null)
{
throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId));
}
var storageSpace = StorageSpacesController.GetStorageSpaceById(folder.StorageSpaceId);
if (storageSpace == null)
{
throw new Exception(string.Format("Storage space with id={0} not found", folder.StorageSpaceId));
}
var ss = GetStorageSpaceService(storageSpace.ServiceId);
return(ss.ShareGetEncyptDataAccessStatus(folder.Path));
}
catch (Exception exception)
{
throw TaskManager.WriteError(exception);
}
}
public static int ChangeUserPassword(string username, string oldPassword, string newPassword, string ip)
{
// place log record
TaskManager.StartTask("USER", "CHANGE_PASSWORD_BY_USERNAME_PASSWORD", username);
TaskManager.WriteParameter("IP", ip);
try
{
UserInfo user = GetUserByUsernamePassword(username, oldPassword, ip);
if (user == null)
{
TaskManager.WriteWarning("Account not found");
return(BusinessErrorCodes.ERROR_USER_NOT_FOUND);
}
// change password
DataProvider.ChangeUserPassword(-1, user.UserId,
CryptoUtils.Encrypt(newPassword));
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ChangeUserPassword(int userId, string password)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// get user details
UserInfo user = GetUserInternally(userId);
// place log record
TaskManager.StartTask("USER", "CHANGE_PASSWORD", user.Username, user.UserId);
try
{
DataProvider.ChangeUserPassword(SecurityContext.User.UserId, userId,
CryptoUtils.Encrypt(password));
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ClearLog(int serverId, string logName)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
TaskManager.StartTask("SERVER", "CLEAR_EVENT_LOG", logName);
TaskManager.ItemId = serverId;
try
{
GetServerService(serverId).ClearLog(logName);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
return(0);
}
public static int RebootSystem(int serverId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load server info
ServerInfo server = ServerController.GetServerById(serverId);
// place log record
TaskManager.StartTask("SERVER", "REBOOT");
TaskManager.ItemId = serverId;
try
{
GetServerService(serverId).RebootSystem();
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int CalculatePackageDiskspace(int packageId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// place log record
TaskManager.StartTask("SPACE", "CALCULATE_DISKSPACE", packageId);
try
{
// create thread parameters
ThreadStartParameters prms = new ThreadStartParameters();
prms.UserId = SecurityContext.User.UserId;
prms.Parameters = new object[] { packageId };
Thread t = new Thread(new ParameterizedThreadStart(CalculatePackageDiskspaceAsync));
t.Start(prms);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ChangeWindowsServiceStatus(int serverId, string id, WindowsServiceStatus status)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load server info
ServerInfo server = ServerController.GetServerById(serverId);
// place log record
TaskManager.StartTask("SERVER", "CHANGE_WINDOWS_SERVICE_STATUS", id);
TaskManager.ItemId = serverId;
TaskManager.WriteParameter("New Status", status);
try
{
GetServerService(serverId).ChangeWindowsServiceStatus(id, status);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public ResultObject DeleteFolders(int itemId, string type)
{
var result = TaskManager.StartResultTask <ResultObject>("ORGANIZATION_FOLDERS", "DELETE_FOLDERS_BY_TYPE");
try
{
var folders = GetFolders(itemId, type);
foreach (var folder in folders)
{
DeleteFolder(itemId, folder.Id);
}
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error deleting organization folders", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
{
if (!(item is DnsZone))
{
return(0);
}
// DNS provider
DNSServer dns = GetDNSServer(item.ServiceId);
// zone records serialized
XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord));
try
{
// get zone records
DnsRecord[] records = dns.GetZoneRecords(item.Name);
// serialize zone records
foreach (DnsRecord record in records)
{
serializer.Serialize(writer, record);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Could not read zone records");
}
return(0);
}
private static IntResult FindBestStorageSpaceServiceInternal(IStorageSpaceSelector selector, string groupName, long quotaSizeBytes)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "FIND_BEST_STORAGE_SPACE_SERVICE");
try
{
var bestStorage = selector.FindBest(groupName, quotaSizeBytes);
result.Value = bestStorage.Id;
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error finding best Storage Space", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
public static UserInfo GetUserByUsernamePassword(string username, string password, string ip)
{
// place log record
TaskManager.StartTask("USER", "GET_BY_USERNAME_PASSWORD", username);
TaskManager.WriteParameter("IP", ip);
try
{
// try to get user from database
UserInfoInternal user = GetUserInternally(username);
// check if the user exists
if (user == null)
{
TaskManager.WriteWarning("Account not found");
return(null);
}
// compare user passwords
if ((CryptoUtils.SHA1(user.Password) == password) || (user.Password == password))
{
return(new UserInfo(user));
}
return(null);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int SetupControlPanelAccounts(string passwordA, string passwordB, string ip)
{
try
{
TaskManager.StartTask("SYSTEM", "COMPLETE_SCPA");
//
TaskManager.WriteParameter("Password A", passwordA);
TaskManager.WriteParameter("Password B", passwordB);
TaskManager.WriteParameter("IP Address", ip);
//
var enabledScpaMode = GetSystemSetupMode();
//
if (enabledScpaMode == false)
{
//
TaskManager.WriteWarning("Attempt to execute SCPA procedure for an uknown reason");
//
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
// Entering the security context into Supervisor mode
SecurityContext.SetThreadSupervisorPrincipal();
//
var accountA = UserController.GetUserInternally("serveradmin");
var accountB = UserController.GetUserInternally("admin");
//
var resultCodeA = UserController.ChangeUserPassword(accountA.UserId, passwordA);
//
if (resultCodeA < 0)
{
TaskManager.WriteParameter("Result Code A", resultCodeA);
//
return(resultCodeA);
}
//
var resultCodeB = UserController.ChangeUserPassword(accountB.UserId, passwordB);
//
if (resultCodeB < 0)
{
TaskManager.WriteParameter("Result Code B", resultCodeB);
//
return(resultCodeB);
}
// Disable SCPA mode
SetSystemSettings(SystemSettings.SETUP_SETTINGS, SystemSettings.Empty);
// Operation has succeeded
return(0);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
//
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int UpdateSqlUser(SqlUser item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SqlUser origItem = (SqlUser)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_MSSQL_USERS_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("SQL_USER", "UPDATE", origItem.Name, item.Id);
try
{
// get service
DatabaseServer sql = GetDatabaseServer(origItem.ServiceId);
// update service item
sql.UpdateUser(item, GetSqlDatabasesArray(origItem.PackageId, origItem.GroupName));
// update meta item
if (item.Password == "")
{
item.Password = CryptoUtils.Decrypt(origItem.Password);
}
item.Password = CryptoUtils.Encrypt(item.Password);
PackageController.UpdatePackageItem(item);
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 ZipFiles(int packageId, 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 rootFolder = "";
foreach (string file in files)
{
string archFile = GetFullPackagePath(packageId, file);
int idx = archFile.LastIndexOf("\\");
rootFolder = archFile.Substring(0, idx);
archFiles.Add(archFile.Substring(idx + 1));
}
os.ZipFiles(zipFilePath, rootFolder, 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();
}
}
private static IntResult SaveStorageSpaceInternal(StorageSpace space, bool isShared = false)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SAVE_STORAGE_SPACE");
try
{
if (space == null)
{
throw new ArgumentNullException("space");
}
var ss = GetStorageSpaceService(space.ServiceId);
if (isShared)
{
var share = ShareStorageSpaceFolderInternal(space.Id, space.Path, space.Name);
space.IsShared = true;
space.UncPath = share.UncPath;
}
if (space.Id > 0)
{
DataProvider.UpdateStorageSpace(space);
TaskManager.Write("Updating Storage Space with id = {0}", space.Id.ToString(CultureInfo.InvariantCulture));
result.Value = space.Id;
}
else
{
result.Value = DataProvider.InsertStorageSpace(space);
TaskManager.Write("Inserting new Storage Space, obtained id = {0}", space.Id.ToString(CultureInfo.InvariantCulture));
space.Id = result.Value;
}
ss.UpdateStorageSettings(space.Path, space.FsrmQuotaSizeBytes, space.FsrmQuotaType);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error saving Storage Space", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
public void CalculatePackage(int packageId)
{
try
{
// get all package items
List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics(
0, packageId, true, false, false, false);
//TaskManager.Write("Items: " + items.Count);
// order items by service
Dictionary <int, List <ServiceProviderItem> > orderedItems =
PackageController.OrderServiceItemsByServices(items);
// calculate statistics for each service set
List <ServiceProviderItemDiskSpace> itemsDiskspace = new List <ServiceProviderItemDiskSpace>();
foreach (int serviceId in orderedItems.Keys)
{
ServiceProviderItemDiskSpace[] serviceDiskspace = CalculateItems(serviceId, orderedItems[serviceId]);
if (serviceDiskspace != null)
{
itemsDiskspace.AddRange(serviceDiskspace);
}
}
// update info in the database
string xml = BuildDiskSpaceStatisticsXml(itemsDiskspace.ToArray());
PackageController.UpdatePackageDiskSpace(packageId, xml);
//TaskManager.Write("XML: " + xml);
// suspend package if requested
if (suspendOverused)
{
// disk space
QuotaValueInfo dsQuota = PackageController.GetPackageQuota(packageId, Quotas.OS_DISKSPACE);
if (dsQuota.QuotaExhausted)
{
PackageController.ChangePackageStatus(null, packageId, PackageStatus.Suspended, false);
}
}
}
catch (Exception ex)
{
// load package details
PackageInfo package = PackageController.GetPackage(packageId);
// load user details
UserInfo user = PackageController.GetPackageOwner(package.PackageId);
// log error
TaskManager.WriteError(String.Format("Error calculating diskspace for '{0}' space of user '{1}': {2}",
package.PackageName, user.Username, ex.ToString()));
}
}
private static IntResult SaveStorageSpaceLevelInternal(StorageSpaceLevel level, List <ResourceGroupInfo> groups)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SAVE_STORAGE_SPACE_LEVEL");
try
{
if (level == null)
{
throw new ArgumentNullException("level");
}
if (level.Id > 0)
{
DataProvider.UpdateStorageSpaceLevel(level);
TaskManager.Write("Updating Storage Space Level with id = {0}",
level.Id.ToString(CultureInfo.InvariantCulture));
result.Value = level.Id;
}
else
{
result.Value = DataProvider.InsertStorageSpaceLevel(level);
TaskManager.Write("Inserting new Storage Space Level, obtained id = {0}",
level.Id.ToString(CultureInfo.InvariantCulture));
level.Id = result.Value;
}
var resultGroup = SaveLevelResourceGroups(result.Value, groups);
if (!resultGroup.IsSuccess)
{
throw new Exception("Error saving resource groups");
}
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error saving Storage Space Level", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
private static ResultObject RenameFolderInternal(int storageSpaceId, int folderId, string organizationId, string group, string fullPath, string newName)
{
var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "RENAME_FOLDER");
try
{
if (storageSpaceId < 0)
{
throw new ArgumentException("Storage Space iD must be greater than 0");
}
var storage = GetStorageSpaceById(storageSpaceId);
if (storage == null)
{
throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId));
}
var ss = GetStorageSpaceService(storage.ServiceId);
ss.RemoveShare(fullPath);
ss.RenameFolder(fullPath, newName);
var newPath = Path.Combine(Directory.GetParent(fullPath).ToString(), newName);
var shareName = GenerateShareName(organizationId, newName);
var share = ShareStorageSpaceFolderInternal(storageSpaceId, newPath, shareName);
var folder = GetStorageSpaceFolderById(folderId);
StorageSpacesController.UpdateStorageSpaceFolder(storageSpaceId, folderId, organizationId, group, newName, share.UncPath, folder.FsrmQuotaSizeBytes, folder.FsrmQuotaType);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error during folder rename", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
private static ResultObject SetStorageSpaceFolderQuotaInternal(int storageSpaceId, int storageSpaceFolderId, long quotaInBytes, QuotaType quotaType)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SET_STORAGE_SPACE_FOLDER_QUOTA");
try
{
if (storageSpaceId < 0)
{
throw new ArgumentException("Storage Space iD must be greater than 0");
}
var storage = GetStorageSpaceById(storageSpaceId);
if (storage == null)
{
throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId));
}
var storageFolder = GetStorageSpaceFolderById(storageSpaceFolderId);
if (storageFolder == null)
{
throw new Exception(string.Format("Storage Space folder with id={0} not found", storageSpaceFolderId));
}
SetFolderQuota(storageSpaceId, storageFolder.Path, quotaInBytes, quotaType);
DataProvider.UpdateStorageSpaceFolder(storageSpaceFolderId, storageFolder.Name, storageSpaceId, storageFolder.Path, storageFolder.UncPath, storageFolder.IsShared, quotaType, quotaInBytes);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error removing Storage Space folder", exception);
if (result.Value > 0)
{
DataProvider.RemoveStorageSpaceFolder(result.Value);
}
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
