public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type) { var files = new List <IFile>(); foreach (var installedPackage in _installedPackages) { if (_blackListedPackages.Contains(installedPackage.Id)) { _log.Warning("Package {0} depends on package {1}. Will not load this dependency...", packageReference.Package, installedPackage.ToString()); continue; } var installPath = new DirectoryPath(_pathResolver.GetInstallPath(installedPackage)); if (!_fileSystem.Exist(installPath)) { _log.Warning("Package {0} is not installed.", installedPackage.Id); 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 = installedPackage.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase) ? packageReference : new PackageReference($"nuget:?package={installedPackage.Id}"); files.AddRange(_contentResolver.GetFiles(installPath, installedPackageReference, type)); } return(files); }
private Type LoadModule(FilePath path) { try { var assembly = LoadAssembly(path); var attribute = assembly.GetCustomAttributes <CakeModuleAttribute>().FirstOrDefault(); if (attribute == null) { _log.Warning("The assembly '{0}' does not have module metadata.", path.FullPath); return(null); } if (!typeof(ICakeModule).IsAssignableFrom(attribute.ModuleType)) { _log.Warning("The module type '{0}' is not an actual module.", attribute.ModuleType.FullName); return(null); } return(attribute.ModuleType); } catch (CakeException) { throw; } catch { _log.Warning("Could not load module '{0}'.", path.FullPath); return(null); } }
// ReSharper disable once UnusedParameter.Local private void AnalyseResultsFile(FilePath resultsFilePath, bool throwOnViolations) { var anyFailures = false; var resultsFile = _fileSystem.GetFile(resultsFilePath); using (var stream = resultsFile.OpenRead()) { var xmlDoc = XDocument.Load(stream); var violations = xmlDoc.Descendants("IssueType").Where(i => i.Attribute("Severity") != null && i.Attribute("Severity").Value == "ERROR"); foreach (var violation in violations) { _log.Warning("Code Inspection Error(s) Located. Description: {0}", violation.Attribute("Description").Value); var tempViolation = violation; // Copy to temporary variable to avoid side effects. var issueLookups = xmlDoc.Descendants("Issue").Where(i => i.Attribute("TypeId") != null && i.Attribute("TypeId").Value == tempViolation.Attribute("Id").Value); foreach (var issueLookup in issueLookups) { var file = issueLookup.Attribute("File") == null ? string.Empty : issueLookup.Attribute("File").Value; var line = issueLookup.Attribute("Line") == null ? string.Empty : issueLookup.Attribute("Line").Value; var message = issueLookup.Attribute("Message") == null ? string.Empty : issueLookup.Attribute("Message").Value; _log.Warning("File Name: {0} Line Number: {1} Message: {2}", file, line, message); } anyFailures = true; } } if (anyFailures && throwOnViolations) { throw new CakeException("Code Inspection Violations found in code base."); } }
private Type LoadModule(FilePath path, ICakeConfiguration configuration) { try { var loader = new AssemblyLoader(_environment, _fileSystem, new AssemblyVerifier(configuration, _log)); var assembly = loader.Load(path, true); var attribute = assembly.GetCustomAttributes <CakeModuleAttribute>().FirstOrDefault(); if (attribute == null) { _log.Warning("The assembly '{0}' does not have module metadata.", path.FullPath); return(null); } if (!typeof(ICakeModule).IsAssignableFrom(attribute.ModuleType)) { _log.Warning("The module type '{0}' is not an actual module.", attribute.ModuleType.FullName); return(null); } return(attribute.ModuleType); } catch (CakeException) { throw; } catch (Exception ex) { _log.Warning("Could not load module '{0}'. {1}", path.FullPath, ex); return(null); } }
public void Execute(Script script) { // Generate the script code. var generator = new RoslynCodeGenerator(); var code = generator.Generate(script); // Warn about any code generation excluded namespaces foreach (var @namespace in script.ExcludedNamespaces) { _log.Warning("Namespace {0} excluded by code generation, affected methods:\r\n\t{1}", @namespace.Key, string.Join("\r\n\t", @namespace.Value)); } // Create the script options dynamically. var options = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default .AddImports(Namespaces.Except(script.ExcludedNamespaces.Keys)) .AddReferences(References) .AddReferences(ReferencePaths.Select(r => r.FullPath)) .WithEmitDebugInformation(_settings.Debug) .WithMetadataResolver(Microsoft.CodeAnalysis.Scripting.ScriptMetadataResolver.Default); var roslynScript = CSharpScript.Create(code, options, _host.GetType()); _log.Verbose("Compiling build script..."); var compilation = roslynScript.GetCompilation(); var diagnostics = compilation.GetDiagnostics(); var errors = new List <Diagnostic>(); foreach (var diagnostic in diagnostics) { switch (diagnostic.Severity) { case DiagnosticSeverity.Info: _log.Information(diagnostic.ToString()); break; case DiagnosticSeverity.Warning: _log.Warning(diagnostic.ToString()); break; case DiagnosticSeverity.Error: _log.Error(diagnostic.ToString()); errors.Add(diagnostic); break; default: break; } } if (errors.Any()) { var errorMessages = string.Join(Environment.NewLine, errors.Select(x => x.ToString())); var message = string.Format(CultureInfo.InvariantCulture, "Error(s) occurred when compiling build script:{0}{1}", Environment.NewLine, errorMessages); throw new CakeException(message); } roslynScript.RunAsync(_host).Wait(); }
/// <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); if (!root.Exists) { _log.Debug("Creating directory {0}", path); root.Create(); } // 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. InstallPackage(package, path); // 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); }
private void AnalyzeResultsFile(FilePath resultsFilePath, bool throwOnDuplicates) { var anyFailures = false; var resultsFile = _fileSystem.GetFile(resultsFilePath); var xmlDoc = XDocument.Load(resultsFile.Open(FileMode.Open)); var duplicates = xmlDoc.Descendants("Duplicate"); foreach (var duplicate in duplicates) { var cost = duplicate.Attribute("Cost") == null ? string.Empty : duplicate.Attribute("Cost").Value; _log.Warning("Duplicate Located with a cost of {0}, across {1} Fragments", cost, duplicate.Descendants("Fragment").Count()); foreach (var fragment in duplicate.Descendants("Fragment")) { var fileNameNode = fragment.Descendants("FileName").FirstOrDefault(); var lineRangeNode = fragment.Descendants("LineRange").FirstOrDefault(); if (fileNameNode != null && lineRangeNode != null) { var start = lineRangeNode.Attribute("Start") == null ? string.Empty : lineRangeNode.Attribute("Start").Value; var end = lineRangeNode.Attribute("End") == null ? string.Empty : lineRangeNode.Attribute("End").Value; _log.Warning("File Name: {0} Line Numbers: {1} - {2}", fileNameNode.Value, start, end); } } anyFailures = true; } if (anyFailures && throwOnDuplicates) { throw new CakeException("Duplicates found in code base."); } }
/// <inheritdoc/> 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); } } _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); }
/// <summary> /// Installs the specified resource. /// </summary> /// <param name="package">The package resource.</param> /// <param name="type">The package type.</param> /// <param name="path">The location where to install the resource.</param> /// <returns>The installed files.</returns> public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path) { if (package == null) { throw new ArgumentNullException(nameof(package)); } // find npm _log.Debug("looking for npm.cmd"); var npmTool = _toolLocator.Resolve("npm.cmd"); if (npmTool == null) { _log.Debug("looking for npm"); npmTool = _toolLocator.Resolve("npm"); } if (npmTool == null) { throw new FileNotFoundException("npm could not be found."); } _log.Debug("Found npm at {0}", npmTool); // Install the package. _log.Debug("Installing package {0} with npm...", package.Package); var process = _processRunner.Start( npmTool.FullPath, new ProcessSettings { Arguments = GetArguments(package, _config), RedirectStandardOutput = true, Silent = _log.Verbosity < Verbosity.Diagnostic }); process.WaitForExit(); var exitCode = process.GetExitCode(); if (exitCode != 0) { _log.Warning("npm exited with {0}", exitCode); var output = string.Join(Environment.NewLine, process.GetStandardOutput()); _log.Verbose(Verbosity.Diagnostic, "Output:\r\n{0}", output); } var result = _contentResolver.GetFiles(package, type, package.GetSwitch("global")); if (result.Count != 0) { return(result); } _log.Warning("Could not determine installed package files! Installation may not be complete."); // TODO: maybe some warnings here return(result); }
public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type) { bool loadDependencies; if (packageReference.Parameters.ContainsKey("LoadDependencies")) { bool.TryParse(packageReference.Parameters["LoadDependencies"].FirstOrDefault() ?? bool.TrueString, out loadDependencies); } else { bool.TryParse(_config.GetValue(Constants.NuGet.LoadDependencies) ?? bool.FalseString, out loadDependencies); } var files = new List <IFile>(); var package = _installedPackages.First(p => p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase)); var installPath = new DirectoryPath(_pathResolver.GetInstallPath(package)); if (!_fileSystem.Exist(installPath)) { _log.Warning("Package {0} is not installed.", packageReference.Package); return(Array.Empty <IFile>()); } files.AddRange(_contentResolver.GetFiles(installPath, packageReference, type)); if (loadDependencies) { foreach (var dependency in _installedPackages .Where(p => !p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase))) { if (_blackListedPackages.Contains(dependency.Id)) { _log.Warning("Package {0} depends on package {1}. Will not load this dependency...", packageReference.Package, dependency.ToString()); continue; } var dependencyInstallPath = new DirectoryPath(_pathResolver.GetInstallPath(dependency)); if (!_fileSystem.Exist(dependencyInstallPath)) { _log.Warning("Package {0} is not installed.", dependency.Id); continue; } files.AddRange(_contentResolver.GetFiles(dependencyInstallPath, packageReference, type)); } } return(files); }
/// <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 installedToolNames = GetInstalledTools(toolLocation); _log.Debug("Checking for tool: {0}", package.Package.ToLowerInvariant()); if (installedToolNames.Contains(package.Package.ToLowerInvariant())) { _log.Information("Tool {0} is already installed, so nothing to do here.", package.Package); } else { InstallTool(package, toolsFolderDirectoryPath); } 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); }
private void ExecuteProcess(FilePath filePath, ProcessArgumentBuilder arguments, int timeout = DefaultTimeoutMs) { try { // Start Runner filePath = filePath.MakeAbsolute(_Environment.WorkingDirectory); IProcess process = _Runner.Start(filePath, new ProcessSettings() { Arguments = arguments, RedirectStandardError = true }); process.WaitForExit(timeout); // Check for Errors IEnumerable <string> errors = process.GetStandardError(); if (errors.Count() > 0) { throw new Exception(string.Join(",", errors)); } } catch (Exception ex) { if (!(ex is TimeoutException)) { throw; } _Log.Warning("Process timed out!"); } }
/// <summary> /// Finds assemblies (DLLs) included in a nuget package. /// </summary> /// <param name="packageDirectory">The package directory.</param> /// <returns> /// the DLLs. /// </returns> public IReadOnlyList <IFile> FindAssemblies(DirectoryPath packageDirectory) { if (packageDirectory == null) { throw new ArgumentNullException("packageDirectory"); } if (packageDirectory.IsRelative) { throw new CakeException("Package directory (" + packageDirectory.FullPath + ") must be an absolute path."); } if (!_fileSystem.Exist(packageDirectory)) { return(new List <IFile>().AsReadOnly()); } var packageAssemblies = GetAllPackageAssemblies(packageDirectory); if (!packageAssemblies.Any()) { _log.Warning("Unable to locate any assemblies under {0}", packageDirectory.FullPath); } var compatibleAssemblyPaths = FilterCompatibleAssemblies(packageAssemblies, packageDirectory); var resolvedAssemblyFiles = ResolveAssemblyFiles(compatibleAssemblyPaths); return(resolvedAssemblyFiles); }
public void Load(IScriptAnalyzerContext context, LoadReference reference) { #if NETCORE throw new NotSupportedException("The NuGet provider for #load is not supported on .NET Core."); #else // Create a package reference from our load reference. // The package should contain the necessary include parameters to make sure // that .cake files are included as part of the result. var separator = reference.OriginalString.Contains("?") ? "&" : "?"; var uri = string.Concat(reference.OriginalString, $"{separator}include=./**/*.cake"); var package = new PackageReference(uri); // Find the tool folder. var toolPath = GetToolPath(context.Root.GetDirectory()); // Install the NuGet package. var files = _installer.Install(package, PackageType.Tool, toolPath); if (files.Count == 0) { // No files found. _log.Warning("No scripts found in NuGet package {0}.", package.Package); return; } foreach (var file in files) { var extension = file.Path.GetExtension(); if (extension != null && extension.Equals(".cake", StringComparison.OrdinalIgnoreCase)) { context.Analyze(file.Path); } } #endif }
/// <inheritdoc/> public void Verify(Assembly assembly) { _log.Debug(_skipVerification ? "Skipping verification of assembly '{0}'." : "Verifying assembly '{0}'.", assembly.FullName); // Verify that the assembly is valid. // We're still pre 1.0, so there are breaking changes from time to time. // We can refuse to load assemblies that reference too old version of Cake. var references = assembly.GetReferencedAssemblies(); foreach (var reference in references) { if (reference.Name.Equals("Cake.Core")) { if (reference.Version < Constants.LatestBreakingChange) { // The assembly is referencing a version of Cake that contains breaking changes. const string message = "The assembly '{0}' \r\n" + "is referencing an older version of Cake.Core ({1}). \r\n" + "This assembly must reference at least Cake.Core version {2}. \r\n" + "Another option is to downgrade Cake to an earlier version. \r\n" + "It's not recommended, but you can explicitly opt out of assembly verification \r\n" + "by configuring the Skip Verification setting to true\r\n" + "(i.e. command line parameter \"--settings_skipverification=true\", \r\n" + "environment variable \"CAKE_SETTINGS_SKIPVERIFICATION=true\", \r\n" + "read more about configuration at https://cakebuild.net/docs/running-builds/configuration/)"; var args = new object[] { assembly.FullName, reference.Version.ToString(3), Constants.LatestBreakingChange.ToString(3) }; if (_skipVerification) { _log.Debug( message, args); return; } throw new CakeException(string.Format(message, args)); } if (reference.Version < Constants.LatestPotentialBreakingChange) { // The assembly is referencing a version of Cake that might contain breaking changes. const string message = "The assembly '{0}' \r\n" + "is referencing an older version of Cake.Core ({1}). \r\n" + "For best compatibility it should target Cake.Core version {2}."; _log.Warning( _skipVerification ? Verbosity.Verbose : Verbosity.Minimal, message, assembly.FullName, reference.Version.ToString(3), Constants.LatestPotentialBreakingChange.ToString(3)); } } } }
public ParallelCakeEngine(ICakeLog logger) { logger.Warning("PARALLELIZER IS A WORK IN PROGRESS! YOU HAVE BEEN WARNED"); _logger = logger; _tasks = new List <CakeTask>(); }
/// <summary> /// Gets all environment variables. /// </summary> /// <returns>The environment variables as IDictionary<string, string> </returns> public IDictionary <string, string> GetEnvironmentVariables() { return(Environment.GetEnvironmentVariables() .Cast <System.Collections.DictionaryEntry>() .Aggregate( new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase), (dictionary, entry) => { var key = (string)entry.Key; var value = entry.Value as string; if (dictionary.TryGetValue(key, out var existingValue)) { if (!StringComparer.OrdinalIgnoreCase.Equals(value, existingValue)) { _log.Warning("GetEnvironmentVariables() encountered duplicate for key: {0}, value: {1} (existing value: {2})", key, value, existingValue); } } else { dictionary.Add(key, value); } return dictionary; }, dictionary => dictionary)); }
private IReadOnlyCollection <IFile> GetAddinAssemblies(DirectoryPath path, PackageReference package) { if (!_fileSystem.Exist(path)) { return(new List <IFile>()); } // Get current framework. var provider = DefaultFrameworkNameProvider.Instance; var current = NuGetFramework.Parse(_environment.Runtime.BuiltFramework.FullName, provider); // Get all ref assemblies. var refAssemblies = _globber.GetFiles(path.FullPath + "/ref/**/*.dll"); // Get all candidate files. var pathComparer = PathComparer.Default; var assemblies = GetFiles(path, package, new[] { path.FullPath + "/**/*.dll" }) .Where(file => !"Cake.Core.dll".Equals(file.Path.GetFilename().FullPath, StringComparison.OrdinalIgnoreCase) && IsCLRAssembly(file) && !refAssemblies.Contains(file.Path, pathComparer)) .ToList(); // Iterate all found files. var comparer = new NuGetFrameworkFullComparer(); var mapping = new Dictionary <NuGetFramework, List <FilePath> >(comparer); foreach (var assembly in assemblies) { // Get relative path. var relative = path.GetRelativePath(assembly.Path); var framework = ParseFromDirectoryPath(current, relative.GetDirectory()); if (!mapping.ContainsKey(framework)) { mapping.Add(framework, new List <FilePath>()); } mapping[framework].Add(assembly.Path); } // Reduce found frameworks to the closest one. var reducer = new FrameworkReducer(); var nearest = reducer.GetNearest(current, mapping.Keys); if (nearest == null || !mapping.ContainsKey(nearest)) { return(new List <IFile>()); } if (nearest == NuGetFramework.AnyFramework) { var framework = _environment.Runtime.BuiltFramework; _log.Warning("Could not find any assemblies compatible with {0} in NuGet package {1}. " + "Falling back to using root folder of NuGet package.", framework.FullName, package.Package); } // Return the result. return(mapping[nearest].Select(p => _fileSystem.GetFile(p)).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("package"); } if (path == null) { throw new ArgumentNullException("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, 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); } // Return the files. return(_contentResolver.GetFiles(packagePath, type)); }
public IEnumerable <string> GetStandardError() { string line; while ((line = _process.StandardError.ReadLine()) != null) { _log.Warning("{0}", _filterOutput(line)); yield return(line); } }
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path) { if (package == null) { throw new ArgumentNullException(nameof(package)); } if (_environment.Platform.Family != PlatformFamily.Linux) { _log.Warning("Non-Linux platform detected! Not attempting installation..."); return(_contentResolver.GetFiles(package, type)); } // Install the package. _log.Debug("Installing package {0} with APT...", package.Package); var process = _processRunner.Start( "apt-get", new ProcessSettings { Arguments = GetArguments(package, _config), RedirectStandardOutput = true, Silent = _log.Verbosity < Verbosity.Diagnostic }); process.WaitForExit(); var exitCode = process.GetExitCode(); if (exitCode != 0) { _log.Warning("APT exited with {0}", exitCode); var output = string.Join(Environment.NewLine, process.GetStandardOutput()); _log.Verbose(Verbosity.Diagnostic, "Output:\r\n{0}", output); } var result = _contentResolver.GetFiles(package, type); if (result.Count != 0) { return(result); } // TODO: maybe some warnings here return(result); }
public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type) { var loadDependencies = packageReference.ShouldLoadDependencies(_config); var files = new List <IFile>(); var package = _installedPackages.First(p => p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase)); var installPath = new DirectoryPath(_pathResolver.GetInstallPath(package)); if (!_fileSystem.Exist(installPath)) { _log.Warning("Package {0} is not installed.", packageReference.Package); return(Array.Empty <IFile>()); } files.AddRange(_contentResolver.GetFiles(installPath, packageReference, type)); if (loadDependencies) { foreach (var dependency in _installedPackages .Where(p => !p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase))) { if (_blackListedPackages.Contains(dependency.Id)) { _log.Warning("Package {0} depends on package {1}. Will not load this dependency...", packageReference.Package, dependency.ToString()); continue; } var dependencyInstallPath = new DirectoryPath(_pathResolver.GetInstallPath(dependency)); if (!_fileSystem.Exist(dependencyInstallPath)) { _log.Warning("Package {0} is not installed.", dependency.Id); continue; } files.AddRange(_contentResolver.GetFiles(dependencyInstallPath, packageReference, type)); } } return(files); }
public ParallelCakeEngine(ICakeLog log) { if (log == null) { throw new ArgumentNullException(nameof(log)); } log.Warning("PARALLELIZER IS A WORK IN PROGRESS! YOU HAVE BEEN WARNED"); _log = log; _tasks = new List <CakeTask>(); }
internal bool EnsureSourceExists() { var data = new EventSourceCreationData(Settings.SourceName, Settings.LogName) { MachineName = Settings.MachineName }; var exists = false; try { exists = System.Diagnostics.EventLog.Exists(Settings.SourceName); if (!exists) { _log?.Information("Source does not exist. Creating..."); System.Diagnostics.EventLog.CreateEventSource(data); exists = System.Diagnostics.EventLog.SourceExists(Settings.SourceName); } } catch (SecurityException) { // we couldn't determine if the source exists LogPrivilegeWarning(); _log?.Warning("Could not determine if the source exists. Attempting creation."); try { System.Diagnostics.EventLog.CreateEventSource(data); } catch (ArgumentException) { // couldn't test if exists but creation failed _log?.Information("Creating event source failed! The source apepars to already exist."); exists = true; } } catch (Exception) { exists = false; } return(exists); }
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} with engine...", taskName); // Get the task's context type. if (!task.HasCompatibleContext(context)) { const string format = "Task cannot be used since the context isn't convertable to {0}."; _log.Warning(format, task.GetContextType().FullName); } else { // Register task with the Cake engine. var cakeTask = engine.RegisterTask(taskName); cakeTask.Does(task.Run); cakeTask.WithCriteria(task.ShouldRun); // 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} does not implement IFrostingTask."); } cakeTask.IsDependentOn(dependencyName); } } } } if (lifetime != null) { _log.Debug("Registering lifetime {0} with engine...", lifetime.GetType().FullName); engine.RegisterSetupAction(info => lifetime.Setup(context)); engine.RegisterTeardownAction(info => lifetime.Teardown(context, info)); } if (taskLifetime != null) { _log.Debug("Registering task lifetime {0} with engine...", taskLifetime.GetType().Name); engine.RegisterTaskSetupAction(info => taskLifetime.Setup(context, info)); engine.RegisterTaskTeardownAction(info => taskLifetime.Teardown(context, info)); } }
public void Load(IScriptAnalyzerContext context, LoadReference reference) { FilePath path = null; if (reference.Parameters.ContainsKey("path")) { if (reference.Parameters["path"].Count == 1) { path = reference.Parameters["path"].FirstOrDefault(); } else if (reference.Parameters["path"].Count > 1) { throw new CakeException("Query string for #load contains more than one parameter 'path'."); } } if (path == null) { throw new CakeException("Query string for #load is missing parameter 'path'."); } // URL decode the path. path = new FilePath(WebUtility.UrlDecode(path.FullPath)); // Get the current script path. var current = context.Current.Path.GetDirectory(); path = path.MakeAbsolute(current); var expectedExtension = path.HasExtension ? path.GetExtension() : ".cake"; var files = _globber .GetFiles(path.FullPath) .Where(file => { var extension = file.GetExtension(); return(extension != null && (extension.Equals(".cake", StringComparison.OrdinalIgnoreCase) || extension.Equals(expectedExtension, StringComparison.OrdinalIgnoreCase))); }) .ToArray(); if (files.Length == 0) { // No scripts found. _log.Warning("No scripts found at {0}.", path); return; } foreach (var file in files) { context.Analyze(file); } }
public SolutionInfoResult GetSolutionToBuild(string fileName = null) { var files = _globber.GetFiles("./**/*.sln").ToList(); if (files.Count == 0) { throw new Exception("Solution file not found"); } if (files.Count > 1) { if (string.IsNullOrWhiteSpace(fileName)) { _log.Warning("Multiple solution files found"); foreach (var file in files) { _log.Warning(file.FullPath); } } else { var matchFile = files.FirstOrDefault(f => string.Compare(f.GetFilename().ToString(), fileName, StringComparison.OrdinalIgnoreCase) == 0); if (matchFile == null) { throw new Exception($"Solution file specified as {fileName} was not found"); } return(new SolutionInfoResult { SolutionFileAndPath = matchFile.FullPath, SolutionFilename = matchFile.GetFilename().ToString() }); } } return(new SolutionInfoResult { SolutionFileAndPath = files[0].FullPath, SolutionFilename = files[0].GetFilename().ToString() }); }
public void Register(ICakeContainerRegistrar registrar) { if (registrar == null) { throw new ArgumentNullException(nameof(registrar)); } if (_options.Mono) { _log.Warning("The Mono script engine has been removed so the expected behavior might differ. " + "See Release Notes for Cake 0.22.0 for more information."); } registrar.RegisterType <RoslynScriptEngine>().As <IScriptEngine>().Singleton(); }
private UnityVersion DetermineVersion(FilePath editorPath) { log.Debug("Determining version of Unity Editor at path {0}...", editorPath); var fileVersion = FileVersionInfo.GetVersionInfo(editorPath.FullPath); var(year, stream, update) = (fileVersion.FileMajorPart, fileVersion.FileMinorPart, fileVersion.FileBuildPart); if (year <= 0 || stream <= 0 || update < 0) { log.Warning("Unity Editor file version {0} is incorrect.", $"{year}.{stream}.{update}.{fileVersion.FilePrivatePart}"); log.Warning("Expected first two numbers to be positive and third one to be non negative."); log.Warning("Path: {0}", editorPath.FullPath); log.Warning(string.Empty); return(null); } log.Debug("Unity version from file version: {0}.{1}.{2}", year, stream, update); var suffix = DetermineVersionSuffix(editorPath, year, stream, update); if (suffix.HasValue) { var version = new UnityVersion(year, stream, update, suffix.Value.character, suffix.Value.number); log.Debug("Result Unity Editor version (full): {0}", version); log.Debug(string.Empty); return(version); } else { var version = new UnityVersion(year, stream, update); log.Debug("Result Unity Editor version (short): {0}", version); log.Debug(string.Empty); return(version); } }
public void Log(MessageLevel level, string message, params object[] args) { switch (level) { case MessageLevel.Warning: _log.Warning(message, args); break; case MessageLevel.Error: _log.Error(message, args); break; default: _log.Debug(message, args); break; } }