public static DnsRecord CreateFromElement(XElement element, HostingConfigManager manager)
{
DnsRecord record = new DnsRecord();
record.FromElement(element, manager);
return(record);
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetElementValue("Name", Name);
element.SetElementValue("Value", Value);
element.SetElementValue("RecordType", RecordType.ToString());
element.SetElementValue("Ttl", Ttl);
}
private WebsiteHost parseVersion1Host(XElement e, HostingConfigManager manager)
{
WebsiteHost host = Activator.CreateInstance <WebsiteHost>();
host.FromElement(e, manager);
return(host);
}
public static FtpUser CreateFromElement(XElement element, HostingConfigManager manager)
{
FtpUser user = new FtpUser();
user.FromElement(element, manager);
return(user);
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
//this.PublicWebsiteUserName = element.GetElementValue<string>("PublicWebsiteUserName", true);
//this.PublicWebsitePassword = Password.FromEncrypted(element.GetElementValue<string>("PublicWebsitePassword", true));
//this.PublicWebsiteUserSid = element.GetElementValue<string>("PublicWebsiteUserSid", true);
//this.WorkerProcessUserName = element.GetElementValue<string>("WorkerProcessUserName", true);
//this.WorkerProcessPassword = Password.FromEncrypted(element.GetElementValue<string>("WorkerProcessPassword", true));
//this.WorkerProcessUserSid = element.GetElementValue<string>("WorkerProcessUserSid", true);
//this.ApplicationPoolName = element.GetElementValue<string>("ApplicationPoolName", true);
// Remove all existing elements from earlier versions nolonger used.
element.Elements("PublicWebsiteUserName").Remove();
element.Elements("PublicWebsitePassword").Remove();
element.Elements("PublicWebsiteUserSid").Remove();
element.Elements("WorkerProcessUserName").Remove();
element.Elements("WorkerProcessPassword").Remove();
element.Elements("WorkerProcessUserSid").Remove();
element.Elements("ApplicationPoolName").Remove();
element.SetElementValue("Name", Name);
element.SetElementValue("FtpEnabled", FtpEnabled);
if (FtpUserArray != null)
{
FtpUserArray.ToList().ForEach(ftpUser => processFtpUser(ftpUser, element, manager));
}
}
public void FromElement(XElement element, HostingConfigManager manager)
{
WebsiteID = new RhspDataID(element.GetElementValue <string>("WebsiteID", false));
Name = element.GetElementValue <string>("Name", false);
DefaultTtl = element.GetElementValue <string>("DefaultTtl", false);
this.RecordArray = getRecordArray(element, manager);
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetElementValue("WebsiteID", WebsiteID);
element.SetElementValue("Name", Name);
element.SetElementValue("Port", Port);
element.SetElementValue("IpAddress", IpAddress);
element.SetElementValue("Protocol", Protocol);
}
public void FromElement(XElement element, HostingConfigManager manager)
{
DataID = new RhspDataID(element.GetElementValue <string>("RecordID", false));
Name = element.GetElementValue <string>("Name", false);
Ttl = element.GetElementValue <string>("Ttl", true);
RecordType = getRecordType(element.GetElementValue <string>("RecordType", false));
Value = element.GetElementValue <string>("Value", false);
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetElementValue("Read", Read);
element.SetElementValue("Write", Write);
element.SetElementValue("Delete", Delete);
element.SetElementValue("Access", Access);
element.SetElementValue("Username", Username);
element.SetElementValue("UseIisIdentity", UseIisIdentity);
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"FtpUser",
new XAttribute("Enabled", Enabled),
new XElement("UserName", UserName),
new XElement("Password", Password.GetEncrypted())
));
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"Record",
new XElement("RecordID", DataID),
new XElement("Name", Name),
new XElement("Ttl", Ttl),
new XElement("RecordType", RecordType.ToString()),
new XElement("Value", Value)
));
}
public void FromElement(XElement element, HostingConfigManager manager)
{
WebsiteID = new RhspDataID(element.GetElementValue <string>("WebsiteID", false));
RelativePath = element.GetElementValue <string>("RelativePath", false);
Username = element.GetElementValue <string>("Username", true);
Read = element.GetElementValue <bool>("Read", false);
Write = element.GetElementValue <bool>("Write", false);
Delete = element.GetElementValue <bool>("Delete", false);
Access = parseAccess(element.GetElementValue <string>("Access", false));
UseIisIdentity = element.GetElementValue <bool>("UseIisIdentity", true);
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"WebsiteHost",
new XElement("WebsiteID", WebsiteID),
new XElement("Name", Name),
new XElement("Port", Port),
new XElement("IpAddress", IpAddress),
new XElement("Protocol", Protocol)
));
}
public void FromElement(XElement element, HostingConfigManager manager)
{
WebsiteID = element.GetElementValue <RhspDataID>("WebsiteID", true);
Name = element.GetElementValue <string>("Name", true);
Port = element.GetElementValue <int>("Port", true);
IpAddress = element.GetElementValue <string>("IpAddress", true);
Protocol = element.GetElementValue <WebsiteHostProtocol>("Protocol", true);
if (manager.GetDataSchemaVersion <WebsiteHost>(DataID) == FirstSchemaVersion)
{
Primary = element.GetElementValue <bool>("Primary", true);
}
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"SecurityRule",
new XElement("WebsiteID", WebsiteID),
new XElement("RelativePath", RelativePath),
new XElement("Username", Username),
new XElement("Read", Read),
new XElement("Write", Write),
new XElement("Delete", Delete),
new XElement("Access", Access.ToString()),
new XElement("UseIisIdentity", UseIisIdentity)
));
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"Customer",
new XElement("Code", Code.ToUpper()),
new XElement("Name", Name),
new XElement("FtpEnabled", FtpEnabled),
new XElement("FtpUsers",
from ftpUser in (FtpUserArray == null ? new FtpUser[0] : FtpUserArray)
where ftpUser.PendingAction != ChildPendingAction.Delete
select ftpUser.ToXElement(manager)
)
));
}
private FtpUser[] getFtpUserArray(XElement element, HostingConfigManager manager)
{
if (element.Element("FtpUsers") == null)
{
return(new FtpUser[0]);
}
else
{
var q = from e in element.Element("FtpUsers").Elements()
select FtpUser.CreateFromElement(e, manager);
return(q.ToArray());
}
}
private DnsRecord[] getRecordArray(XElement element, HostingConfigManager manager)
{
if (element.Element("Records") == null)
{
return(new DnsRecord[0]);
}
else
{
var q = from e in element.Elements("Records").Elements()
select DnsRecord.CreateFromElement(e, manager);
return(q.ToArray());
}
}
public void FromElement(XElement element, HostingConfigManager manager)
{
this.Code = element.GetElementValue <string>("Code", false);
this.Name = element.GetElementValue <string>("Name", false);
this.FtpEnabled = element.GetElementValue <bool>("FtpEnabled", true);
//this.PublicWebsiteUserName = element.GetElementValue<string>("PublicWebsiteUserName", true);
//this.PublicWebsitePassword = Password.FromEncrypted(element.GetElementValue<string>("PublicWebsitePassword", true));
//this.PublicWebsiteUserSid = element.GetElementValue<string>("PublicWebsiteUserSid", true);
//this.WorkerProcessUserName = element.GetElementValue<string>("WorkerProcessUserName", true);
//this.WorkerProcessPassword = Password.FromEncrypted(element.GetElementValue<string>("WorkerProcessPassword", true));
//this.WorkerProcessUserSid = element.GetElementValue<string>("WorkerProcessUserSid", true);
//this.ApplicationPoolName = element.GetElementValue<string>("ApplicationPoolName", true);
this.FtpUserArray = getFtpUserArray(element, manager);
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"DnsZone",
new XElement("WebsiteID", WebsiteID),
new XElement("Name", Name),
new XElement("DefaultTtl", DefaultTtl),
new XElement("Records",
from r in RecordArray
where r.PendingAction.Equals(ChildPendingAction.Create)
select r.ToXElement(manager)
)
));
}
//public void SetReadOnlyValues(XElement element, RhspManager manager)
//{
// ApplicationPoolName = Code + " Application Pool";
// element.SetElementValue("ApplicationPoolName", ApplicationPoolName);
// PublicWebsiteUserName = Code + "-PublicWebsite";
// PublicWebsitePassword = manager.EncryptPassword(RsRandom.GenerateString(14));
// WorkerProcessUserName = Code + "-WorkerProcess";
// WorkerProcessPassword = manager.EncryptPassword(RsRandom.GenerateString(14));
// element.SetElementValue("PublicWebsiteUserName", PublicWebsiteUserName);
// element.SetElementValue("PublicWebsitePassword", PublicWebsitePassword.GetEncrypted());
// element.SetElementValue("WorkerProcessUserName", WorkerProcessUserName);
// element.SetElementValue("WorkerProcessPassword", WorkerProcessPassword.GetEncrypted());
//}
private void processFtpUser(FtpUser ftpUser, XElement customerElement, HostingConfigManager manager)
{
switch (ftpUser.PendingAction)
{
case ChildPendingAction.Create:
customerElement.Element("FtpUsers").Add(ftpUser.ToXElement(manager));
break;
case ChildPendingAction.Update:
ftpUser.UpdateElement(getFtpUserElement(customerElement, ftpUser.UserName), manager);
break;
case ChildPendingAction.Delete:
getFtpUserElement(customerElement, ftpUser.UserName).Remove();
break;
}
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetElementValue("PrimaryHostID", PrimaryHostID);
// Remove all existing elements from earlier versions nolonger used.
element.Elements("IisMode").Remove();
element.Elements("IisSiteID").Remove();
element.Elements("IisSiteName").Remove();
element.Elements("IisRedirectUrl").Remove();
element.Elements("IisIdentitySid").Remove();
element.Elements("IisIdentityUserName").Remove();
element.Elements("IisIdentityPassword").Remove();
element.Elements("IisApplicationPoolName").Remove();
element.Elements("IisManagedPipelineMode").Remove();
element.Elements("IisManagedRuntimeVersion").Remove();
XElement ise;
var iisSiteQuery = from e in element.Elements() where e.Name == "IisSite" select e;
if (iisSiteQuery.Count() != 0)
{
ise = iisSiteQuery.Single();
}
else
{
ise = new XElement("IisSite");
element.Add(ise);
}
// Ensure website set for when name is called.
IisSite.Website = this;
ise.SetElementValue("IisMode", IisSite.Mode);
ise.SetElementValue("IisSiteID", IisSite.SiteID);
ise.SetElementValue("IisSiteName", IisSite.SiteName);
ise.SetElementValue("IisRedirectUrl", IisSite.RedirectUrl);
ise.SetElementValue("IisIdentitySid", IisSite.IdentitySid);
ise.SetElementValue("IisIdentityUserName", IisSite.IdentityUserName);
ise.SetElementValue("IisIdentityPassword", getEncryptedPassword(IisSite.IdentityPassword));
ise.SetElementValue("IisApplicationPoolName", IisSite.ApplicationPoolName);
ise.SetElementValue("IisManagedPipelineMode", IisSite.ManagedPipelineMode.ToString());
ise.SetElementValue("IisManagedRuntimeVersion", IisSite.ManagedRuntimeVersion);
// As of version 2, hosts are nolonger within website.
element.Elements("Hosts").Remove();
}
public XElement ToXElement(HostingConfigManager manager)
{
return(new XElement(
"Website",
new XElement("CustomerID", CustomerID),
new XElement("PrimaryHostID", PrimaryHostID),
new XElement("IisSite",
new XElement("IisMode", IisSite.Mode),
new XElement("IisSiteID", IisSite.SiteID),
new XElement("IisSiteName", IisSite.SiteName),
new XElement("IisRedirectUrl", IisSite.RedirectUrl),
new XElement("IisIdentitySid", IisSite.IdentitySid),
new XElement("IisIdentityUserName", IisSite.IdentityUserName),
new XElement("IisIdentityPassword", getEncryptedPassword(IisSite.IdentityPassword)),
new XElement("IisApplicationPoolName", IisSite.ApplicationPoolName),
new XElement("IisManagedPipelineMode", IisSite.ManagedPipelineMode),
new XElement("IisManagedRuntimeVersion", IisSite.ManagedRuntimeVersion)
)
));
}
public void FromElement(XElement element, HostingConfigManager manager)
{
CustomerID = element.GetElementValue <RhspDataID>("CustomerID", false);
PrimaryHostID = element.GetElementValue <RhspDataID>("PrimaryHostID", true);
if (manager.GetDataSchemaVersion <Website>(DataID) >= 3)
{
fromVersion3IisSite(element);
}
else
{
fromVersion2IisSite(element);
}
if (GetSchemaVersion(manager) == 1)
{
// In in the first version of website, hosts are stored within the website structure.
IEnumerable <XElement> hostElements = element.Element("Hosts").Nodes().Cast <XElement>();
HostArray = hostElements.Select(e => parseVersion1Host(e, manager)).ToArray();
}
}
private void processRecord(DnsRecord record, XElement zoneElement, HostingConfigManager manager)
{
switch (record.PendingAction)
{
case ChildPendingAction.Create:
zoneElement.Element("Records").Add(record.ToXElement(manager));
break;
case ChildPendingAction.Update:
record.UpdateElement(getRecordElement(zoneElement, record.DataID), manager);
break;
case ChildPendingAction.Delete:
try
{
getRecordElement(zoneElement, record.DataID).Remove();
}
catch (Exception ex)
{
throw new Exception("Could not remove DNS zone from config.", ex);
}
break;
}
}
protected int GetSchemaVersion(HostingConfigManager manager)
{
return(manager.GetDataSchemaVersion(DataID, GetType()));
}
public void FromElement(XElement element, HostingConfigManager manager)
{
this.Enabled = element.GetAttributeValue <bool>("Enabled", false);
this.UserName = element.GetElementValue <string>("UserName", false);
this.Password = Password.FromEncrypted(element.GetElementValue <string>("Password", false));
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetAttributeValue("Enabled", Enabled);
element.SetAttributeValue("Password", Password.GetEncrypted());
}
public void UpdateElement(XElement element, HostingConfigManager manager)
{
element.SetElementValue("Name", Name);
element.SetElementValue("DefaultTtl", DefaultTtl);
RecordArray.ToList().ForEach(r => processRecord(r, element, manager));
}
