public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
var packageRoot = path.MakeAbsolute(_environment).FullPath;
var targetFramework = type == PackageType.Addin ? _currentFramework : NuGetFramework.AnyFramework;
var sourceRepositoryProvider = new NuGetSourceRepositoryProvider(_nugetSettings, _config, package, packageRoot);
var localAndPrimaryRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.LocalRepositories);
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.PrimaryRepositories);
var allRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
allRepositories.AddRange(localAndPrimaryRepositories);
allRepositories.AddRange(sourceRepositoryProvider.Repositories);
var packageIdentity = GetPackageId(package, localAndPrimaryRepositories, targetFramework, _sourceCacheContext, _nugetLogger);
if (packageIdentity == null)
{
return(Array.Empty <IFile>());
}
if (packageIdentity.Version.IsPrerelease && !package.IsPrerelease())
{
// TODO: Is this allowed? If not, log and return
return(Array.Empty <IFile>());
}
var pathResolver = new PackagePathResolver(packageRoot);
var dependencyBehavior = GetDependencyBehavior(type, package);
var downloadContext = new PackageDownloadContext(_sourceCacheContext);
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
GetPackageDependencies(packageIdentity,
targetFramework,
_sourceCacheContext,
_nugetLogger,
allRepositories,
availablePackages,
dependencyBehavior,
localAndPrimaryRepositories);
var resolverContext = new PackageResolverContext(
dependencyBehavior,
new[] { packageIdentity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <global::NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
allRepositories.Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, _nugetLogger),
_nugetLogger);
var installedFiles = new List <IFile>();
foreach (var packageToInstall in packagesToInstall)
{
var isTargetPackage = packageToInstall.Id.Equals(package.Package, StringComparison.OrdinalIgnoreCase);
var installPath = new DirectoryPath(pathResolver.GetInstallPath(packageToInstall));
if (!_fileSystem.Exist(installPath))
{
var downloadResource = packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).GetAwaiter().GetResult();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
_nugetLogger, CancellationToken.None).GetAwaiter().GetResult();
PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
pathResolver,
packageExtractionContext,
CancellationToken.None).GetAwaiter().GetResult();
// If this is the target package, to avoid problems with casing, get the actual install path from the nuspec
if (isTargetPackage)
{
installPath = new DirectoryPath(pathResolver.GetInstallPath(downloadResult.PackageReader.GetIdentity()));
}
}
if (_blackListedPackages.Contains(packageToInstall.Id))
{
const string format = "Package {0} depends on package {1}. This dependency won't be loaded.";
_log.Debug(format, package.Package, packageToInstall.ToString());
continue;
}
// If the installed package is not the target package, create a new PackageReference
// which is passed to the content resolver. This makes logging make more sense.
var installedPackageReference = isTargetPackage ? package : new PackageReference($"nuget:?package={packageToInstall.Id}");
installedFiles.AddRange(_contentResolver.GetFiles(installPath, installedPackageReference, type));
}
return(installedFiles);
}
public IReadOnlyCollection <UnityEditorDescriptor> Seek()
{
var searchPattern = $"{ProgramFiles}/*Unity*/**/Editor/Unity.exe";
log.Debug("Searching for available Unity Editors...");
log.Debug("Search pattern: {0}", searchPattern);
var candidates = globber.GetFiles(searchPattern).ToList();
log.Debug("Found {0} candidates.", candidates.Count);
log.Debug(string.Empty);
var editors =
from candidatePath in candidates
let version = DetermineVersion(candidatePath)
where version != null
select new UnityEditorDescriptor(version, candidatePath);
return(editors.ToList());
}
/// <summary>
/// Installs the specified resource at the given location.
/// </summary>
/// <param name="package">The package reference.</param>
/// <param name="type">The package type.</param>
/// <param name="path">The location where to install the package.</param>
/// <returns>The installed files.</returns>
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
path = path.MakeAbsolute(_environment);
var root = _fileSystem.GetDirectory(path);
var packagePath = path.Combine(package.Package);
// Create the addin directory if it doesn't exist.
if (!root.Exists)
{
_log.Debug("Creating directory {0}", path);
root.Create();
}
// Fetch available content from disc.
var content = _contentResolver.GetFiles(packagePath, package, type);
if (content.Any())
{
_log.Debug("Package {0} has already been installed.", package.Package);
return(content);
}
// Install the package.
_log.Debug("Installing NuGet package {0}...", package.Package);
var nugetPath = GetNuGetPath();
var process = _processRunner.Start(nugetPath, new ProcessSettings
{
Arguments = GetArguments(package, path, _config),
RedirectStandardOutput = true,
Silent = _log.Verbosity < Verbosity.Diagnostic
});
process.WaitForExit();
var exitCode = process.GetExitCode();
if (exitCode != 0)
{
_log.Warning("NuGet exited with {0}", exitCode);
var output = string.Join(Environment.NewLine, process.GetStandardOutput());
_log.Verbose(Verbosity.Diagnostic, "Output:\r\n{0}", output);
}
// Get the files.
var result = _contentResolver.GetFiles(packagePath, package, type);
if (result.Count == 0)
{
if (type == PackageType.Addin)
{
var framework = _environment.Runtime.TargetFramework;
_log.Warning("Could not find any assemblies compatible with {0}.", framework.FullName);
}
else if (type == PackageType.Tool)
{
const string format = "Could not find any relevant files for tool '{0}'. Perhaps you need an include parameter?";
_log.Warning(format, package.Package);
}
}
return(result);
}
private void LogExecutingCommand(PowershellSettings settings, string script, bool safe = true)
{
_Log.Debug(Verbosity.Normal, String.Format("Executing: {0}", this.AppendArguments(script, settings.Arguments, safe).EscapeCurleyBrackets()));
}
private int Convert(string wkhtmltopdfPath, string switches, string baseDirectory, ICakeLog log)
{
if (string.IsNullOrEmpty(wkhtmltopdfPath))
{
wkhtmltopdfPath = Path.Combine(baseDirectory, "wkhtmltopdf.exe");
}
log.Debug("Run html to pdf converter: " + wkhtmltopdfPath);
log.Debug("Using switches: " + switches);
Process process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = wkhtmltopdfPath,
Arguments = switches,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
RedirectStandardInput = true,
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden
}
};
var output = new StringBuilder();
ExecutionOutputText = "";
void OnOutputDataReceived(object o, DataReceivedEventArgs e) => output.AppendLine(e.Data);
process.OutputDataReceived += OnOutputDataReceived;
process.ErrorDataReceived += OnOutputDataReceived;
try
{
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
bool result = process.WaitForExit(3 * 60 * 1000);
if (!result)
{
return(-10);
}
}
catch (Exception e)
{
output.AppendLine(e.ToString());
log.Error(e);
return(-1);
}
finally
{
process.OutputDataReceived -= OnOutputDataReceived;
process.ErrorDataReceived -= OnOutputDataReceived;
}
ExecutionOutputText = output.ToString();
return(process.ExitCode);
}
/// <summary>
/// Finds script aliases in the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to find script aliases in.</param>
/// <returns>The script aliases that were found.</returns>
public IReadOnlyList <ScriptAlias> FindAliases(IEnumerable <Assembly> assemblies)
{
var result = new List <ScriptAlias>();
if (assemblies != null)
{
foreach (var reference in assemblies)
{
try
{
foreach (var typeInfo in reference.DefinedTypes)
{
var type = typeInfo.AsType();
if (type.IsStatic())
{
foreach (var method in GetAliasMethods(type))
{
var alias = CreateAlias(method);
if (alias != null)
{
result.Add(alias);
}
}
}
}
}
catch (ReflectionTypeLoadException ex)
{
HashSet <string> notFound = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (Exception loaderException in ex.LoaderExceptions)
{
_log.Debug(loaderException.Message);
FileNotFoundException fileNotFoundException = loaderException as FileNotFoundException;
if (fileNotFoundException != null)
{
if (!notFound.Contains(fileNotFoundException.FileName))
{
notFound.Add(fileNotFoundException.FileName);
}
#if !NETCORE
if (!string.IsNullOrEmpty(fileNotFoundException.FusionLog))
{
_log.Debug("Fusion Log:");
_log.Debug(fileNotFoundException.FusionLog);
}
#endif
}
_log.Debug(string.Empty);
}
foreach (var file in notFound)
{
_log.Warning("Could not load {0} (missing {1})", reference.Location, file);
}
}
catch (FileNotFoundException ex)
{
_log.Warning("Could not load {0} (missing {1}))", reference.Location, ex.FileName);
}
}
}
return(result);
}
/// <inheritdoc/>
public IReadOnlyList <FilePath> InstallAddins(
IReadOnlyCollection <PackageReference> addins,
DirectoryPath installPath)
{
if (addins == null)
{
throw new ArgumentNullException(nameof(addins));
}
if (installPath == null)
{
throw new ArgumentNullException(nameof(installPath));
}
// Make the installation root absolute.
installPath = installPath.MakeAbsolute(_environment);
var result = new HashSet <FilePath>(PathComparer.Default);
if (addins.Count > 0)
{
_log.Verbose("Installing addins...");
foreach (var addin in addins)
{
CheckPackageVersion(addin, "addin");
// Get the installer.
var installer = GetInstaller(addin, PackageType.Addin);
if (installer == null)
{
const string format = "Could not find an installer for the '{0}' scheme.";
var message = string.Format(CultureInfo.InvariantCulture, format, addin.Scheme);
throw new CakeException(message);
}
var assemblies = installer.Install(addin, PackageType.Addin, installPath);
if (assemblies.Count == 0)
{
const string format = "Failed to install addin '{0}'.";
var message = string.Format(CultureInfo.InvariantCulture, format, addin.Package);
throw new CakeException(message);
}
// Reference found assemblies.
foreach (var assembly in assemblies)
{
var assemblyPath = assembly.Path.MakeAbsolute(_environment);
try
{
assemblyPath = _environment.WorkingDirectory.GetRelativePath(assemblyPath);
}
catch (InvalidOperationException)
{
// Paths must share a common prefix.
}
_log.Debug("The addin {0} will reference {1}.", addin.Package, assemblyPath);
result.Add(assembly.Path);
}
}
}
return(result.ToArray());
}
public void Debug(string message)
{
_cakeLogger.Debug(message);
}
public VersionHelper(ICakeEnvironment environment, ICakeLog log, ICakeArguments arguments,
IAppVeyorProvider appVeyorProvider, ITFBuildProvider azureProvider, IGlobber globber, IFileSystem fileSystem, IProcessRunner processRunner, IToolLocator tools)
{
_environment = environment;
_log = log;
_arguments = arguments;
_appVeyorProvider = appVeyorProvider;
_azureProvider = azureProvider;
_globber = globber;
_fileSystem = fileSystem;
_processRunner = processRunner;
_tools = tools;
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
Configuration = environment.GetEnvironmentVariable("CONFIGURATION");
if (string.IsNullOrWhiteSpace(Configuration))
{
Configuration = _arguments.HasArgument("configuration") ? _arguments.GetArgument("configuration") : "Release";
}
string envLogging = environment.GetEnvironmentVariable("LOGGINGLEVEL");
if (!string.IsNullOrWhiteSpace(envLogging))
{
Verbosity loggingEnum;
if (Enum.TryParse(envLogging, true, out loggingEnum))
{
log.Verbosity = loggingEnum;
log.Information($"Logging Level: {loggingEnum}", Verbosity.Quiet);
if (IsAppVeyor)
{
_appVeyorProvider.AddInformationalMessage($"Logging set by LoggingLevel enviornment variable to {loggingEnum}");
}
_isDefaultLoggingLevel = false;
}
else
{
string msg = $"Invalid logging level [{envLogging}]. Use {Verbosity.Quiet}, {Verbosity.Minimal}, {Verbosity.Normal}, {Verbosity.Verbose} or {Verbosity.Diagnostic}";
if (IsAppVeyor)
{
log.Warning(msg);
}
_appVeyorProvider.AddWarningMessage(msg);
}
}
else
{
_isDefaultLoggingLevel = !arguments.HasArgument("verbosity");
}
if (_log.Verbosity > Verbosity.Normal)
{
var environmentVariables = environment.GetEnvironmentVariables();
foreach (string key in environmentVariables.Keys)
{
log.Verbose($"{key}:{environmentVariables[key]}");
}
}
CommitMessageMatches = new MatchResult {
Success = false
};
if (IsAppVeyor)
{
Branch = _appVeyorProvider.Environment.Repository.Branch;
CommitMessageShort = _appVeyorProvider.Environment.Repository.Commit.Message;
var match = CommitMessageRegex.Match(_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage);
CommitMessageMatches = new MatchResult {
Success = match.Success, Groups = match.Groups
};
_log.Debug($"Branch:{Branch}");
_log.Debug($"Commit Msg Short:{CommitMessageShort}");
_log.Debug($"Commit Msg Extended:{_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage}");
_log.Debug($"Commit Message Cmd Match:{CommitMessageMatches.Success}");
if (_log.Verbosity >= Verbosity.Verbose && CommitMessageMatches.Success)
{
_log.Debug("RegEx Group Matches");
foreach (string groupName in CommitMessageRegex.GetGroupNames())
{
_log.Debug($"{groupName} : {CommitMessageMatches.Groups[groupName].Value}");
}
}
}
if (IsAzureDevops)
{
Branch = _azureProvider.Environment.Repository.Branch;
//CommitMessageShort = _azureProvider.Environment.Repository.Commit.Message;
//var match = CommitMessageRegex.Match(_azureProvider.Environment.Repository.Commit.ExtendedMessage);
//CommitMessageMatches = new MatchResult { Success = match.Success, Groups = match.Groups };
//_log.Debug($"Branch:{Branch}");
//_log.Debug($"Commit Msg Short:{CommitMessageShort}");
//_log.Debug($"Commit Msg Extended:{_appVeyorProvider.Environment.Repository.Commit.ExtendedMessage}");
//_log.Debug($"Commit Message Cmd Match:{CommitMessageMatches.Success}");
//if (_log.Verbosity >= Verbosity.Verbose && CommitMessageMatches.Success)
//{
// _log.Debug("RegEx Group Matches");
// foreach (string groupName in CommitMessageRegex.GetGroupNames())
// {
// _log.Debug($"{groupName} : {CommitMessageMatches.Groups[groupName].Value}");
// }
//}
}
}
/// <summary>
/// Deploys the content of a website
/// </summary>
/// <param name="settings">The deployment settings.</param>
/// <returns>The <see cref="DeploymentChangeSummary"/> that was applied during the deployment.</returns>
public DeploymentChangeSummary Deploy(DeploySettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (settings.SourcePath == null)
{
throw new ArgumentNullException("settings.SourcePath");
}
DeploymentBaseOptions sourceOptions = new DeploymentBaseOptions();
DeploymentBaseOptions destOptions = this.GetBaseOptions(settings);
FilePath sourcePath = settings.SourcePath.MakeAbsolute(_Environment);
string destPath = settings.SiteName;
destOptions.TraceLevel = settings.TraceLevel;
destOptions.Trace += OnTraceEvent;
DeploymentWellKnownProvider sourceProvider = DeploymentWellKnownProvider.ContentPath;
DeploymentWellKnownProvider destProvider = DeploymentWellKnownProvider.Auto;
//If a target path was specified, it could be virtual or physical
if (settings.DestinationPath != null)
{
if (System.IO.Path.IsPathRooted(settings.DestinationPath.FullPath))
{
// If it's rooted (e.g. d:\home\site\foo), use DirPath
sourceProvider = DeploymentWellKnownProvider.DirPath;
destProvider = DeploymentWellKnownProvider.DirPath;
destPath = settings.DestinationPath.FullPath;
}
else
{
// It's virtual, so append it to what we got from the publish profile
destPath += "/" + settings.DestinationPath.FullPath;
}
}
//When a SiteName is given but no DestinationPath
else if (!String.IsNullOrWhiteSpace(settings.SiteName))
{
//use ContentPath so it gets deployed to the Path of the named website in IIS
//which is the same behaviour as in Visual Studio
destProvider = DeploymentWellKnownProvider.ContentPath;
}
//If the content path is a zip file, use the Package provider
string extension = sourcePath.GetExtension();
if (extension != null && extension.Equals(".zip", StringComparison.OrdinalIgnoreCase))
{
// For some reason, we can't combine a zip with a physical target path
if (destProvider == DeploymentWellKnownProvider.DirPath)
{
throw new Exception("A source zip file can't be used with a physical target path");
}
sourceProvider = DeploymentWellKnownProvider.Package;
}
// If a parameters file was specified then read the file in and add the parameters
if (settings.ParametersFilePath != null)
{
FilePath parametersFile = settings.ParametersFilePath.MakeAbsolute(_Environment);
if (System.IO.File.Exists(parametersFile.FullPath))
{
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
doc.Load(parametersFile.FullPath);
System.Xml.XmlNodeList nodes = doc.SelectNodes("/parameters/setParameter");
foreach (System.Xml.XmlElement node in nodes)
{
settings.AddParameter(node.GetAttribute("name"), node.GetAttribute("value"));
}
}
}
//Sync Options
DeploymentSyncOptions syncOptions = new DeploymentSyncOptions
{
DoNotDelete = !settings.Delete,
WhatIf = settings.WhatIf,
UseChecksum = settings.UseChecksum
};
if (settings.UseAppOffline)
{
AddRule(syncOptions, "appOffline");
}
// Add SkipRules
foreach (var rule in settings.SkipRules)
{
syncOptions.Rules.Add(new DeploymentSkipRule(rule.Name, rule.SkipAction, rule.ObjectName, rule.AbsolutePath, rule.XPath));
}
//Deploy
_Log.Debug(Verbosity.Normal, "Deploying Website...");
_Log.Debug(Verbosity.Normal, String.Format("-siteName '{0}'", settings.SiteName));
_Log.Debug(Verbosity.Normal, String.Format("-destination '{0}'", settings.PublishUrl));
_Log.Debug(Verbosity.Normal, String.Format("-source '{0}'", sourcePath.FullPath));
_Log.Debug("");
using (var deploymentObject = DeploymentManager.CreateObject(sourceProvider, sourcePath.FullPath, sourceOptions))
{
foreach (var kv in settings.Parameters)
{
if (deploymentObject.SyncParameters.Contains(kv.Key))
{
deploymentObject.SyncParameters[kv.Key].Value = kv.Value;
}
else
{
deploymentObject.SyncParameters.Add(new DeploymentSyncParameter(kv.Key, kv.Key, "", "")
{
Value = kv.Value
});
}
}
return(deploymentObject.SyncTo(destProvider, destPath, destOptions, syncOptions));
}
}
/// <summary>
/// Installs the specified resource at the given location.
/// </summary>
/// <param name="package">The package reference.</param>
/// <param name="type">The package type.</param>
/// <param name="path">The location where to install the package.</param>
/// <returns>The installed files.</returns>
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
// We are going to assume that the default install location is the
// currently configured location for the Cake Tools Folder
var toolsFolderDirectoryPath = _config.GetToolPath(_environment.WorkingDirectory, _environment);
_log.Debug("Configured Tools Folder: {0}", toolsFolderDirectoryPath);
var toolLocation = toolsFolderDirectoryPath.FullPath;
if (package.Parameters.ContainsKey("global"))
{
toolLocation = "global";
}
// First we need to check if the Tool is already installed
var installedTools = GetInstalledTools(toolLocation);
_log.Debug("Checking for tool: {0}", package.Package.ToLowerInvariant());
var installedTool = installedTools.FirstOrDefault(t => string.Equals(t.Id, package.Package, StringComparison.InvariantCultureIgnoreCase));
if (installedTool != null)
{
// The tool is already installed, so need to check if requested version is the same as
// what is already installed
string requestedVersion = null;
if (package.Parameters.ContainsKey("version"))
{
requestedVersion = package.Parameters["version"].First();
}
if (requestedVersion == null)
{
_log.Warning("Tool {0} is already installed, and no specific version has been requested via pre-processor directive, so leaving current version installed.", package.Package);
}
else if (requestedVersion.ToLowerInvariant() != installedTool.Version.ToLowerInvariant())
{
_log.Warning("Tool {0} is already installed, but a different version has been requested. Uninstall/install will now be performed...", package.Package);
RunDotNetTool(package, toolsFolderDirectoryPath, DotNetToolOperation.Uninstall);
RunDotNetTool(package, toolsFolderDirectoryPath, DotNetToolOperation.Install);
}
else
{
_log.Information("Tool {0} is already installed, with required version.", package.Package);
}
}
else
{
// The tool isn't already installed, go ahead and install it
RunDotNetTool(package, toolsFolderDirectoryPath, DotNetToolOperation.Install);
}
var result = _contentResolver.GetFiles(package, type);
if (result.Count == 0)
{
const string format = "Could not find any relevant files for tool '{0}'. Perhaps you need an include parameter?";
_log.Warning(format, package.Package);
}
return(result);
}
/// <summary>
/// Writes a debug message to the log using the specified string value.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="value">The value.</param>
public static void Debug(this ICakeLog log, string value)
{
log.Debug("{0}", value);
}
/// <summary>
/// Writes a debug message to the log using the specified value.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="value">The value.</param>
public static void Debug(this ICakeLog log, object value)
{
log.Debug("{0}", value);
}
public void Debug(string message)
{
_cakeLogger?.Debug(message);
_serilogLogger?.Debug(message);
}
public void LogDebug(string data) => _log.Debug(data);
public void Initialize(ICakeEngine engine, IFrostingContext context, IEnumerable <IFrostingTask> tasks,
IFrostingLifetime lifetime, IFrostingTaskLifetime taskLifetime)
{
if (tasks != null)
{
foreach (var task in tasks)
{
var taskName = TaskNameHelper.GetTaskName(task);
_log.Debug("Registering task: {0}", taskName);
// Get the task's context type.
if (!task.HasCompatibleContext(context))
{
const string format = "Task cannot be used since the context isn't convertible to {0}.";
_log.Warning(format, task.GetContextType().FullName);
}
else
{
// Register task with the Cake engine.
var cakeTask = engine.RegisterTask(taskName);
// Is the run method overridden?
if (task.IsRunOverridden(context))
{
cakeTask.Does(task.RunAsync);
}
// Is the criteria method overridden?
if (task.IsShouldRunOverridden(context))
{
cakeTask.WithCriteria(task.ShouldRun);
}
// Continue on error?
if (task.IsContinueOnError())
{
cakeTask.ContinueOnError();
}
// Is the on error method overridden?
if (task.IsOnErrorOverridden(context))
{
cakeTask.OnError(exception => task.OnError(exception, context));
}
// Is the finally method overridden?
if (task.IsFinallyOverridden(context))
{
cakeTask.Finally(() => task.Finally(context));
}
// Add dependencies
var attributes = task.GetType().GetTypeInfo().GetCustomAttributes <DependencyAttribute>();
foreach (var dependency in attributes)
{
var dependencyName = TaskNameHelper.GetTaskName(dependency);
if (!typeof(IFrostingTask).IsAssignableFrom(dependency.Task))
{
throw new FrostingException($"The dependency '{dependencyName}' is not a valid task.");
}
cakeTask.IsDependentOn(dependencyName);
}
}
}
}
if (lifetime != null)
{
_log.Debug("Registering lifetime: {0}", lifetime.GetType().Name);
if (lifetime.IsSetupOverridden(context))
{
engine.RegisterSetupAction(info => lifetime.Setup(context));
}
if (lifetime.IsTeardownOverridden(context))
{
engine.RegisterTeardownAction(info => lifetime.Teardown(context, info));
}
}
if (taskLifetime != null)
{
_log.Debug("Registering task lifetime: {0}", taskLifetime.GetType().Name);
if (taskLifetime.IsSetupOverridden(context))
{
engine.RegisterTaskSetupAction(info => taskLifetime.Setup(context, info));
}
if (taskLifetime.IsTeardownOverridden(context))
{
engine.RegisterTaskTeardownAction(info => taskLifetime.Teardown(context, info));
}
}
}
/// <summary>
/// Installs the specified resource at the given location.
/// </summary>
/// <param name="package">The package reference.</param>
/// <param name="type">The package type.</param>
/// <param name="path">The location where to install the package.</param>
/// <returns>The installed files.</returns>
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
// Create the addin directory if it doesn't exist.
path = GetPackagePath(path.MakeAbsolute(_environment), package);
var root = _fileSystem.GetDirectory(path);
var createdDirectory = false;
if (!root.Exists)
{
_log.Debug("Creating package directory {0}...", path);
root.Create();
createdDirectory = true;
}
// Package already exist?
var packagePath = GetPackagePath(root, package.Package);
if (packagePath != null)
{
// Fetch available content from disc.
var content = _contentResolver.GetFiles(packagePath, package, type);
if (content.Any())
{
_log.Debug("Package {0} has already been installed.", package.Package);
return(content);
}
}
// Install the package.
if (!InstallPackage(package, path))
{
_log.Warning("An error occured while installing package {0}.", package.Package);
if (createdDirectory)
{
_log.Debug("Deleting package directory {0}...", path);
root.Delete(true);
return(Array.Empty <IFile>());
}
}
// Try locating the install folder again.
packagePath = GetPackagePath(root, package.Package);
// Get the files.
var result = _contentResolver.GetFiles(packagePath, package, type);
if (result.Count == 0)
{
if (type == PackageType.Addin)
{
var framework = _environment.Runtime.TargetFramework;
_log.Warning("Could not find any assemblies compatible with {0}.", framework.FullName);
}
else if (type == PackageType.Tool)
{
const string format = "Could not find any relevant files for tool '{0}'. Perhaps you need an include parameter?";
_log.Warning(format, package.Package);
}
}
return(result);
}
/// <summary>
/// Deploys the content of a website
/// </summary>
/// <param name="settings">The deployment settings.</param>
/// <returns>The <see cref="DeploymentChangeSummary"/> that was applied during the deployment.</returns>
public DeploymentChangeSummary Deploy(DeploySettings settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (settings.SourcePath == null)
{
throw new ArgumentNullException("settings.SourcePath");
}
DeploymentBaseOptions sourceOptions = new DeploymentBaseOptions();
DeploymentBaseOptions destOptions = this.GetBaseOptions(settings);
FilePath sourcePath = settings.SourcePath.MakeAbsolute(_Environment);
string destPath = settings.SiteName;
destOptions.TraceLevel = settings.TraceLevel;
destOptions.Trace += OnTraceEvent;
DeploymentWellKnownProvider sourceProvider = DeploymentWellKnownProvider.ContentPath;
DeploymentWellKnownProvider destProvider = DeploymentWellKnownProvider.Auto;
//If a target path was specified, it could be virtual or physical
if (settings.DestinationPath != null)
{
if (System.IO.Path.IsPathRooted(settings.DestinationPath.FullPath))
{
// If it's rooted (e.g. d:\home\site\foo), use DirPath
sourceProvider = DeploymentWellKnownProvider.DirPath;
destProvider = DeploymentWellKnownProvider.DirPath;
destPath = settings.DestinationPath.FullPath;
}
else
{
// It's virtual, so append it to what we got from the publish profile
destPath += "/" + settings.DestinationPath.FullPath;
}
}
//When a SiteName is given but no DestinationPath
else if (!String.IsNullOrWhiteSpace(settings.SiteName))
{
//use ContentPath so it gets deployed to the Path of the named website in IIS
//which is the same behaviour as in Visual Studio
destProvider = DeploymentWellKnownProvider.ContentPath;
}
//If the content path is a zip file, use the Package provider
string extension = sourcePath.GetExtension();
if (extension != null && extension.Equals(".zip", StringComparison.OrdinalIgnoreCase))
{
// For some reason, we can't combine a zip with a physical target path
if (destProvider == DeploymentWellKnownProvider.DirPath)
{
throw new Exception("A source zip file can't be used with a physical target path");
}
sourceProvider = DeploymentWellKnownProvider.Package;
}
//Sync Options
DeploymentSyncOptions syncOptions = new DeploymentSyncOptions
{
DoNotDelete = !settings.Delete,
WhatIf = settings.WhatIf
};
//Deploy
_Log.Debug(Verbosity.Normal, "Deploying Website...");
_Log.Debug(Verbosity.Normal, String.Format("-siteName '{0}'", settings.SiteName));
_Log.Debug(Verbosity.Normal, String.Format("-destination '{0}'", settings.PublishUrl));
_Log.Debug(Verbosity.Normal, String.Format("-source '{0}'", sourcePath.FullPath));
_Log.Debug("");
using (var deploymentObject = DeploymentManager.CreateObject(sourceProvider, sourcePath.FullPath, sourceOptions))
{
foreach (var kv in settings.Parameters)
{
deploymentObject.SyncParameters[kv.Key].Value = kv.Value;
}
return(deploymentObject.SyncTo(destProvider, destPath, destOptions, syncOptions));
}
}
public Assembly[] GetReferenceAssemblies()
{
IEnumerable <Assembly> TryGetReferenceAssemblies()
{
foreach (var reference in
#if NETCOREAPP3_1
Basic.Reference.Assemblies.NetCoreApp31.All)
#elif NET5_0
Basic.Reference.Assemblies.Net50.All)
#else
Basic.Reference.Assemblies.Net60.All)
#endif
{
Assembly assembly;
try
{
assembly = Assembly.Load(System.IO.Path.GetFileNameWithoutExtension(reference.FilePath));
}
catch (Exception ex)
{
_log.Debug(log => log("Failed to load {0}\r\nException: {1}", reference.FilePath, ex));
continue;
}
if (assembly == null)
{
continue;
}
yield return(assembly);
foreach (var assemblyRefName in assembly.GetReferencedAssemblies())
{
if (assemblyRefName == null ||
assemblyRefName.Version == VersionZero)
{
continue;
}
Assembly assemblyRef;
try
{
assemblyRef = Assembly.Load(assemblyRefName);
}
catch (Exception ex)
{
_log.Debug(log => log("Failed to load {0}\r\nReference: {1}\r\n Exception: {2}", assemblyRefName, assembly, ex));
continue;
}
if (assemblyRef == null)
{
continue;
}
yield return(assemblyRef);
}
}
}
return(TryGetReferenceAssemblies().ToArray());
}
