private const int FILE_BUFFER_LENGTH = 5000000; // ~5MB
private static SharePointServer GetSharePoint(int serviceId)
{
SharePointServer sps = new SharePointServer();
ServiceProviderProxy.Init(sps, serviceId);
return(sps);
}
public static void SwithEnginesEnabled(int serviceId, bool enabled)
{
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
zooServer.SwithEnginesEnabled(enabled);
}
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 FTPServer GetFTPServer(int serviceId)
{
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, serviceId);
return(ftp);
}
public static bool IsEnginesEnabled(int serviceId)
{
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
return(zooServer.IsEnginesEnabled());
}
public static void SetWebCosoleEnabled(int serviceId, bool enabled)
{
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
zooServer.SetWebCosoleEnabled(enabled);
}
public static HeliconZooEngine[] GetEngines(int serviceId)
{
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
return(zooServer.GetEngines());
}
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;
}
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, serviceId);
if (itemType == typeof(StatsSite))
{
// import statistics site
StatsSite site = new StatsSite();
site.ServiceId = serviceId;
site.PackageId = packageId;
site.Name = itemName;
site.GroupName = group.GroupName;
// load site id
site.SiteId = stats.GetSiteId(itemName);
PackageController.AddPackageItem(site);
}
}
public static FtpSite[] GetFtpSites(int serviceId)
{
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, serviceId);
return(ftp.GetSites());
}
private const int FILE_BUFFER_LENGTH = 5000000; // ~5MB
public static DatabaseServer GetDatabaseServer(int serviceId)
{
DatabaseServer db = new DatabaseServer();
ServiceProviderProxy.Init(db, serviceId);
return(db);
}
public static StatisticsServer GetStatisticsServer(int serviceId)
{
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, serviceId);
return(stats);
}
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 WindowsServer GetServerService(int serverId)
{
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, serverId);
return(winServer);
}
public List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
{
List <string> items = new List <string>();
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return(items);
}
// FTP provider
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, serviceId);
FtpAccount[] accounts = ftp.GetAccounts();
foreach (FtpAccount account in accounts)
{
items.Add(account.Name);
}
return(items);
}
private static DNSServer GetDNSServer(int serviceId)
{
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, serviceId);
return(dns);
}
public static RemoteDesktopServices GetRemoteDesktopServices(int serviceId)
{
var rds = new RemoteDesktopServices();
ServiceProviderProxy.Init(rds, serviceId);
return(rds);
}
public static StorageSpaceServices GetStorageSpaceService(int serviceId)
{
var ss = new StorageSpaceServices();
ServiceProviderProxy.Init(ss, serviceId);
return(ss);
}
public static void SetEnabledEnginesForSite(string siteId, int packageId, string[] engines)
{
int serviceId = GetHeliconZooServiceIdByPackageId(packageId);
// tell Server to enable engines for site
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
zooServer.SetEnabledEnginesForSite(siteId, engines);
}
public static void SetEngines(int serviceId, HeliconZooEngine[] userEngines)
{
// update applicationHost.config
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
zooServer.SetEngines(userEngines);
// update Helicon Zoo quotas in Quotas table
UpdateQuotas(serviceId, userEngines);
}
public static int UpdateSite(StatsSite item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
StatsSite origItem = (StatsSite)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// update statistics site
item.Name = origItem.Name;
item.SiteId = origItem.SiteId;
// place log record
TaskManager.StartTask("STATS_SITE", "UPDATE", origItem.Name, origItem.Id);
try
{
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, origItem.ServiceId);
stats.UpdateSite(item);
// update service item
PackageController.UpdatePackageItem(item);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
internal static SpamExperts GetServer(int serviceId)
{
SpamExperts ws = new SpamExperts();
ServiceProviderProxy.Init(ws, serviceId);
string[] settings = ws.ServiceProviderSettingsSoapHeaderValue.Settings;
List <string> resSettings = new List <string>(settings);
ws.ServiceProviderSettingsSoapHeaderValue.Settings = resSettings.ToArray();
return(ws);
}
public static OS.OperatingSystem GetOS(int packageId)
{
int sid = PackageController.GetPackageServiceId(packageId, ResourceGroups.Os);
if (sid <= 0)
{
return(null);
}
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, sid);
return(os);
}
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 override void DoWork()
{
// Input parameters:
// - SERVER_NAME
// - EXECUTABLE_PATH
BackgroundTask topTask = TaskManager.TopTask;
// get input parameters
string serverName = (string)topTask.GetParamValue("SERVER_NAME");
string execPath = (string)topTask.GetParamValue("EXECUTABLE_PATH");
string execParams = (string)topTask.GetParamValue("EXECUTABLE_PARAMS");
if (execParams == null)
{
execParams = "";
}
// check input parameters
if (String.IsNullOrEmpty(serverName))
{
TaskManager.WriteWarning("Specify 'Server Name' task parameter");
return;
}
if (String.IsNullOrEmpty(execPath))
{
TaskManager.WriteWarning("Specify 'Executable Path' task parameter");
return;
}
// find server by name
ServerInfo server = ServerController.GetServerByName(serverName);
if (server == null)
{
TaskManager.WriteWarning(String.Format("Server with the name '{0}' was not found", serverName));
return;
}
// execute system command
WindowsServer winServer = new WindowsServer();
ServiceProviderProxy.ServerInit(winServer, server.ServerId);
TaskManager.Write(winServer.ExecuteSystemCommand(execPath, execParams));
}
public static StatsSite GetSite(int itemId)
{
// load meta item
StatsSite item = (StatsSite)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(null);
}
// load item from service
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, item.ServiceId);
StatsSite site = stats.GetSite(item.SiteId);
if (site == null)
{
return(null);
}
site.Id = item.Id;
site.Name = item.Name;
site.ServiceId = item.ServiceId;
site.PackageId = item.PackageId;
site.SiteId = item.SiteId;
// update statistics URL
if (!String.IsNullOrEmpty(site.StatisticsUrl))
{
// load space owner
UserInfo user = PackageController.GetPackageOwner(item.PackageId);
if (user != null)
{
UserInfoInternal userInternal = UserController.GetUserInternally(user.UserId);
site.StatisticsUrl = Utils.ReplaceStringVariable(site.StatisticsUrl, "username",
HttpUtility.UrlEncode(userInternal.Username));
site.StatisticsUrl = Utils.ReplaceStringVariable(site.StatisticsUrl, "password",
HttpUtility.UrlEncode(userInternal.Password));
}
}
return(site);
}
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, itemId);
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 string[] GetEnabledEnginesForSite(string siteId, int packageId)
{
int serviceId = GetHeliconZooServiceIdByPackageId(packageId);
if (-1 == serviceId)
{
// Helicon Zoo is not enabled for this package
return(new string[0]);
}
// ask Server to enabled engines for site
HeliconZoo zooServer = new HeliconZoo();
ServiceProviderProxy.Init(zooServer, serviceId);
string[] enabledEngines = zooServer.GetEnabledEnginesForSite(siteId);
return(enabledEngines);
}
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, 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 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 List <string> GetImportableItems(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group)
{
List <string> items = new List <string>();
// get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return(items);
}
// Mail provider
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, serviceId);
// IDN: The list of importable names is populated with unicode names, to make it easier for the user
var idn = new IdnMapping();
if (itemType == typeof(DnsZone))
{
items.AddRange(dns.GetZones().Select(z =>
{
try
{
return(idn.GetUnicode(z));
}
catch
{
return(null);
}
}));
}
return(items);
}
