private static void packageGeneralFiles(DevelopmentInstallation installation, string folderPath, bool includeDatabaseUpdates)
{
// configuration files
var configurationFolderPath = EwlStatics.CombinePaths(folderPath, InstallationConfiguration.ConfigurationFolderName);
IoMethods.CopyFolder(installation.ExistingInstallationLogic.RuntimeConfiguration.ConfigurationFolderPath, configurationFolderPath, false);
IoMethods.RecursivelyRemoveReadOnlyAttributeFromItem(configurationFolderPath);
IoMethods.DeleteFolder(EwlStatics.CombinePaths(configurationFolderPath, InstallationConfiguration.InstallationConfigurationFolderName));
IoMethods.DeleteFolder(EwlStatics.CombinePaths(configurationFolderPath, ConfigurationStatics.ProvidersFolderAndNamespaceName));
if (!includeDatabaseUpdates)
{
IoMethods.DeleteFile(EwlStatics.CombinePaths(configurationFolderPath, ExistingInstallationLogic.SystemDatabaseUpdatesFileName));
}
IoMethods.DeleteFile(EwlStatics.CombinePaths(configurationFolderPath, InstallationConfiguration.SystemDevelopmentConfigurationFileName));
IoMethods.DeleteFolder(EwlStatics.CombinePaths(configurationFolderPath, ".hg")); // EWL uses a nested repository for configuration.
IoMethods.DeleteFile(EwlStatics.CombinePaths(configurationFolderPath, "Update All Dependent Logic.bat")); // EWL has this file.
// other files
var filesFolderInInstallationPath = EwlStatics.CombinePaths(
InstallationFileStatics.GetGeneralFilesFolderPath(installation.GeneralLogic.Path, true),
InstallationFileStatics.FilesFolderName);
if (Directory.Exists(filesFolderInInstallationPath))
{
IoMethods.CopyFolder(filesFolderInInstallationPath, EwlStatics.CombinePaths(folderPath, InstallationFileStatics.FilesFolderName), false);
}
}
internal static byte[] CreateEwlNuGetPackage(DevelopmentInstallation installation, bool useDebugAssembly, string outputFolderPath, bool?prerelease)
{
var localExportDateAndTime = prerelease.HasValue ? null as DateTime? : DateTime.Now;
IoMethods.ExecuteWithTempFolder(folderPath => {
var ewlOutputFolderPath = StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path,
"Standard Library",
StandardLibraryMethods.GetProjectOutputFolderPath(useDebugAssembly));
var libFolderPath = StandardLibraryMethods.CombinePaths(folderPath, @"lib\net451-full");
foreach (var fileName in new[] { "dll", "pdb", "xml" }.Select(i => "EnterpriseWebLibrary." + i))
{
IoMethods.CopyFile(StandardLibraryMethods.CombinePaths(ewlOutputFolderPath, fileName), StandardLibraryMethods.CombinePaths(libFolderPath, fileName));
}
IoMethods.CopyFile(StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path, @"Development Utility\Package Manager Console Commands.ps1"),
StandardLibraryMethods.CombinePaths(folderPath, @"tools\init.ps1"));
var webSitePath = StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path, "Web Site");
var webProjectFilesFolderPath = StandardLibraryMethods.CombinePaths(folderPath, AppStatics.WebProjectFilesFolderName);
IoMethods.CopyFolder(StandardLibraryMethods.CombinePaths(webSitePath, AppStatics.EwfFolderName),
StandardLibraryMethods.CombinePaths(webProjectFilesFolderPath, AppStatics.EwfFolderName),
false);
IoMethods.CopyFile(StandardLibraryMethods.CombinePaths(webSitePath, AppStatics.StandardLibraryFilesFileName),
StandardLibraryMethods.CombinePaths(webProjectFilesFolderPath, AppStatics.StandardLibraryFilesFileName));
const string duProjectAndFolderName = "Development Utility";
IoMethods.CopyFolder(
StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path,
duProjectAndFolderName,
StandardLibraryMethods.GetProjectOutputFolderPath(useDebugAssembly)),
StandardLibraryMethods.CombinePaths(folderPath, duProjectAndFolderName),
false);
packageGeneralFiles(installation, folderPath, false);
IoMethods.CopyFolder(
StandardLibraryMethods.CombinePaths(installation.ExistingInstallationLogic.RuntimeConfiguration.ConfigurationFolderPath,
InstallationConfiguration.InstallationConfigurationFolderName,
InstallationConfiguration.InstallationsFolderName,
(!prerelease.HasValue || prerelease.Value ? "Testing" : "Live")),
StandardLibraryMethods.CombinePaths(folderPath,
InstallationConfiguration.ConfigurationFolderName,
InstallationConfiguration.InstallationConfigurationFolderName),
false);
var manifestPath = StandardLibraryMethods.CombinePaths(folderPath, "Package.nuspec");
using (var writer = IoMethods.GetTextWriterForWrite(manifestPath))
writeNuGetPackageManifest(installation, prerelease, localExportDateAndTime, writer);
StatusStatics.SetStatus(StandardLibraryMethods.RunProgram(StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path, @"Solution Files\nuget"),
"pack \"" + manifestPath + "\" -OutputDirectory \"" + outputFolderPath + "\"",
"",
true));
});
return
(File.ReadAllBytes(StandardLibraryMethods.CombinePaths(outputFolderPath,
EwlNuGetPackageSpecificationStatics.GetNuGetPackageFileName(installation.ExistingInstallationLogic.RuntimeConfiguration.SystemShortName,
installation.CurrentMajorVersion,
!prerelease.HasValue || prerelease.Value ? installation.NextBuildNumber as int? : null,
localExportDateAndTime: localExportDateAndTime))));
}
private void copyServerSideProject(DevelopmentInstallation installation, string serverSideLogicFolderPath, string project)
{
IoMethods.CopyFolder(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, project, EwlStatics.GetProjectOutputFolderPath(false)),
EwlStatics.CombinePaths(serverSideLogicFolderPath, project),
false);
}
private void copyInWebProjectFiles(Installation installation, WebProject webProject)
{
var webProjectFilesFolderPath = StandardLibraryMethods.CombinePaths(AppTools.InstallationPath, AppStatics.WebProjectFilesFolderName);
var webProjectPath = StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path, webProject.name);
// Copy Ewf folder and customize namespaces in .aspx, .ascx, .master, and .cs files.
var webProjectEwfFolderPath = StandardLibraryMethods.CombinePaths(webProjectPath, StaticFileHandler.EwfFolderName);
IoMethods.DeleteFolder(webProjectEwfFolderPath);
IoMethods.CopyFolder(StandardLibraryMethods.CombinePaths(webProjectFilesFolderPath, StaticFileHandler.EwfFolderName), webProjectEwfFolderPath, false);
IoMethods.RecursivelyRemoveReadOnlyAttributeFromItem(webProjectEwfFolderPath);
var matchingFiles = new List <string>();
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.aspx", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.ascx", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.master", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.cs", SearchOption.AllDirectories));
foreach (var filePath in matchingFiles)
{
File.WriteAllText(filePath, customizeNamespace(File.ReadAllText(filePath), webProject));
}
IoMethods.CopyFile(
StandardLibraryMethods.CombinePaths(webProjectFilesFolderPath, AppStatics.StandardLibraryFilesFileName),
StandardLibraryMethods.CombinePaths(webProjectPath, AppStatics.StandardLibraryFilesFileName));
IoMethods.RecursivelyRemoveReadOnlyAttributeFromItem(StandardLibraryMethods.CombinePaths(webProjectPath, AppStatics.StandardLibraryFilesFileName));
}
private void copyInEwlFiles(DevelopmentInstallation installation)
{
if (installation is RecognizedDevelopmentInstallation recognizedInstallation)
{
recognizedInstallation.KnownSystemLogic.DownloadAsposeLicenses(installation.ExistingInstallationLogic.RuntimeConfiguration.ConfigurationFolderPath);
}
if (installation.DevelopmentInstallationLogic.SystemIsEwl)
{
foreach (var fileName in GlobalStatics.ConfigurationXsdFileNames)
{
IoMethods.CopyFile(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, EwlStatics.CoreProjectName, "Configuration", fileName + FileExtensions.Xsd),
EwlStatics.CombinePaths(
InstallationFileStatics.GetGeneralFilesFolderPath(installation.GeneralLogic.Path, true),
InstallationFileStatics.FilesFolderName,
fileName + FileExtensions.Xsd));
}
}
else
{
// If web projects exist for this installation, copy in web-framework static files.
if (installation.DevelopmentInstallationLogic.DevelopmentConfiguration.webProjects != null)
{
var webFrameworkStaticFilesFolderPath = EwlStatics.CombinePaths(
installation.GeneralLogic.Path,
InstallationFileStatics.WebFrameworkStaticFilesFolderName);
IoMethods.DeleteFolder(webFrameworkStaticFilesFolderPath);
IoMethods.CopyFolder(
EwlStatics.CombinePaths(ConfigurationStatics.InstallationPath, InstallationFileStatics.WebFrameworkStaticFilesFolderName),
webFrameworkStaticFilesFolderPath,
false);
}
}
}
private void packageClientSideApp(DevelopmentInstallation installation, string clientSideAppFolder)
{
IoMethods.CopyFolder(
StandardLibraryMethods.CombinePaths(installation.GeneralLogic.Path,
installation.DevelopmentInstallationLogic.DevelopmentConfiguration.clientSideAppProject.name,
StandardLibraryMethods.GetProjectOutputFolderPath(false)),
StandardLibraryMethods.CombinePaths(clientSideAppFolder, installation.DevelopmentInstallationLogic.DevelopmentConfiguration.clientSideAppProject.name),
false);
}
private void packageWindowsServices(DevelopmentInstallation installation, string serverSideLogicFolderPath)
{
foreach (var service in installation.ExistingInstallationLogic.RuntimeConfiguration.WindowsServices)
{
IoMethods.CopyFolder(installation.ExistingInstallationLogic.GetWindowsServiceFolderPath(service, false),
StandardLibraryMethods.CombinePaths(serverSideLogicFolderPath, service.Name),
false);
}
}
private void copyInWebProjectFiles(Installation installation, WebProject webProject)
{
var webProjectFilesFolderPath = EwlStatics.CombinePaths(ConfigurationStatics.InstallationPath, AppStatics.WebProjectFilesFolderName);
var webProjectPath = EwlStatics.CombinePaths(installation.GeneralLogic.Path, webProject.name);
// Copy Ewf folder and customize namespaces in .aspx, .ascx, .master, and .cs files.
var webProjectEwfFolderPath = EwlStatics.CombinePaths(webProjectPath, StaticFileHandler.EwfFolderName);
IoMethods.DeleteFolder(webProjectEwfFolderPath);
IoMethods.CopyFolder(EwlStatics.CombinePaths(webProjectFilesFolderPath, StaticFileHandler.EwfFolderName), webProjectEwfFolderPath, false);
IoMethods.RecursivelyRemoveReadOnlyAttributeFromItem(webProjectEwfFolderPath);
var matchingFiles = new List <string>();
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.aspx", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.ascx", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.master", SearchOption.AllDirectories));
matchingFiles.AddRange(Directory.GetFiles(webProjectEwfFolderPath, "*.cs", SearchOption.AllDirectories));
foreach (var filePath in matchingFiles)
{
File.WriteAllText(filePath, customizeNamespace(File.ReadAllText(filePath), webProject));
}
IoMethods.CopyFile(
EwlStatics.CombinePaths(webProjectFilesFolderPath, AppStatics.StandardLibraryFilesFileName),
EwlStatics.CombinePaths(webProjectPath, AppStatics.StandardLibraryFilesFileName));
IoMethods.RecursivelyRemoveReadOnlyAttributeFromItem(EwlStatics.CombinePaths(webProjectPath, AppStatics.StandardLibraryFilesFileName));
// Add the Import element to the project file if it's not already present.
var projectDocument = new XmlDocument {
PreserveWhitespace = true
};
var projectDocumentPath = EwlStatics.CombinePaths(webProjectPath, "{0}.csproj".FormatWith(webProject.name));
projectDocument.Load(projectDocumentPath);
var projectElement = projectDocument["Project"];
const string webProjectFilesFileName = "Standard Library Files.xml";
var namespaceManager = new XmlNamespaceManager(projectDocument.NameTable);
const string ns = "http://schemas.microsoft.com/developer/msbuild/2003";
namespaceManager.AddNamespace("p", ns);
if (projectElement.SelectSingleNode("p:Import[ @Project = \"{0}\" ]".FormatWith(webProjectFilesFileName), namespaceManager) == null)
{
var importElement = projectDocument.CreateElement("Import", ns);
importElement.SetAttribute("Project", webProjectFilesFileName);
projectElement.AppendChild(importElement);
projectDocument.Save(projectDocumentPath);
}
}
private static int Main(string[] args)
{
GlobalInitializationOps.InitStatics(new GlobalInitializer(), "Development Utility", true);
try {
return(GlobalInitializationOps.ExecuteAppWithStandardExceptionHandling(
() => {
try {
AppStatics.Init();
if (args.Length < 2)
{
throw new UserCorrectableException("You must specify the installation path as the first argument and the operation name as the second.");
}
// Create installations folder from template if necessary.
var installationPath = args[0];
var templateFolderPath = getInstallationsFolderPath(installationPath, true);
var message = "";
if (!Directory.Exists(templateFolderPath))
{
message = "No installation-configuration template exists.";
}
else
{
var configurationFolderPath = getInstallationsFolderPath(installationPath, false);
if (IoMethods.GetFilePathsInFolder(configurationFolderPath, searchOption: SearchOption.AllDirectories).Any())
{
message = "Installation configuration already exists.";
}
else
{
IoMethods.CopyFolder(templateFolderPath, configurationFolderPath, false);
Console.WriteLine("Created installation configuration from template.");
}
}
if (args[1] == "CreateInstallationConfiguration")
{
if (message.Any())
{
throw new UserCorrectableException(message);
}
return;
}
// Get installation.
DevelopmentInstallation installation;
try {
installation = getInstallation(installationPath);
}
catch (Exception e) {
throw new UserCorrectableException("The installation at \"" + installationPath + "\" is invalid.", e);
}
// Get operation.
var operations = AssemblyTools.BuildSingletonDictionary <Operation, string>(Assembly.GetExecutingAssembly(), i => i.GetType().Name);
var operationName = args[1];
if (!operations.ContainsKey(operationName))
{
throw new UserCorrectableException(operationName + " is not a known operation.");
}
var operation = operations[operationName];
if (!operation.IsValid(installation))
{
throw new UserCorrectableException("The " + operation.GetType().Name + " operation cannot be performed on this installation.");
}
operation.Execute(installation, args.Skip(2).ToImmutableArray(), new OperationResult());
}
catch (Exception e) {
Output.WriteTimeStampedError(e.ToString());
if (e is UserCorrectableException)
{
throw new DoNotEmailOrLogException();
}
throw;
}
}));
}
finally {
GlobalInitializationOps.CleanUpStatics();
}
}
internal static IReadOnlyCollection <(string id, IReadOnlyList <byte[]> packages)> CreateEwlNuGetPackages(
DevelopmentInstallation installation, PackagingConfiguration packagingConfiguration, bool useDebugAssembly, string outputFolderPath,
IEnumerable <bool?> prereleaseValues)
{
var now = DateTime.Now;
var packages = new List <(string, IReadOnlyList <byte[]>)>();
var mainId = packagingConfiguration.SystemShortName;
var mainPackages = prereleaseValues.Select(
prerelease => {
var localExportDateAndTime = prerelease.HasValue ? (DateTime?)null : now;
IoMethods.ExecuteWithTempFolder(
folderPath => {
var ewlOutputFolderPath = EwlStatics.CombinePaths(
installation.GeneralLogic.Path,
EwlStatics.CoreProjectName,
EwlStatics.GetProjectOutputFolderPath(useDebugAssembly));
var libFolderPath = EwlStatics.CombinePaths(folderPath, @"lib\net472-full");
foreach (var fileName in new[] { "dll", "pdb", "xml" }.Select(i => "EnterpriseWebLibrary." + i))
{
IoMethods.CopyFile(EwlStatics.CombinePaths(ewlOutputFolderPath, fileName), EwlStatics.CombinePaths(libFolderPath, fileName));
}
IoMethods.CopyFile(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, @"Development Utility\Package Manager Console Commands.ps1"),
EwlStatics.CombinePaths(folderPath, @"tools\init.ps1"));
IoMethods.CopyFolder(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, EwlStatics.CoreProjectName, StaticFile.FrameworkStaticFilesSourceFolderPath),
EwlStatics.CombinePaths(folderPath, InstallationFileStatics.WebFrameworkStaticFilesFolderName),
false);
IoMethods.DeleteFolder(
EwlStatics.CombinePaths(folderPath, InstallationFileStatics.WebFrameworkStaticFilesFolderName, AppStatics.StaticFileLogicFolderName));
const string duProjectAndFolderName = "Development Utility";
IoMethods.CopyFolder(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, duProjectAndFolderName, EwlStatics.GetProjectOutputFolderPath(useDebugAssembly)),
EwlStatics.CombinePaths(folderPath, duProjectAndFolderName),
false);
packageGeneralFiles(installation, folderPath, false);
IoMethods.CopyFolder(
EwlStatics.CombinePaths(
installation.ExistingInstallationLogic.RuntimeConfiguration.ConfigurationFolderPath,
InstallationConfiguration.InstallationConfigurationFolderName,
InstallationConfiguration.InstallationsFolderName,
!prerelease.HasValue || prerelease.Value ? "Testing" : "Live"),
EwlStatics.CombinePaths(
folderPath,
InstallationConfiguration.ConfigurationFolderName,
InstallationConfiguration.InstallationConfigurationFolderName),
false);
if (File.Exists(installation.ExistingInstallationLogic.RuntimeConfiguration.InstallationSharedConfigurationFilePath))
{
IoMethods.CopyFile(
installation.ExistingInstallationLogic.RuntimeConfiguration.InstallationSharedConfigurationFilePath,
EwlStatics.CombinePaths(
folderPath,
InstallationConfiguration.ConfigurationFolderName,
InstallationConfiguration.InstallationConfigurationFolderName,
InstallationConfiguration.InstallationSharedConfigurationFileName));
}
var manifestPath = EwlStatics.CombinePaths(folderPath, "Package.nuspec");
using (var writer = IoMethods.GetTextWriterForWrite(manifestPath))
writeNuGetPackageManifest(
writer,
installation,
mainId,
"",
w => {
var lines = from line in File.ReadAllLines(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, EwlStatics.CoreProjectName, "packages.config"))
let trimmedLine = line.Trim()
where trimmedLine.StartsWith("<package ")
select trimmedLine;
foreach (var line in lines)
{
w.WriteLine(Regex.Replace(line.Replace("package", "dependency"), @" targetFramework=""[\w]+""", ""));
}
},
prerelease,
localExportDateAndTime);
StatusStatics.SetStatus(
TewlContrib.ProcessTools.RunProgram(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, @"Solution Files\nuget"),
"pack \"" + manifestPath + "\" -OutputDirectory \"" + outputFolderPath + "\"",
"",
true));
});
return(File.ReadAllBytes(
EwlStatics.CombinePaths(
outputFolderPath,
EwlNuGetPackageSpecificationStatics.GetNuGetPackageFileName(
mainId,
installation.CurrentMajorVersion,
!prerelease.HasValue || prerelease.Value ? installation.NextBuildNumber as int? : null,
localExportDateAndTime: localExportDateAndTime))));
})
.MaterializeAsList();
packages.Add((mainId, mainPackages));
var samlId = mainId + ".Saml";
var samlPackages = prereleaseValues.Select(
prerelease => {
var localExportDateAndTime = prerelease.HasValue ? (DateTime?)null : now;
IoMethods.ExecuteWithTempFolder(
folderPath => {
foreach (var fileName in new[] { "dll", "pdb" }.Select(i => "EnterpriseWebLibrary.Saml." + i))
{
IoMethods.CopyFile(
EwlStatics.CombinePaths(
installation.GeneralLogic.Path,
EwlStatics.SamlProviderProjectPath,
EwlStatics.GetProjectOutputFolderPath(useDebugAssembly),
fileName),
EwlStatics.CombinePaths(folderPath, @"lib\net472-full", fileName));
}
var manifestPath = EwlStatics.CombinePaths(folderPath, "Package.nuspec");
using (var writer = IoMethods.GetTextWriterForWrite(manifestPath))
writeNuGetPackageManifest(
writer,
installation,
samlId,
"SAML Provider",
w => {
w.WriteLine(
"<dependency id=\"{0}\" version=\"[{1}]\" />".FormatWith(
mainId,
EwlNuGetPackageSpecificationStatics.GetNuGetPackageVersionString(
installation.CurrentMajorVersion,
!prerelease.HasValue || prerelease.Value ? (int?)installation.NextBuildNumber : null,
localExportDateAndTime: localExportDateAndTime)));
w.WriteLine("<dependency id=\"ComponentSpace.Saml2.Net.Licensed\" version=\"5.0.0\" />");
},
prerelease,
localExportDateAndTime);
StatusStatics.SetStatus(
TewlContrib.ProcessTools.RunProgram(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, @"Solution Files\nuget"),
"pack \"" + manifestPath + "\" -OutputDirectory \"" + outputFolderPath + "\"",
"",
true));
});
return(File.ReadAllBytes(
EwlStatics.CombinePaths(
outputFolderPath,
EwlNuGetPackageSpecificationStatics.GetNuGetPackageFileName(
samlId,
installation.CurrentMajorVersion,
!prerelease.HasValue || prerelease.Value ? installation.NextBuildNumber as int? : null,
localExportDateAndTime: localExportDateAndTime))));
})
.MaterializeAsList();
packages.Add((samlId, samlPackages));
return(packages);
}
private void packageWebApps(DevelopmentInstallation installation, string serverSideLogicFolderPath)
{
// NOTE: When packaging web apps, try to find a way to exclude data files. Apparently web deployment projects include these in their output even though
// they aren't part of the source web projects. NOTE ON NOTE: We don't use WDPs anymore, so maybe we can eliminate this note.
foreach (var webProject in installation.DevelopmentInstallationLogic.DevelopmentConfiguration.webProjects ?? new WebProject[0])
{
var webAppPath = EwlStatics.CombinePaths(serverSideLogicFolderPath, webProject.name);
// Pre-compile the web project.
try {
TewlContrib.ProcessTools.RunProgram(
EwlStatics.CombinePaths(RuntimeEnvironment.GetRuntimeDirectory(), "aspnet_compiler"),
"-v \"/" + webProject.name + ".csproj\" -p \"" + EwlStatics.CombinePaths(installation.GeneralLogic.Path, webProject.name) + "\" " +
(webProject.IsUpdateableWhenInstalledSpecified && webProject.IsUpdateableWhenInstalled ? "-u " : "") + "-f \"" + webAppPath + "\"",
"",
true);
}
catch (Exception e) {
throw new UserCorrectableException("ASP.NET pre-compilation failed for web project " + webProject.name + ".", e);
}
try {
TewlContrib.ProcessTools.RunProgram(
EwlStatics.CombinePaths(AppStatics.DotNetToolsFolderPath, "aspnet_merge"),
"\"" + webAppPath + "\" -o " + webProject.NamespaceAndAssemblyName + ".Package -a -copyattrs",
"",
true);
}
catch (Exception e) {
throw new UserCorrectableException("ASP.NET Merge Tool failed for web project " + webProject.name + ".", e);
}
// Delete files and folders that aren't necessary for installed installations.
IoMethods.DeleteFolder(EwlStatics.CombinePaths(webAppPath, "Generated Code"));
IoMethods.DeleteFolder(EwlStatics.CombinePaths(webAppPath, "obj"));
IoMethods.DeleteFile(EwlStatics.CombinePaths(webAppPath, webProject.name + ".csproj"));
IoMethods.DeleteFile(EwlStatics.CombinePaths(webAppPath, webProject.name + ".csproj.user"));
IoMethods.DeleteFile(EwlStatics.CombinePaths(webAppPath, webProject.name + ".csproj.vspscc"));
var webConfigPath = EwlStatics.CombinePaths(webAppPath, WebApplication.WebConfigFileName);
File.WriteAllText(webConfigPath, File.ReadAllText(webConfigPath).Replace("debug=\"true\"", "debug=\"false\""));
}
if (installation.DevelopmentInstallationLogic.SystemIsEwl)
{
IoMethods.CopyFolder(
EwlStatics.CombinePaths(installation.GeneralLogic.Path, EwlStatics.CoreProjectName, StaticFile.FrameworkStaticFilesSourceFolderPath),
EwlStatics.CombinePaths(serverSideLogicFolderPath, InstallationFileStatics.WebFrameworkStaticFilesFolderName),
false);
IoMethods.DeleteFolder(
EwlStatics.CombinePaths(
serverSideLogicFolderPath,
InstallationFileStatics.WebFrameworkStaticFilesFolderName,
AppStatics.StaticFileLogicFolderName));
}
else
{
var frameworkStaticFilesFolderPath = EwlStatics.CombinePaths(
installation.GeneralLogic.Path,
InstallationFileStatics.WebFrameworkStaticFilesFolderName);
if (Directory.Exists(frameworkStaticFilesFolderPath))
{
IoMethods.CopyFolder(
frameworkStaticFilesFolderPath,
EwlStatics.CombinePaths(serverSideLogicFolderPath, InstallationFileStatics.WebFrameworkStaticFilesFolderName),
false);
}
}
}
void Operation.Execute(Installation genericInstallation, IReadOnlyList <string> arguments, OperationResult operationResult)
{
var installation = genericInstallation as DevelopmentInstallation;
var packagingConfiguration = GetPackagingConfiguration(installation);
var logicPackagesFolderPath = EwlStatics.CombinePaths(installation.GeneralLogic.Path, "Logic Packages");
IoMethods.DeleteFolder(logicPackagesFolderPath);
// Set up the main (build) object in the build message.
var build = new InstallationSupportUtility.SystemManagerInterface.Messages.BuildMessage.Build();
build.SystemName = packagingConfiguration.SystemName;
build.SystemShortName = packagingConfiguration.SystemShortName;
build.MajorVersion = installation.CurrentMajorVersion;
build.BuildNumber = installation.NextBuildNumber;
var hgOutput = Directory.Exists(EwlStatics.CombinePaths(installation.GeneralLogic.Path, AppStatics.MercurialRepositoryFolderName))
? TewlContrib.ProcessTools.RunProgram(
@"C:\Program Files\TortoiseHg\hg",
"--debug identify --id \"{0}\"".FormatWith(installation.GeneralLogic.Path),
"",
true)
.Trim()
: "";
build.HgChangesetId = hgOutput.Length == 40 ? hgOutput : "";
build.LogicSize = AppStatics.NDependIsPresent && !installation.DevelopmentInstallationLogic.SystemIsEwl
? GetLogicSize.GetNDependLocCount(installation, false) as int?
: null;
var serverSideLogicFolderPath = EwlStatics.CombinePaths(logicPackagesFolderPath, "Server Side Logic");
packageWebApps(installation, serverSideLogicFolderPath);
packageWindowsServices(installation, serverSideLogicFolderPath);
packageServerSideConsoleApps(installation, serverSideLogicFolderPath);
packageGeneralFiles(installation, serverSideLogicFolderPath, true);
build.ServerSideLogicPackage = ZipOps.ZipFolderAsByteArray(serverSideLogicFolderPath);
operationResult.NumberOfBytesTransferred = build.ServerSideLogicPackage.LongLength;
// Set up the client side application object in the build message, if necessary.
if (installation.DevelopmentInstallationLogic.DevelopmentConfiguration.clientSideAppProject != null)
{
build.ClientSideApp = new InstallationSupportUtility.SystemManagerInterface.Messages.BuildMessage.Build.ClientSideAppType();
build.ClientSideApp.Name = installation.DevelopmentInstallationLogic.DevelopmentConfiguration.clientSideAppProject.name;
build.ClientSideApp.AssemblyName = installation.DevelopmentInstallationLogic.DevelopmentConfiguration.clientSideAppProject.assemblyName;
var clientSideAppFolder = EwlStatics.CombinePaths(logicPackagesFolderPath, "Client Side Application");
packageClientSideApp(installation, clientSideAppFolder);
packageGeneralFiles(installation, clientSideAppFolder, false);
build.ClientSideApp.Package = ZipOps.ZipFolderAsByteArray(clientSideAppFolder);
operationResult.NumberOfBytesTransferred += build.ClientSideApp.Package.LongLength;
}
// Set up the list of installation objects in the build message.
build.Installations = new InstallationSupportUtility.SystemManagerInterface.Messages.BuildMessage.Build.InstallationsType();
foreach (var installationConfigurationFolderPath in Directory.GetDirectories(
EwlStatics.CombinePaths(
installation.ExistingInstallationLogic.RuntimeConfiguration.ConfigurationFolderPath,
InstallationConfiguration.InstallationConfigurationFolderName,
InstallationConfiguration.InstallationsFolderName)))
{
if (!new[] { InstallationConfiguration.DevelopmentInstallationFolderName, AppStatics.MercurialRepositoryFolderName }.Contains(
Path.GetFileName(installationConfigurationFolderPath)))
{
var buildMessageInstallation = new InstallationSupportUtility.SystemManagerInterface.Messages.BuildMessage.Installation();
// Do not perform schema validation since the schema file on disk may not match this version of the ISU.
var installationConfigurationFile = XmlOps.DeserializeFromFile <InstallationStandardConfiguration>(
EwlStatics.CombinePaths(installationConfigurationFolderPath, InstallationConfiguration.InstallationStandardConfigurationFileName),
false);
buildMessageInstallation.Id = installationConfigurationFile.rsisInstallationId;
buildMessageInstallation.Name = installationConfigurationFile.installedInstallation.name;
buildMessageInstallation.ShortName = installationConfigurationFile.installedInstallation.shortName;
buildMessageInstallation.IsLiveInstallation =
installationConfigurationFile.installedInstallation.InstallationTypeConfiguration is LiveInstallationConfiguration;
var packageFolderPath = EwlStatics.CombinePaths(
logicPackagesFolderPath,
$"{installationConfigurationFile.installedInstallation.name} Configuration");
IoMethods.CopyFolder(installationConfigurationFolderPath, packageFolderPath, false);
if (File.Exists(installation.ExistingInstallationLogic.RuntimeConfiguration.InstallationSharedConfigurationFilePath))
{
IoMethods.CopyFile(
installation.ExistingInstallationLogic.RuntimeConfiguration.InstallationSharedConfigurationFilePath,
EwlStatics.CombinePaths(packageFolderPath, InstallationConfiguration.InstallationSharedConfigurationFileName));
}
buildMessageInstallation.ConfigurationPackage = ZipOps.ZipFolderAsByteArray(packageFolderPath);
build.Installations.Add(buildMessageInstallation);
operationResult.NumberOfBytesTransferred += buildMessageInstallation.ConfigurationPackage.LongLength;
}
}
build.NuGetPackages = new InstallationSupportUtility.SystemManagerInterface.Messages.BuildMessage.Build.NuGetPackagesType();
if (installation.DevelopmentInstallationLogic.SystemIsEwl)
{
build.NuGetPackages.AddRange(packageEwl(installation, packagingConfiguration, logicPackagesFolderPath));
}
var recognizedInstallation = installation as RecognizedDevelopmentInstallation;
if (recognizedInstallation == null)
{
return;
}
build.SystemId = recognizedInstallation.KnownSystemLogic.RsisSystem.Id;
operationResult.TimeSpentWaitingForNetwork = EwlStatics.ExecuteTimedRegion(
delegate {
using (var memoryStream = new MemoryStream()) {
// Understand that by doing this, we are not really taking advantage of streaming, but at least it will be easier to do it the right way some day (probably by implementing our own BuildMessageStream)
XmlOps.SerializeIntoStream(build, memoryStream);
memoryStream.Position = 0;
ConfigurationLogic.ExecuteIsuServiceMethod(
channel => channel.UploadBuild(
new InstallationSupportUtility.SystemManagerInterface.Messages.BuildUploadMessage
{
AuthenticationKey = ConfigurationLogic.SystemManagerAccessToken, BuildDocument = memoryStream
}),
"build upload");
}
});
}