private bool BuildResources(BuildSettings settings, ResourceUpdater resourceUpdater)
{
if (_cultures.Count == 0)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoResources"));
return false;
}
int codePage = -1;
XmlNode resourcesNode = GetResourcesNodeForSettings(settings, _results, ref codePage);
XmlNode stringsNode = resourcesNode.SelectSingleNode("Strings");
XmlNode fontsNode = resourcesNode.SelectSingleNode("Fonts");
if (stringsNode == null)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoStringsForCulture", resourcesNode.Attributes.GetNamedItem("Culture").Value));
return false;
}
XmlNodeList stringNodes = stringsNode.SelectNodes("String");
foreach (XmlNode stringNode in stringNodes)
{
XmlAttribute resourceIdAttribute = (XmlAttribute)stringNode.Attributes.GetNamedItem("Name");
if (resourceIdAttribute != null)
{
resourceUpdater.AddStringResource(MESSAGE_TABLE, resourceIdAttribute.Value.ToUpper(CultureInfo.InvariantCulture), stringNode.InnerText);
}
}
if (fontsNode != null)
{
foreach (XmlNode fontNode in fontsNode.SelectNodes("Font"))
{
ConvertChildsNodeToAttributes(fontNode);
}
string fontsConfig = XmlToConfigurationFile(fontsNode);
resourceUpdater.AddStringResource(RESOURCE_TABLE, "SETUPRES", fontsConfig);
DumpXmlToFile(fontsNode, "fonts.cfg.xml");
DumpStringToFile(fontsConfig, "fonts.cfg", false);
if (codePage != -1)
resourceUpdater.AddStringResource(RESOURCE_TABLE, "CODEPAGE", codePage.ToString(CultureInfo.InvariantCulture));
}
return true;
}
private void AddStringResourceForUrl(ResourceUpdater resourceUpdater, string name, string url, string nameToUseInLog)
{
if (!String.IsNullOrEmpty(url))
{
resourceUpdater.AddStringResource(40, name, url);
if (!Util.IsWebUrl(url) && !Util.IsUncPath(url))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.InvalidUrl", nameToUseInLog, url));
}
}
}
private bool BuildPackages(BuildSettings settings, XmlElement configElement, ResourceUpdater resourceUpdater, ArrayList filesCopied, Hashtable eulas)
{
bool fSucceeded = true;
foreach (ProductBuilder builder in settings.ProductBuilders)
{
if (Validate && !builder.Product.ValidationPassed)
{
if (_results != null)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ProductValidation", builder.Name, builder.Product.ValidationResults.FilePath));
foreach (string validationMessage in builder.Product.ValidationResults.ValidationErrors)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationError", builder.Product.ValidationResults.FilePath, validationMessage));
}
foreach (string validationMessage in builder.Product.ValidationResults.ValidationWarnings)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationWarning", builder.Product.ValidationResults.FilePath, validationMessage));
}
}
}
Package package = GetPackageForSettings(settings, builder, _results);
if (package == null)
{
// GetPackage should have already added the correct message info
continue;
}
if (Validate && !package.ValidationPassed)
{
if (_results != null)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.PackageValidation", builder.Name, package.ValidationResults.FilePath));
foreach (string validationMessage in package.ValidationResults.ValidationErrors)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationError", package.ValidationResults.FilePath, validationMessage));
}
foreach (string validationMessage in package.ValidationResults.ValidationWarnings)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationWarning", package.ValidationResults.FilePath, validationMessage));
}
}
}
XmlNode node = package.Node;
// Copy the files for this package to the output directory
XmlAttribute eulaAttribute = node.Attributes[EULA_ATTRIBUTE];
XmlNodeList packageFileNodes = node.SelectNodes(BOOTSTRAPPER_PREFIX + ":PackageFiles/" + BOOTSTRAPPER_PREFIX + ":PackageFile", _xmlNamespaceManager);
XmlNode installChecksNode = node.SelectSingleNode(BOOTSTRAPPER_PREFIX + ":InstallChecks", _xmlNamespaceManager);
foreach (XmlNode packageFileNode in packageFileNodes)
{
XmlAttribute packageFileSource = (XmlAttribute)(packageFileNode.Attributes.GetNamedItem("SourcePath"));
XmlAttribute packageFileDestination = (XmlAttribute)(packageFileNode.Attributes.GetNamedItem("TargetPath"));
XmlAttribute packageFileName = (XmlAttribute)(packageFileNode.Attributes.GetNamedItem("Name"));
XmlAttribute packageFileCopy = (XmlAttribute)(packageFileNode.Attributes.GetNamedItem("CopyOnBuild"));
if (packageFileSource != null && eulaAttribute != null && !String.IsNullOrEmpty(eulaAttribute.Value) && packageFileSource.Value == eulaAttribute.Value)
{
// need to remove EULA from the package file list
XmlNode packageFilesNode = node.SelectSingleNode(BOOTSTRAPPER_PREFIX + ":PackageFiles", _xmlNamespaceManager);
packageFilesNode.RemoveChild(packageFileNode);
continue;
}
if ((packageFileSource != null) && (packageFileDestination != null))
{
// Calculate the hash of this file and add it to the PackageFileNode
if (!AddVerificationInformation(packageFileNode, packageFileSource.Value, packageFileName.Value, builder, settings, _results))
fSucceeded = false;
}
if ((packageFileSource != null) && (packageFileDestination != null) &&
((packageFileCopy == null) || (String.Compare(packageFileCopy.Value, "False", StringComparison.InvariantCulture) != 0)))
{
// if this is the key for an external check, we will add it to the Resource Updater instead of copying the file
XmlNode subNode = null;
if ((installChecksNode != null) && (packageFileName != null))
{
subNode = QueryForSubNode(installChecksNode, "PackageFile", packageFileName.Value);
}
if (subNode != null)
{
if (resourceUpdater != null)
{
if (!File.Exists(packageFileSource.Value))
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageResourceFileNotFound", packageFileSource.Value, builder.Name));
fSucceeded = false;
continue;
}
resourceUpdater.AddFileResource(packageFileSource.Value, packageFileDestination.Value);
}
}
else
{
if (settings.ComponentsLocation != ComponentsLocation.HomeSite || !VerifyHomeSiteInformation(packageFileNode, builder, settings, _results))
{
if (settings.CopyComponents)
{
string strDestinationFileName = System.IO.Path.Combine(settings.OutputPath, packageFileDestination.Value);
try
{
if (!File.Exists(packageFileSource.Value))
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageFileNotFound", packageFileDestination.Value, builder.Name));
fSucceeded = false;
continue;
}
EnsureFolderExists(System.IO.Path.GetDirectoryName(strDestinationFileName));
File.Copy(packageFileSource.Value, strDestinationFileName, true);
ClearReadOnlyAttribute(strDestinationFileName);
}
catch (UnauthorizedAccessException ex)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message));
fSucceeded = false;
continue;
}
catch (IOException ex)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message));
fSucceeded = false;
continue;
}
catch (ArgumentException ex)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message));
fSucceeded = false;
continue;
}
catch (NotSupportedException ex)
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", packageFileSource.Value, builder.Name, ex.Message));
fSucceeded = false;
continue;
}
filesCopied.Add(strDestinationFileName);
}
else
{
filesCopied.Add(packageFileSource.Value);
}
// Add the file size to the PackageFileNode
XmlAttribute sizeAttribute = packageFileNode.OwnerDocument.CreateAttribute("Size");
FileInfo fi = new FileInfo(packageFileSource.Value);
sizeAttribute.Value = "" + (fi.Length.ToString(CultureInfo.InvariantCulture));
MergeAttribute(packageFileNode, sizeAttribute);
}
}
}
}
// Add the Eula attribute correctly
if (eulas != null && eulaAttribute != null && !String.IsNullOrEmpty(eulaAttribute.Value))
{
if (File.Exists(eulaAttribute.Value))
{
// eulas[GetFileHash(eulaAttribute.Value)] = eulaAttribute.Value;
string key = GetFileHash(eulaAttribute.Value);
if (eulas.ContainsKey(key))
eulaAttribute.Value = ((DictionaryEntry)eulas[key]).Key.ToString();
else
{
string configFileKey = string.Format(CultureInfo.InvariantCulture, "EULA{0}", eulas.Count);
DictionaryEntry de = new DictionaryEntry(configFileKey, eulaAttribute.Value);
eulas[key] = de;
eulaAttribute.Value = configFileKey;
}
}
else
{
if (_results != null)
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageResourceFileNotFound", eulaAttribute.Value, builder.Name));
fSucceeded = false;
continue;
}
}
// Write the package node
if (configElement != null)
{
configElement.AppendChild(configElement.OwnerDocument.ImportNode(node, true));
DumpXmlToFile(node, string.Format(CultureInfo.CurrentCulture, "{0}.{1}.xml", package.Product.ProductCode, package.Culture));
}
}
return fSucceeded;
}
/// <summary>
/// Generates a bootstrapper based on the specified settings.
/// </summary>
/// <param name="settings">The properties used to build this bootstrapper.</param>
/// <returns>The results of the bootstrapper generation</returns>
public BuildResults Build(BuildSettings settings)
{
_results = new BuildResults();
try
{
if (settings.ApplicationFile == null && (settings.ProductBuilders == null || settings.ProductBuilders.Count == 0))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.InvalidInput"));
return _results;
}
if (String.IsNullOrEmpty(settings.OutputPath))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoOutputPath"));
return _results;
}
if (!_fInitialized)
Refresh();
if (String.IsNullOrEmpty(settings.Culture))
settings.Culture = MapLCIDToCultureName(settings.LCID);
if (String.IsNullOrEmpty(settings.FallbackCulture))
settings.FallbackCulture = MapLCIDToCultureName(settings.FallbackLCID);
if (String.IsNullOrEmpty(settings.Culture) || settings.Culture == "*")
{
settings.Culture = settings.FallbackCulture;
}
AddBuiltProducts(settings);
ArrayList componentFilesCopied = new ArrayList();
// Copy setup.bin to the output directory
string strOutputExe = System.IO.Path.Combine(settings.OutputPath, SETUP_EXE);
if (!CopySetupToOutputDirectory(settings, strOutputExe))
{
// Appropriate messages should have been stuffed into the results already
return _results;
}
ResourceUpdater resourceUpdater = new ResourceUpdater();
// Build up the String table for setup.exe
if (!BuildResources(settings, resourceUpdater))
{
// Appropriate messages should have been stuffed into the results already
return _results;
}
AddStringResourceForUrl(resourceUpdater, "BASEURL", settings.ApplicationUrl, "ApplicationUrl");
AddStringResourceForUrl(resourceUpdater, "COMPONENTSURL", settings.ComponentsUrl, "ComponentsUrl");
AddStringResourceForUrl(resourceUpdater, "SUPPORTURL", settings.SupportUrl, "SupportUrl");
if (settings.ComponentsLocation == ComponentsLocation.HomeSite)
{
resourceUpdater.AddStringResource(40, "HOMESITE", true.ToString());
}
XmlElement configElement = _document.CreateElement("Configuration");
XmlElement applicationElement = CreateApplicationElement(configElement, settings);
if (applicationElement != null)
{
configElement.AppendChild(applicationElement);
}
// Key: File hash, Value: A DictionaryEntry whose Key is "EULAx" and value is a
// fully qualified path to a eula. It can be any eula that matches the hash.
Hashtable eulas = new Hashtable();
// Copy package files, add each Package config info to the config file
if (!BuildPackages(settings, configElement, resourceUpdater, componentFilesCopied, eulas))
return _results;
// Transform the configuration xml into something the bootstrapper will understand
DumpXmlToFile(configElement, "bootstrapper.cfg.xml");
string config = XmlToConfigurationFile(configElement);
resourceUpdater.AddStringResource(41, "SETUPCFG", config);
DumpStringToFile(config, "bootstrapper.cfg", false);
// Put eulas in the resource stream
foreach (object obj in eulas.Values)
{
DictionaryEntry de = (DictionaryEntry)obj;
string data;
FileInfo fi = new System.IO.FileInfo(de.Value.ToString());
using (FileStream fs = fi.OpenRead())
{
data = new StreamReader(fs).ReadToEnd();
}
resourceUpdater.AddStringResource(44, de.Key.ToString(), data);
}
resourceUpdater.AddStringResource(44, "COUNT", eulas.Count.ToString(CultureInfo.InvariantCulture));
if (!resourceUpdater.UpdateResources(strOutputExe, _results))
{
return _results;
}
_results.SetKeyFile(strOutputExe);
string[] componentFiles = new string[componentFilesCopied.Count];
componentFilesCopied.CopyTo(componentFiles);
_results.AddComponentFiles(componentFiles);
_results.BuildSucceeded();
}
catch (Exception ex)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.General", ex.Message));
}
return _results;
}
private bool BuildResources(BuildSettings settings, ResourceUpdater resourceUpdater)
{
if (this.cultures.Count == 0)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoResources", new object[0]));
}
return false;
}
int codepage = -1;
XmlNode node = this.GetResourcesNodeForSettings(settings, this.results, ref codepage);
XmlNode node2 = node.SelectSingleNode("Strings");
XmlNode input = node.SelectSingleNode("Fonts");
if (node2 == null)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoStringsForCulture", new object[] { node.Attributes.GetNamedItem("Culture").Value }));
}
return false;
}
foreach (XmlNode node4 in node2.SelectNodes("String"))
{
XmlAttribute namedItem = (XmlAttribute) node4.Attributes.GetNamedItem("Name");
if (namedItem != null)
{
resourceUpdater.AddStringResource(0x2b, namedItem.Value.ToUpper(CultureInfo.InvariantCulture), node4.InnerText);
}
}
if (input != null)
{
foreach (XmlNode node5 in input.SelectNodes("Font"))
{
this.ConvertChildsNodeToAttributes(node5);
}
string data = this.XmlToConfigurationFile(input);
resourceUpdater.AddStringResource(0x2d, "SETUPRES", data);
this.DumpXmlToFile(input, "fonts.cfg.xml");
this.DumpStringToFile(data, "fonts.cfg", false);
if (codepage != -1)
{
resourceUpdater.AddStringResource(0x2d, "CODEPAGE", codepage.ToString(CultureInfo.InvariantCulture));
}
}
return true;
}
private bool BuildPackages(BuildSettings settings, XmlElement configElement, ResourceUpdater resourceUpdater, ArrayList filesCopied, Hashtable eulas)
{
bool flag = true;
foreach (ProductBuilder builder in settings.ProductBuilders)
{
if ((this.Validate && !builder.Product.ValidationPassed) && (this.results != null))
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ProductValidation", new object[] { builder.Name, builder.Product.ValidationResults.FilePath }));
foreach (string str in builder.Product.ValidationResults.ValidationErrors)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationError", new object[] { builder.Product.ValidationResults.FilePath, str }));
}
foreach (string str2 in builder.Product.ValidationResults.ValidationWarnings)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationWarning", new object[] { builder.Product.ValidationResults.FilePath, str2 }));
}
}
Package package = this.GetPackageForSettings(settings, builder, this.results);
if (package != null)
{
if ((this.Validate && !package.ValidationPassed) && (this.results != null))
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.PackageValidation", new object[] { builder.Name, package.ValidationResults.FilePath }));
foreach (string str3 in package.ValidationResults.ValidationErrors)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationError", new object[] { package.ValidationResults.FilePath, str3 }));
}
foreach (string str4 in package.ValidationResults.ValidationWarnings)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Warning, "GenerateBootstrapper.ValidationWarning", new object[] { package.ValidationResults.FilePath, str4 }));
}
}
XmlNode node = package.Node;
XmlAttribute attribute = node.Attributes["LicenseAgreement"];
XmlNodeList list = node.SelectNodes("bootstrapper:PackageFiles/bootstrapper:PackageFile", this.xmlNamespaceManager);
XmlNode subNode = node.SelectSingleNode("bootstrapper:InstallChecks", this.xmlNamespaceManager);
foreach (XmlNode node3 in list)
{
XmlAttribute namedItem = (XmlAttribute) node3.Attributes.GetNamedItem("SourcePath");
XmlAttribute attribute3 = (XmlAttribute) node3.Attributes.GetNamedItem("TargetPath");
XmlAttribute attribute4 = (XmlAttribute) node3.Attributes.GetNamedItem("Name");
XmlAttribute attribute5 = (XmlAttribute) node3.Attributes.GetNamedItem("CopyOnBuild");
if (((namedItem != null) && (attribute != null)) && (!string.IsNullOrEmpty(attribute.Value) && (namedItem.Value == attribute.Value)))
{
node.SelectSingleNode("bootstrapper:PackageFiles", this.xmlNamespaceManager).RemoveChild(node3);
}
else
{
if (((namedItem != null) && (attribute3 != null)) && !this.AddVerificationInformation(node3, namedItem.Value, attribute4.Value, builder, settings, this.results))
{
flag = false;
}
if (((namedItem != null) && (attribute3 != null)) && ((attribute5 == null) || (string.Compare(attribute5.Value, "False", StringComparison.InvariantCulture) != 0)))
{
XmlNode node5 = null;
if ((subNode != null) && (attribute4 != null))
{
node5 = this.QueryForSubNode(subNode, "PackageFile", attribute4.Value);
}
if (node5 != null)
{
if (resourceUpdater != null)
{
if (!File.Exists(namedItem.Value))
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageResourceFileNotFound", new object[] { namedItem.Value, builder.Name }));
}
flag = false;
}
else
{
resourceUpdater.AddFileResource(namedItem.Value, attribute3.Value);
}
}
}
else if ((settings.ComponentsLocation != ComponentsLocation.HomeSite) || !this.VerifyHomeSiteInformation(node3, builder, settings, this.results))
{
if (settings.CopyComponents)
{
string path = System.IO.Path.Combine(settings.OutputPath, attribute3.Value);
try
{
if (!File.Exists(namedItem.Value))
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageFileNotFound", new object[] { attribute3.Value, builder.Name }));
}
flag = false;
goto Label_06D6;
}
this.EnsureFolderExists(System.IO.Path.GetDirectoryName(path));
File.Copy(namedItem.Value, path, true);
this.ClearReadOnlyAttribute(path);
}
catch (UnauthorizedAccessException exception)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", new object[] { namedItem.Value, builder.Name, exception.Message }));
}
flag = false;
goto Label_06D6;
}
catch (IOException exception2)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", new object[] { namedItem.Value, builder.Name, exception2.Message }));
}
flag = false;
goto Label_06D6;
}
catch (ArgumentException exception3)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", new object[] { namedItem.Value, builder.Name, exception3.Message }));
}
flag = false;
goto Label_06D6;
}
catch (NotSupportedException exception4)
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.CopyPackageError", new object[] { namedItem.Value, builder.Name, exception4.Message }));
}
flag = false;
goto Label_06D6;
}
filesCopied.Add(path);
}
else
{
filesCopied.Add(namedItem.Value);
}
XmlAttribute attribute6 = node3.OwnerDocument.CreateAttribute("Size");
FileInfo info = new FileInfo(namedItem.Value);
attribute6.Value = info.Length.ToString(CultureInfo.InvariantCulture) ?? "";
this.MergeAttribute(node3, attribute6);
}
}
Label_06D6:;
}
}
if (((eulas != null) && (attribute != null)) && !string.IsNullOrEmpty(attribute.Value))
{
if (File.Exists(attribute.Value))
{
string fileHash = this.GetFileHash(attribute.Value);
if (eulas.ContainsKey(fileHash))
{
DictionaryEntry entry2 = (DictionaryEntry) eulas[fileHash];
attribute.Value = entry2.Key.ToString();
}
else
{
string key = string.Format(CultureInfo.InvariantCulture, "EULA{0}", new object[] { eulas.Count });
DictionaryEntry entry = new DictionaryEntry(key, attribute.Value);
eulas[fileHash] = entry;
attribute.Value = key;
}
}
else
{
if (this.results != null)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.PackageResourceFileNotFound", new object[] { attribute.Value, builder.Name }));
}
flag = false;
continue;
}
}
if (configElement != null)
{
configElement.AppendChild(configElement.OwnerDocument.ImportNode(node, true));
this.DumpXmlToFile(node, string.Format(CultureInfo.CurrentCulture, "{0}.{1}.xml", new object[] { package.Product.ProductCode, package.Culture }));
}
}
}
return flag;
}
public BuildResults Build(BuildSettings settings)
{
this.results = new BuildResults();
try
{
if ((settings.ApplicationFile == null) && ((settings.ProductBuilders == null) || (settings.ProductBuilders.Count == 0)))
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.InvalidInput", new object[0]));
return this.results;
}
if (string.IsNullOrEmpty(settings.OutputPath))
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.NoOutputPath", new object[0]));
return this.results;
}
if (!this.fInitialized)
{
this.Refresh();
}
if (string.IsNullOrEmpty(settings.Culture))
{
settings.Culture = this.MapLCIDToCultureName(settings.LCID);
}
if (string.IsNullOrEmpty(settings.FallbackCulture))
{
settings.FallbackCulture = this.MapLCIDToCultureName(settings.FallbackLCID);
}
this.AddBuiltProducts(settings);
ArrayList filesCopied = new ArrayList();
string strOutputExe = System.IO.Path.Combine(settings.OutputPath, "setup.exe");
if (!this.CopySetupToOutputDirectory(settings, strOutputExe))
{
return this.results;
}
ResourceUpdater resourceUpdater = new ResourceUpdater();
if (!this.BuildResources(settings, resourceUpdater))
{
return this.results;
}
this.AddStringResourceForUrl(resourceUpdater, "BASEURL", settings.ApplicationUrl, "ApplicationUrl");
this.AddStringResourceForUrl(resourceUpdater, "COMPONENTSURL", settings.ComponentsUrl, "ComponentsUrl");
this.AddStringResourceForUrl(resourceUpdater, "SUPPORTURL", settings.SupportUrl, "SupportUrl");
if (settings.ComponentsLocation == ComponentsLocation.HomeSite)
{
resourceUpdater.AddStringResource(40, "HOMESITE", true.ToString());
}
XmlElement configElement = this.document.CreateElement("Configuration");
XmlElement newChild = this.CreateApplicationElement(configElement, settings);
if (newChild != null)
{
configElement.AppendChild(newChild);
}
Hashtable eulas = new Hashtable();
if (!this.BuildPackages(settings, configElement, resourceUpdater, filesCopied, eulas))
{
return this.results;
}
this.DumpXmlToFile(configElement, "bootstrapper.cfg.xml");
string data = this.XmlToConfigurationFile(configElement);
resourceUpdater.AddStringResource(0x29, "SETUPCFG", data);
this.DumpStringToFile(data, "bootstrapper.cfg", false);
foreach (object obj2 in eulas.Values)
{
string str3;
DictionaryEntry entry = (DictionaryEntry) obj2;
FileInfo info = new FileInfo(entry.Value.ToString());
using (FileStream stream = info.OpenRead())
{
str3 = new StreamReader(stream).ReadToEnd();
}
resourceUpdater.AddStringResource(0x2c, entry.Key.ToString(), str3);
}
resourceUpdater.AddStringResource(0x2c, "COUNT", eulas.Count.ToString(CultureInfo.InvariantCulture));
if (!resourceUpdater.UpdateResources(strOutputExe, this.results))
{
return this.results;
}
this.results.SetKeyFile(strOutputExe);
string[] array = new string[filesCopied.Count];
filesCopied.CopyTo(array);
this.results.AddComponentFiles(array);
this.results.BuildSucceeded();
}
catch (Exception exception)
{
this.results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateBootstrapper.General", new object[] { exception.Message }));
}
return this.results;
}
