public async Task Publish_by_msbuild_Test()
{
// Given
var solutionDir = FileIO.FindContainerDirToAncestor("*.sln");
var srcDir = Path.Combine(solutionDir, "SampleApps", "BlazorWasmApp0");
using var workDir = WorkDirectory.CreateCopyFrom(srcDir, dst => dst.Name is not "obj" and not "bin");
for (var i = 0; i < 2; i++)
{
Console.WriteLine($"{(i == 0 ? "1st" : "2nd")} time publishing...");
// When
await XProcess.Start("dotnet", "restore", workDir).WaitForExitAsync();
var dotnetCLI = await XProcess.Start("dotnet", "msbuild -p:Configuration=Debug -p:BlazorEnableCompression=false -p:DeployOnBuild=true -p:PublishUrl=bin/publish", workDir).WaitForExitAsync();
dotnetCLI.ExitCode.Is(0, message: dotnetCLI.StdOutput + dotnetCLI.StdError);
// Then
// Validate prerendered contents.
var wwwrootDir = Path.Combine(workDir, "bin", "publish", "wwwroot");
ValidatePrerenderedContents_of_BlazorWasmApp0(wwwrootDir);
}
}
public static WorkDirectory CreateSampleAppsWorkDir()
{
var solutionDir = FileIO.FindContainerDirToAncestor("*.sln");
var srcSampleAppsDir = Path.Combine(solutionDir, "SampleApps");
return(WorkDirectory.CreateCopyFrom(srcSampleAppsDir, arg => arg.Name is (not "obj" and not "bin")));
}
public async Task Publish_with_SingleFileEnabled_Test()
{
var rid = "win-x64";
var driverFileName = "chromedriver.exe";
var executableFileFormat = Format.PE32;
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
using var workDir = WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "Project"), predicate: item => item.Name is not "obj" and not "bin");
var publishCommand = new[] {
"dotnet", "publish", "-r", rid, "-o", "out",
"-c:Release",
"-p:PublishChromeDriver=true",
"-p:PublishSingleFile=true",
"-p:SelfContained=false"
};
// IMPORTANT: 2nd time of publishing, sometimes lost driver file in the published folder, so we have to validate it..
for (var i = 0; i < 2; i++)
{
using var dotnet = await XProcess.Start(
filename : publishCommand.First(),
arguments : String.Join(' ', publishCommand.Skip(1)),
workDir).WaitForExitAsync();
dotnet.ExitCode.Is(0);
var driverFullPath = Path.Combine(workDir, "out", driverFileName);
File.Exists(driverFullPath).IsTrue();
DetectFormat(driverFullPath).Is(executableFileFormat);
}
}
private void CreateOrUnloadEngine()
{
if (mEngineCreationDisabled)
{
return;
}
// don't do anything when the engine was never loaded to begin with
if (WorkDirectory.IsNullOrEmpty() && Engine == null)
{
return;
}
var eventAggregator = IoC.Get <IEventAggregator>();
bool unload = Engine != null;
bool reload = unload && WorkDirectory.IsNotNullOrEmpty();
bool load = !unload && WorkDirectory.IsNotNullOrEmpty();
if (unload)
{
Engine = null;
eventAggregator.PublishOnUIThread(new ProjectEngineUnloadedEventArgs());
}
if (reload || load)
{
var engine = KSoft.Phoenix.Engine.PhxEngine.CreateForHaloWars(
WorkDirectory, WorkDirectory,
GameVersion == GameVersionType.Xbox360);
Engine = engine;
eventAggregator.PublishOnUIThread(new ProjectEngineCreatedEventArgs(Engine));
}
}
public void BuildPrerenderingOptions_Test()
{
// Given
using var workFolder = new WorkDirectory();
var cmdlineOptions = new CommandLineOptions
{
IntermediateDir = workFolder,
PublishedDir = workFolder,
AssemblyName = "BlazorWasmApp1",
TypeNameOfRootComponent = "BlazorWasmApp1.App",
SelectorOfRootComponent = "#app",
MiddlewarePackages = "",
FrameworkName = "net5.0",
};
Directory.CreateDirectory(Path.Combine(cmdlineOptions.PublishedDir, "wwwroot", "_framework"));
File.Copy(sourceFileName: Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "BlazorWasmApp1.dll"),
destFileName: Path.Combine(cmdlineOptions.PublishedDir, "wwwroot", "_framework", "BlazorWasmApp1.dll"));
File.Copy(sourceFileName: Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "index.html"),
destFileName: Path.Combine(cmdlineOptions.PublishedDir, "wwwroot", "index.html"));
// When
var options = Program.BuildPrerenderingOptions(new CustomAssemblyLoader(), cmdlineOptions);
// Then
options.RootComponentType.FullName.Is("BlazorWasmApp1.App");
}
public async Task Output_of_ProjectB_Contains_DriverFile_Test()
{
var vsAppDir = Environment.GetEnvironmentVariable("VSAPPIDDIR");
if (vsAppDir == null)
{
Assert.Inconclusive(@"This test requires Visual Studio and the definition of the ""VSAPPDIR"" environment variable to point out the directory where Visual Studio ""devenv.exe"" exists. (ex: VSAPPDIR=C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\)");
}
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
using var workDir = WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "ProjectAB"), item => item.Name is not "obj" and not "bin");
var nuget = Path.Combine(unitTestProjectDir, "..", "buildTools", "nuget.exe");
var devenv = Path.Combine(vsAppDir, "devenv.exe");
await XProcess.Start(nuget, "restore", workDir).ExitCodeIs(0);
await XProcess.Start(devenv, "ProjectAB.sln /Build", workDir).ExitCodeIs(0);
var outDir = Path.Combine(workDir, "ProjectB", "bin", "Debug", "net472");
var driverFullPath1 = Path.Combine(outDir, "geckodriver");
var driverFullPath2 = Path.Combine(outDir, "geckodriver.exe");
(File.Exists(driverFullPath1) || File.Exists(driverFullPath2)).IsTrue();
}
/* ----------------------------------------------------------------- */
///
/// Invoke
///
/// <summary>
/// 作業ディレクトリを設定した後 Action を実行します。
/// </summary>
///
/* ----------------------------------------------------------------- */
private void Invoke(Action action, string dest)
{
var name = "TEMP";
var prev = Environment.GetEnvironmentVariable(name);
try
{
var info = IO.Get(dest);
if (!IO.Exists(info.DirectoryName))
{
IO.CreateDirectory(info.DirectoryName);
}
if (WorkDirectory.HasValue())
{
if (!IO.Exists(WorkDirectory))
{
IO.CreateDirectory(WorkDirectory);
}
SetVariable(name, WorkDirectory);
}
action();
}
finally { SetVariable(name, prev); }
}
public async Task Publish_Test()
{
// Given
var solutionDir = FileIO.FindContainerDirToAncestor("*.sln");
var srcDir = Path.Combine(solutionDir, "SampleApps", "BlazorWasmApp0");
using var workDir = WorkDirectory.CreateCopyFrom(srcDir, dst => dst.Name is not "obj" and not "bin");
var expectedHomeTitles = new Dictionary <int, string> {
[1] = "Home", [2] = "My Home"
};
var expectedEnvNames = new Dictionary <int, string> {
[1] = "Prerendering", [2] = "Foo"
};
for (var i = 1; i <= 2; i++)
{
Console.WriteLine($"{(i == 1 ? "1st" : "2nd")} time publishing...");
// When
var arg = "publish -c:Debug -p:BlazorEnableCompression=false -o:bin/publish";
// if 2nd time publishing, override the environment name.
if (i == 2)
{
arg += " -p:BlazorWasmPrerenderingEnvironment=" + expectedEnvNames[2];
}
var dotnetCLI = await XProcess.Start("dotnet", arg, workDir).WaitForExitAsync();
dotnetCLI.ExitCode.Is(0, message: dotnetCLI.StdOutput + dotnetCLI.StdError);
// Then
// Validate prerendered contents.
var wwwrootDir = Path.Combine(workDir, "bin", "publish", "wwwroot");
ValidatePrerenderedContents_of_BlazorWasmApp0(
wwwrootDir,
homeTitle: expectedHomeTitles[i],
environment: expectedEnvNames[i]);
// Validate PWA assets manifest.
var indexHtmlBytes = File.ReadAllBytes(Path.Combine(wwwrootDir, "index.html"));
using var sha256 = SHA256.Create();
var hash = "sha256-" + Convert.ToBase64String(sha256.ComputeHash(indexHtmlBytes));
var serviceWorkerAssetsJs = File.ReadAllText(Path.Combine(wwwrootDir, "my-assets.js"));
serviceWorkerAssetsJs = Regex.Replace(serviceWorkerAssetsJs, @"^self\.assetsManifest\s*=\s*", "");
serviceWorkerAssetsJs = Regex.Replace(serviceWorkerAssetsJs, ";\\s*$", "");
var assetsManifestFile = JsonSerializer.Deserialize <AssetsManifestFile>(serviceWorkerAssetsJs);
var assetManifestEntry = assetsManifestFile?.assets?.First(a => a.url == "index.html");
assetManifestEntry.IsNotNull();
assetManifestEntry !.hash.Is(hash);
}
}
public void GenerateProjectToGetMiddleware_IfEmpty_Test()
{
// Given
using var workFolder = new WorkDirectory();
var middlewarePackages = Enumerable.Empty <MiddlewarePackageReference>();
// When
var outputDir = Program.GenerateProjectToGetMiddleware(middlewarePackages, workFolder, "net5.0");
// Then
outputDir.IsNull();
}
public async Task PublishWithRuntimeIdentifier_NoPublish_Test(string rid, string driverFileName, Format _)
{
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
using var workDir = WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "Project"), predicate: item => item.Name is not "obj" and not "bin");
using var dotnet = await XProcess.Start("dotnet", $"publish -r {rid} -o out", workDir).WaitForExitAsync();
dotnet.ExitCode.Is(0);
var driverFullPath = Path.Combine(workDir, "out", driverFileName);
File.Exists(driverFullPath).IsFalse();
}
public async Task Publish_with_HTTP500_Test()
{
// Given
var solutionDir = FileIO.FindContainerDirToAncestor("*.sln");
var srcDir = Path.Combine(solutionDir, "SampleApps", "BlazorWasmApp1");
using var workDir = WorkDirectory.CreateCopyFrom(srcDir, dst => dst.Name is not "obj" and not "bin");
// When (Set the hoting environment name to "ExceptionTest")
var dotnetCLI = await XProcess.Start("dotnet", "publish -c:Release -p:BlazorWasmPrerenderingEnvironment=ExceptionTest -p:BlazorEnableCompression=false --nologo", workDir).WaitForExitAsync();
// Then (Exit code is NOT 0)
dotnetCLI.ExitCode.IsNot(0, message: dotnetCLI.Output);
}
public async ValueTask <WorkDirectory> PublishAsync()
{
if (!this.PublishedOnce)
{
var publishProcess = XProcess.Start(
"dotnet",
$"publish -c:{this.Configuration} -p:BlazorWasmPrerendering=disable -p:BlazorEnableCompression=false -p:UsingBrowserRuntimeWorkload=false",
workingDirectory: this.ProjectDir);
await publishProcess.WaitForExitAsync();
publishProcess.ExitCode.Is(0, message: publishProcess.StdOutput + publishProcess.StdError);
this.PublishedOnce = true;
}
return(WorkDirectory.CreateCopyFrom(this.PublishSrcDir, _ => true));
}
public async Task PublishWithRuntimeIdentifier_with_DefineConstants_Test(string rid, string driverFileName, Format executableFileFormat)
{
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
using var workDir = WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "Project"), predicate: item => item.Name is not "obj" and not "bin");
using var dotnet = await XProcess.Start("dotnet", $"publish -r {rid} -o out -p:DefineConstants=_PUBLISH_CHROMEDRIVER", workDir).WaitForExitAsync();
dotnet.ExitCode.Is(0);
var driverFullPath = Path.Combine(workDir, "out", driverFileName);
File.Exists(driverFullPath).IsTrue();
DetectFormat(driverFullPath).Is(executableFileFormat);
}
public WorkSpace(string startupProjDir, string framework, string configuration)
{
this.WorkSpaceDir = WorkDirectory.CreateCopyFrom(GetTestDir(), predicate: item => item.Name is not "obj" and not "bin" and not ".vs");
var nugetConfigPath = Path.Combine(this.WorkSpaceDir, "nuget.config");
if (File.Exists(nugetConfigPath))
{
File.Delete(nugetConfigPath);
}
this.StartupProj = Path.Combine(this.WorkSpaceDir, startupProjDir);
this.Bin = Path.Combine(this.StartupProj, "bin");
this.Obj = Path.Combine(this.StartupProj, "obj");
this.OutputDir = Path.Combine(this.Bin, configuration, framework);
this.PublishDir = Path.Combine(this.OutputDir, "publish");
}
public void GetMiddlewareDlls_Test()
{
// Given
using var workFolder = new WorkDirectory();
var templateProjectFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "ExpectedProjectFile.xml");
var targetProjectFilePath = Path.Combine(workFolder, "Project.csproj");
File.Copy(templateProjectFilePath, targetProjectFilePath);
// When
var outputDir = Program.GetMiddlewareDlls(workFolder, frameworkName: "net5.0");
// Then
outputDir.Is(Path.Combine(workFolder, "bin", "Release", "net5.0"));
var targetAssemblyPath = Path.Combine(outputDir, "Toolbelt.Blazor.HeadElement.ServerPrerendering.dll");
File.Exists(targetAssemblyPath).IsTrue();
}
public async Task SaveToStaticFileAsync_AppendHtmlExtension_Style_Test()
{
const string baseUrl = "http://127.0.0.1:5052";
await using var testSiteServer = await StartTestSite1(baseUrl);
using var outDir = new WorkDirectory();
var crawler = new StaticlizeCrawler(
baseUrl,
urlPathToExplicitFetch: null,
webRootPath: outDir,
OutputStyle.AppendHtmlExtension,
enableBrotliCompression: false,
enableGZipCompression: false);
await crawler.SaveToStaticFileAsync();
File.ReadAllText(Path.Combine(outDir, "index.html")).Contains("<h1>Home</h1>").IsTrue();
File.ReadAllText(Path.Combine(outDir, "counter.html")).Contains("<h1>Counter</h1>").IsTrue();
File.ReadAllText(Path.Combine(outDir, "fetchdata", "weather-forecast.html")).Contains("<h1>Fetch Data</h1>").IsTrue();
}
public string this[string name]
{
get
{
if (name == "Alias")
{
if (Alias == null || Alias.Trim().Length == 0)
{
return("Alias is required, and can't be all spaces.");
}
else if (CheckAlias(Alias))
{
return("Alias already exists.");
}
}
else if (name == "Path")
{
if (Path == null || Path.Trim().Length == 0)
{
return("Aplication path is required.");
}
else if (!File.Exists(ExpandedPath))
{
return("Aplication path doesn't exist.");
}
}
else if (name == "WorkDirectory")
{
if (WorkDirectory == null || WorkDirectory.Trim().Length == 0)
{
return("Aplication work directory is required.");
}
else if (!Directory.Exists(ExpandedWorkDirectory))
{
return("Aplication work directory doesn't exist.");
}
}
return(null);
}
}
public async Task Output_of_ProjectB_Contains_DriverFile_Test()
{
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
using var workDir = WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "ProjectAB"), item => item.Name is not "obj" and not "bin");
//var devenv = Environment.ExpandEnvironmentVariables(Path.Combine("%DevEnvDir%", "devenv.exe"));
var devenv = @"C:\Program Files\Microsoft Visual Studio\2022\Preview\Common7\IDE\devenv.exe";
using var nugetProcess = await XProcess.Start("nuget", "restore", workDir).WaitForExitAsync();
nugetProcess.ExitCode.Is(0);
using var devenvProcess = await XProcess.Start(devenv, "ProjectAB.sln /Build", workDir).WaitForExitAsync();
devenvProcess.ExitCode.Is(0);
var outDir = Path.Combine(workDir, "ProjectB", "bin", "Debug", "net472");
var driverFullPath1 = Path.Combine(outDir, "chromedriver");
var driverFullPath2 = Path.Combine(outDir, "chromedriver.exe");
(File.Exists(driverFullPath1) || File.Exists(driverFullPath2)).IsTrue();
}
public async Task AppSettings_Test()
{
// Given
var solutionDir = FileIO.FindContainerDirToAncestor("*.sln");
var srcDir = Path.Combine(solutionDir, "SampleApps", "BlazorWasmApp0");
using var workDir = WorkDirectory.CreateCopyFrom(srcDir, dst => dst.Name is not "obj" and not "bin");
File.WriteAllText(Path.Combine(workDir, "wwwroot", "appsettings.json"), @"{""HomeTitle"":""127.0.0.1""}");
// When
var dotnetCLI = await XProcess.Start("dotnet", "publish -c:Debug -p:BlazorEnableCompression=false -o:bin/publish", workDir).WaitForExitAsync();
dotnetCLI.ExitCode.Is(0, message: dotnetCLI.StdOutput + dotnetCLI.StdError);
// Then
// Validate prerendered contents.
var wwwrootDir = Path.Combine(workDir, "bin", "publish", "wwwroot");
ValidatePrerenderedContents_of_BlazorWasmApp0(wwwrootDir, homeTitle: "127.0.0.1");
}
public void GenerateProjectToGetMiddleware_Test()
{
// Given
using var workFolder = new WorkDirectory();
var middlewarePackages = new MiddlewarePackageReference[] {
new() { PackageIdentity = "Toolbelt.Blazor.HeadElement.ServerPrerendering", Assembly = "", Version = "1.5.1" }
};
// When
var outputDir = Program.GenerateProjectToGetMiddleware(middlewarePackages, workFolder, "net5.0");
// Then
outputDir.IsNotNull();
var generatedProjectFilePath = Path.Combine(outputDir, "Project.csproj");
File.Exists(generatedProjectFilePath).IsTrue();
// Then
var expectedProjectFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "ExpectedProjectFile.xml");
var expectedProjectFileLines = File.ReadAllLines(expectedProjectFilePath).Select(line => line.Trim()).ToArray();
var actualProjectFileLines = File.ReadAllLines(generatedProjectFilePath).Select(line => line.Trim()).ToArray();
actualProjectFileLines.Is(expectedProjectFileLines);
}
protected override void RegisterTasks()
{
//// ----------------------------------------------------------------------------------------------------------------------------
var initTask = Task(
"Init the workflow",
_ =>
{
IDirectory currentDirectory = WorkDirectory.Closest(dir => dir.Name.Equals("src", StringComparison.InvariantCultureIgnoreCase));
if (currentDirectory == null)
{
throw new Exception("Could not find Src directory " + WorkDirectory);
}
IDirectory artifacts = currentDirectory.Parent / "Artifacts";
artifacts.EnsureExists();
artifacts.Files.IncludeByExtension("nupkg", "nuspec").DeleteAll();
IDirectory mergedBin = currentDirectory.Parent / "bin" / "Merged";
mergedBin.EnsureExists();
return(new
{
Version = "4.2.1.0",
Configuration = "Debug",
Solution = new SolutionStructure(currentDirectory.Parent)
}.AsTaskResult());
});
//// ----------------------------------------------------------------------------------------------------------------------------
var generateCommonAssemblyInfo = Task(
"Generate common assembly info",
from data in initTask
select new GenerateAssemblyInfo(data.Solution.Src / "CommonAssemblyInfo.cs")
{
Attributes =
{
_ => new AssemblyProductAttribute("CrystalQuartz"),
_ => new AssemblyVersionAttribute(data.Version),
_ => new AssemblyFileVersionAttribute(data.Version)
}
});
//// ----------------------------------------------------------------------------------------------------------------------------
var compileTypescript = Task(
"Compile TypescriptFiles",
from data in initTask
select new ExecTask
{
ToolPath = "tsc",
Arguments =
(data.Solution.CrystalQuartz_Application / "Client" / "Scripts" / "Application.ts").AsFile().GetRelativePath(WorkDirectory) + " -out " +
(data.Solution.CrystalQuartz_Application / "Content" / "Scripts" / "application.js").AsFile().GetRelativePath(WorkDirectory)
});
//// ----------------------------------------------------------------------------------------------------------------------------
var transformIndexHtml = Task(
"Transform intex.html template",
from data in initTask
select new ExecTask
{
ToolPath = (data.Solution.Src / "packages").AsDirectory().Directories.Last(dir => dir.Name.StartsWith("Mono.TextTransform")) / "tools" / "TextTransform.exe",
Arguments = data.Solution.CrystalQuartz_Application / "Content" / "index.tt"
});
//// ----------------------------------------------------------------------------------------------------------------------------
var buildSolution = Task(
"Build solution",
new MsBuildTask(),
DependsOn(generateCommonAssemblyInfo),
DependsOn(compileTypescript),
DependsOn(transformIndexHtml));
//// ----------------------------------------------------------------------------------------------------------------------------
var cleanArtifacts = Task(
"Clean artifacts",
from data in initTask
select _ => data.Solution.Artifacts.Files.IncludeByExtension("nupkg", "nuspec").DeleteAll());
var mergeBinaries = Task(
"MergeBinaries",
from data in initTask
select new MergeBinariesTask(data.Solution, data.Configuration).AsSubflow(),
DependsOn(buildSolution));
var generateNuspecs = Task(
"GenerateNuspecs",
from data in initTask
select new GenerateNuspecsTask(data.Solution, data.Configuration, data.Version),
DependsOn(cleanArtifacts),
DependsOn(mergeBinaries));
//// ----------------------------------------------------------------------------------------------------------------------------
var buildPackages = Task(
"Build packages",
from data in initTask
select ForEach(data.Solution.Artifacts.Files.IncludeByExtension(".nuspec")).Do(
nuspec => new GeneratePackageTask(nuspec)
{
WorkDirectory = data.Solution.Artifacts,
ToolPath = data.Solution.Src / ".nuget" / "NuGet.exe"
},
nuspec => string.Format("Generate NuGet package for {0}", nuspec.NameWithoutExtension)),
Default(),
DependsOn(generateNuspecs));
//// ----------------------------------------------------------------------------------------------------------------------------
Task(
"PushPackages",
from data in initTask
select
ForEach(data.Solution.Artifacts.Files.IncludeByExtension("nupkg")).Do(
package => new PushPackageTask(package)
{
WorkDirectory = data.Solution.Artifacts,
ToolPath = data.Solution.Src / ".nuget" / "NuGet.exe"
},
package => "Push" + package.NameWithoutExtension),
DependsOn(buildPackages));
}
protected override void RegisterTasks()
{
//// ----------------------------------------------------------------------------------------------------------------------------
var initTask = Task(
"Init the workflow",
_ =>
{
IDirectory currentDirectory = WorkDirectory.Closest(dir => dir.Name.Equals("src", StringComparison.InvariantCultureIgnoreCase));
if (currentDirectory == null)
{
throw new Exception("Could not find Src directory");
}
IDirectory artifacts = currentDirectory.Parent / "Artifacts";
artifacts.EnsureExists();
return(new
{
Root = currentDirectory.Parent,
Artifacts = artifacts,
Version = "3.1.0.0",
Src = currentDirectory,
Configuration = "Debug",
BuildAssets = (currentDirectory / "CrystalQuartz.Build" / "Assets").AsDirectory()
}.AsTaskResult());
});
//// ----------------------------------------------------------------------------------------------------------------------------
var generateCommonAssemblyInfo = Task(
"Generate common assembly info",
from data in initTask
select new GenerateAssemblyInfo(data.Src / "CommonAssemblyInfo.cs")
{
Attributes =
{
_ => new AssemblyProductAttribute("CrystalQuartz"),
_ => new AssemblyVersionAttribute(data.Version),
_ => new AssemblyFileVersionAttribute(data.Version)
}
});
//// ----------------------------------------------------------------------------------------------------------------------------
var compileTypescript = Task(
"Compile TypescriptFiles",
from data in initTask
select new ExecTask
{
ToolPath = "tsc",
Arguments =
(data.Src / "CrystalQuartz.Web" / "Client" / "Scripts" / "Application.ts").AsFile().GetRelativePath(WorkDirectory) + " -out " +
(data.Src / "CrystalQuartz.Web" / "Content" / "Scripts" / "application.js").AsFile().GetRelativePath(WorkDirectory)
});
//// ----------------------------------------------------------------------------------------------------------------------------
var transformIndexHtml = Task(
"Transform intex.html template",
from data in initTask
select new ExecTask
{
ToolPath = (data.Src / "packages").AsDirectory().Directories.Last(dir => dir.Name.StartsWith("Mono.TextTransform")) / "tools" / "TextTransform.exe",
Arguments = data.Src / "CrystalQuartz.Web/Content" / "index.tt"
});
//// ----------------------------------------------------------------------------------------------------------------------------
var buildSolution = Task(
"Build solution",
new MsBuildTask(),
DependsOn(generateCommonAssemblyInfo),
DependsOn(compileTypescript),
DependsOn(transformIndexHtml));
//// ----------------------------------------------------------------------------------------------------------------------------
var cleanArtifacts = Task(
"Clean artifacts",
from data in initTask
select _ => data.Artifacts.Files.IncludeByExtension("nupkg", "nuspec").DeleteAll());
//// ----------------------------------------------------------------------------------------------------------------------------
var generateSimplePackageNuspec = Task(
"Generate simple package spec",
from data in initTask
select new GenerateNuGetSpecTask(data.Artifacts / "CrystalQuartz.Simple.nuspec")
.Id("CrystalQuartz.Simple")
.FillCommonProperties(data.Root / "bin" / data.Configuration, data.Version)
.Description("Installs CrystalQuartz panel (pluggable Qurtz.NET viewer) using simple scheduler provider. This approach is appropriate for scenarios where the scheduler and a web application works in the same AppDomain.")
.WithFiles((data.BuildAssets / "Simple").AsDirectory().Files, "content"),
DependsOn(cleanArtifacts),
DependsOn(buildSolution));
//// ----------------------------------------------------------------------------------------------------------------------------
var generateRemotePackageNuspec = Task(
"Generate remote package spec",
from data in initTask
select new GenerateNuGetSpecTask(data.Artifacts / "CrystalQuartz.Remote.nuspec")
.Id("CrystalQuartz.Remote")
.FillCommonProperties(data.Root / "bin" / data.Configuration, data.Version)
.Description("Installs CrystalQuartz panel (pluggable Qurtz.NET viewer) using remote scheduler provider. Note that you should set remote scheduler URI after the installation.")
.WithFiles(data.BuildAssets.GetDirectory("Remote").Files, "content"),
DependsOn(generateSimplePackageNuspec));
//// ----------------------------------------------------------------------------------------------------------------------------
var buildPackages = Task(
"Build packages",
from data in initTask
select ForEach(data.Artifacts.Files.IncludeByExtension(".nuspec")).Do(
nuspec => new GeneratePackageTask(nuspec)
{
WorkDirectory = data.Artifacts,
ToolPath = data.Src / ".nuget" / "NuGet.exe"
},
nuspec => string.Format("Generate NuGet package for {0}", nuspec.NameWithoutExtension)),
Default(),
DependsOn(generateRemotePackageNuspec),
DependsOn(generateSimplePackageNuspec));
}
protected override void RegisterTasks()
{
//// ----------------------------------------------------------------------------------------------------------------------------
var initTask = Task(
"Init the workflow",
context =>
{
IDirectory currentDirectory = WorkDirectory.Closest(dir => dir.Name.Equals("src", StringComparison.InvariantCultureIgnoreCase));
if (currentDirectory == null)
{
throw new Exception("Could not find Src directory " + WorkDirectory);
}
IDirectory artifacts = currentDirectory.Parent / "Artifacts";
artifacts.EnsureExists();
artifacts.Files.IncludeByExtension("nupkg", "nuspec").DeleteAll();
IDirectory mergedBin = currentDirectory.Parent / "bin" / "Merged";
mergedBin.EnsureExists();
var solutionStructure = new SolutionStructure(currentDirectory.Parent);
IFile versionNumberFile = solutionStructure.Src / "version.txt";
return(new
{
Version = versionNumberFile.Exists ? versionNumberFile.ReadAllText().Trim() : "1.0.0.0",
Configuration = "Release",
Solution = solutionStructure,
SkipCoreProject = context.Environment.IsMono
}.AsTaskResult());
});
//// ----------------------------------------------------------------------------------------------------------------------------
var generateCommonAssemblyInfo = Task(
"Generate common assembly info",
from data in initTask
select new GenerateAssemblyInfo(data.Solution.Src / "CommonAssemblyInfo.cs")
{
Attributes =
{
_ => new AssemblyProductAttribute("CrystalQuartz"),
_ => new AssemblyVersionAttribute(data.Version),
_ => new AssemblyFileVersionAttribute(data.Version)
}
});
//// ----------------------------------------------------------------------------------------------------------------------------
var buildClient = Task(
"BuildClient",
from data in initTask
select new CompileClientAssets(data.Solution, data.Version).AsSubflow());
//// ----------------------------------------------------------------------------------------------------------------------------
var copyGhPagesAssets = Task(
"CopyAssetsToGhPagesArtifacts",
from data in initTask
select c =>
{
(data.Solution.Root / "_gh-pages-assets").AsDirectory().SearchFilesRecursively().CopyRelativelyTo(data.Solution.Artifacts / "gh-pages");
});
//// ----------------------------------------------------------------------------------------------------------------------------
var restoreNugetPackages = Task(
"RestoreNugetPackages",
from data in initTask
select new ExecTask
{
ToolPath = data.Solution.Src / ".nuget" / "NuGet.exe",
Arguments = "restore " + (data.Solution.Src / "CrystalQuartz.sln").AsFile().AbsolutePath + " -Verbosity quiet"
}.AsTask());
//// ----------------------------------------------------------------------------------------------------------------------------
var buildSolution = Task(
"Build solution",
from data in initTask
select new CustomMsBuildTask
{
ProjectFile = data.Solution.Src / "CrystalQuartz.sln",
Switches =
{
MsBuildSwitch.Configuration(data.Configuration),
MsBuildSwitch.VerbosityQuiet()
}
}
.AsTask(),
DependsOn(restoreNugetPackages),
DependsOn(generateCommonAssemblyInfo),
DependsOn(buildClient));
//// ----------------------------------------------------------------------------------------------------------------------------
var buildCoreSolution = Task(
"Build Core projects",
from data in initTask
select new ExecTask
{
ToolPath = "dotnet",
Arguments = "build " + (data.Solution.Src / "CrystalQuartz.AspNetCore" / "CrystalQuartz.AspNetCore.csproj") + " --verbosity quiet --configuration " + data.Configuration
}
.AsTask(),
DependsOn(buildSolution),
DependsOn(restoreNugetPackages),
DependsOn(generateCommonAssemblyInfo),
DependsOn(buildClient));
//// ----------------------------------------------------------------------------------------------------------------------------
var cleanArtifacts = Task(
"Clean artifacts",
from data in initTask
select _ => data.Solution.Artifacts.Files.IncludeByExtension("nupkg", "nuspec").DeleteAll());
//// ----------------------------------------------------------------------------------------------------------------------------
var mergeBinaries = Task(
"MergeBinaries",
from data in initTask
select new MergeBinariesTask(data.Solution, data.Configuration, data.SkipCoreProject).AsSubflow(),
DependsOn(buildSolution),
DependsOn(buildCoreSolution));
//// ----------------------------------------------------------------------------------------------------------------------------
var generateNuspecs = Task(
"GenerateNuspecs",
from data in initTask
select new GenerateNuspecsTask(data.Solution, data.Configuration, data.Version + "-beta", data.SkipCoreProject),
DependsOn(cleanArtifacts),
DependsOn(mergeBinaries));
//// ----------------------------------------------------------------------------------------------------------------------------
var buildPackages = Task(
"BuildPackages",
from data in initTask
select ForEach(data.Solution.Artifacts.Files.IncludeByExtension(".nuspec")).Do(
nuspec => new GeneratePackageTask(nuspec)
{
WorkDirectory = data.Solution.Artifacts,
ToolPath = data.Solution.Src / ".nuget" / "NuGet.exe"
},
nuspec => string.Format("Generate NuGet package for {0}", nuspec.NameWithoutExtension)),
DependsOn(generateNuspecs));
//// ----------------------------------------------------------------------------------------------------------------------------
var buildDocs = Task(
"BuildDocs",
from data in initTask
select new CompileDocsTask(data.Solution, data.Version).AsSubflow(),
DependsOn(buildClient));
//// ----------------------------------------------------------------------------------------------------------------------------
Task(
"DevBuild",
() => { },
Default(),
DependsOn(buildClient),
DependsOn(buildPackages),
DependsOn(copyGhPagesAssets),
DependsOn(buildDocs));
//// ----------------------------------------------------------------------------------------------------------------------------
///
Task(
"CiBuild",
() => { },
DependsOn(buildPackages),
DependsOn(copyGhPagesAssets),
DependsOn(buildDocs));
//// ----------------------------------------------------------------------------------------------------------------------------
Task(
"PushPackages",
from data in initTask
select
ForEach(data.Solution.Artifacts.Files.IncludeByExtension("nupkg")).Do(
package => new ExecTask
{
WorkDirectory = data.Solution.Artifacts,
ToolPath = data.Solution.Src / ".nuget" / "NuGet.exe",
Arguments = "push " + package.AbsolutePath + " -Source https://api.nuget.org/v3/index.json -NonInteractive"
},
package => "Push" + package.NameWithoutExtension),
DependsOn(buildPackages));
}
private WorkDirectory CreateWorkDir()
{
var unitTestProjectDir = FileIO.FindContainerDirToAncestor("*.csproj");
return(WorkDirectory.CreateCopyFrom(Path.Combine(unitTestProjectDir, "Project"), predicate: item => item.Name is not "obj" and not "bin"));
}
