public void DumpStats(IUserOutput output)
{
output.Message("Builder store statistics");
output.Indent();
output.Message("Total number of created builders: {0}", addCount);
output.Message("Number of unique builders: {0}", instances.Count);
output.Unindent();
}
public override void Dump(IUserOutput output)
{
output.Message("Project {0}.{1}'s properties:", project.Module.Name, project.Name);
output.Indent();
try
{
foreach (var prop in properties)
{
output.Message(prop);
}
}
finally
{
output.Unindent();
}
}
public override void Dump(IUserOutput output)
{
output.Message("Project {0}.{1}'s properties:", project.Module.Name, project.Name);
output.Indent();
try
{
foreach (var prop in properties)
{
output.Message(prop);
}
}
finally
{
output.Unindent();
}
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
if (reference == null)
{
throw new InvalidOperationException("FS repository reference was not set on the builder");
}
if (reference != null && resolutionContext == null)
{
ResolveReference();
}
if (output != null)
{
output.Message(String.Format("Resolving reference {0}", reference.Uri));
}
log.DebugFormat("Resolving reference {0} using {1}", reference.Uri, resolvedPath);
var depsRoot = targetRoot.CreateDirectory("deps");
var depDir = depsRoot.CreateDirectory(resolutionContext.DependencyName);
string fileName = resolutionContext.FileName + "." + resolutionContext.Extension;
if (fileName == "*.*")
{
return(DeployDirectoryContents(depDir, Path.GetDirectoryName(resolvedPath), ""));
}
else
{
return(DeploySingleFile(depDir, fileName));
}
}
/// <summary>
/// Tries to get the command given by its name and prints its help string to the output
/// </summary>
/// <param name="cmdName">Name of the command</param>
private void PrintCommandHelp(string cmdName)
{
var cmd = commandFactory.CreateCommand(cmdName);
if (cmd == null)
{
throw new InvalidCommandParameterException(
"help",
string.Format("The given command ({0}) does no exist", cmdName));
}
else
{
output.Message(cmd.Help);
output.Message(GlobalParameters);
}
}
/// <summary>
/// Formatted message output
/// </summary>
/// <param name="output">Output interface to be used</param>
/// <param name="format">Format string, used by <see cref="string.Format(string,object)"/></param>
/// <param name="args">Parameters of the string formatting</param>
public static void Message(this IUserOutput output, string format, params object[] args)
{
Contract.Requires(output != null);
Contract.Requires(format != null);
Contract.Requires(args != null);
output.Message(string.Format(format, args));
}
public bool Run(Suite suite, string[] parameters)
{
var data = new {
products = suite.Products.Select(p => p.Name).ToArray(),
goals = suite.Goals.Select(g => g.Name).ToArray()
};
output.Message(JsonConvert.SerializeObject(data));
return(true);
}
private void RunWithProjects(CommandTarget target, bool dumpMode, bool dumpDepsMode)
{
log.InfoFormat("Building...");
var context = buildContextFactory.CreateBuildContext();
var projects = target.Projects.ToList();
IBuilder rootBuilder = coreBuilderFactory.Merge(
projectBuilders
.Select(pb => pb.Create(projects))
.Where(b => b != null).ToArray(),
new ProjectBuilderTag("Top level project builders", projects));
if (rootBuilder != null)
{
context.AddBuilder(rootBuilder);
var productTarget = target as ProductTarget;
if (productTarget != null)
{
rootBuilder = AddProductBuildStep(context, productTarget.Product, rootBuilder);
}
if (dumpMode)
{
context.Dump(name => targetRoot.CreateBinaryFile("builders." + name + ".dot"), rootBuilder);
}
else if (dumpDepsMode)
{
context.DumpDependencies(rootBuilder, output);
}
else
{
var result = context.Run(rootBuilder);
if (result.Count > 0)
{
var outputs = context.GetResults(rootBuilder);
foreach (var outputPath in outputs)
{
log.DebugFormat("Generated output for build: {0}", outputPath);
}
}
else
{
log.Warn("Build produced no results");
}
}
}
output.Message("Build completed.");
}
/// <summary>
/// Runs the command
/// </summary>
/// <param name="suite">The current suite model the command is applied to</param>
/// <param name="parameters">Parameters given to the command (in unprocessed form)</param>
/// <returns>Returns <c>true</c> if the command succeeded</returns>
public bool Run(Suite suite, string[] parameters)
{
var fileSystem = new ExtendedPhysicalFileSystem(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
var updater = new AppUpdaterBuilder(NUGET_PACKAGE_ID)
.FileSystemAccessedThrough(fileSystem)
.Build();
output.Message("Checking for updates (current version: {0})...", updater.CurrentVersion);
var check = updater.CheckForUpdate();
if (check.UpdateAvailable)
{
output.Message("..found update: {0}", check.UpdatePackage.Version);
output.Message("..preparing update..");
var preparedUpdate = PrepareUpdate(updater, fileSystem, check.UpdatePackage);
output.Message("..applying update..");
updater.ApplyPreparedUpdate(preparedUpdate);
output.Message("Update completed.");
output.Warning("You should rebuild your suites with the updated bari before using them!");
}
else
{
output.Message("No updates available.");
}
return(true);
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Subtask {0}", subtask));
output.Indent();
try
{
subtask.Dependencies.Dump(output);
}
finally
{
output.Unindent();
}
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Subtask {0}", subtask));
output.Indent();
try
{
subtask.Dependencies.Dump(output);
}
finally
{
output.Unindent();
}
}
/// <summary>
/// Runs the main bari process
/// </summary>
public bool Run()
{
if (!parameters.QuietMode)
{
output.Message("bari version {0}\n", Assembly.GetAssembly(typeof(MainProcess)).GetName().Version.ToString());
}
var cmdPrereq = commandFactory.CreateCommandPrerequisites(parameters.Command);
Suite suite;
if (cmdPrereq == null || cmdPrereq.RequiresSuite)
{
suite = loader.Load(parameters.Suite);
binding.Bind <Suite>().ToConstant(suite);
explorer.RunAll(suite);
suite.CheckForWarnings(output);
}
else
{
suite = new Suite(new LocalFileSystemDirectory(Path.GetTempPath()));
}
var cmd = commandFactory.CreateCommand(parameters.Command);
if (cmd != null)
{
binding.Bind <ICommand>().ToConstant(cmd).WhenTargetHas <CurrentAttribute>();
try
{
return(cmd.Run(suite, parameters.CommandParameters));
}
finally
{
#if DEBUG
if (!parameters.QuietMode)
{
builderStore.DumpStats(output);
}
#endif
}
}
else
{
throw new InvalidCommandException(parameters.Command, "Unknown command");
}
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Multiple dependencies ({0} subdeps)", dependencies.Count));
output.Indent();
try
{
foreach (var dep in dependencies)
{
dep.Dump(output);
}
}
finally
{
output.Unindent();
}
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Multiple dependencies ({0} subdeps)", dependencies.Count));
output.Indent();
try
{
foreach (var dep in dependencies)
{
dep.Dump(output);
}
}
finally
{
output.Unindent();
}
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context"> </param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet<TargetRelativePath> Run(IBuildContext context)
{
if (output != null)
output.Message(String.Format("Resolving reference {0}", reference.Uri));
string pkgName = reference.Uri.Host;
string pkgVersion = reference.Uri.AbsolutePath.TrimStart('/');
var depsRoot = targetRoot.CreateDirectory("deps");
var depDir = depsRoot.CreateDirectory(pkgName);
var files = nuget.InstallPackage(pkgName, pkgVersion, depDir, "", dllsOnly: reference.Type == ReferenceType.Build, maxProfile: GetMaxProfile());
var relativeRoot = Path.Combine(targetRoot.GetRelativePath(depDir), files.Item1);
return new HashSet<TargetRelativePath>(
from path in files.Item2
let relativePath = path.Substring(files.Item1.Length).TrimStart(Path.DirectorySeparatorChar)
select new TargetRelativePath(relativeRoot, relativePath));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public override ISet <TargetRelativePath> Run(IBuildContext context)
{
if (output != null)
{
output.Message(String.Format("Resolving reference {0}", reference.Uri));
}
var depsRoot = targetRoot.CreateDirectory("deps");
var sourcePath = reference.Uri.OriginalString.Substring(7).Replace('/', Path.DirectorySeparatorChar).TrimEnd(Path.DirectorySeparatorChar);
var fileName = Path.GetFileName(sourcePath);
using (var source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var target = depsRoot.CreateBinaryFile(sourcePath))
{
StreamOperations.Copy(source, target);
}
return(new HashSet <TargetRelativePath>(new[]
{
new TargetRelativePath(targetRoot.GetRelativePath(depsRoot), fileName)
}));
}
/// <summary>
/// Runs this builder
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>Returns a set of generated files, in target relative paths</returns>
public ISet <TargetRelativePath> Run(IBuildContext context)
{
if (output != null)
{
output.Message(String.Format("Resolving reference {0}", reference.Uri));
}
log.DebugFormat("Resolving reference {0} using {1}", reference.Uri, resolvedPath);
var depsRoot = targetRoot.CreateDirectory("deps");
var depDir = depsRoot.CreateDirectory(resolutionContext.DependencyName);
string fileName = resolutionContext.FileName + "." + resolutionContext.Extension;
if (fileName == "*.*")
{
return(DeployDirectoryContents(depDir));
}
else
{
return(DeploySingleFile(depDir, fileName));
}
}
/// <summary>
/// Runs the main bari process
/// </summary>
public bool Run()
{
output.Message("bari version {0}\n", Assembly.GetAssembly(typeof(MainProcess)).GetName().Version.ToString());
var suite = loader.Load(parameters.Suite);
binding.Bind <Suite>().ToConstant(suite);
explorer.RunAll(suite);
suite.CheckForWarnings(output);
var cmd = commandFactory.CreateCommand(parameters.Command);
if (cmd != null)
{
binding.Bind <ICommand>().ToConstant(cmd).WhenTargetHas <CurrentAttribute>();
return(cmd.Run(suite, parameters.CommandParameters));
}
else
{
throw new InvalidCommandException(parameters.Command, "Unknown command");
}
}
private void RunWithProjects(CommandTarget target, bool dumpMode)
{
log.InfoFormat("Building...");
var context = buildContextFactory.CreateBuildContext();
var projects = target.Projects.ToList();
IBuilder rootBuilder = projectBuilders.Select(pb => pb.AddToContext(context, projects))
.Where(b => b != null).ToArray().Merge();
rootBuilder.AddToContext(context);
if (dumpMode)
{
using (var builderGraph = targetRoot.CreateBinaryFile("builders.dot"))
context.Dump(builderGraph, rootBuilder);
}
else
{
context.Run(rootBuilder);
var outputs = context.GetResults(rootBuilder);
foreach (var outputPath in outputs)
{
log.DebugFormat("Generated output for build: {0}", outputPath);
}
var productTarget = target as ProductTarget;
if (productTarget != null)
{
MergeOutputForProduct(productTarget.Product, outputs);
}
}
output.Message("Build completed.");
}
public override void Dump(IUserOutput output)
{
output.Message("no dependencies");
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Script source `{0}`", buildScript.Name));
}
public override void Dump(IUserOutput output)
{
output.Message("Builder UID {0}", builder.Uid);
}
public override void Dump(IUserOutput output)
{
output.Message("Builder UID {0}", builder.Uid);
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Script source `{0}`", buildScript.Name));
}
public override void Dump(IUserOutput output)
{
output.Message("Reference {0}", reference.Uri);
}
public override void Dump(IUserOutput output)
{
output.Message(string.Format("FS repo: `{0}`", path));
}
public override void Dump(IUserOutput output)
{
output.Message(string.Format("FS repo: `{0}`", path));
}
public override void Dump(IUserOutput output)
{
output.Message("Reference {0}", reference.Uri);
}
public override void Dump(IUserOutput output)
{
output.Message("no dependencies");
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Source set structure *{0}* ({1} files)", sourceSet.Type, sourceSet.Files.Count()));
}
/// <summary>
/// Runs the command
/// </summary>
/// <param name="suite">The current suite model the command is applied to</param>
/// <param name="parameters">Parameters given to the command (in unprocessed form)</param>
public bool Run(Suite suite, string[] parameters)
{
if (parameters.Length != 0)
{
throw new InvalidCommandParameterException("info",
"The 'info' command must be called without parameters!");
}
output.Message("*Suite name:* {0}\n", suite.Name);
output.Message("*Modules:*");
foreach (var module in suite.Modules)
{
PrintModuleDetails(module);
}
output.Message("*Products:*");
foreach (var product in suite.Products)
{
PrintProductDetails(product);
}
return(true);
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Source set *{0}* ({1} files)", sourceSet.Type, sourceSet.Files.Count()));
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Project {0}.{1}'s parameter block {2}", project.Module.Name, project.Name, blockName));
}
public override void Dump(IUserOutput output)
{
output.Message(String.Format("Project {0}.{1}'s parameter block {2}", project.Module.Name, project.Name, blockName));
}
