/// <summary>
/// If verification fails, the package will be installed by this method.
/// </summary>
/// <param name="packageFileName">The file name of the Sitecore Package located in Sitecore's configured Packages folder.</param>
protected virtual void InstallPackage(string packageFileName)
{
var filePath = $"{Sitecore.Configuration.Settings.DataFolder}/packages/{packageFileName}";
using (new SecurityDisabler())
{
var installMode = Details.InstallMode;
if (installMode == InstallMode.Undefined)
{
installMode = PackageVerifierConfiguration.Current.DefaultInstallMode;
}
var mergeMode = Details.MergeMode;
if (mergeMode == MergeMode.Undefined)
{
mergeMode = PackageVerifierConfiguration.Current.DefaultMergeMode;
}
using (new SyncOperationContext())
{
IProcessingContext context = new SimpleProcessingContext();
IItemInstallerEvents events =
new DefaultItemInstallerEvents(
new BehaviourOptions(installMode, mergeMode));
context.AddAspect(events);
IFileInstallerEvents events1 = new DefaultFileInstallerEvents(true);
context.AddAspect(events1);
var installer = new Sitecore.Install.Installer();
installer.InstallPackage(MainUtil.MapPath(filePath), context);
}
}
}
public void RegisterSitemapToRobotsFile()
{
string robotsPath = MainUtil.MapPath(string.Concat("/", "robots.txt"));
StringBuilder sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
StreamReader sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
StreamWriter sw = new StreamWriter(robotsPath, false);
foreach (string sitemapUrl in m_Sites.Values)
{
string sitemapLine = string.Concat("Sitemap: ", sitemapUrl);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(sitemapLine);
}
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
public void RegisterSitemapToRobotsFile()
{
if (string.IsNullOrWhiteSpace(_config.FileName))
{
return;
}
var robotsPath = MainUtil.MapPath(string.Concat("/", Constants.RobotsFileName));
var sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
var sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
else
{
sitemapContent.AppendLine("User-agent: *");
sitemapContent.AppendLine("Disallow:");
}
var sw = new StreamWriter(robotsPath, false);
var sitemapUrl = _config.ServerUrl + "/" + _config.FileName;
var sitemapLine = string.Concat("Sitemap: ", sitemapUrl);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(sitemapLine);
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
public void AddSitemapToRobots(string xmlFileName)
{
try
{
string _RobotsFilePath = MainUtil.MapPath("/" + "robots.txt");
StringBuilder sbRobots = new StringBuilder(string.Empty);
if (File.Exists(_RobotsFilePath))
{
StreamReader reader = new StreamReader(_RobotsFilePath);
sbRobots.Append(reader.ReadToEnd());
reader.Close();
}
StreamWriter writer = new StreamWriter(_RobotsFilePath, false);
string _stringToAppend = "Sitemap: " + xmlFileName;
if (!sbRobots.ToString().Contains(_stringToAppend))
{
sbRobots.AppendLine(_stringToAppend);
}
writer.Write(sbRobots.ToString());
writer.Close();
}
catch (Exception ex)
{
Log.Error(ex.Message, "SiteMapBuilder - AddSitemapToRobots method");
}
}
public ActionResult InstallPackage()
{
StringBuilder ret = new StringBuilder();
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
using (new SecurityDisabler())
using (new SyncOperationContext())
{
IProcessingContext context = new SimpleProcessingContext();
IItemInstallerEvents events =
new DefaultItemInstallerEvents(
new BehaviourOptions(InstallMode.Overwrite, MergeMode.Undefined));
context.AddAspect(events);
IFileInstallerEvents events1 = new DefaultFileInstallerEvents(true);
context.AddAspect(events1);
Sitecore.Install.Installer installer = new Sitecore.Install.Installer();
installer.InstallPackage(MainUtil.MapPath(@"C:\inetpub\wwwroot\demo1.local\App_Data\packages\bigtst.zip"), context);
}
}
catch (Exception e)
{
ret.Append(e.ToString());
}
finally
{
ret.Append($"\n\n{sw.Elapsed.TotalSeconds}");
}
return(Content(ret.ToString()));
}
public void RegisterSitemapToRobotsFile()
{
if (string.IsNullOrWhiteSpace(_config.FileName))
{
return;
}
string robotsPath = MainUtil.MapPath(string.Concat("/", Constants.RobotsFileName));
StringBuilder sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
StreamReader sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
StreamWriter sw = new StreamWriter(robotsPath, false);
//string sitemapLine = string.Concat(_config.SiteRobotsTxtContent);
string robotsContent = string.Concat(_config.SiteRobotsTxtContent);
string sitemapLine = string.Concat("Sitemap: " + _config.ServerUrl + "/" + _config.FileName);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(robotsContent);
sitemapContent.AppendLine(sitemapLine);
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
public void RegisterSitemapToRobotsFile()
{
string robotsPath = MainUtil.MapPath(string.Concat("/", "robots.txt"));
StringBuilder sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
StreamReader sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
StreamWriter sw = new StreamWriter(robotsPath, false);
foreach (DictionaryEntry site in m_Sites)
{
string sitemapLine = string.Format("Sitemap: http://{0}/{1}", SitemapManagerConfiguration.GetServerUrlBySite(site.Key.ToString()), site.Value);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(sitemapLine);
}
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
public bool LoadFromFile([NotNull] string name)
{
lock (this)
{
try
{
name = MainUtil.MapPath(name);
if (!File.Exists(name))
{
return(false);
}
var formatter = new BinaryFormatter();
using (var stream = File.OpenRead(name))
{
var loadedState = (State)formatter.Deserialize(stream);
if (CurrentStateVersion == loadedState.version)
{
_State = loadedState;
return(true);
}
return(false);
}
}
catch (Exception e)
{
Log.Error("Memory Data Provider - Failed to load from cache: ", e, this);
return(false);
}
}
}
public void RegisterSitemapToRobotsFile()
{
if (!SitemapManagerConfiguration.GenerateRobotsFile)
{
return;
}
var robotsPath = MainUtil.MapPath(string.Concat("/", "robots.txt"));
var sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
var sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
var sw = new StreamWriter(robotsPath, false);
foreach (var sitemapUrl in _sites.Values)
{
var sitemapLine = string.Concat("Sitemap: ", sitemapUrl);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(sitemapLine);
}
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
public ProtobufDataProvider([NotNull] string databaseName, [NotNull] string filePath)
{
Assert.ArgumentNotNullOrEmpty(databaseName, nameof(databaseName));
Assert.ArgumentNotNullOrEmpty(filePath, nameof(filePath));
DataSet = new ItemsDataSet(new FileInfo(MainUtil.MapPath(filePath)));
}
public void RegisterSitemapToRobotsFile()
{
string robotsPath = MainUtil.MapPath(string.Concat("/", "robots.txt"));
StringBuilder sitemapContent = new StringBuilder(string.Empty);
if (File.Exists(robotsPath))
{
StreamReader sr = new StreamReader(robotsPath);
sitemapContent.Append(sr.ReadToEnd());
sr.Close();
}
StreamWriter sw = new StreamWriter(robotsPath, false);
// If production, add sitemap Urls to robots.txt. Otherwise, disallow all bots.
if (SitemapManagerConfiguration.IsProductionEnvironment)
{
foreach (string sitemapUrl in m_Sites.Values)
{
string sitemapLine = string.Concat("sitemap: ", sitemapUrl);
if (!sitemapContent.ToString().Contains(sitemapLine))
{
sitemapContent.AppendLine(sitemapLine);
}
}
}
else
{
sitemapContent = new StringBuilder();
sitemapContent.AppendLine("User-agent: *");
sitemapContent.AppendLine("Disallow: /");
}
sw.Write(sitemapContent.ToString());
sw.Close();
}
/// <summary>
/// Ensures that sitemaps directory exists
/// </summary>
protected static void EnsureSitemapsDirectoryExists()
{
String dirPath = MainUtil.MapPath(DynamicSitemapConfiguration.SitemapConfigurationOutputFolder + "/");
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
}
/// <summary>
/// Generates sitemaps index
/// </summary>
protected void GenerateSitemapsIndex()
{
if (!DynamicSitemapConfiguration.UseSitemapsIndexFile)
{
return;
}
var encoding = Encoding.UTF8;
StringWriterWithEncoding stringWriter = new StringWriterWithEncoding(encoding);
// - Creating the XML Header -
var xml = new XmlTextWriter(stringWriter);
xml.WriteStartDocument();
xml.WriteStartElement("sitemapindex", DynamicSitemapConfiguration.XmlnsTpl);
int sitemapsCount = 0;
try
{
foreach (var sitemap in this.SiteConfigurations)
{
xml.WriteStartElement("sitemap");
xml.WriteElementString("loc", sitemap.SitemapUrl);
var lastModified = DateTime.UtcNow.ToString("yyyy-MM-ddThh:mm:sszzz");
xml.WriteElementString("lastmod", lastModified);
xml.WriteEndElement();
sitemapsCount++;
}
}
catch (Exception exc)
{
Diagnostics.Log.Error("DynamicSitemapGenerator: " + exc.Message + "\n\n" + exc.StackTrace, this);
}
finally
{
xml.WriteEndElement();
xml.WriteEndDocument();
xml.Flush();
String result = stringWriter.ToString();
string path = MainUtil.MapPath("/" + this.SitemapIndex.FileName);
StreamWriter streamWriter = new StreamWriter(path, false);
streamWriter.Write(result);
streamWriter.Close();
Diagnostics.Log.Info("DynamicSitemapGenerator: Sitemap index generated - in path " + path + ", " + sitemapsCount + " sitemaps attached", this);
}
}
public void InstallPackage()
{
var filepath = "";
if (System.Text.RegularExpressions.Regex.IsMatch(Settings.DataFolder, @"^(([a-zA-Z]:\\)|(//)).*"))
{
//if we have an absolute path, rather than relative to the site root
filepath = Settings.DataFolder +
@"\packages\DemandbasePackage.zip";
}
else
{
filepath = HttpRuntime.AppDomainAppPath + Settings.DataFolder.Substring(1) +
@"\packages\DemandbasePackage.zip";
}
try
{
GeneratePackage(filepath);
int count = 0;
while (true)
{
if (count > 15)
{
throw new Exception("Demandbase package extracted to data folder packages however appears to be locked, unlock this file and recycle the app pool.");
}
if (!IsFileLocked(new FileInfo(filepath)))
{
using (new SecurityDisabler())
{
using (new SyncOperationContext())
{
IProcessingContext context = new SimpleProcessingContext();
IItemInstallerEvents events =
new DefaultItemInstallerEvents(
new BehaviourOptions(InstallMode.Overwrite, MergeMode.Undefined));
context.AddAspect(events);
IFileInstallerEvents events1 = new DefaultFileInstallerEvents(true);
context.AddAspect(events1);
Sitecore.Install.Installer installer = new Sitecore.Install.Installer();
installer.InstallPackage(MainUtil.MapPath(filepath), context);
break;
}
}
}
else
{
Thread.Sleep(1000);
}
}
}
catch (Exception e)
{
Log.Error("Demandbase was unable to initialize", e, this);
}
}
private void BuildSiteMapIndex()
{
string fullPath = MainUtil.MapPath(string.Concat("/", SitemapManagerConfiguration.SitemapIndexFilename));
string xmlContent = this.BuildSitemapIndexXML();
StreamWriter strWriter = new StreamWriter(fullPath, false);
strWriter.Write(xmlContent);
strWriter.Close();
}
protected virtual string PackageStoragePath(BuildPackageArgs args)
{
var storageSetting = Settings.GetSetting("Pintle.PackageStoragePath", "/packager");
if (storageSetting.StartsWith("/"))
{
return(MainUtil.MapPath(storageSetting));
}
return(storageSetting);
}
private void BuildSiteMap(string sitename, string sitemapUrlNew)
{
Site site = SiteManager.GetSite(sitename);
string startPath = Factory.GetSite(sitename).StartPath;
List <Item> sitemapItems = this.GetSitemapItems(startPath);
string path = MainUtil.MapPath("/" + sitemapUrlNew);
XmlDocument doc = this.BuildSitemapXML(sitemapItems, site);
XmlTextWriter writer = new XmlTextWriter(path, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
doc.Save(writer);
}
protected override void OnLoad(EventArgs e)
{
Assert.ArgumentNotNull(e, "e");
if (!Context.ClientPage.IsEvent && !Context.ClientPage.IsPostBack)
{
var packageGeneratorFolder = Settings.GetSetting("PackageGeneratorFolder");
this.Directory = MainUtil.MapPath(string.Format("{0}/{1}", Settings.PackagePath, packageGeneratorFolder));
this.FileList.Controls.Add(new LiteralControl(this.BuildFileInput()));
}
base.OnLoad(e);
}
/// <summary>
/// Registers sitemaps to robots.txt
/// </summary>
public virtual void RegisterSitemapToRobotsFile()
{
if (DynamicSitemapConfiguration.RefreshRobotsFile)
{
String robotsPath = MainUtil.MapPath("/" + "robots.txt");
StringBuilder stringBuilder = new StringBuilder(String.Empty);
if (File.Exists(robotsPath))
{
StreamReader streamReader = new StreamReader(robotsPath);
stringBuilder.Append(streamReader.ReadToEnd());
streamReader.Close();
}
StreamWriter streamWriter = new StreamWriter(robotsPath, false);
List <String> sitemapUrls = new List <String>();
if (DynamicSitemapConfiguration.UseSitemapsIndexFile)
{
sitemapUrls.Add(SitemapIndex.Url);
}
else
{
sitemapUrls.AddRange(SiteConfigurations.Select(x => x.SitemapUrl));
}
foreach (var url in sitemapUrls)
{
String value = "Sitemap: " + url;
if (!stringBuilder.ToString().Contains(value))
{
if (!stringBuilder.ToString().EndsWith(Environment.NewLine) && stringBuilder.ToString().Trim() != String.Empty)
{
stringBuilder.AppendLine();
}
stringBuilder.AppendLine(value);
}
}
streamWriter.Write(stringBuilder.ToString());
streamWriter.Close();
}
}
protected override void LoadAutoIncludeFiles(XmlNode element)
{
Assert.ArgumentNotNull((object)element, "element");
var configPatcher = this.GetConfigPatcher(element);
LoadAutoIncludeFiles(configPatcher, Path.Combine(ConfigurationRootDirectory, ConditionalConfigFolderName));
this.LoadAutoIncludeFiles(configPatcher, MainUtil.MapPath("/App_Config/Sitecore/Components"));
this.LoadAutoIncludeFiles(configPatcher, MainUtil.MapPath("/App_Config/Include"));
foreach (var includeDirectory in ConfigurationIncludeDirectories)
{
if (Directory.Exists(includeDirectory))
{
LoadAutoIncludeFiles(configPatcher, includeDirectory);
}
}
}
private void BuildSiteMap(string sitename, string sitemapUrlNew)
{
var site = SiteManager.GetSite(sitename);
var siteContext = Factory.GetSite(sitename);
var items = GetSitemapItems(siteContext.StartPath);
var fullPath = MainUtil.MapPath(string.Concat("/", sitemapUrlNew));
var xmlContent = BuildSitemapXml(items, site);
using (var writer = new XmlTextWriter(fullPath, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
xmlContent.WriteContentTo(writer);
writer.Flush();
}
}
private void BuildSiteMap()
{
Site site = Sitecore.Sites.SiteManager.GetSite(_config.SiteName);
SiteContext siteContext = Factory.GetSite(_config.SiteName);
string rootPath = siteContext.StartPath;
List <SitemapItem> items = GetSitemapItems(rootPath);
string fullPath = MainUtil.MapPath(string.Concat("/", _config.FileName));
string xmlContent = this.BuildSitemapXML(items, site);
StreamWriter strWriter = new StreamWriter(fullPath, false);
strWriter.Write(xmlContent);
strWriter.Close();
}
private void BuildSiteMap()
{
var site = SiteManager.GetSite(_config.SiteName);
var siteContext = Factory.GetSite(_config.SiteName);
var rootPath = siteContext.StartPath;
var items = GetSitemapItems(rootPath);
var fullPath = MainUtil.MapPath(string.Concat("/", _config.FileName));
var xmlContent = BuildSitemapXML(items, site);
var strWriter = new StreamWriter(fullPath, false);
strWriter.Write(xmlContent);
strWriter.Close();
}
/// <summary>
/// Restarts the web server by making a request to the webroot. The request has a short timeout and is expected to fail.
/// The purpose is to initiate a request to IIS to restart the AppPool. The Url is determined by the Sitecore API or an optional config parameter.
/// </summary>
private void RestartSitecoreServer()
{
try
{
//Force restart of all apppools pointing the website. This can happen during long installs
Log.Info("Forcing restart", this);
string configFile = MainUtil.MapPath("/App_Config/Include/SPD_Restart.config");
using (FileStream fs = File.Open(configFile, FileMode.Create))
{
using (StreamWriter sw = new StreamWriter(fs))
{
sw.WriteLine("<!-- Restart -->");
}
}
Thread.Sleep(250);
File.Delete(configFile);
}
catch (Exception ex)
{
Log.Error("Exception when forcing restart", ex, this);
}
string url = _restartUrl;
if (string.IsNullOrEmpty(_restartUrl))
{
url = WebUtil.GetServerUrl();
}
Log.Info("Sitecore Package Deployer is attempting to restart Sitecore at the url: " + url, this);
WebRequest req = WebRequest.Create(url);
req.Timeout = 100;
try
{
using (WebResponse resp = req.GetResponse())
{
}
}
catch (Exception)
{ }
}
internal static string GetPackageSource()
{
string packageSource = Settings.GetSetting("SitecorePackageDeployer.PackageSource");
//See if the package source is a web path instead of a file system path.
if (packageSource.StartsWith("/"))
{
packageSource = MainUtil.MapPath(packageSource);
}
if (!Directory.Exists(packageSource))
{
Directory.CreateDirectory(packageSource);
}
return(packageSource);
}
private void BuildSiteMap(string Sitename, string FileName, string IsSeparatelanguagefile)
{
List <Item> sitemapItems;
Site site = SiteManager.GetSite(Sitename);
SiteContext siteContext = Factory.GetSite(Sitename);
XmlDocument xDoc = null;
List <(XmlDocument doc, string lang)> sitedetails = new List <(XmlDocument doc, string lang)>();
List <string> enabledLanguages = BuildListFromString(siteContext.Properties["enabledLanguages"], '|');
if (enabledLanguages.Count == 0)
{ //if the config doesn't specify any enabled languages, use the current context to retrieve items
sitemapItems = this.GetSitemapItems(siteContext.StartPath, null);
xDoc = StartSitemapXML();
xDoc = this.BuildSitemapXML(xDoc, sitemapItems, site, null);
sitedetails.Add((xDoc, ""));
}
else
{
//For each language supported by the site, retrieve the items using the language and build out sitemap links
foreach (var language in enabledLanguages)
{
sitemapItems = this.GetSitemapItems(siteContext.StartPath, Sitecore.Globalization.Language.Parse(language));
xDoc = StartSitemapXML();
xDoc = this.BuildSitemapXML(xDoc, sitemapItems, site, Sitecore.Globalization.Language.Parse(language));
if (IsSeparatelanguagefile.ToLower() == "yes")
{
sitedetails.Add((xDoc, language));
}
else
{
sitedetails.Add((xDoc, ""));
}
}
}
foreach (var details in sitedetails)
{
string str = String.Empty;
string filename = !String.IsNullOrWhiteSpace(details.lang) ? String.Format("{0}-{1}.xml", FileName, details.lang) : FileName;
str = MainUtil.MapPath(string.Concat("/", filename));
StreamWriter streamWriter = new StreamWriter(str, false);
streamWriter.Write(details.doc.OuterXml);
streamWriter.Close();
}
}
protected void StartGeneration(Message message)
{
var packageGeneratorFolder = Settings.GetSetting("PackageGeneratorFolder");
var filename = FileUtil.MakePath(Settings.PackagePath, string.Format(@"\{0}\{1}", packageGeneratorFolder, this.PackageFile.Value));
this.ResultFile = MainUtil.MapPath(string.Format("{0}/{1}/{2}.zip", Settings.PackagePath, packageGeneratorFolder, this.PackageName.Value));
if (FileUtil.IsFile(filename))
{
this.StartTask(filename);
}
else
{
Context.ClientPage.ClientResponse.Alert("Package not found");
this.Active = "Ready";
this.BackButton.Disabled = true;
}
}
/// <summary>
/// Locates changed configs installed by the package installer
/// </summary>
private void FindAndUpdateChangedConfigs(string installPackageName)
{
string appConfigFolder = MainUtil.MapPath("/");
foreach (string newConfigFile in Directory.GetFiles(appConfigFolder, "*.config." + installPackageName, SearchOption.AllDirectories))
{
Log.Info(string.Format("Found changed config {0}", newConfigFile), this);
int configExtensionPos = newConfigFile.LastIndexOf(".config") + 7;
string oldConfigFile = Path.Combine(Path.GetDirectoryName(newConfigFile), newConfigFile.Substring(0, configExtensionPos));
string backupConfigFile = newConfigFile + string.Format(".backup{0:yyyyMMddhhmmss}", DateTime.Now);
//Backup the existing config file
if (File.Exists(oldConfigFile))
{
if (File.Exists(backupConfigFile))
{
File.Delete(backupConfigFile);
}
Log.Info(string.Format("Backing up config file {0} as {1}", oldConfigFile, backupConfigFile), this);
File.Move(oldConfigFile, backupConfigFile);
}
Log.Info(string.Format("Copying new config file from {0} to {1}", newConfigFile, oldConfigFile), this);
//Move the new file into place
File.Copy(newConfigFile, oldConfigFile);
//Someone didn't cleanup their handle to the new config file. This waits for it to be cleaned up
GC.WaitForPendingFinalizers();
try
{
File.Delete(newConfigFile);
}
catch (Exception)
{
Log.Warn(string.Format("Can't delete file {0}", newConfigFile), this);
}
}
}
public MemoryDataProvider([NotNull] string filename, [NotNull] string serializationPath)
{
Assert.ArgumentNotNullOrEmpty(serializationPath, nameof(serializationPath));
Assert.ArgumentNotNullOrEmpty(filename, nameof(filename));
ID = GetId(filename);
Log.Debug("MemoryDataProvider " + ID + " is starting", this);
filename = MainUtil.MapPath(filename);
serializationPath = Path.GetFullPath(Path.Combine(MainUtil.MapPath("/"), serializationPath));
var started = new AutoResetEvent(false);
ManagedThreadPool.QueueUserWorkItem(
a =>
{
lock (this)
{
started.Set();
try
{
using (new SecurityDisabler())
{
lock (string.Intern(filename))
{
if (!LoadFromFile(filename))
{
LoadTree(serializationPath);
SaveToFile(filename);
}
}
}
}
catch (Exception e)
{
Log.Error(e.ToString(), this);
}
}
});
started.WaitOne();
}
public void AddSegment([NotNull] XmlNode componentNode)
{
Assert.ArgumentNotNull(componentNode, "componentNode");
var segmentElement = (XmlElement)componentNode;
var rootString = segmentElement.GetAttribute("root");
Assert.IsNotNull(rootString, "root attribute is not specified or has empty string value: " + segmentElement.OuterXml);
ID root;
Assert.IsTrue(ID.TryParse(rootString, out root), "root attribute is not a valid GUID value: " + segmentElement.OuterXml);
var file = segmentElement.GetAttribute("file");
Assert.IsNotNullOrEmpty(file, "file attribute is not specified or has empty string value: " + segmentElement.OuterXml);
var filePath = MainUtil.MapPath(file);
var segment = new JsonSegment(root, filePath);
this.Segments.Add(segment);
}
