4431 lines
162 KiB
C#
4431 lines
162 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Collections.Specialized;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
|
|
using WebsitePanel.Providers;
|
|
using WebsitePanel.Providers.Web;
|
|
using WebsitePanel.Providers.DNS;
|
|
using OS = WebsitePanel.Providers.OS;
|
|
using WebsitePanel.Providers.Common;
|
|
using WebsitePanel.Providers.ResultObjects;
|
|
using System.Resources;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using WebsitePanel.Templates;
|
|
using WebsitePanel.Providers.Database;
|
|
using WebsitePanel.Providers.FTP;
|
|
using System.Collections;
|
|
|
|
namespace WebsitePanel.EnterpriseServer
|
|
{
|
|
public class WebServerController : IImportController, IBackupController
|
|
{
|
|
private const string LOG_SOURCE_WEB = "WEB";
|
|
|
|
private const int DOMAIN_RANDOM_LENGTH = 8;
|
|
private const int MAX_ACCOUNT_LENGTH = 20;
|
|
private const string ANON_ACCOUNT_SUFFIX = "_web";
|
|
private const string FRONTPAGE_ACCOUNT_SUFFIX = "_fp";
|
|
|
|
private const string WEBSITE_ROOT_FOLDER_PATTERN = "\\[DOMAIN_NAME]";
|
|
private const string WEBSITE_LOGS_FOLDER_PATTERN = "\\WebLogs\\[DOMAIN_NAME]";
|
|
private const string WEBSITE_DATA_FOLDER_PATTERN = "\\WebData\\[DOMAIN_NAME]";
|
|
|
|
public static WebServer GetWebServer(int serviceId)
|
|
{
|
|
WebServer ws = new WebServer();
|
|
ServiceProviderProxy.Init(ws, serviceId);
|
|
return ws;
|
|
}
|
|
|
|
#region Web Sites
|
|
public static DataSet GetRawWebSitesPaged(int packageId,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return PackageController.GetRawPackageItemsPaged(packageId, typeof(WebSite),
|
|
true, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static List<WebSite> GetWebSites(int packageId, bool recursive)
|
|
{
|
|
List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(
|
|
packageId, typeof(WebSite), recursive);
|
|
|
|
List<WebSite> sites = items.ConvertAll<WebSite>(new Converter<ServiceProviderItem, WebSite>(ConvertItemToWebSite));
|
|
foreach (WebSite site in sites)
|
|
{
|
|
IPAddressInfo ip = ServerController.GetIPAddress(site.SiteIPAddressId);
|
|
if(ip != null)
|
|
site.SiteIPAddress = ip.ExternalIP;
|
|
}
|
|
return sites;
|
|
}
|
|
|
|
private static WebSite ConvertItemToWebSite(ServiceProviderItem item)
|
|
{
|
|
return (WebSite)item;
|
|
}
|
|
|
|
public static WebSite GetWebSite(int packageId, string siteName)
|
|
{
|
|
ServiceProviderItem siteItem = PackageController.GetPackageItemByName(packageId, siteName, typeof(WebSite));
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
return GetWebSite(siteItem.Id);
|
|
}
|
|
|
|
public static WebSite GetWebSite(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// load live site from service
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
WebSite site = web.GetSite(siteItem.SiteId);
|
|
|
|
// set other properties
|
|
site.Id = siteItem.Id;
|
|
site.Name = siteItem.Name;
|
|
site.ServiceId = siteItem.ServiceId;
|
|
site.PackageId = siteItem.PackageId;
|
|
|
|
// load IP address
|
|
site.SiteIPAddressId = siteItem.SiteIPAddressId;
|
|
IPAddressInfo ip = ServerController.GetIPAddress(siteItem.SiteIPAddressId);
|
|
if(ip != null)
|
|
site.SiteIPAddress = ip.ExternalIP;
|
|
|
|
// check if site has dedicated IP assigned
|
|
var siteIpAddresses = ServerController.GetItemIPAddresses(siteItemId, IPAddressPool.None);
|
|
foreach (var siteIp in siteIpAddresses)
|
|
{
|
|
var packageIpAddress = ServerController.GetPackageIPAddress(siteIp.AddressID);
|
|
if (packageIpAddress != null && packageIpAddress.ExternalIP == site.SiteIPAddress)
|
|
{
|
|
site.IsDedicatedIP = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// truncate home folder
|
|
site.ContentPath = FilesController.GetVirtualPackagePath(siteItem.PackageId, site.ContentPath);
|
|
|
|
//check if Coldfusion is available
|
|
//site.ColdFusionAvailable = siteItem.ColdFusionAvailable;
|
|
|
|
// set FrontPage account
|
|
site.FrontPageAccount = siteItem.FrontPageAccount;
|
|
if (String.IsNullOrEmpty(site.FrontPageAccount))
|
|
site.FrontPageAccount = GetFrontPageUsername(site.Name);
|
|
|
|
// Set Web Deploy publishing account
|
|
site.WebDeployPublishingAccount = siteItem.WebDeployPublishingAccount;
|
|
// Set Web Deploy site publishing enabled
|
|
site.WebDeploySitePublishingEnabled = siteItem.WebDeploySitePublishingEnabled;
|
|
// Set Web Deploy site publishing profile
|
|
site.WebDeploySitePublishingProfile = siteItem.WebDeploySitePublishingProfile;
|
|
|
|
return site;
|
|
}
|
|
|
|
public static int AddWebSite(int packageId, string hostName, int domainId, int ipAddressId)
|
|
{
|
|
return AddWebSite(packageId, hostName, domainId, ipAddressId, false, true);
|
|
}
|
|
|
|
|
|
private static bool IsValidIPAdddress(string addr)
|
|
{
|
|
System.Net.IPAddress ip;
|
|
if (System.Net.IPAddress.TryParse(addr, out ip))
|
|
{
|
|
return ((ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6) |
|
|
(ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork));
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static int AddWebSite(int packageId, string hostName, int domainId, int packageAddressId,
|
|
bool addInstantAlias, bool ignoreGlobalDNSRecords)
|
|
{
|
|
// 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;
|
|
|
|
// check quota
|
|
QuotaValueInfo sitesQuota = PackageController.GetPackageQuota(packageId, Quotas.WEB_SITES);
|
|
if (sitesQuota.QuotaExhausted)
|
|
return BusinessErrorCodes.ERROR_WEB_SITES_QUOTA_LIMIT;
|
|
|
|
// load domain name
|
|
DomainInfo domain = ServerController.GetDomain(domainId);
|
|
string domainName = domain.DomainName;
|
|
|
|
string siteName = string.IsNullOrEmpty(hostName) ? domainName : hostName + "." + domainName;
|
|
|
|
// check if the web site already exists (legacy)
|
|
if (PackageController.GetPackageItemByName(packageId, siteName, typeof(WebSite)) != null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_ALREADY_EXISTS;
|
|
|
|
if (DataProvider.CheckDomain(domain.PackageId, siteName, true) != 0)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_ALREADY_EXISTS;
|
|
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "ADD", siteName);
|
|
|
|
try
|
|
{
|
|
|
|
// get service
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Web);
|
|
if (serviceId == 0)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE;
|
|
|
|
|
|
// Initialize IIS provider webservice proxy
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, serviceId);
|
|
|
|
// Ensure the web site is being created doesn't exist on the server
|
|
if (web.SiteExists(siteName))
|
|
{
|
|
//
|
|
PackageInfo packageInfo = PackageController.GetPackage(packageId);
|
|
//
|
|
ServerInfo serverInfo = ServerController.GetServerById(packageInfo.ServerId);
|
|
// Give as much clues for the issue to an administrator as possible
|
|
TaskManager.WriteError("Web site '{0}' could not be created because site with the name requested already " +
|
|
"exists on '{1}' server.", siteName, serverInfo.ServerName);
|
|
// Return generic operation failed error
|
|
return BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION;
|
|
}
|
|
|
|
// load web settings
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(serviceId);
|
|
int addressId = Utils.ParseInt(webSettings["SharedIP"], 0);
|
|
|
|
bool dedicatedIp = false;
|
|
if (packageAddressId != 0)
|
|
{
|
|
// dedicated IP
|
|
PackageIPAddress packageIp = ServerController.GetPackageIPAddress(packageAddressId);
|
|
if (packageIp != null)
|
|
{
|
|
addressId = packageIp.AddressID;
|
|
dedicatedIp = true;
|
|
}
|
|
}
|
|
|
|
// load assigned IP address
|
|
string ipAddr = "*";
|
|
IPAddressInfo ip = ServerController.GetIPAddress(addressId);
|
|
if (ip != null)
|
|
ipAddr = !String.IsNullOrEmpty(ip.InternalIP) ? ip.InternalIP : ip.ExternalIP;
|
|
|
|
|
|
// load web DNS records
|
|
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId);
|
|
|
|
if (dedicatedIp)
|
|
{
|
|
foreach (GlobalDnsRecord d in dnsRecords)
|
|
{
|
|
if (!string.IsNullOrEmpty(d.ExternalIP))
|
|
{
|
|
if (!IsValidIPAdddress(d.ExternalIP)) return BusinessErrorCodes.ERROR_GLOBALDNS_FOR_DEDICATEDIP;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (domain.ZoneItemId > 0)
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
|
|
if (string.IsNullOrEmpty(settings["PublicSharedIP"]))
|
|
return BusinessErrorCodes.ERROR_PUBLICSHAREDIP_FOR_SHAREDIP;
|
|
}
|
|
}
|
|
|
|
// prepare site bindings
|
|
List<ServerBinding> bindings = new List<ServerBinding>();
|
|
|
|
// SHARED IP
|
|
// fill main domain bindings
|
|
FillWebServerBindings(bindings, dnsRecords, ipAddr, hostName, domain.DomainName, ignoreGlobalDNSRecords);
|
|
|
|
//double check all bindings
|
|
foreach (ServerBinding b in bindings)
|
|
{
|
|
if (DataProvider.CheckDomain(domain.PackageId, b.Host, true) != 0)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_ALREADY_EXISTS;
|
|
}
|
|
|
|
if (dedicatedIp)
|
|
{
|
|
// DEDICATED IP
|
|
bindings.Add(new ServerBinding(ipAddr, "80", ""));
|
|
}
|
|
|
|
UserInfo user = PackageController.GetPackageOwner(packageId);
|
|
UserSettings webPolicy = UserController.GetUserSettings(user.UserId, UserSettings.WEB_POLICY);
|
|
|
|
// craete web site
|
|
string siteId = null;
|
|
WebSite site = new WebSite();
|
|
|
|
// web site name and bindings
|
|
site.Name = siteName;
|
|
site.Bindings = bindings.ToArray();
|
|
|
|
site.AnonymousUsername = GetWebSiteUsername(webPolicy, siteName);
|
|
site.AnonymousUserPassword = Guid.NewGuid().ToString("P");
|
|
|
|
// folders
|
|
string packageHome = FilesController.GetHomeFolder(packageId);
|
|
|
|
// add random string to the domain if specified
|
|
string randDomainName = siteName;
|
|
if (!String.IsNullOrEmpty(webPolicy["AddRandomDomainString"])
|
|
&& Utils.ParseBool(webPolicy["AddRandomDomainString"], false))
|
|
randDomainName += "_" + Utils.GetRandomString(DOMAIN_RANDOM_LENGTH);
|
|
|
|
// ROOT folder
|
|
site.ContentPath = GetWebFolder(packageId, WEBSITE_ROOT_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebRootFolder"]))
|
|
site.ContentPath = GetWebFolder(packageId, webPolicy["WebRootFolder"], randDomainName);
|
|
|
|
// LOGS folder
|
|
site.LogsPath = GetWebFolder(packageId, WEBSITE_LOGS_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebLogsFolder"]))
|
|
site.LogsPath = GetWebFolder(packageId, webPolicy["WebLogsFolder"], randDomainName);
|
|
|
|
// DATA folder
|
|
site.DataPath = GetWebFolder(packageId, WEBSITE_DATA_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebDataFolder"]))
|
|
site.DataPath = GetWebFolder(packageId, webPolicy["WebDataFolder"], randDomainName);
|
|
|
|
// default documents
|
|
site.DefaultDocs = null; // inherit from service
|
|
if (!String.IsNullOrEmpty(webPolicy["DefaultDocuments"]))
|
|
site.DefaultDocs = webPolicy["DefaultDocuments"];
|
|
|
|
if (!String.IsNullOrEmpty(webPolicy["EnableWritePermissions"]))
|
|
{
|
|
// security settings
|
|
site.EnableWritePermissions = Utils.ParseBool(webPolicy["EnableWritePermissions"], false);
|
|
site.EnableDirectoryBrowsing = Utils.ParseBool(webPolicy["EnableDirectoryBrowsing"], false);
|
|
site.EnableParentPaths = Utils.ParseBool(webPolicy["EnableParentPaths"], false);
|
|
site.DedicatedApplicationPool = Utils.ParseBool(webPolicy["EnableDedicatedPool"], false);
|
|
|
|
|
|
// Ensure the website meets hosting plan quotas
|
|
QuotaValueInfo quotaInfo = PackageController.GetPackageQuota(packageId, Quotas.WEB_APPPOOLS);
|
|
site.DedicatedApplicationPool = site.DedicatedApplicationPool && (quotaInfo.QuotaAllocatedValue > 0);
|
|
|
|
site.EnableAnonymousAccess = Utils.ParseBool(webPolicy["EnableAnonymousAccess"], false);
|
|
site.EnableWindowsAuthentication = Utils.ParseBool(webPolicy["EnableWindowsAuthentication"], false);
|
|
site.EnableBasicAuthentication = Utils.ParseBool(webPolicy["EnableBasicAuthentication"], false);
|
|
|
|
// extensions
|
|
site.AspInstalled = Utils.ParseBool(webPolicy["AspInstalled"], false);
|
|
site.AspNetInstalled = webPolicy["AspNetInstalled"];
|
|
site.PhpInstalled = webPolicy["PhpInstalled"];
|
|
site.PerlInstalled = Utils.ParseBool(webPolicy["PerlInstalled"], false);
|
|
site.PythonInstalled = Utils.ParseBool(webPolicy["PythonInstalled"], false);
|
|
site.CgiBinInstalled = Utils.ParseBool(webPolicy["CgiBinInstalled"], false);
|
|
site.ColdFusionInstalled = false;
|
|
|
|
}
|
|
else
|
|
{
|
|
// security settings
|
|
site.EnableWritePermissions = false;
|
|
site.EnableDirectoryBrowsing = false;
|
|
site.EnableParentPaths = false;
|
|
site.DedicatedApplicationPool = false;
|
|
|
|
site.EnableAnonymousAccess = true;
|
|
site.EnableWindowsAuthentication = true;
|
|
site.EnableBasicAuthentication = false;
|
|
|
|
// extensions
|
|
site.AspInstalled = true;
|
|
site.AspNetInstalled = "1";
|
|
site.PhpInstalled = "";
|
|
site.PerlInstalled = false;
|
|
site.PythonInstalled = false;
|
|
site.CgiBinInstalled = false;
|
|
site.ColdFusionInstalled = false;
|
|
}
|
|
|
|
site.HttpRedirect = "";
|
|
site.HttpErrors = null;
|
|
site.MimeMaps = null;
|
|
|
|
// CREATE WEB SITE
|
|
siteId = web.CreateSite(site);
|
|
|
|
// register item
|
|
site.ServiceId = serviceId;
|
|
site.PackageId = packageId;
|
|
site.Name = siteName;
|
|
site.SiteIPAddressId = addressId;
|
|
site.SiteId = siteId;
|
|
|
|
int siteItemId = PackageController.AddPackageItem(site);
|
|
|
|
// associate IP with web site
|
|
if (packageAddressId != 0)
|
|
ServerController.AddItemIPAddress(siteItemId, packageAddressId);
|
|
|
|
// update domain
|
|
// add main pointer
|
|
AddWebSitePointer(siteItemId, hostName, domain.DomainId, false, ignoreGlobalDNSRecords, false);
|
|
|
|
|
|
// add parking page
|
|
// load package
|
|
if (webPolicy["AddParkingPage"] != null)
|
|
{
|
|
bool addParkingPage = Utils.ParseBool(webPolicy["AddParkingPage"], false);
|
|
if (addParkingPage)
|
|
{
|
|
// add page
|
|
string pageName = webPolicy["ParkingPageName"];
|
|
string pageContent = webPolicy["ParkingPageContent"];
|
|
|
|
if (!String.IsNullOrEmpty(pageName)
|
|
&& pageContent != null)
|
|
{
|
|
|
|
if (Utils.ParseBool(webPolicy["EnableParkingPageTokens"], false))
|
|
{
|
|
pageContent = pageContent.Replace("[DOMAIN_NAME]", site.Name);
|
|
pageContent = pageContent.Replace("[SITE_IP]", site.SiteIPAddress);
|
|
|
|
}
|
|
string path = Path.Combine(
|
|
FilesController.GetVirtualPackagePath(packageId, site.ContentPath), pageName);
|
|
|
|
if (!FilesController.FileExists(packageId, path))
|
|
{
|
|
FilesController.CreateFile(packageId, path);
|
|
|
|
byte[] content = Encoding.UTF8.GetBytes(pageContent);
|
|
byte[] fileContent = new byte[content.Length + 3];
|
|
fileContent[0] = 0xEF;
|
|
fileContent[1] = 0xBB;
|
|
fileContent[2] = 0xBF;
|
|
content.CopyTo(fileContent, 3);
|
|
FilesController.UpdateFileBinaryContent(packageId, path, fileContent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TaskManager.ItemId = siteItemId;
|
|
|
|
return siteItemId;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UpdateWebSite(WebSite site)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load web site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(site.Id);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE", siteItem.Name, site.Id);
|
|
|
|
try
|
|
{
|
|
// update home folder
|
|
string origPath = site.ContentPath;
|
|
site.ContentPath = FilesController.GetFullPackagePath(site.PackageId, site.ContentPath);
|
|
|
|
// build data folder path
|
|
site.DataPath = siteItem.DataPath;
|
|
|
|
// update site on the service
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.UpdateSite(site);
|
|
// Restore settings back
|
|
#region Web Deploy Settings
|
|
site.WebDeployPublishingAccount = siteItem.WebDeployPublishingAccount;
|
|
site.WebDeployPublishingPassword = siteItem.WebDeployPublishingPassword;
|
|
site.WebDeploySitePublishingEnabled = siteItem.WebDeploySitePublishingEnabled;
|
|
site.WebDeploySitePublishingProfile = siteItem.WebDeploySitePublishingProfile;
|
|
#endregion
|
|
|
|
// update service item
|
|
PackageController.UpdatePackageItem(site);
|
|
|
|
// set origpath
|
|
site.ContentPath = origPath;
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int RepairWebSite(int siteItemId)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public static int ChangeSiteState(int siteItemId, ServerState state)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(siteItem.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0) return packageCheck;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "CHANGE_STATE", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("New state", state);
|
|
|
|
try
|
|
{
|
|
|
|
// change state
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.ChangeSiteState(siteItem.SiteId, state);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
// AppPool
|
|
public static int ChangeAppPoolState(int siteItemId, AppPoolState state)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(siteItem.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0) return packageCheck;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "CHANGE_STATE", siteItem.Name);
|
|
TaskManager.ItemId = siteItemId;
|
|
TaskManager.WriteParameter("New state", state);
|
|
|
|
try
|
|
{
|
|
|
|
// change state
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.ChangeAppPoolState(siteItem.SiteId, state);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static AppPoolState GetAppPoolState(int siteItemId)
|
|
{
|
|
AppPoolState state = AppPoolState.Unknown;
|
|
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return state;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return state;
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(siteItem.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0) return state;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "GET_STATE", siteItem.Name);
|
|
TaskManager.ItemId = siteItemId;
|
|
|
|
try
|
|
{
|
|
// get state
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
state = web.GetAppPoolState(siteItem.SiteId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
public static int DeleteWebSite(int siteItemId, bool deleteWebsiteDirectory)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load web site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE", siteItem.Name, siteItemId);
|
|
|
|
// delete web site
|
|
try
|
|
{
|
|
//cleanup certificates
|
|
//cleanup certificates
|
|
List<SSLCertificate> certificates = GetCertificatesForSite(siteItemId);
|
|
foreach (SSLCertificate c in certificates)
|
|
{
|
|
DeleteCertificate(siteItemId, c);
|
|
}
|
|
|
|
// remove all web site pointers
|
|
List<DomainInfo> pointers = GetWebSitePointers(siteItemId);
|
|
foreach (DomainInfo pointer in pointers)
|
|
DeleteWebSitePointer(siteItemId, pointer.DomainId, false, true, true);
|
|
|
|
// remove web site main pointer
|
|
DomainInfo domain = ServerController.GetDomain(siteItem.Name);
|
|
if(domain != null)
|
|
DeleteWebSitePointer(siteItemId, domain.DomainId, false, true, true);
|
|
|
|
List<WebSite> sites = WebServerController.GetWebSites(domain.PackageId, false);
|
|
bool oneSiteOnly = (sites.Count == 1);
|
|
|
|
if (oneSiteOnly)
|
|
{
|
|
// load site item
|
|
IPAddressInfo ip = ServerController.GetIPAddress(sites[0].SiteIPAddressId);
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(sites[0].ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
ServerController.RemoveServiceDNSRecords(domain.PackageId, ResourceGroups.Web, domain, serviceIp, true);
|
|
}
|
|
|
|
|
|
|
|
|
|
// delete web site
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
|
|
//
|
|
if (web.IsFrontPageSystemInstalled() && web.IsFrontPageInstalled(siteItem.SiteId))
|
|
{
|
|
web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount);
|
|
}
|
|
|
|
//
|
|
web.DeleteSite(siteItem.SiteId);
|
|
|
|
// Delete WebManagementAccess Account
|
|
WebServerController.RevokeWebManagementAccess(siteItemId);
|
|
|
|
if (deleteWebsiteDirectory)
|
|
{
|
|
// Delete website directory from file server
|
|
// This will remove the hard quota as well
|
|
FilesController.DeleteDirectoryRecursive(siteItem.PackageId, new DirectoryInfo(siteItem.DataPath).Parent.FullName);
|
|
|
|
}
|
|
// delete service item
|
|
PackageController.DeletePackageItem(siteItemId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int SwitchWebSiteToDedicatedIP(int siteItemId, int ipAddressId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load web site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
|
|
int addressId = 0;
|
|
PackageIPAddress packageIp = ServerController.GetPackageIPAddress(ipAddressId);
|
|
if (packageIp != null)
|
|
{
|
|
addressId = packageIp.AddressID;
|
|
}
|
|
|
|
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(siteItem.ServiceId);
|
|
|
|
foreach (GlobalDnsRecord d in dnsRecords)
|
|
{
|
|
if (!string.IsNullOrEmpty(d.ExternalIP))
|
|
{
|
|
if (!IsValidIPAdddress(d.ExternalIP)) return BusinessErrorCodes.ERROR_GLOBALDNS_FOR_DEDICATEDIP;
|
|
}
|
|
}
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "SWITCH_TO_DEDICATED_IP", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
IPAddressInfo ip;
|
|
|
|
// remove all web site pointers
|
|
DomainInfo domain = ServerController.GetDomain(siteItem.Name);
|
|
DomainInfo ZoneInfo = ServerController.GetDomain(domain.DomainItemId);
|
|
|
|
if (ZoneInfo == null)
|
|
throw new Exception("Parent zone not found");
|
|
|
|
//cleanup certificates
|
|
List<SSLCertificate> certificates = GetCertificatesForSite(siteItemId);
|
|
foreach (SSLCertificate c in certificates)
|
|
{
|
|
DeleteCertificate(siteItemId, c);
|
|
}
|
|
|
|
certificates = GetPendingCertificates(siteItemId);
|
|
foreach (SSLCertificate c in certificates)
|
|
{
|
|
DeleteCertificateRequest(siteItemId, c.id);
|
|
}
|
|
|
|
List<DomainInfo> pointers = GetWebSitePointers(siteItemId);
|
|
foreach (DomainInfo pointer in pointers)
|
|
DeleteWebSitePointer(siteItemId, pointer.DomainId, true, true, false);
|
|
|
|
// remove web site main pointer
|
|
if (domain != null)
|
|
DeleteWebSitePointer(siteItemId, domain.DomainId, true, true, false);
|
|
|
|
// clear binding left overs
|
|
List<ServerBinding> newBindings = new List<ServerBinding>();
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
try
|
|
{
|
|
web.UpdateSiteBindings(siteItem.SiteId, newBindings.ToArray(), true);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
|
|
List<WebSite> sites = WebServerController.GetWebSites(domain.PackageId, false);
|
|
bool oneSiteOnly = (sites.Count == 1);
|
|
|
|
if (oneSiteOnly)
|
|
{
|
|
// load site item
|
|
ip = ServerController.GetIPAddress(sites[0].SiteIPAddressId);
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(sites[0].ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
ServerController.RemoveServiceDNSRecords(domain.PackageId, ResourceGroups.Web, domain, serviceIp, true);
|
|
}
|
|
|
|
|
|
// update site item
|
|
siteItem.SiteIPAddressId = addressId;
|
|
PackageController.UpdatePackageItem(siteItem);
|
|
|
|
// associate IP with web site
|
|
ServerController.AddItemIPAddress(siteItemId, ipAddressId);
|
|
|
|
|
|
string parentZone = domain.ZoneName;
|
|
if (string.IsNullOrEmpty(parentZone))
|
|
{
|
|
DomainInfo parentDomain = ServerController.GetDomain(domain.DomainItemId);
|
|
parentZone = parentDomain.DomainName;
|
|
}
|
|
|
|
|
|
AddWebSitePointer(siteItemId,
|
|
((domain.DomainName.Replace("." + parentZone, "") == parentZone) |
|
|
(domain.DomainName == parentZone))
|
|
? "" : domain.DomainName.Replace("." + parentZone, "")
|
|
, ZoneInfo.DomainId, true, true, true);
|
|
|
|
foreach (DomainInfo pointer in pointers)
|
|
{
|
|
string pointerParentZone = pointer.ZoneName;
|
|
if (string.IsNullOrEmpty(pointerParentZone))
|
|
{
|
|
DomainInfo parentDomain = ServerController.GetDomain(pointer.DomainItemId);
|
|
pointerParentZone = parentDomain.DomainName;
|
|
}
|
|
|
|
|
|
ZoneInfo = ServerController.GetDomain(pointerParentZone);
|
|
|
|
AddWebSitePointer(siteItemId,
|
|
((pointer.DomainName.Replace("." + pointerParentZone, "") == pointerParentZone) |
|
|
(pointer.DomainName == pointerParentZone))
|
|
? "" : pointer.DomainName.Replace("." + pointerParentZone, "")
|
|
, ZoneInfo.DomainId, true, true, true);
|
|
}
|
|
|
|
// load web site IP address
|
|
ip = ServerController.GetIPAddress(siteItem.SiteIPAddressId);
|
|
string ipAddr = "*";
|
|
if (ip != null)
|
|
ipAddr = !String.IsNullOrEmpty(ip.InternalIP) ? ip.InternalIP : ip.ExternalIP;
|
|
|
|
newBindings = new List<ServerBinding>();
|
|
|
|
ServerBinding srvBinding = new ServerBinding(ipAddr, "80", "");
|
|
newBindings.Add(srvBinding);
|
|
|
|
foreach (ServerBinding b in web.GetSiteBindings(siteItem.SiteId))
|
|
{
|
|
if (!((b.Host == srvBinding.Host) &
|
|
(b.IP == srvBinding.IP) &
|
|
(b.Port == srvBinding.Port)))
|
|
newBindings.Add(b);
|
|
}
|
|
|
|
web.UpdateSiteBindings(siteItem.SiteId, newBindings.ToArray(), false);
|
|
|
|
if (oneSiteOnly)
|
|
{
|
|
sites = WebServerController.GetWebSites(domain.PackageId, false);
|
|
|
|
// load site item
|
|
ip = ServerController.GetIPAddress(sites[0].SiteIPAddressId);
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(sites[0].ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.Web, domain, serviceIp, true);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int SwitchWebSiteToSharedIP(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load web site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "SWITCH_TO_SHARED_IP", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
IPAddressInfo ip;
|
|
|
|
DomainInfo domain = ServerController.GetDomain(siteItem.Name);
|
|
DomainInfo ZoneInfo = ServerController.GetDomain(domain.DomainItemId);
|
|
|
|
if (ZoneInfo == null)
|
|
throw new Exception("Parent zone not found");
|
|
|
|
|
|
if (ZoneInfo.ZoneItemId > 0)
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(siteItem.ServiceId);
|
|
if (string.IsNullOrEmpty(settings["PublicSharedIP"]))
|
|
return BusinessErrorCodes.ERROR_PUBLICSHAREDIP_FOR_SHAREDIP;
|
|
|
|
}
|
|
|
|
//cleanup certificates
|
|
List<SSLCertificate> certificates = GetCertificatesForSite(siteItemId);
|
|
foreach (SSLCertificate c in certificates)
|
|
{
|
|
DeleteCertificate(siteItemId, c);
|
|
}
|
|
|
|
certificates = GetPendingCertificates(siteItemId);
|
|
foreach (SSLCertificate c in certificates)
|
|
{
|
|
DeleteCertificateRequest(siteItemId, c.id);
|
|
}
|
|
|
|
// remove all web site pointers
|
|
List<DomainInfo> pointers = GetWebSitePointers(siteItemId);
|
|
foreach (DomainInfo pointer in pointers)
|
|
DeleteWebSitePointer(siteItemId, pointer.DomainId, true, true, false);
|
|
|
|
// remove web site main pointer
|
|
if (domain != null)
|
|
DeleteWebSitePointer(siteItemId, domain.DomainId, true, true, false);
|
|
|
|
// clear binding left overs
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
List<ServerBinding> newBindings = new List<ServerBinding>();
|
|
|
|
try
|
|
{
|
|
web.UpdateSiteBindings(siteItem.SiteId, newBindings.ToArray(), true);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
List<WebSite> sites = WebServerController.GetWebSites(domain.PackageId, false);
|
|
bool oneSiteOnly = (sites.Count == 1);
|
|
|
|
if (oneSiteOnly)
|
|
{
|
|
// load site item
|
|
ip = ServerController.GetIPAddress(sites[0].SiteIPAddressId);
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(sites[0].ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
ServerController.RemoveServiceDNSRecords(domain.PackageId, ResourceGroups.Web, domain, serviceIp, true);
|
|
}
|
|
|
|
|
|
//figure out the PackageAddressId
|
|
PackageIPAddress packageIpAddress = null;
|
|
var siteIpAddresses = ServerController.GetItemIPAddresses(siteItemId, IPAddressPool.None);
|
|
foreach (var siteIp in siteIpAddresses)
|
|
{
|
|
packageIpAddress = ServerController.GetPackageIPAddress(siteIp.AddressID);
|
|
if (packageIpAddress != null && packageIpAddress.AddressID == siteItem.SiteIPAddressId)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Deallocate IP Address
|
|
if (packageIpAddress != null)
|
|
ServerController.DeleteItemIPAddress(siteItemId, packageIpAddress.PackageAddressID);
|
|
|
|
// update site item
|
|
siteItem.SiteIPAddressId = 0;
|
|
PackageController.UpdatePackageItem(siteItem);
|
|
|
|
string parentZone = domain.ZoneName;
|
|
if (string.IsNullOrEmpty(parentZone))
|
|
{
|
|
DomainInfo parentDomain = ServerController.GetDomain(domain.DomainItemId);
|
|
parentZone = parentDomain.DomainName;
|
|
}
|
|
|
|
AddWebSitePointer(siteItemId,
|
|
((domain.DomainName.Replace("." + parentZone, "") == parentZone) |
|
|
(domain.DomainName == parentZone))
|
|
? "" : domain.DomainName.Replace("." + parentZone, "")
|
|
, ZoneInfo.DomainId, true, true, true);
|
|
|
|
foreach (DomainInfo pointer in pointers)
|
|
{
|
|
string pointerParentZone = pointer.ZoneName;
|
|
if (string.IsNullOrEmpty(pointerParentZone))
|
|
{
|
|
DomainInfo parentDomain = ServerController.GetDomain(pointer.DomainItemId);
|
|
pointerParentZone = parentDomain.DomainName;
|
|
}
|
|
|
|
|
|
ZoneInfo = ServerController.GetDomain(pointerParentZone);
|
|
|
|
AddWebSitePointer(siteItemId,
|
|
((pointer.DomainName.Replace("." + pointerParentZone, "") == pointerParentZone) |
|
|
(pointer.DomainName == pointerParentZone))
|
|
? "" : pointer.DomainName.Replace("." + pointerParentZone, "")
|
|
, ZoneInfo.DomainId, true, true, true);
|
|
}
|
|
|
|
if (oneSiteOnly)
|
|
{
|
|
sites = WebServerController.GetWebSites(domain.PackageId, false);
|
|
|
|
// load site item
|
|
ip = ServerController.GetIPAddress(sites[0].SiteIPAddressId);
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(sites[0].ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
ServerController.AddServiceDNSRecords(domain.PackageId, ResourceGroups.Web, domain, serviceIp, true);
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
private static void FillWebServerBindings(List<ServerBinding> bindings, List<GlobalDnsRecord> dnsRecords,
|
|
string ipAddr, string hostName, string domainName, bool ignoreGlobalDNSRecords)
|
|
// TODO test if IPv6 works
|
|
{
|
|
int bindingsCount = bindings.Count;
|
|
foreach (GlobalDnsRecord dnsRecord in dnsRecords)
|
|
{
|
|
if ((dnsRecord.RecordType == "A" || dnsRecord.RecordType == "AAAA" || dnsRecord.RecordType == "CNAME") &&
|
|
dnsRecord.RecordName != "*")
|
|
{
|
|
string recordData = Utils.ReplaceStringVariable(dnsRecord.RecordName, "host_name", hostName, true);
|
|
|
|
if (!string.IsNullOrEmpty(domainName))
|
|
recordData = recordData + ((string.IsNullOrEmpty(recordData)) ? "" : ".") + domainName;
|
|
//otherwise full recordData is supplied by hostName
|
|
|
|
if (ignoreGlobalDNSRecords)
|
|
{
|
|
//only look for the host_nanme record, ignore all others
|
|
if (dnsRecord.RecordName == "[host_name]")
|
|
{
|
|
AddBinding(bindings, new ServerBinding(ipAddr, "80", recordData));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddBinding(bindings, new ServerBinding(ipAddr, "80", recordData));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((bindings.Count == bindingsCount) | (bindings.Count == 0))
|
|
{
|
|
AddBinding(bindings, new ServerBinding(ipAddr, "80", string.IsNullOrEmpty(hostName) ? domainName : string.IsNullOrEmpty(domainName) ? hostName : hostName + "." + domainName));
|
|
}
|
|
}
|
|
|
|
private static void AddBinding(List<ServerBinding> bindings, ServerBinding binding)
|
|
{
|
|
foreach (ServerBinding b in bindings)
|
|
{
|
|
if (string.Compare(b.Host, binding.Host, true) == 0)
|
|
return;
|
|
}
|
|
|
|
bindings.Add(binding);
|
|
}
|
|
|
|
|
|
private static string GetWebSiteUsername(UserSettings webPolicy, string domainName)
|
|
{
|
|
UsernamePolicy policy = new UsernamePolicy(webPolicy["AnonymousAccountPolicy"]);
|
|
|
|
// remove dots from the domain
|
|
domainName = Regex.Replace(domainName, "\\W+", "", RegexOptions.Compiled);
|
|
|
|
if (!policy.Enabled)
|
|
{
|
|
// default algorythm
|
|
int maxLength = MAX_ACCOUNT_LENGTH - ANON_ACCOUNT_SUFFIX.Length - 2;
|
|
string username = (domainName.Length > maxLength) ? domainName.Substring(0, maxLength) : domainName;
|
|
return (username + ANON_ACCOUNT_SUFFIX); // suffix
|
|
}
|
|
else
|
|
{
|
|
// policy-enabled
|
|
// use prefix and suffix only
|
|
|
|
// adjust maximum length
|
|
int maxLength = MAX_ACCOUNT_LENGTH - 2; // 2 symbols for number
|
|
if (policy.Prefix != null)
|
|
maxLength -= policy.Prefix.Length;
|
|
|
|
if (policy.Suffix != null)
|
|
maxLength -= policy.Suffix.Length;
|
|
|
|
string username = (domainName.Length > maxLength) ? domainName.Substring(0, maxLength) : domainName;
|
|
return ((policy.Prefix != null) ? policy.Prefix : "")
|
|
+ username
|
|
+ ((policy.Suffix != null) ? policy.Suffix : "");
|
|
}
|
|
}
|
|
|
|
private static string GetWebFolder(int packageId, string pattern, string domainName)
|
|
{
|
|
string path = Utils.ReplaceStringVariable(pattern, "domain_name", domainName);
|
|
return FilesController.GetFullPackagePath(packageId, path);
|
|
}
|
|
|
|
private static string GetFrontPageUsername(string domainName)
|
|
{
|
|
int maxLength = MAX_ACCOUNT_LENGTH - FRONTPAGE_ACCOUNT_SUFFIX.Length - 1;
|
|
string username = (domainName.Length > maxLength) ? domainName.Substring(0, maxLength) : domainName;
|
|
return (username + FRONTPAGE_ACCOUNT_SUFFIX); // suffix
|
|
}
|
|
|
|
public static string GetWebUsersOU(int packageId)
|
|
{
|
|
int webServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Web);
|
|
if (webServiceId > 0)
|
|
{
|
|
// get users OU defined on web server
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(webServiceId);
|
|
return webSettings["ADUsersOU"];
|
|
}
|
|
return null;
|
|
}
|
|
#endregion
|
|
|
|
#region Web Site Pointers
|
|
public static List<DomainInfo> GetWebSitePointers(int siteItemId)
|
|
{
|
|
List<DomainInfo> pointers = new List<DomainInfo>();
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return pointers;
|
|
|
|
// get the list of all domains
|
|
List<DomainInfo> myDomains = ServerController.GetMyDomains(siteItem.PackageId);
|
|
|
|
foreach (DomainInfo domain in myDomains)
|
|
{
|
|
if (domain.WebSiteId == siteItemId &&
|
|
String.Compare(domain.DomainName, siteItem.Name, true) != 0)
|
|
pointers.Add(domain);
|
|
}
|
|
|
|
return pointers;
|
|
}
|
|
|
|
public static int AddWebSitePointer(int siteItemId, string hostName, int domainId)
|
|
{
|
|
return AddWebSitePointer(siteItemId, hostName, domainId, true, true, false);
|
|
}
|
|
|
|
internal static int AddWebSitePointer(int siteItemId, string hostName, int domainId, bool updateWebSite)
|
|
{
|
|
return AddWebSitePointer(siteItemId, hostName, domainId, updateWebSite, false, false);
|
|
}
|
|
|
|
internal static int AddWebSitePointer(int siteItemId, string hostName, int domainId, bool updateWebSite, bool ignoreGlobalDNSRecords, bool rebuild)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// load domain item
|
|
DomainInfo domain = ServerController.GetDomain(domainId);
|
|
if (domain == null)
|
|
return BusinessErrorCodes.ERROR_DOMAIN_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check if the web site already exists
|
|
if (!rebuild)
|
|
{
|
|
if (DataProvider.CheckDomain(domain.PackageId, string.IsNullOrEmpty(hostName) ? domain.DomainName : hostName + "." + domain.DomainName, true) != 0)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_ALREADY_EXISTS;
|
|
}
|
|
|
|
// get zone records for the service
|
|
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(siteItem.ServiceId);
|
|
|
|
// load web site IP address
|
|
IPAddressInfo ip = ServerController.GetIPAddress(siteItem.SiteIPAddressId);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "ADD_POINTER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Domain pointer", domain.DomainName);
|
|
TaskManager.WriteParameter("Host name", hostName);
|
|
TaskManager.WriteParameter("updateWebSite", updateWebSite.ToString());
|
|
|
|
try
|
|
{
|
|
|
|
|
|
// load appropriate zone
|
|
DnsZone zone = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
|
|
|
|
|
|
if (zone != null)
|
|
{
|
|
// change DNS zone
|
|
List<GlobalDnsRecord> tmpDnsRecords = new List<GlobalDnsRecord>();
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(siteItem.ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
//filter initiat GlobaDNSRecords list
|
|
if (ignoreGlobalDNSRecords)
|
|
{
|
|
//ignore all other except the host_name record
|
|
foreach (GlobalDnsRecord r in dnsRecords)
|
|
{
|
|
if (r.RecordName == "[host_name]")
|
|
{
|
|
tmpDnsRecords.Add(r);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
tmpDnsRecords = dnsRecords;
|
|
|
|
|
|
List<DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(tmpDnsRecords, hostName, domain.DomainName, serviceIp);
|
|
|
|
if (!rebuild)
|
|
{
|
|
foreach (DnsRecord r in resourceRecords)
|
|
{
|
|
if (r.RecordName != "*")
|
|
{
|
|
// check if the web site already exists
|
|
if (DataProvider.CheckDomain(domain.PackageId, string.IsNullOrEmpty(r.RecordName) ? domain.DomainName : r.RecordName + "." + domain.DomainName, true) != 0)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_ALREADY_EXISTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
DNSServer dns = new DNSServer();
|
|
ServiceProviderProxy.Init(dns, zone.ServiceId);
|
|
|
|
DnsRecord[] domainRecords = dns.GetZoneRecords(zone.Name);
|
|
var duplicateRecords = (from zoneRecord in domainRecords
|
|
from resRecord in resourceRecords
|
|
where zoneRecord.RecordName == resRecord.RecordName
|
|
where zoneRecord.RecordType == resRecord.RecordType
|
|
select zoneRecord).ToArray();
|
|
if (duplicateRecords != null && duplicateRecords.Count() > 0)
|
|
{
|
|
dns.DeleteZoneRecords(zone.Name, duplicateRecords);
|
|
}
|
|
|
|
// add new resource records
|
|
dns.AddZoneRecords(zone.Name, resourceRecords.ToArray());
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
TaskManager.WriteError(ex1, "Error updating DNS records");
|
|
}
|
|
}
|
|
|
|
// update host headers
|
|
List<ServerBinding> bindings = new List<ServerBinding>();
|
|
|
|
// get existing web site bindings
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
|
|
bindings.AddRange(web.GetSiteBindings(siteItem.SiteId));
|
|
|
|
// check if web site has dedicated IP assigned
|
|
bool dedicatedIp = bindings.Exists(binding => { return String.IsNullOrEmpty(binding.Host) && binding.IP != "*"; });
|
|
|
|
// update binding only for "shared" ip addresses
|
|
// add new host headers
|
|
string ipAddr = "*";
|
|
if (ip != null)
|
|
ipAddr = !String.IsNullOrEmpty(ip.InternalIP) ? ip.InternalIP : ip.ExternalIP;
|
|
|
|
// fill bindings
|
|
FillWebServerBindings(bindings, dnsRecords, ipAddr, hostName, domain.DomainName, ignoreGlobalDNSRecords);
|
|
|
|
//for logging purposes
|
|
foreach (ServerBinding b in bindings)
|
|
{
|
|
string header = string.Format("{0} {1} {2}", b.Host, b.IP, b.Port);
|
|
TaskManager.WriteParameter("Add Binding", header);
|
|
}
|
|
|
|
// update bindings
|
|
if (updateWebSite)
|
|
web.UpdateSiteBindings(siteItem.SiteId, bindings.ToArray(), false);
|
|
|
|
// update domain
|
|
if (!rebuild)
|
|
{
|
|
domain.WebSiteId = siteItemId;
|
|
domain.IsDomainPointer = true;
|
|
foreach (ServerBinding b in bindings)
|
|
{
|
|
//add new domain record
|
|
if (!string.IsNullOrEmpty(b.Host))
|
|
{
|
|
domain.DomainName = b.Host;
|
|
|
|
DomainInfo domainTmp = ServerController.GetDomain(domain.DomainName);
|
|
if (!((domainTmp != null) && (domainTmp.WebSiteId == siteItemId)))
|
|
{
|
|
int domainID = ServerController.AddDomain(domain, domain.IsInstantAlias, false);
|
|
domainTmp = ServerController.GetDomain(domainID);
|
|
if (domainTmp != null)
|
|
{
|
|
domainTmp.WebSiteId = siteItemId;
|
|
domainTmp.ZoneItemId = domain.ZoneItemId;
|
|
domainTmp.DomainItemId = domainId;
|
|
|
|
ServerController.UpdateDomain(domainTmp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (domain.ZoneItemId > 0)
|
|
{
|
|
DomainInfo domainTmp = ServerController.GetDomain(string.IsNullOrEmpty(hostName) ? domain.DomainName : hostName + "." + domain.DomainName, true, true);
|
|
if (domainTmp != null)
|
|
{
|
|
domainTmp.ZoneItemId = domain.ZoneItemId;
|
|
ServerController.UpdateDomain(domainTmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteWebSitePointer(int siteItemId, int domainId)
|
|
{
|
|
return DeleteWebSitePointer(siteItemId, domainId, true, true, true);
|
|
}
|
|
|
|
public static int DeleteWebSitePointer(int siteItemId, int domainId, bool updateWebSite, bool ignoreGlobalDNSRecords, bool deleteDomainsRecord)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// load domain item
|
|
DomainInfo domain = ServerController.GetDomain(domainId);
|
|
if (domain == null)
|
|
return BusinessErrorCodes.ERROR_DOMAIN_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// load appropriate zone
|
|
DnsZone zone = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
|
|
|
|
// get zone records for the service
|
|
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(siteItem.ServiceId);
|
|
|
|
// load web site IP address
|
|
IPAddressInfo ip = ServerController.GetIPAddress(siteItem.SiteIPAddressId);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_POINTER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Domain pointer", domain.DomainName);
|
|
TaskManager.WriteParameter("updateWebSite", updateWebSite.ToString());
|
|
|
|
try
|
|
{
|
|
if (zone != null)
|
|
{
|
|
// change DNS zone
|
|
List<GlobalDnsRecord> tmpDnsRecords = new List<GlobalDnsRecord>();
|
|
|
|
string serviceIp = (ip != null) ? ip.ExternalIP : null;
|
|
|
|
if (string.IsNullOrEmpty(serviceIp))
|
|
{
|
|
StringDictionary settings = ServerController.GetServiceSettings(siteItem.ServiceId);
|
|
if (settings["PublicSharedIP"] != null)
|
|
serviceIp = settings["PublicSharedIP"].ToString();
|
|
}
|
|
|
|
if (ignoreGlobalDNSRecords)
|
|
{
|
|
foreach (GlobalDnsRecord r in dnsRecords)
|
|
{
|
|
if ((r.RecordName == "[host_name]") | ((r.RecordName + (string.IsNullOrEmpty(r.RecordName) ? domain.ZoneName : "." + domain.ZoneName)) == domain.DomainName))
|
|
tmpDnsRecords.Add(r);
|
|
}
|
|
}
|
|
else tmpDnsRecords = dnsRecords;
|
|
|
|
List<DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(
|
|
tmpDnsRecords, domain.DomainName, "", serviceIp);
|
|
|
|
try
|
|
{
|
|
DNSServer dns = new DNSServer();
|
|
ServiceProviderProxy.Init(dns, zone.ServiceId);
|
|
dns.DeleteZoneRecords(zone.Name, resourceRecords.ToArray());
|
|
}
|
|
catch(Exception ex1)
|
|
{
|
|
TaskManager.WriteError(ex1, "Error deleting DNS records");
|
|
}
|
|
}
|
|
|
|
// get existing web site bindings
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
|
|
List<ServerBinding> bindings = new List<ServerBinding>();
|
|
bindings.AddRange(web.GetSiteBindings(siteItem.SiteId));
|
|
|
|
// check if web site has dedicated IP assigned
|
|
bool dedicatedIp = bindings.Exists(binding => { return String.IsNullOrEmpty(binding.Host) && binding.IP != "*"; });
|
|
|
|
// update binding only for "shared" ip addresses
|
|
|
|
// remove host headers
|
|
List<ServerBinding> domainBindings = new List<ServerBinding>();
|
|
FillWebServerBindings(domainBindings, dnsRecords, "", domain.DomainName, "", ignoreGlobalDNSRecords);
|
|
|
|
// fill to remove list
|
|
List<string> headersToRemove = new List<string>();
|
|
foreach (ServerBinding domainBinding in domainBindings)
|
|
headersToRemove.Add(domainBinding.Host);
|
|
|
|
// remove bndings
|
|
bindings.RemoveAll(b => { return headersToRemove.Contains(b.Host) && b.Port == "80"; } );
|
|
|
|
// update bindings
|
|
if (updateWebSite)
|
|
web.UpdateSiteBindings(siteItem.SiteId, bindings.ToArray(), true);
|
|
|
|
// update domain
|
|
if (deleteDomainsRecord)
|
|
{
|
|
if ((domain.WebSiteId > 0) && (!domain.IsDomainPointer))
|
|
{
|
|
domain.WebSiteId = 0;
|
|
ServerController.UpdateDomain(domain);
|
|
}
|
|
else
|
|
{
|
|
domain.WebSiteId = 0;
|
|
ServerController.UpdateDomain(domain);
|
|
ServerController.DeleteDomain(domain.DomainId);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Virtual Directories
|
|
public static List<WebVirtualDirectory> GetVirtualDirectories(int siteItemId)
|
|
{
|
|
List<WebVirtualDirectory> dirs = new List<WebVirtualDirectory>();
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return dirs;
|
|
|
|
// truncate home folders
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
WebVirtualDirectory[] vdirs = web.GetVirtualDirectories(siteItem.SiteId);
|
|
|
|
foreach (WebVirtualDirectory vdir in vdirs)
|
|
{
|
|
vdir.ContentPath = FilesController.GetVirtualPackagePath(siteItem.PackageId, vdir.ContentPath);
|
|
dirs.Add(vdir);
|
|
}
|
|
|
|
return dirs;
|
|
}
|
|
|
|
public static WebVirtualDirectory GetVirtualDirectory(int siteItemId, string vdirName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// create directory
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
WebVirtualDirectory vdir = web.GetVirtualDirectory(siteItem.SiteId, vdirName);
|
|
// truncate home folder
|
|
vdir.ContentPath = FilesController.GetVirtualPackagePath(siteItem.PackageId, vdir.ContentPath);
|
|
|
|
// set name
|
|
vdir.ParentSiteName = siteItem.Name;
|
|
vdir.PackageId = siteItem.PackageId;
|
|
return vdir;
|
|
}
|
|
|
|
public static int AddVirtualDirectory(int siteItemId, string vdirName, string vdirPath)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(siteItem.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0) return packageCheck;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "ADD_VDIR", vdirName, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Web site", siteItem.Name);
|
|
|
|
try
|
|
{
|
|
// create virtual directory
|
|
WebVirtualDirectory dir = new WebVirtualDirectory();
|
|
dir.Name = vdirName;
|
|
dir.ContentPath = FilesController.GetFullPackagePath(siteItem.PackageId, vdirPath);
|
|
|
|
dir.EnableAnonymousAccess = true;
|
|
dir.EnableWindowsAuthentication = true;
|
|
dir.EnableBasicAuthentication = false;
|
|
|
|
//dir.InstalledDotNetFramework = aspNet;
|
|
|
|
dir.DefaultDocs = null; // inherit from service
|
|
dir.HttpRedirect = "";
|
|
dir.HttpErrors = null;
|
|
dir.MimeMaps = null;
|
|
|
|
// create directory
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
if (web.VirtualDirectoryExists(siteItem.SiteId, vdirName))
|
|
return BusinessErrorCodes.ERROR_VDIR_ALREADY_EXISTS;
|
|
|
|
web.CreateVirtualDirectory(siteItem.SiteId, dir);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UpdateVirtualDirectory(int siteItemId, WebVirtualDirectory vdir)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_VDIR", vdir.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Web site", siteItem.Name);
|
|
|
|
try
|
|
{
|
|
// normalize path
|
|
vdir.ContentPath = FilesController.GetFullPackagePath(siteItem.PackageId, vdir.ContentPath);
|
|
|
|
// create directory
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.UpdateVirtualDirectory(siteItem.SiteId, vdir);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteVirtualDirectory(int siteItemId, string vdirName)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_VDIR", vdirName, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Web site", siteItem.Name);
|
|
|
|
try
|
|
{
|
|
// create directory
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.DeleteVirtualDirectory(siteItem.SiteId, vdirName);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region FrontPage
|
|
public static int InstallFrontPage(int siteItemId, string username, string password)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(siteItem.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0) return packageCheck;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "INSTALL_FP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("FrontPage username", username);
|
|
|
|
try
|
|
{
|
|
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
|
|
// load original site
|
|
//WebSite origSite = GetWebSite(siteItemId);
|
|
|
|
// install FP
|
|
bool success = web.InstallFrontPage(siteItem.SiteId, username, password);
|
|
if (!success)
|
|
{
|
|
TaskManager.WriteWarning("Account exists");
|
|
return BusinessErrorCodes.ERROR_FP_ACCOUNT_EXISTS;
|
|
}
|
|
|
|
// update site with FP account
|
|
siteItem.FrontPageAccount = username;
|
|
siteItem.FrontPagePassword = CryptoUtils.Encrypt(password);
|
|
PackageController.UpdatePackageItem(siteItem);
|
|
|
|
// restore original site
|
|
//UpdateWebSite(origSite);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UninstallFrontPage(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UNINSTALL_FP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("FrontPage username", siteItem.FrontPageAccount);
|
|
|
|
try
|
|
{
|
|
if (String.IsNullOrEmpty(siteItem.FrontPageAccount))
|
|
siteItem.FrontPageAccount = GetFrontPageUsername(siteItem.Name);
|
|
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount);
|
|
|
|
// update site with FP account
|
|
siteItem.FrontPageAccount = "";
|
|
PackageController.UpdatePackageItem(siteItem);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int ChangeFrontPagePassword(int siteItemId, string password)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "CHANGE_FP_PASSWORD", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("FrontPage username", siteItem.FrontPageAccount);
|
|
|
|
try
|
|
{
|
|
if (String.IsNullOrEmpty(siteItem.FrontPageAccount))
|
|
siteItem.FrontPageAccount = GetFrontPageUsername(siteItem.Name);
|
|
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
web.ChangeFrontPagePassword(siteItem.FrontPageAccount, password);
|
|
|
|
// update site with FP account
|
|
siteItem.FrontPagePassword = CryptoUtils.Encrypt(password);
|
|
PackageController.UpdatePackageItem(siteItem);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Secured Folders
|
|
public static int InstallSecuredFolders(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "INSTALL_SECURED_FOLDERS", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
|
|
// install folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.InstallSecuredFolders(siteItem.SiteId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UninstallSecuredFolders(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UNINSTALL_SECURED_FOLDERS", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
// install folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UninstallSecuredFolders(siteItem.SiteId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static WebFolder[] GetFolders(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetFolders(siteItem.SiteId);
|
|
}
|
|
|
|
public static WebFolder GetFolder(int siteItemId, string folderPath)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetFolder(siteItem.SiteId, folderPath);
|
|
}
|
|
|
|
public static int UpdateFolder(int siteItemId, WebFolder folder)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
folder.Path = FilesController.CorrectRelativePath(folder.Path);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_SECURED_FOLDER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Folder", folder.Path);
|
|
|
|
try
|
|
{
|
|
// update folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateFolder(siteItem.SiteId, folder);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteFolder(int siteItemId, string folderPath)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_SECURED_FOLDER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Folder", folderPath);
|
|
|
|
try
|
|
{
|
|
// delete folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteFolder(siteItem.SiteId, folderPath);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Secured Users
|
|
public static WebUser[] GetUsers(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get users
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetUsers(siteItem.SiteId);
|
|
}
|
|
|
|
public static WebUser GetUser(int siteItemId, string userName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetUser(siteItem.SiteId, userName);
|
|
}
|
|
|
|
public static int UpdateUser(int siteItemId, WebUser user)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_SECURED_USER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("User", user.Name);
|
|
|
|
try
|
|
{
|
|
// update user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateUser(siteItem.SiteId, user);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteUser(int siteItemId, string userName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_SECURED_USER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("User", userName);
|
|
|
|
try
|
|
{
|
|
// delete user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteUser(siteItem.SiteId, userName);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Secured Groups
|
|
public static WebGroup[] GetGroups(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get groups
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetGroups(siteItem.SiteId);
|
|
}
|
|
|
|
public static WebGroup GetGroup(int siteItemId, string groupName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetGroup(siteItem.SiteId, groupName);
|
|
}
|
|
|
|
public static int UpdateGroup(int siteItemId, WebGroup group)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_SECURED_GROUP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Group", group.Name);
|
|
|
|
try
|
|
{
|
|
// update group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateGroup(siteItem.SiteId, group);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteGroup(int siteItemId, string groupName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_SECURED_GROUP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Group", groupName);
|
|
|
|
try
|
|
{
|
|
// delete group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteGroup(siteItem.SiteId, groupName);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Shared SSL Folders
|
|
public static List<string> GetSharedSSLDomains(int packageId)
|
|
{
|
|
List<string> domains = new List<string>();
|
|
|
|
PackageSettings settings = PackageController.GetPackageSettings(packageId, PackageSettings.SHARED_SSL_SITES);
|
|
if (settings != null && !String.IsNullOrEmpty(settings["SharedSslSites"]))
|
|
domains.AddRange(settings["SharedSslSites"].Split(';'));
|
|
|
|
return domains;
|
|
}
|
|
|
|
public static DataSet GetRawSSLFoldersPaged(int packageId,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return PackageController.GetRawPackageItemsPaged(packageId, typeof(SharedSSLFolder),
|
|
true, filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static List<SharedSSLFolder> GetSharedSSLFolders(int packageId, bool recursive)
|
|
{
|
|
List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(
|
|
packageId, typeof(SharedSSLFolder), recursive);
|
|
|
|
return items.ConvertAll<SharedSSLFolder>(
|
|
new Converter<ServiceProviderItem, SharedSSLFolder>(ConvertItemToSharedSSLFolder));
|
|
}
|
|
|
|
private static SharedSSLFolder ConvertItemToSharedSSLFolder(ServiceProviderItem item)
|
|
{
|
|
return (SharedSSLFolder)item;
|
|
}
|
|
|
|
public static SharedSSLFolder GetSharedSSLFolder(int itemId)
|
|
{
|
|
// load original item
|
|
SharedSSLFolder vdirItem = (SharedSSLFolder)PackageController.GetPackageItem(itemId);
|
|
if (vdirItem == null)
|
|
return null;
|
|
|
|
// load shared SSL site
|
|
int idx = vdirItem.Name.LastIndexOf("/");
|
|
string domainName = vdirItem.Name.Substring(0, idx);
|
|
string vdirName = vdirItem.Name.Substring(idx + 1);
|
|
|
|
WebServer web = GetWebServer(vdirItem.ServiceId);
|
|
string siteId = web.GetSiteId(domainName);
|
|
if (siteId == null)
|
|
return null;
|
|
|
|
// get virtual directory
|
|
WebVirtualDirectory vdir = web.GetVirtualDirectory(siteId, vdirName);
|
|
if (vdir != null)
|
|
{
|
|
vdir.ContentPath = FilesController.GetVirtualPackagePath(vdirItem.PackageId, vdir.ContentPath);
|
|
}
|
|
vdir.Id = itemId;
|
|
vdir.Name = vdirItem.Name;
|
|
vdir.PackageId = vdirItem.PackageId;
|
|
return ObjectUtils.ConvertObject<WebVirtualDirectory, SharedSSLFolder>(vdir);
|
|
}
|
|
|
|
public static int AddSharedSSLFolder(int packageId, string sslDomain, int webSiteId, string vdirName, string vdirPath)
|
|
{
|
|
// 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;
|
|
|
|
// check quota
|
|
QuotaValueInfo sitesQuota = PackageController.GetPackageQuota(packageId, Quotas.WEB_SHAREDSSL);
|
|
if (sitesQuota.QuotaExhausted)
|
|
return BusinessErrorCodes.ERROR_WEB_SHARED_SSL_QUOTA_LIMIT;
|
|
|
|
//get site
|
|
WebSite site = GetWebSite(webSiteId);
|
|
bool updateRequired = (site != null) && (site.Name.Equals(sslDomain, StringComparison.InvariantCulture) != true);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "ADD_SSL_FOLDER", sslDomain);
|
|
TaskManager.WriteParameter("Directory name", vdirName);
|
|
TaskManager.WriteParameter("Path", vdirPath);
|
|
|
|
try
|
|
{
|
|
// create virtual directory
|
|
SharedSSLFolder dir = new SharedSSLFolder();
|
|
dir.Name = vdirName;
|
|
dir.ContentPath = FilesController.GetFullPackagePath(packageId, vdirPath);
|
|
|
|
dir.EnableAnonymousAccess = true;
|
|
dir.EnableWindowsAuthentication = true;
|
|
dir.EnableBasicAuthentication = false;
|
|
|
|
//dir.InstalledDotNetFramework = aspNet;
|
|
|
|
dir.DefaultDocs = null; // inherit from service
|
|
dir.HttpRedirect = "";
|
|
dir.HttpErrors = null;
|
|
dir.MimeMaps = null;
|
|
|
|
// create directory
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Web);
|
|
WebServer web = GetWebServer(serviceId);
|
|
|
|
// get site id
|
|
string siteId = web.GetSiteId(sslDomain);
|
|
if (siteId == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// check if vdir exists
|
|
if (web.VirtualDirectoryExists(siteId, vdirName))
|
|
return BusinessErrorCodes.ERROR_VDIR_ALREADY_EXISTS;
|
|
|
|
if (updateRequired)
|
|
{
|
|
dir.ApplicationPool = site.ApplicationPool;
|
|
dir.AnonymousUsername = site.AnonymousUsername;
|
|
dir.AnonymousUserPassword = site.AnonymousUserPassword;
|
|
dir.DedicatedApplicationPool = site.DedicatedApplicationPool;
|
|
dir.AspInstalled = site.AspInstalled;
|
|
dir.AspNetInstalled = site.AspNetInstalled;
|
|
dir.CgiBinInstalled = site.CgiBinInstalled;
|
|
}
|
|
|
|
// create vdir
|
|
WebVirtualDirectory virtDir = ObjectUtils.ConvertObject<SharedSSLFolder, WebVirtualDirectory>(dir);
|
|
web.CreateVirtualDirectory(siteId, virtDir);
|
|
|
|
//anonymous user and applcation pool
|
|
if (updateRequired)
|
|
{
|
|
web.UpdateVirtualDirectory(siteId, virtDir);
|
|
}
|
|
|
|
// save item
|
|
dir.Name = sslDomain + "/" + vdirName;
|
|
dir.PackageId = packageId;
|
|
dir.ServiceId = serviceId;
|
|
|
|
int itemId = PackageController.AddPackageItem(dir);
|
|
|
|
TaskManager.ItemId = itemId;
|
|
|
|
return itemId;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UpdateSharedSSLFolder(SharedSSLFolder vdir)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load original item
|
|
SharedSSLFolder origVdir = (SharedSSLFolder)PackageController.GetPackageItem(vdir.Id);
|
|
if (origVdir == null)
|
|
return 0;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_SSL_FOLDER", origVdir.Name, vdir.Id);
|
|
|
|
try
|
|
{
|
|
int idx = origVdir.Name.LastIndexOf("/");
|
|
string domainName = origVdir.Name.Substring(0, idx);
|
|
string vdirName = origVdir.Name.Substring(idx + 1);
|
|
|
|
WebServer web = GetWebServer(origVdir.ServiceId);
|
|
string siteId = web.GetSiteId(domainName);
|
|
if (siteId == null)
|
|
return 0;
|
|
|
|
// normalize path
|
|
vdir.ContentPath = FilesController.GetFullPackagePath(origVdir.PackageId, vdir.ContentPath);
|
|
vdir.Name = vdirName;
|
|
|
|
// copy object
|
|
WebVirtualDirectory virtDir = ObjectUtils.ConvertObject<SharedSSLFolder, WebVirtualDirectory>(vdir);
|
|
|
|
// update directory
|
|
web.UpdateVirtualDirectory(siteId, virtDir);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteSharedSSLFolder(int itemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load original item
|
|
SharedSSLFolder origVdir = (SharedSSLFolder)PackageController.GetPackageItem(itemId);
|
|
if (origVdir == null)
|
|
return 0;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_SSL_FOLDER", origVdir.Name, itemId);
|
|
|
|
try
|
|
{
|
|
int idx = origVdir.Name.LastIndexOf("/");
|
|
string domainName = origVdir.Name.Substring(0, idx);
|
|
string vdirName = origVdir.Name.Substring(idx + 1);
|
|
|
|
WebServer web = GetWebServer(origVdir.ServiceId);
|
|
string siteId = web.GetSiteId(domainName);
|
|
if (siteId == null)
|
|
return 0;
|
|
|
|
// delete directory
|
|
web.DeleteVirtualDirectory(siteId, vdirName);
|
|
|
|
// delete item
|
|
PackageController.DeletePackageItem(itemId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Web Deploy Publishing Access
|
|
|
|
public static ResultObject SaveWebDeployPublishingProfile(int siteItemId, int[] serviceItemIds)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "SaveWebDeployPublishingProfile");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
// load site item
|
|
var item = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteError("Web site not found");
|
|
//
|
|
result.AddError("WEBSITE_NOT_FOUND", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
//
|
|
result.AddError("DEMO_USER", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
//
|
|
result.AddError("NOT_ALLOWED", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
// Ensure all service items specified are within the same hosting space
|
|
// This is a logcally correct and secure statement than the other one
|
|
// TO-DO: Uncomment this line before demo!
|
|
//var profileIntegritySucceeded = false;
|
|
|
|
var profileIntegritySucceeded = true;
|
|
//
|
|
foreach (int itemId in serviceItemIds)
|
|
{
|
|
try
|
|
{
|
|
//
|
|
PackageController.GetPackageItem(itemId);
|
|
//
|
|
profileIntegritySucceeded = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
//
|
|
profileIntegritySucceeded = false;
|
|
// Exit from the loop
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
if (profileIntegritySucceeded == true)
|
|
{
|
|
// Build service items list
|
|
item.WebDeploySitePublishingProfile = String.Join(",", Array.ConvertAll<int, string>(serviceItemIds, (int x) => { return x.ToString(); }));
|
|
// Put changes in effect
|
|
PackageController.UpdatePackageItem(item);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
//
|
|
result.IsSuccess = false;
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
public static ResultObject GrantWebDeployPublishingAccess(int siteItemId, string accountName, string accountPassword)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWeDeployPublishingAccess");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
// load site item
|
|
var item = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteError("Web site not found");
|
|
//
|
|
result.AddError("WEBSITE_NOT_FOUND", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
//
|
|
result.AddError("DEMO_USER", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
//
|
|
result.AddError("NOT_ALLOWED", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(item.ServiceId);
|
|
if (!String.IsNullOrEmpty(webSettings["WmSvc.NETBIOS"]))
|
|
{
|
|
accountName = webSettings["WmSvc.NETBIOS"].ToString() + "\\" + accountName;
|
|
}
|
|
|
|
// Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes,
|
|
// so we can re-use the existing functionality to deliver seamless development experience.
|
|
if (server.CheckWebManagementAccountExists(accountName))
|
|
{
|
|
TaskManager.WriteWarning("Account name specified already exists");
|
|
//
|
|
result.AddError("ACCOUNTNAME_PROHIBITED", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
// Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes,
|
|
// so we can re-use the existing functionality to deliver seamless development experience.
|
|
ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword);
|
|
if (!passwResult.IsSuccess)
|
|
{
|
|
TaskManager.WriteWarning("Account password does not meet complexity requirements");
|
|
//
|
|
result.ErrorCodes.AddRange(passwResult.ErrorCodes);
|
|
result.IsSuccess = false;
|
|
//
|
|
return result;
|
|
}
|
|
|
|
// Execute a call to remote server to enable Web Deploy publishing access for the specified user account
|
|
server.GrantWebDeployPublishingAccess(item.SiteId, accountName, accountPassword);
|
|
// Enable Web Deploy flag for the web site
|
|
item.WebDeploySitePublishingEnabled = true;
|
|
// Remember Web Deploy publishing account
|
|
item.WebDeployPublishingAccount = accountName;
|
|
// Remember Web Deploy publishing password
|
|
item.WebDeployPublishingPassword = CryptoUtils.Encrypt(accountPassword);
|
|
// Put changes in effect
|
|
PackageController.UpdatePackageItem(item);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
//
|
|
result.IsSuccess = false;
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
public static void RevokeWebDeployPublishingAccess(int siteItemId)
|
|
{
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "RevokeWebDeployPublishingAccess");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
// load site item
|
|
var item = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteWarning("Web site not found");
|
|
return;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
return;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
return;
|
|
}
|
|
|
|
//
|
|
string accountName = item.WebDeployPublishingAccount;
|
|
//
|
|
if (String.IsNullOrEmpty(accountName))
|
|
{
|
|
TaskManager.WriteWarning("Web Deploy Publishing Access account name is either not set or empty");
|
|
return;
|
|
}
|
|
|
|
//
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
// Revoke
|
|
server.RevokeWebDeployPublishingAccess(item.SiteId, accountName);
|
|
// Cleanup web site properties
|
|
item.WebDeployPublishingAccount = String.Empty;
|
|
item.WebDeploySitePublishingEnabled = false;
|
|
item.WebDeploySitePublishingProfile = String.Empty;
|
|
item.WebDeployPublishingPassword = String.Empty;
|
|
// Put changes into effect
|
|
PackageController.UpdatePackageItem(item);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject ChangeWebDeployPublishingPassword(int siteItemId, string newAccountPassword)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "ChangeWebDeployPublishingPassword");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
//
|
|
var item = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteWarning("Web site not found");
|
|
|
|
//
|
|
result.AddError("WEBSITE_NOT_FOUND", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
|
|
result.AddError("DEMO_USER", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
|
|
//
|
|
result.AddError("NOT_ALLOWED", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
// Revoke access first
|
|
RevokeWebDeployPublishingAccess(siteItemId);
|
|
//
|
|
result = GrantWebDeployPublishingAccess(siteItemId, item.WebDeployPublishingAccount, newAccountPassword);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
public static BytesResult GetWebDeployPublishingProfile(int siteItemId)
|
|
{
|
|
var result = new BytesResult();
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "GetWebDeployPublishingProfile");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
// load site item
|
|
WebSite item = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
//
|
|
var siteItem = GetWebSite(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteWarning("Web site not found");
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string accountName = item.WebDeployPublishingAccount;
|
|
//
|
|
if (String.IsNullOrEmpty(accountName))
|
|
{
|
|
TaskManager.WriteWarning("Web Deploy Publishing Access account name is either not set or empty");
|
|
return result;
|
|
}
|
|
//
|
|
var packageInfo = PackageController.GetPackage(item.PackageId);
|
|
//
|
|
var userInfo = UserController.GetUser(packageInfo.UserId);
|
|
//
|
|
var items = new Hashtable()
|
|
{
|
|
{ "WebSite", siteItem },
|
|
{ "User", userInfo },
|
|
};
|
|
|
|
// Retrieve service item ids from the profile
|
|
var serviceItemIds = Array.ConvertAll<string, int>(
|
|
item.WebDeploySitePublishingProfile.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries),
|
|
(string x) => { return Convert.ToInt32(x.Trim()); });
|
|
|
|
//
|
|
foreach (var serviceItemId in serviceItemIds)
|
|
{
|
|
var packageItem = PackageController.GetPackageItem(serviceItemId);
|
|
// Handle SQL databases
|
|
if (packageItem is SqlDatabase)
|
|
{
|
|
var dbItemKey = packageItem.GroupName.StartsWith("MsSQL") ? "MsSqlDatabase" : "MySqlDatabase";
|
|
var dbServerKeyExt = packageItem.GroupName.StartsWith("MsSQL") ? "MsSqlServerExternalAddress" : "MySqlServerExternalAddress";
|
|
var dbServerKeyInt = packageItem.GroupName.StartsWith("MsSQL") ? "MsSqlServerInternalAddress" : "MySqlServerInternalAddress";
|
|
//
|
|
items.Add(dbItemKey, DatabaseServerController.GetSqlDatabase(serviceItemId));
|
|
// Retrieve settings
|
|
var sqlSettings = ServerController.GetServiceSettings(packageItem.ServiceId);
|
|
items[dbServerKeyExt] = sqlSettings["ExternalAddress"];
|
|
items[dbServerKeyInt] = sqlSettings["InternalAddress"];
|
|
}
|
|
else if (packageItem is SqlUser)
|
|
{
|
|
var itemKey = packageItem.GroupName.StartsWith("MsSQL") ? "MsSqlUser" : "MySqlUser";
|
|
//
|
|
items.Add(itemKey, DatabaseServerController.GetSqlUser(serviceItemId));
|
|
}
|
|
else if (packageItem is FtpAccount)
|
|
{
|
|
//
|
|
items.Add("FtpAccount", FtpServerController.GetFtpAccount(serviceItemId));
|
|
// Get FTP DNS records
|
|
List<GlobalDnsRecord> ftpRecords = ServerController.GetDnsRecordsByService(packageItem.ServiceId);
|
|
if (ftpRecords.Count > 0)
|
|
{
|
|
GlobalDnsRecord ftpRecord = ftpRecords[0];
|
|
string ftpIp = ftpRecord.ExternalIP;
|
|
if (String.IsNullOrEmpty(ftpIp))
|
|
ftpIp = ftpRecord.RecordData;
|
|
// Assign FTP service address variable
|
|
items["FtpServiceAddress"] = ftpIp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decrypt publishing password & copy related settings
|
|
siteItem.WebDeployPublishingPassword = CryptoUtils.Decrypt(item.WebDeployPublishingPassword);
|
|
siteItem.WebDeployPublishingAccount = item.WebDeployPublishingAccount;
|
|
siteItem.WebDeploySitePublishingEnabled = item.WebDeploySitePublishingEnabled;
|
|
siteItem.WebDeploySitePublishingProfile = item.WebDeploySitePublishingProfile;
|
|
|
|
// Retrieve publishing profile template from the Web Policy settings
|
|
var webPolicy = UserController.GetUserSettings(packageInfo.UserId, UserSettings.WEB_POLICY);
|
|
// Instantiate template, it's content and related items and then evaluate it
|
|
var template = new Template(webPolicy["PublishingProfile"]);
|
|
// Receive bytes for the evaluated template
|
|
result.Value = Encoding.UTF8.GetBytes(template.Evaluate(items));
|
|
//
|
|
result.IsSuccess = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
//
|
|
result.IsSuccess = false;
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helicon Ape
|
|
public static int EnableHeliconApe(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "ENABLE_HELICON_APE", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
|
|
// install folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.EnableHeliconApe(siteItem.SiteId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
|
|
}
|
|
|
|
public static int DisableHeliconApe(int siteItemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DISABLE_HELICON_APE", siteItem.Name, siteItemId);
|
|
|
|
try
|
|
{
|
|
// install folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DisableHeliconApe(siteItem.SiteId);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enables Helicon Ape on the server globally. Requires Administrator role to execute.
|
|
/// </summary>
|
|
/// <param name="ServiceId"></param>
|
|
/// <returns></returns>
|
|
public static int EnableHeliconApeGlobally(int ServiceId)
|
|
{
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin | DemandAccount.IsActive | DemandAccount.NotDemo);
|
|
if (accountCheck < 0)
|
|
{
|
|
return accountCheck;
|
|
}
|
|
|
|
WebServer web = GetWebServer(ServiceId);
|
|
web.EnableHeliconApe("");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Disables Helicon Ape on the server globally. Requires Administrator role to execute.
|
|
/// </summary>
|
|
/// <param name="ServiceId"></param>
|
|
/// <returns></returns>
|
|
public static int DisableHeliconApeGlobally(int ServiceId)
|
|
{
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin | DemandAccount.IsActive | DemandAccount.NotDemo);
|
|
//
|
|
if (accountCheck < 0)
|
|
{
|
|
return accountCheck;
|
|
}
|
|
|
|
WebServer web = GetWebServer(ServiceId);
|
|
web.DisableHeliconApe("");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Retrieves Helicon Ape extension status from the server. Requires Administrator role to execute.
|
|
/// </summary>
|
|
/// <param name="ServiceId"></param>
|
|
/// <returns></returns>
|
|
public static HeliconApeStatus GetHeliconApeStatus(int ServiceId)
|
|
{
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin | DemandAccount.IsActive | DemandAccount.NotDemo);
|
|
//
|
|
if (accountCheck < 0)
|
|
{
|
|
return HeliconApeStatus.Empty;
|
|
}
|
|
|
|
WebServer web = GetWebServer(ServiceId);
|
|
|
|
return web.GetHeliconApeStatus("");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Installs Helicon Ape on the target server. Requires Administrator role to execute.
|
|
/// </summary>
|
|
/// <param name="ServiceId"></param>
|
|
/// <returns></returns>
|
|
public static int InstallHeliconApe(int ServiceId)
|
|
{
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin | DemandAccount.IsActive | DemandAccount.NotDemo);
|
|
//
|
|
if (accountCheck < 0)
|
|
{
|
|
return accountCheck;
|
|
}
|
|
//
|
|
WebServer web = GetWebServer(ServiceId);
|
|
//
|
|
web.InstallHeliconApe(String.Empty);
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
public static HtaccessFolder[] GetHeliconApeFolders(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get folders
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeFolders(siteItem.SiteId);
|
|
}
|
|
|
|
public static HtaccessFolder GetHeliconApeHttpdFolder(int serviceId)
|
|
{
|
|
// get folder
|
|
WebServer web = GetWebServer(serviceId);
|
|
return web.GetHeliconApeHttpdFolder();
|
|
}
|
|
|
|
public static HtaccessFolder GetHeliconApeFolder(int siteItemId, string folderPath)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeFolder(siteItem.SiteId, folderPath);
|
|
}
|
|
|
|
public static int UpdateHeliconApeFolder(int siteItemId, HtaccessFolder folder)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
folder.Path = FilesController.CorrectRelativePath(folder.Path);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_HELICON_APE_FOLDER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Folder", folder.Path);
|
|
|
|
try
|
|
{
|
|
// update folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateHeliconApeFolder(siteItem.SiteId, folder);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int UpdateHeliconApeHttpdFolder(int serviceId, HtaccessFolder folder)
|
|
{
|
|
folder.Path = FilesController.CorrectRelativePath(folder.Path);
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_HELICON_APE_HTTPD_FOLDER");
|
|
TaskManager.WriteParameter("Folder", folder.Path);
|
|
|
|
try
|
|
{
|
|
// update folder
|
|
WebServer web = GetWebServer(serviceId);
|
|
web.UpdateHeliconApeHttpdFolder(folder);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteHeliconApeFolder(int siteItemId, string folderPath)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_HELICON_APE_FOLDER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Folder", folderPath);
|
|
|
|
try
|
|
{
|
|
// delete folder
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteHeliconApeFolder(siteItem.SiteId, folderPath);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helicon Ape Users
|
|
public static HtaccessUser[] GetHeliconApeUsers(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get users
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeUsers(siteItem.SiteId);
|
|
}
|
|
|
|
public static HtaccessUser GetHeliconApeUser(int siteItemId, string userName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeUser(siteItem.SiteId, userName);
|
|
}
|
|
|
|
public static int UpdateHeliconApeUser(int siteItemId, HtaccessUser user)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_HELICON_APE_USER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("User", user.Name);
|
|
|
|
try
|
|
{
|
|
// update user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateHeliconApeUser(siteItem.SiteId, user);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteHeliconApeUser(int siteItemId, string userName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_HELICON_APE_USER", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("User", userName);
|
|
|
|
try
|
|
{
|
|
// delete user
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteHeliconApeUser(siteItem.SiteId, userName);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Helicon Ape Groups
|
|
public static WebGroup[] GetHeliconApeGroups(int siteItemId)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get groups
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeGroups(siteItem.SiteId);
|
|
}
|
|
|
|
public static WebGroup GetHeliconApeGroup(int siteItemId, string groupName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return null;
|
|
|
|
// get group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
return web.GetHeliconApeGroup(siteItem.SiteId, groupName);
|
|
}
|
|
|
|
public static int UpdateHeliconApeGroup(int siteItemId, WebGroup group)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "UPDATE_HELICON_APE_GROUP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Group", group.Name);
|
|
|
|
try
|
|
{
|
|
// update group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.UpdateHeliconApeGroup(siteItem.SiteId, group);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static int DeleteHeliconApeGroup(int siteItemId, string groupName)
|
|
{
|
|
// load site item
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteItemId);
|
|
if (siteItem == null)
|
|
return BusinessErrorCodes.ERROR_WEB_SITE_PACKAGE_ITEM_NOT_FOUND;
|
|
|
|
// place log record
|
|
TaskManager.StartTask("WEB_SITE", "DELETE_HELICON_APE_GROUP", siteItem.Name, siteItemId);
|
|
|
|
TaskManager.WriteParameter("Group", groupName);
|
|
|
|
try
|
|
{
|
|
// delete group
|
|
WebServer web = GetWebServer(siteItem.ServiceId);
|
|
web.DeleteHeliconApeGroup(siteItem.SiteId, groupName);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region WebManagement Access
|
|
|
|
public static ResultObject GrantWebManagementAccess(int siteItemId, string accountName, string accountPassword)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWebManagementAccess");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
//
|
|
WebSite item = GetWebSite(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteError("Web site not found");
|
|
//
|
|
result.AddError("WEBSITE_NOT_FOUND", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
//
|
|
result.AddError("DEMO_USER", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
//
|
|
result.AddError("NOT_ALLOWED", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(item.ServiceId);
|
|
if (!String.IsNullOrEmpty(webSettings["WmSvc.NETBIOS"]))
|
|
{
|
|
accountName = webSettings["WmSvc.NETBIOS"].ToString() + "\\" + accountName;
|
|
}
|
|
|
|
//
|
|
if (server.CheckWebManagementAccountExists(accountName))
|
|
{
|
|
TaskManager.WriteWarning("Account name specified already exists");
|
|
//
|
|
result.AddError("ACCOUNTNAME_PROHIBITED", null);
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword);
|
|
if (!passwResult.IsSuccess)
|
|
{
|
|
TaskManager.WriteWarning("Account password does not meet complexity requirements");
|
|
//
|
|
result.ErrorCodes.AddRange(passwResult.ErrorCodes);
|
|
result.IsSuccess = false;
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
server.GrantWebManagementAccess(item.SiteId, accountName, accountPassword);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
public static void RevokeWebManagementAccess(int siteItemId)
|
|
{
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "RevokeWebManagementAccess");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
//
|
|
WebSite item = GetWebSite(siteItemId);
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteWarning("Web site not found");
|
|
return;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
return;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
return;
|
|
}
|
|
|
|
//
|
|
string accountName = item.GetValue<string>(WebSite.WmSvcAccountName);
|
|
//
|
|
if (String.IsNullOrEmpty(accountName))
|
|
{
|
|
TaskManager.WriteWarning("WebManagement Access account name is either not set or empty");
|
|
return;
|
|
}
|
|
|
|
//
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
//
|
|
server.RevokeWebManagementAccess(item.SiteId, accountName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject ChangeWebManagementAccessPassword(int siteItemId, string accountPassword)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "ChangeWebManagementAccessPassword");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
//
|
|
WebSite item = GetWebSite(siteItemId) as WebSite;
|
|
|
|
//
|
|
if (item == null)
|
|
{
|
|
TaskManager.WriteWarning("Web site not found");
|
|
|
|
//
|
|
result.AddError("WEBSITE_NOT_FOUND", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either demo or inactive");
|
|
|
|
result.AddError("DEMO_USER", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
// check package
|
|
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
{
|
|
TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive");
|
|
|
|
//
|
|
result.AddError("NOT_ALLOWED", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string accountName = item.GetValue<string>(WebSite.WmSvcAccountName);
|
|
//
|
|
if (String.IsNullOrEmpty(accountName))
|
|
{
|
|
TaskManager.WriteWarning("WebManagement Access account name is either not set or empty");
|
|
|
|
result.AddError("EMPTY_WMSVC_ACCOUNT", null);
|
|
result.IsSuccess = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
//
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
|
|
//
|
|
ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword);
|
|
if (!passwResult.IsSuccess)
|
|
{
|
|
TaskManager.WriteWarning("Account password does not meet complexity requirements");
|
|
//
|
|
result.ErrorCodes.AddRange(passwResult.ErrorCodes);
|
|
result.IsSuccess = false;
|
|
//
|
|
return result;
|
|
}
|
|
//
|
|
server.ChangeWebManagementAccessPassword(accountName, accountPassword);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IImportController Members
|
|
|
|
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;
|
|
|
|
WebServer web = GetWebServer(serviceId);
|
|
if (itemType == typeof(WebSite))
|
|
items.AddRange(web.GetSites());
|
|
|
|
return items;
|
|
}
|
|
|
|
public void ImportItem(int packageId, int itemTypeId, Type itemType,
|
|
ResourceGroupInfo group, string itemName)
|
|
{
|
|
// Controller supports web sites only
|
|
if (itemType != typeof(WebSite))
|
|
return;
|
|
// Get service id
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
|
|
if (serviceId == 0)
|
|
return;
|
|
//
|
|
WebServer web = GetWebServer(serviceId);
|
|
// Obtaining web site unique id
|
|
string siteId = web.GetSiteId(itemName);
|
|
if (siteId == null)
|
|
return;
|
|
// Obtaining OperatingSystem service provider id within the context of package.
|
|
int osServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Os);
|
|
if (osServiceId == 0)
|
|
return;
|
|
//
|
|
OS.OperatingSystem os = new OS.OperatingSystem();
|
|
ServiceProviderProxy.Init(os, osServiceId);
|
|
|
|
// get site info
|
|
WebSite site = web.GetSite(siteId);
|
|
PackageIPAddress ipMatch = default(PackageIPAddress);
|
|
|
|
#region Resolving web site ip
|
|
// Loading package context to evaluate IP Addresses quota
|
|
PackageContext packageCtx = PackageController.GetPackageContext(packageId);
|
|
|
|
// We are unable to step further because there are
|
|
// no bindings on the web site to choose from
|
|
if (site.Bindings == null || site.Bindings.Length == 0)
|
|
{
|
|
TaskManager.WriteError("Could not import the web site because it has no bindings assigned.");
|
|
return;
|
|
}
|
|
|
|
// Loading service provider settings
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(serviceId);
|
|
int sharedIpId = Utils.ParseInt(webSettings["SharedIP"], 0);
|
|
IPAddressInfo sharedIp = ServerController.GetIPAddress(sharedIpId);
|
|
|
|
// Trying to match site's bindings to against either
|
|
// external or internal address of the shared ip
|
|
bool sharedIpMatch = Array.Exists(site.Bindings,
|
|
x => sharedIp != null && (x.IP.Equals(sharedIp.ExternalIP) || x.IP.Equals(sharedIp.InternalIP)));
|
|
|
|
// Quering dedicated ips package quota allotted
|
|
bool dedicatedIpsAllotted = Array.Exists(packageCtx.QuotasArray,
|
|
x => x.QuotaName == Quotas.WEB_IP_ADDRESSES && x.QuotaAllocatedValue != 0);
|
|
|
|
// By default we fallback to the service provider's shared ip,
|
|
// so the web site being imported is "hooked up" to the proper ip,
|
|
// even if current bindings match different ip for some reason
|
|
if (!dedicatedIpsAllotted || sharedIpMatch)
|
|
{
|
|
site.SiteIPAddressId = sharedIpId;
|
|
}
|
|
|
|
// Trying to find a match in dedicated ips list if any.
|
|
if (dedicatedIpsAllotted && !sharedIpMatch)
|
|
{
|
|
// Obtaining first binding with non-empty ip
|
|
ServerBinding binding = Array.Find<ServerBinding>(site.Bindings, x => !String.IsNullOrEmpty(x.IP));
|
|
// No bindings were found - throw an exception
|
|
if (binding == null)
|
|
{
|
|
TaskManager.WriteError(@"Could not import the web site because IP address field of all of its bindings is empty.
|
|
Please ensure the web site has been assigned bindings in the appropriate format and then try to run import procedure once again.");
|
|
return;
|
|
}
|
|
//
|
|
ServiceInfo webService = ServerController.GetServiceInfo(serviceId);
|
|
// Loading ip addresses from Web Sites address pool related to the package
|
|
List<PackageIPAddress> ips = ServerController.GetPackageUnassignedIPAddresses(packageId, IPAddressPool.WebSites);
|
|
// Looking for an entry matching by package and external/internal ip
|
|
ipMatch = Array.Find<PackageIPAddress>(ips.ToArray(),
|
|
x => x.ExternalIP == binding.IP || x.InternalIP == binding.IP);
|
|
// No match has been found - we are in a fault state
|
|
if (ipMatch == null)
|
|
{
|
|
TaskManager.WriteError(@"Could not import the web site because no dedicated IP address match in the target space has been found.
|
|
Please ensure the space has been allocated {0} IP address as a dedicated one and it is free. Then try to run import procedure once again.", binding.IP);
|
|
return;
|
|
}
|
|
//
|
|
site.SiteIPAddressId = ipMatch.AddressID;
|
|
}
|
|
#endregion
|
|
|
|
// folders
|
|
UserInfo user = PackageController.GetPackageOwner(packageId);
|
|
UserSettings webPolicy = UserController.GetUserSettings(user.UserId, UserSettings.WEB_POLICY);
|
|
string packageHome = FilesController.GetHomeFolder(packageId);
|
|
|
|
// add random string to the domain if specified
|
|
string randDomainName = itemName;
|
|
if (!String.IsNullOrEmpty(webPolicy["AddRandomDomainString"])
|
|
&& Utils.ParseBool(webPolicy["AddRandomDomainString"], false))
|
|
randDomainName += "_" + Utils.GetRandomString(DOMAIN_RANDOM_LENGTH);
|
|
|
|
// ROOT folder
|
|
string contentPath = GetWebFolder(packageId, WEBSITE_ROOT_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebRootFolder"]))
|
|
contentPath = GetWebFolder(packageId, webPolicy["WebRootFolder"], randDomainName);
|
|
|
|
// LOGS folder
|
|
string logsPath = GetWebFolder(packageId, WEBSITE_LOGS_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebLogsFolder"]))
|
|
logsPath = GetWebFolder(packageId, webPolicy["WebLogsFolder"], randDomainName);
|
|
|
|
// DATA folder
|
|
string dataPath = GetWebFolder(packageId, WEBSITE_DATA_FOLDER_PATTERN, randDomainName);
|
|
if (!String.IsNullOrEmpty(webPolicy["WebDataFolder"]))
|
|
dataPath = GetWebFolder(packageId, webPolicy["WebDataFolder"], randDomainName);
|
|
|
|
// copy site files
|
|
try
|
|
{
|
|
os.CopyFile(site.ContentPath, contentPath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex, "Can't copy web site files");
|
|
}
|
|
|
|
// copy site logs
|
|
try
|
|
{
|
|
string logFolder = (site.IIs7) ? site[WebSite.IIS7_SITE_ID] : "W3SVC" + siteId;
|
|
string logsSrcFolder = Path.Combine(site.LogsPath, logFolder);
|
|
if (os.DirectoryExists(logsSrcFolder))
|
|
os.CopyFile(logsSrcFolder, Path.Combine(logsPath, logFolder));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex, "Can't copy web site log files");
|
|
}
|
|
|
|
// set new folders
|
|
site.ContentPath = contentPath;
|
|
site.LogsPath = logsPath;
|
|
site.DataPath = dataPath;
|
|
|
|
// update web site
|
|
web.UpdateSite(site);
|
|
|
|
// process virtual directories
|
|
WebVirtualDirectory[] virtDirs = web.GetVirtualDirectories(siteId);
|
|
foreach (WebVirtualDirectory virtDirPointer in virtDirs)
|
|
{
|
|
try
|
|
{
|
|
// load virtual directory
|
|
WebVirtualDirectory virtDir = web.GetVirtualDirectory(siteId, virtDirPointer.Name);
|
|
|
|
// copy directory files
|
|
string vdirPath = Path.Combine(contentPath, virtDir.Name);
|
|
os.CopyFile(virtDir.ContentPath, vdirPath);
|
|
|
|
virtDir.ContentPath = vdirPath;
|
|
|
|
// update directory
|
|
web.UpdateVirtualDirectory(siteId, virtDir);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex, String.Format("Error importing '{0}' virtual directory",
|
|
virtDirPointer.Name));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// import web site
|
|
site.ServiceId = serviceId;
|
|
site.PackageId = packageId;
|
|
site.Name = itemName;
|
|
site.SiteId = siteId;
|
|
int webSiteId = PackageController.AddPackageItem(site);
|
|
// Assign dedicated IP address to the web site from package context.
|
|
if (ipMatch != null)
|
|
{
|
|
ServerController.AddItemIPAddress(webSiteId, ipMatch.PackageAddressID);
|
|
}
|
|
|
|
// restore/update domains
|
|
RestoreDomainsByWebSite(site.Bindings, packageId, webSiteId, itemName);
|
|
}
|
|
|
|
private void RestoreDomainsByWebSite(ServerBinding[] bindings, int packageId, int webSiteId, string itemName)
|
|
{
|
|
// detect all web site related domains
|
|
List<string> domainNames = new List<string>();
|
|
foreach (ServerBinding binding in bindings)
|
|
{
|
|
string pointerName = binding.Host;
|
|
if (pointerName == null)
|
|
continue;
|
|
pointerName = pointerName.ToLower();
|
|
if (pointerName.StartsWith("www."))
|
|
pointerName = pointerName.Substring(4);
|
|
|
|
if (!domainNames.Contains(pointerName) && !String.IsNullOrEmpty(pointerName))
|
|
domainNames.Add(pointerName);
|
|
}
|
|
|
|
string siteName = itemName.ToLower();
|
|
if (siteName.StartsWith("www."))
|
|
siteName = siteName.Substring(4);
|
|
if (!domainNames.Contains(siteName))
|
|
domainNames.Add(siteName);
|
|
|
|
foreach (string domainName in domainNames)
|
|
{
|
|
DomainInfo domain = ServerController.GetDomain(domainName);
|
|
if (domain == null)
|
|
{
|
|
domain = new DomainInfo();
|
|
domain.DomainName = domainName;
|
|
domain.PackageId = packageId;
|
|
domain.WebSiteId = webSiteId;
|
|
ServerController.AddDomainItem(domain);
|
|
}
|
|
else
|
|
{
|
|
domain.WebSiteId = webSiteId;
|
|
ServerController.UpdateDomain(domain);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static int ImporHostHeader(int userId, int packageId, int siteId)
|
|
{
|
|
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteId);
|
|
if (siteItem == null)
|
|
return -1;
|
|
|
|
// load live site from service
|
|
WebServer web = new WebServer();
|
|
ServiceProviderProxy.Init(web, siteItem.ServiceId);
|
|
|
|
// Verify if already exists
|
|
List<DomainInfo> domains = ServerController.GetDomains(packageId);
|
|
|
|
// Get hostheader
|
|
foreach (ServerBinding b in web.GetSiteBindings(siteItem.SiteId))
|
|
{
|
|
if ((!DoesHeaderExistInDomains(b.Host.ToLower(), domains)) && (!string.IsNullOrEmpty(b.Host)))
|
|
{
|
|
// If not get domain info and add to domains
|
|
int domainId = FindDomainForHeader(b.Host.ToLower(), domains);
|
|
if (domainId > 0)
|
|
{
|
|
DomainInfo domain = ServerController.GetDomain(domainId);
|
|
DomainInfo newDomain = new DomainInfo();
|
|
newDomain.DomainName = b.Host.ToLower();
|
|
newDomain.PackageId = domain.PackageId;
|
|
newDomain.IsDomainPointer = true;
|
|
|
|
int newDomainID = ServerController.AddDomain(newDomain, domain.IsInstantAlias, false);
|
|
if (newDomainID > 0)
|
|
{
|
|
newDomain = ServerController.GetDomain(newDomainID);
|
|
if (newDomain != null)
|
|
{
|
|
newDomain.WebSiteId = siteId;
|
|
newDomain.ZoneItemId = domain.ZoneItemId;
|
|
newDomain.DomainItemId = domain.DomainId;
|
|
ServerController.UpdateDomain(newDomain);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static bool DoesHeaderExistInDomains(string header, List<DomainInfo> domains)
|
|
{
|
|
bool bExist = false;
|
|
|
|
if (!string.IsNullOrEmpty(header))
|
|
{
|
|
foreach (DomainInfo d in domains)
|
|
{
|
|
if ((header == d.DomainName.ToLower()) &&
|
|
(d.IsDomainPointer))
|
|
{
|
|
bExist = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bExist;
|
|
}
|
|
|
|
|
|
private static int FindDomainForHeader(string header, List<DomainInfo> domains)
|
|
{
|
|
int domainId = 0;
|
|
int counter = 0;
|
|
while ((header.IndexOf(".") != -1) & (counter < 2))
|
|
{
|
|
|
|
foreach (DomainInfo d in domains)
|
|
{
|
|
if ((header == d.DomainName.ToLower()) && (!d.IsDomainPointer))
|
|
{
|
|
return d.DomainId;
|
|
}
|
|
}
|
|
|
|
header = header.Substring(header.IndexOf(".") + 1);
|
|
counter++;
|
|
|
|
}
|
|
|
|
return domainId;
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region IBackupController Members
|
|
|
|
public int BackupItem(string tempFolder, System.Xml.XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
|
|
{
|
|
if (item is WebSite)
|
|
{
|
|
WebServer web = GetWebServer(item.ServiceId);
|
|
|
|
// read web site
|
|
WebSite itemSite = item as WebSite;
|
|
string siteId = itemSite.SiteId;
|
|
WebSite site = web.GetSite(siteId);
|
|
site.SiteId = itemSite.SiteId;
|
|
site.SiteIPAddressId = itemSite.SiteIPAddressId;
|
|
site.DataPath = itemSite.DataPath;
|
|
site.FrontPageAccount = itemSite.FrontPageAccount;
|
|
site.FrontPagePassword = itemSite.FrontPagePassword;
|
|
|
|
// serialize web site
|
|
XmlSerializer serializer = new XmlSerializer(typeof(WebSite));
|
|
serializer.Serialize(writer, site);
|
|
|
|
// process virtual directories
|
|
WebVirtualDirectory[] vdirs = web.GetVirtualDirectories(siteId);
|
|
foreach (WebVirtualDirectory vdirShort in vdirs)
|
|
{
|
|
WebVirtualDirectory vdir = web.GetVirtualDirectory(siteId, vdirShort.Name);
|
|
|
|
// serialize vdir
|
|
serializer = new XmlSerializer(typeof(WebVirtualDirectory));
|
|
serializer.Serialize(writer, vdir);
|
|
}
|
|
}
|
|
else if (item is SharedSSLFolder)
|
|
{
|
|
SharedSSLFolder sslFolder = GetSharedSSLFolder(item.Id);
|
|
|
|
// convert content path to physical
|
|
sslFolder.ContentPath = FilesController.GetFullPackagePath(item.PackageId, sslFolder.ContentPath);
|
|
|
|
XmlSerializer serializer = new XmlSerializer(typeof(SharedSSLFolder));
|
|
serializer.Serialize(writer, sslFolder);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public int RestoreItem(string tempFolder, System.Xml.XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group)
|
|
{
|
|
if (itemType == typeof(WebSite))
|
|
{
|
|
WebServer web = GetWebServer(serviceId);
|
|
|
|
// restore web site
|
|
XmlSerializer serializer = new XmlSerializer(typeof(WebSite));
|
|
WebSite site = (WebSite)serializer.Deserialize(
|
|
new XmlNodeReader(itemNode.SelectSingleNode("WebSite")));
|
|
|
|
// create site if required
|
|
if (!web.SiteExists(site.SiteId))
|
|
{
|
|
web.CreateSite(site);
|
|
|
|
// install FPSE if required
|
|
if (site.FrontPageInstalled && !web.IsFrontPageInstalled(site.SiteId))
|
|
{
|
|
web.InstallFrontPage(site.SiteId, site.FrontPageAccount,
|
|
CryptoUtils.Decrypt(site.FrontPagePassword));
|
|
}
|
|
}
|
|
|
|
// restore virtual directories
|
|
foreach (XmlNode vdirNode in itemNode.SelectNodes("WebVirtualDirectory"))
|
|
{
|
|
// deserialize vdir
|
|
serializer = new XmlSerializer(typeof(WebVirtualDirectory));
|
|
WebVirtualDirectory vdir = (WebVirtualDirectory)serializer.Deserialize(
|
|
new XmlNodeReader(vdirNode));
|
|
|
|
if (!web.VirtualDirectoryExists(site.SiteId, vdir.Name))
|
|
{
|
|
web.CreateVirtualDirectory(site.SiteId, vdir);
|
|
}
|
|
}
|
|
|
|
// add meta-item if required
|
|
int webSiteId = 0;
|
|
WebSite existItem = (WebSite)PackageController.GetPackageItemByName(packageId, itemName, typeof(WebSite));
|
|
if (existItem == null)
|
|
{
|
|
site.PackageId = packageId;
|
|
site.ServiceId = serviceId;
|
|
webSiteId = PackageController.AddPackageItem(site);
|
|
}
|
|
else
|
|
{
|
|
webSiteId = existItem.Id;
|
|
}
|
|
|
|
// restore/update domains
|
|
RestoreDomainsByWebSite(site.Bindings, packageId, webSiteId, itemName);
|
|
}
|
|
else if (itemType == typeof(SharedSSLFolder))
|
|
{
|
|
WebServer web = GetWebServer(serviceId);
|
|
|
|
// extract meta item
|
|
XmlSerializer serializer = new XmlSerializer(typeof(SharedSSLFolder));
|
|
SharedSSLFolder sslFolder = (SharedSSLFolder)serializer.Deserialize(
|
|
new XmlNodeReader(itemNode.SelectSingleNode("SharedSSLFolder")));
|
|
|
|
// create vdir if required
|
|
int idx = sslFolder.Name.LastIndexOf("/");
|
|
string domainName = sslFolder.Name.Substring(0, idx);
|
|
string vdirName = sslFolder.Name.Substring(idx + 1);
|
|
|
|
string siteId = web.GetSiteId(domainName);
|
|
if (siteId == null)
|
|
return -1;
|
|
|
|
if (!web.VirtualDirectoryExists(siteId, vdirName))
|
|
{
|
|
web.CreateVirtualDirectory(siteId, sslFolder);
|
|
}
|
|
|
|
// add meta-item if required
|
|
if (PackageController.GetPackageItemByName(packageId, itemName, typeof(SharedSSLFolder)) == null)
|
|
{
|
|
sslFolder.PackageId = packageId;
|
|
sslFolder.ServiceId = serviceId;
|
|
PackageController.AddPackageItem(sslFolder);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SSL
|
|
public static SSLCertificate CertificateRequest(SSLCertificate certificate, int siteItemId)
|
|
{
|
|
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "certificateRequest");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
TaskManager.WriteParameter("Hostname", certificate.Hostname);
|
|
|
|
|
|
WebSite item = GetWebSite(siteItemId) as WebSite;
|
|
PackageInfo service = PackageController.GetPackage(item.PackageId);
|
|
TaskManager.WriteParameter("WebSite.Name", item.Name);
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
TaskManager.WriteParameter("item.ServiceId", item.ServiceId);
|
|
certificate.UserID = service.UserId;
|
|
// We want to have a unique identifier for the FriendlyName to help us to identify it easily
|
|
long ticks = DateTime.UtcNow.Ticks - DateTime.Parse("01/01/1970 00:00:00").Ticks;
|
|
ticks /= 10000000; // Convert windows ticks to seconds
|
|
|
|
//clean up bindings
|
|
|
|
|
|
|
|
certificate.FriendlyName = String.Format("{0}_{1}", certificate.Hostname, ticks.ToString());
|
|
certificate = server.generateCSR(certificate);
|
|
certificate.id = DataProvider.AddSSLRequest(SecurityContext.User.UserId, item.PackageId,
|
|
certificate.SiteID, certificate.UserID, certificate.FriendlyName, certificate.Hostname,
|
|
certificate.CSR, certificate.CSRLength, certificate.DistinguishedName, certificate.IsRenewal,
|
|
certificate.PreviousId);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return certificate;
|
|
|
|
}
|
|
|
|
public static ResultObject InstallCertificate(SSLCertificate certificate, int siteItemId)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "installCertificate");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
TaskManager.WriteParameter("Hostname", certificate.Hostname);
|
|
|
|
|
|
WebSite item = GetWebSite(siteItemId) as WebSite;
|
|
TaskManager.WriteParameter("WebSite.Name", item.Name);
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
TaskManager.WriteParameter("item.ServiceId", item.ServiceId);
|
|
|
|
IPAddressInfo ip = ServerController.GetIPAddress(item.SiteIPAddressId);
|
|
|
|
if (ip != null)
|
|
item.SiteIPAddress = !String.IsNullOrEmpty(ip.InternalIP) ? ip.InternalIP : ip.ExternalIP;
|
|
|
|
certificate = server.installCertificate(certificate, item);
|
|
if (certificate.SerialNumber == null)
|
|
{
|
|
result.AddError("Error_Installing_certificate", null);
|
|
result.IsSuccess = false;
|
|
}
|
|
|
|
|
|
DataProvider.CompleteSSLRequest(SecurityContext.User.UserId, item.PackageId,
|
|
certificate.id, certificate.Certificate,
|
|
certificate.DistinguishedName, certificate.SerialNumber,
|
|
certificate.Hash, certificate.ValidFrom, certificate.ExpiryDate);
|
|
if (certificate.IsRenewal)
|
|
{
|
|
DataProvider.DeleteCertificate(SecurityContext.User.UserId, item.PackageId, certificate.PreviousId);
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.AddError("0", ex);
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static ResultObject InstallPfx(byte[] pfx, int siteItemId, string password)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "installPFX");
|
|
TaskManager.WriteParameter("SiteItemId", siteItemId);
|
|
|
|
WebSite item = GetWebSite(siteItemId) as WebSite;
|
|
PackageInfo service = PackageController.GetPackage(item.PackageId);
|
|
|
|
TaskManager.WriteParameter("WebSite.Name", item.Name);
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
TaskManager.WriteParameter("item.ServiceId", item.ServiceId);
|
|
|
|
// remove all web site pointers
|
|
List<DomainInfo> pointers = GetWebSitePointers(siteItemId);
|
|
foreach (DomainInfo pointer in pointers)
|
|
DeleteWebSitePointer(siteItemId, pointer.DomainId, true, true, true);
|
|
|
|
SSLCertificate certificate = server.installPFX(pfx, password, item);
|
|
if (certificate.SerialNumber == null)
|
|
{
|
|
result.AddError("Error_Installing_certificate", null);
|
|
result.IsSuccess = false;
|
|
}
|
|
DataProvider.AddPFX(SecurityContext.User.UserId, item.PackageId, item.Id, service.UserId, certificate.Hostname,
|
|
certificate.FriendlyName, certificate.DistinguishedName, certificate.CSRLength, certificate.SerialNumber,
|
|
certificate.ValidFrom, certificate.ExpiryDate);
|
|
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.IsSuccess = false;
|
|
result.AddError("Error_Installing_certificate", ex);
|
|
TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static List<SSLCertificate> GetPendingCertificates(int siteItemId)
|
|
{
|
|
WebSite item = GetWebSite(siteItemId) as WebSite;
|
|
List<SSLCertificate> certificates = new List<SSLCertificate>();
|
|
return ObjectUtils.CreateListFromDataSet<SSLCertificate>(
|
|
DataProvider.GetPendingCertificates(SecurityContext.User.UserId, item.PackageId, item.Id, false));
|
|
|
|
}
|
|
|
|
public static SSLCertificate GetSslCertificateById(int iD)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<SSLCertificate>(
|
|
DataProvider.GetSSLCertificateByID(SecurityContext.User.UserId, iD));
|
|
}
|
|
|
|
public static int CheckSSL(int siteID, bool renewal)
|
|
{
|
|
return DataProvider.CheckSSL(siteID, renewal);
|
|
}
|
|
|
|
public static ResultObject CheckSSLForDomain(string domain, int siteID)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
return result;
|
|
}
|
|
|
|
public static SSLCertificate GetSiteCert(int siteid)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<SSLCertificate>(
|
|
DataProvider.GetSiteCert(SecurityContext.User.UserId, siteid));
|
|
}
|
|
|
|
public static List<SSLCertificate> GetCertificatesForSite(int siteId)
|
|
{
|
|
WebSite item = GetWebSite(siteId) as WebSite;
|
|
List<SSLCertificate> certificates = new List<SSLCertificate>();
|
|
return ObjectUtils.CreateListFromDataSet<SSLCertificate>(
|
|
DataProvider.GetCertificatesForSite(SecurityContext.User.UserId, item.PackageId, item.Id));
|
|
}
|
|
|
|
public static byte[] ExportCertificate(int siteId, string serialNumber, string password)
|
|
{
|
|
WebSite item = GetWebSite(siteId) as WebSite;
|
|
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
return server.exportCertificate(serialNumber, password);
|
|
}
|
|
|
|
public static ResultObject DeleteCertificate(int siteId, SSLCertificate certificate)
|
|
{
|
|
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "DeleteCertificate");
|
|
WebSite item = GetWebSite(siteId) as WebSite;
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
result = server.DeleteCertificate(certificate, item);
|
|
if (result.IsSuccess)
|
|
{
|
|
DataProvider.DeleteCertificate(SecurityContext.User.UserId, item.PackageId, certificate.id);
|
|
}
|
|
else
|
|
{
|
|
List<string> exceptions = result.ErrorCodes;
|
|
foreach (string s in exceptions)
|
|
{
|
|
TaskManager.WriteError(s.ToString());
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
result.IsSuccess = false;
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static ResultObject ImportCertificate(int siteId)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
try
|
|
{
|
|
TaskManager.StartTask(LOG_SOURCE_WEB, "ImportCertificate");
|
|
|
|
WebSite item = GetWebSite(siteId) as WebSite;
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
PackageInfo service = PackageController.GetPackage(item.PackageId);
|
|
SSLCertificate certificate = server.ImportCertificate(item);
|
|
if (!certificate.Success)
|
|
{
|
|
result.IsSuccess = false;
|
|
TaskManager.WriteError(certificate.Certificate.ToString());
|
|
}
|
|
else
|
|
{
|
|
DataProvider.AddPFX(SecurityContext.User.UserId, item.PackageId, item.Id, service.UserId, certificate.Hostname,
|
|
certificate.FriendlyName, certificate.DistinguishedName, certificate.CSRLength, certificate.SerialNumber,
|
|
certificate.ValidFrom, certificate.ExpiryDate);
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
result.IsSuccess = false;
|
|
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static ResultObject CheckCertificate(int siteId)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = false };
|
|
bool serverResult = false;
|
|
|
|
try
|
|
{
|
|
WebSite item = GetWebSite(siteId) as WebSite;
|
|
WebServer server = GetWebServer(item.ServiceId);
|
|
serverResult = server.CheckCertificate(item);
|
|
if (serverResult && !DataProvider.CheckSSLExistsForWebsite(siteId))
|
|
{
|
|
result.IsSuccess = true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
result.IsSuccess = false;
|
|
result.AddError("610", ex);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static ResultObject DeleteCertificateRequest(int siteId, int csrID)
|
|
{
|
|
ResultObject result = new ResultObject { IsSuccess = true };
|
|
|
|
try
|
|
{
|
|
WebSite item = GetWebSite(siteId);
|
|
PackageInfo service = PackageController.GetPackage(item.PackageId);
|
|
|
|
DataProvider.DeleteCertificate(SecurityContext.User.UserId, service.PackageId, csrID);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
result.IsSuccess = false;
|
|
result.AddError("610", ex);
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|