private IReadOnlyCollection <IFile> GetToolFiles(PackageReference package, bool isGlobal = false) { DirectoryPath modulesPath; if (isGlobal) { modulesPath = GetGlobalPrefix()?.Combine("./bin/") ?? "./bin"; _log.Verbose($"Found global npm path at: {modulesPath.FullPath}"); _log.Verbose( "Using global npm binaries folder: installation may succeed without binaries being installed"); } else { modulesPath = GetLocalInstallPath(package); _log.Verbose("Using local install path: " + modulesPath?.FullPath); } if (modulesPath == null || !_fileSystem.GetDirectory(modulesPath).Exists) { throw new System.IO.DirectoryNotFoundException("Could not determine install path!"); } var installRoot = _fileSystem.GetDirectory(modulesPath); if (installRoot.Exists) { return(new ReadOnlyCollection <IFile>(installRoot.GetFiles("*", SearchScope.Recursive).ToList())); } return(new ReadOnlyCollection <IFile>(new List <IFile>())); }
/// <summary> /// Runs the specified target. /// </summary> /// <param name="target">The target to run.</param> /// <returns>The resulting report.</returns> public CakeReport RunTarget(string target) { var graph = CakeGraphBuilder.Build(_tasks); // Make sure target exist. if (!graph.Exist(target)) { const string format = "The target '{0}' was not found."; throw new CakeException(string.Format(CultureInfo.InvariantCulture, format, target)); } var stopWatch = new Stopwatch(); var report = new CakeReport(); foreach (var task in graph.Traverse(target)) { var taskNode = _tasks.FirstOrDefault(x => x.Name.Equals(task, StringComparison.OrdinalIgnoreCase)); Debug.Assert(taskNode != null, "Node should not be null."); if (ShouldTaskExecute(taskNode)) { _log.Verbose("Executing task: {0}", taskNode.Name); ExecuteTask(stopWatch, taskNode, report); _log.Verbose("Finished executing task: {0}", taskNode.Name); } } return(report); }
/// <summary> /// Starts an Amazon EBS-backed AMI that you've previously stopped. Instances that use Amazon EBS volumes as their root devices can be quickly stopped /// and started. When an instance is stopped, the compute resources are released and you are not billed for hourly instance usage. However, your root partition /// Amazon EBS volume remains, continues to persist your data, and you are charged for Amazon EBS volume usage. You can restart your instance at any time. Each /// time you transition an instance from stopped to started, Amazon EC2 charges a full instance hour, even if transitions happen multiple times within a single hour. /// </summary> /// <param name="instances">A list of instance IDs to be started.</param> /// <param name="settings">The <see cref="EC2Settings"/> used during the request to AWS.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> public async Task <bool> StartInstances(IList <string> instances, EC2Settings settings, CancellationToken cancellationToken = default(CancellationToken)) { if ((instances == null) || (instances.Count == 0)) { throw new ArgumentNullException("instances"); } //Create Request AmazonEC2Client client = this.CreateClient(settings); StartInstancesRequest request = new StartInstancesRequest(); foreach (string instance in instances) { request.InstanceIds.Add(instance); } //Check Response StartInstancesResponse response = await client.StartInstancesAsync(request, cancellationToken); if (response.HttpStatusCode == HttpStatusCode.OK) { _Log.Verbose("Successfully started instances '{0}'", string.Join(",", instances)); return(true); } else { _Log.Error("Failed to start instances '{0}'", string.Join(",", instances)); return(false); } }
public void Add(DirectoryPath value, PathSettings pathSettings) { if (value == null) { throw new ArgumentNullException(nameof(value), "Value to add to path is null."); } if (pathSettings == null) { throw new ArgumentNullException(nameof(pathSettings), "Path settings is null."); } var pathTarget = pathSettings .Target .GetValueOrDefault(PathTarget.User); var parts = _environmentWrapper .GetEnvironmentVariable("PATH", pathTarget, string.Empty) .Split(';') .Where(x => !string.IsNullOrWhiteSpace(x)) .ToList(); if (parts.Contains(value.FullPath)) { _log.Verbose($"PATH already contains '{value}'."); return; } parts.Add(value.FullPath); _environmentWrapper.SetEnvironmentVariable("PATH", string.Join(";", parts), pathTarget); _log.Verbose($"Added '{value}' to PATH."); }
private Assembly AssemblyResolve(object sender, ResolveEventArgs args) { var name = new AssemblyName(args.Name); // Prevent recursion from the Assembly.Load() call inside if (_resolvedNames.Add(name.Name)) { _log.Verbose($"Resolving assembly {args.Name}"); try { var assembly = AppDomain.CurrentDomain.GetAssemblies() .FirstOrDefault(x => !x.IsDynamic && x.GetName().Name == name.Name) ?? Assembly.Load(name.Name); if (assembly != null) { _log.Verbose($"Resolved {name.Name} by assembly {assembly.FullName}"); } else { _log.Verbose($"Assembly {name.Name} not resolved"); } return(assembly); } catch (Exception ex) { _log.Verbose($"Exception while resolving assembly {name.Name}: {ex.Message}"); } } return(null); }
public void CreateIso(string inputPath, string outputPath, string volumeIdentifier) { _log.Verbose($"Creating ISO from directory {inputPath}"); var builder = new CDBuilder { UseJoliet = true, VolumeIdentifier = volumeIdentifier ?? "CAKE_ISO" }; foreach (var entry in Directory.GetFileSystemEntries(inputPath, "*", SearchOption.AllDirectories)) { var fileInfo = new FileInfo(entry); if ((fileInfo.Attributes & FileAttributes.Directory) != 0) { _log.Verbose($"Creating directory: {Path.GetFullPath(entry).Replace(inputPath, "")}"); builder.AddDirectory(Path.GetFullPath(entry).Replace(inputPath, "")); } else { _log.Verbose($"Creating file: {Path.GetFullPath(entry).Replace(inputPath, "")}"); builder.AddFile(Path.GetFullPath(entry).Replace(inputPath, ""), entry); } } builder.Build(outputPath); }
/// <summary> /// Uploads a file. /// </summary> /// <param name="serverUri">The URI for the FTP server.</param> /// <param name="uploadFile">The file to upload.</param> /// <param name="username">The FTP username.</param> /// <param name="password">The FTP password.</param> public void UploadFile(Uri serverUri, IFile uploadFile, string username, string password) { // Adding verbose logging for the URI being used. _log.Verbose("Uploading file to {0}", serverUri); // Creating the request var request = (FtpWebRequest)WebRequest.Create(serverUri); request.Method = WebRequestMethods.Ftp.UploadFile; request.Credentials = new NetworkCredential(username, password); request.ContentLength = uploadFile.Length; using (var stream = new FileStream(uploadFile.Path.FullPath, FileMode.Open, FileAccess.Read)) { var requestStream = request.GetRequestStream(); stream.CopyTo(requestStream); requestStream.Close(); // Getting the response from the FTP server. var response = (FtpWebResponse)request.GetResponse(); // Logging if it completed and the description of the status returned. _log.Information("File upload complete, status {0}", response.StatusDescription); response.Close(); } }
private void Install(DirectoryPath root) { if (root == null) { throw new ArgumentNullException("root"); } var installRoot = root.Combine(Guid.NewGuid().ToString().Replace("-", string.Empty)); // Install package. _log.Verbose("Installing package..."); var repository = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2"); var packageManager = new PackageManager(repository, installRoot.FullPath); packageManager.InstallPackage("Roslyn.Compilers.CSharp", new SemanticVersion(new Version(1, 2, 20906, 2)), false, true); // Copy files _log.Verbose("Copying files..."); foreach (var path in _paths) { var source = _fileSystem.GetFile(installRoot.CombineWithFilePath(path)); var destination = _fileSystem.GetFile(root.CombineWithFilePath(path.GetFilename())); _log.Information("Copying {0}...", source.Path.GetFilename()); if (!destination.Exists) { source.Copy(destination.Path, true); } } // Delete the install directory. _log.Verbose("Deleting installation directory..."); _fileSystem.GetDirectory(installRoot).Delete(true); }
/// <summary> /// Returns the build definition for the <paramref name="settings"/>. /// </summary> /// <param name="log">The Cake log context.</param> /// <param name="settings">Settings for accessing AzureDevOps.</param> /// <returns>The build definition for the BuildDefinitionName on <paramref name="settings"/>. /// <c>null</c> if the BuildDefinitionName was not set or no build definition was found.</returns> private static AzureDevOpsBuildDefinition GetBuildDefinition( ICakeLog log, AzureDevOpsBuildsSettings settings) { log.NotNull(nameof(log)); settings.NotNull(nameof(settings)); var buildDefinitions = AzureDevOpsBuildsDefinitionHelper .GetAzureDevOpsBuildDefinitions( log, settings); var buildDefinition = buildDefinitions .SingleOrDefault(x => x.Name.Equals(settings.BuildDefinitionName, StringComparison.InvariantCultureIgnoreCase)); if (buildDefinition == null) { log.Verbose( "Build definition '{0}' not found", settings.BuildDefinitionName); } log.Verbose( "Build definition '{0}' found", settings.BuildDefinitionName); return(buildDefinition); }
public void UploadFile(Uri serverUri, IFile uploadFile, string username, string password) { // Adding verbose logging for the URI being used. _log.Verbose("Uploading file to {0}", serverUri); // Creating the request var request = (FtpWebRequest)WebRequest.Create(serverUri); request.Method = WebRequestMethods.Ftp.UploadFile; // Adding verbose logging for credentials used. _log.Verbose("Using the following credentials {0}, {1}", username, password); request.Credentials = new NetworkCredential(username, password); using (var streamReader = new StreamReader(uploadFile.OpenRead())) { // Get the file contents. var fileContents = Encoding.UTF8.GetBytes(streamReader.ReadToEnd()); request.ContentLength = fileContents.Length; // Writing the file to the request stream. var requestStream = request.GetRequestStream(); requestStream.Write(fileContents, 0, fileContents.Length); requestStream.Close(); // Getting the response from the FTP server. var response = (FtpWebResponse)request.GetResponse(); // Logging if it completed and the description of the status returned. _log.Information("File upload complete, status {0}", response.StatusDescription); response.Close(); } }
/// <summary> /// Does the actual bootstrapping. /// </summary> /// <param name="version">The Version to download.</param> internal void Bootstrap(GradleVersionIdentifier version) { var versionInfo = GetGradleVersion(version) .ConfigureAwait(false) .GetAwaiter() .GetResult(); _log.Verbose($"Current gradle version is {versionInfo.Version}"); var toolsFolder = _fileSystem.GetDirectory( _config.GetToolPath(_environment.WorkingDirectory, _environment)); if (!toolsFolder.Exists) { toolsFolder.Create(); } var gradleInstallFolder = toolsFolder.Path.Combine($"gradle-{versionInfo.Version}"); if (_fileSystem.GetDirectory(gradleInstallFolder).Exists) { _log.Debug("Gradle tool directory exists. Not downloading."); return; } // download gradle var gradleZip = DownloadGradle(versionInfo.DownloadUrl, toolsFolder.Path) .ConfigureAwait(false) .GetAwaiter() .GetResult(); UnzipGradle(gradleZip, toolsFolder.Path); }
/// <summary> /// Installs a Topshelf windows service /// </summary> /// <param name="filePath">The file path of the Topshelf executable to install.</param> /// <param name="settings">The <see cref="TopshelfSettings"/> used to install the service.</param> public void InstallService(FilePath filePath, TopshelfSettings settings = null) { if (filePath == null) { throw new ArgumentNullException("filePath"); } this.ExecuteProcess(filePath, this.GetInstallArguments(settings), settings.Timeout); _Log.Verbose("Topshelf service installed."); }
internal string CreateNewVersionAsync(HockeyAppUploadSettings settings) { _log.Verbose($"Creating Version {settings.ShortVersion} ({settings.Version}) for {settings.AppId}."); var response = _client.CreateNewVersionAsync(settings.ApiToken, settings.AppId, settings.Version, settings.ShortVersion); _log.Information($"Created Version {response.ShortVersion} ({response.Version}) for {response.Title}."); return(response.Id); }
public bool CreateApplicationVersion(string applicationName, string description, string versionLabel, string s3Bucket, string s3Key, bool autoCreateApplication, ElasticBeanstalkSettings settings) { if (string.IsNullOrEmpty(applicationName)) { throw new ArgumentNullException("applicationName"); } if (string.IsNullOrEmpty(description)) { throw new ArgumentNullException("description"); } if (string.IsNullOrEmpty(versionLabel)) { throw new ArgumentNullException("versionLabel"); } if (string.IsNullOrEmpty(s3Bucket)) { throw new ArgumentNullException("s3Bucket"); } if (string.IsNullOrEmpty(s3Key)) { throw new ArgumentNullException("s3Key"); } try { var client = GetClient(settings); client.CreateApplicationVersion(new CreateApplicationVersionRequest { ApplicationName = applicationName, AutoCreateApplication = autoCreateApplication, Description = description, //Process = true, VersionLabel = versionLabel, SourceBundle = new S3Location { S3Bucket = s3Bucket, S3Key = s3Key } }); } catch (Exception ex) { _Log.Error("Failed to create new application version '{0}'", ex.Message); return(false); } _Log.Verbose("Successfully created new application version '{0}' for application '{1}'", versionLabel, applicationName); return(true); }
/// <summary> /// Returns the build definition for the <paramref name="settings"/>. /// </summary> /// <param name="log">The Cake log context.</param> /// <param name="buildHttpClient">The Http build client.</param> /// <param name="settings">Settings for accessing AzureDevOps.</param> /// <returns>The build definition for the BuildDefinitionName on <paramref name="settings"/>. /// <c>null</c> if the BuildDefinitionName was not set or no build definition was found.</returns> private static BuildDefinitionReference GetBuildDefinition( ICakeLog log, BuildHttpClient buildHttpClient, AzureDevOpsBuildsSettings settings) { log.NotNull(nameof(log)); buildHttpClient.NotNull(nameof(buildHttpClient)); settings.NotNull(nameof(settings)); List <BuildDefinitionReference> buildDefinitions = null; if (settings.ProjectGuid != Guid.Empty) { buildDefinitions = buildHttpClient .GetDefinitionsAsync(settings.ProjectGuid) .ConfigureAwait(false) .GetAwaiter() .GetResult(); } else if (!string.IsNullOrWhiteSpace(settings.ProjectName)) { buildDefinitions = buildHttpClient .GetDefinitionsAsync(settings.ProjectName) .ConfigureAwait(false) .GetAwaiter() .GetResult(); } else { throw new ArgumentOutOfRangeException( nameof(settings), "Either ProjectGuid or ProjectName needs to be set"); } var buildDefinition = buildDefinitions .SingleOrDefault(x => x.Name.Equals(settings.BuildDefinitionName, StringComparison.InvariantCultureIgnoreCase)); if (buildDefinition == null) { log.Verbose( "Build definition '{0}' not found", settings.BuildDefinitionName); } log.Verbose( "Build definition '{0}' found", settings.BuildDefinitionName); return(buildDefinition); }
public override void Execute(Script script) { // Generate the script code. var generator = new RoslynCodeGenerator(); var code = generator.Generate(script); // Create the script options dynamically. var options = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default .AddNamespaces(Namespaces) .AddReferences(References) .AddReferences(ReferencePaths.Select(r => r.FullPath)); _log.Verbose("Compiling build script for debugging..."); var roslynScript = Microsoft.CodeAnalysis.Scripting.CSharp.CSharpScript.Create(code, options) .WithGlobalsType(_host.GetType()); var compilation = roslynScript.GetCompilation(); compilation = compilation.WithOptions(compilation.Options .WithOptimizationLevel(Microsoft.CodeAnalysis.OptimizationLevel.Debug) .WithOutputKind(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary)); using (var exeStream = new MemoryStream()) using (var pdbStream = new MemoryStream()) { var result = compilation.Emit(exeStream, pdbStream: pdbStream); if (result.Success) { _log.Verbose("Compilation successful"); var assembly = AppDomain.CurrentDomain.Load(exeStream.ToArray(), pdbStream.ToArray()); var type = assembly.GetType(CompiledType); var method = type.GetMethod(CompiledMethod, BindingFlags.Static | BindingFlags.Public); var submissionStates = new object[2]; submissionStates[0] = _host; method.Invoke(null, new[] { submissionStates }); } else { _log.Verbose("Compilation failed"); var errors = string.Join(Environment.NewLine, result.Diagnostics.Select(x => x.ToString())); var message = string.Format(System.Globalization.CultureInfo.InvariantCulture, "Error occurred when compiling: {0}", errors); throw new CakeException(message); } } }
/// <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) { _log.Debug("The addin {0} will reference {1}.", addin.Package, assembly.Path.GetFilename()); result.Add(assembly.Path); } } } return(result.ToArray()); }
private void Install(SemanticVersion version) { var root = _environment.GetApplicationRoot().MakeAbsolute(_environment); var installRoot = root.Combine(Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture)); var packages = new Dictionary <string, SemanticVersion> { { "Microsoft.CodeAnalysis.Scripting", version }, { "Microsoft.CodeAnalysis.CSharp", version } }; // Install package. var nugetSource = _configuration.GetValue("Roslyn_NuGetSource") ?? "https://packages.nuget.org/api/v2"; var repo = PackageRepositoryFactory.Default.CreateRepository(nugetSource); var packageManager = new PackageManager(repo, installRoot.FullPath); _log.Verbose("Installing packages (using {0})...", nugetSource); foreach (var package in packages) { _log.Information("Downloading package {0} ({1})...", package.Key, package.Value); packageManager.InstallPackage(package.Key, package.Value, false, true); } // Copy files. _log.Verbose("Copying files..."); foreach (var path in _paths) { // Find the file within the temporary directory. var exp = string.Concat(installRoot.FullPath, "/**/", path); var foundFile = _globber.Match(exp).FirstOrDefault(); if (foundFile == null) { var format = "Could not find file {0}."; var message = string.Format(CultureInfo.InvariantCulture, format, path); throw new CakeException(message); } var source = _fileSystem.GetFile((FilePath)foundFile); var destination = _fileSystem.GetFile(root.CombineWithFilePath(path.GetFilename())); _log.Information("Copying {0}...", source.Path.GetFilename()); if (!destination.Exists) { source.Copy(destination.Path, true); } } // Delete the install directory. _log.Verbose("Deleting installation directory..."); _fileSystem.GetDirectory(installRoot).Delete(true); }
/// <summary> /// Performs the setup. /// </summary> /// <param name="action">The action.</param> public void PerformSetup(Action action) { if (action != null) { _log.Information(string.Empty); _log.Information("----------------------------------------"); _log.Information("Setup"); _log.Information("----------------------------------------"); _log.Verbose("Executing custom setup action..."); action(); } }
private Assembly AssemblyResolve(object sender, ResolveEventArgs args) { var name = new AssemblyName(args.Name); // Prevent recursion from the Assembly.Load() call inside if (_resolvedNames.Add(name.Name)) { _log.Verbose($"Resolving assembly {args.Name}"); return(AssemblyResolve(name)); } return(null); }
/// <summary> /// Deploys an application revision through the specified deployment group. /// </summary> /// <param name="applicationName">The name of an AWS CodeDeploy application associated with the applicable IAM user or AWS account.</param> /// <param name="deploymentGroup">The name of the deployment group.</param> /// <param name="settings">The <see cref="DeploySettings"/> used during the request to AWS.</param> /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> public async Task <bool> CreateDeployment(string applicationName, string deploymentGroup, DeploySettings settings, CancellationToken cancellationToken = default(CancellationToken)) { if (String.IsNullOrEmpty(applicationName)) { throw new ArgumentNullException("applicationName"); } if (String.IsNullOrEmpty(deploymentGroup)) { throw new ArgumentNullException("deploymentGroup"); } // Create Request AmazonCodeDeployClient client = this.CreateClient(settings); CreateDeploymentRequest request = new CreateDeploymentRequest(); request.ApplicationName = applicationName; request.DeploymentGroupName = deploymentGroup; request.Revision = new RevisionLocation() { RevisionType = RevisionLocationType.S3, S3Location = new S3Location() { BundleType = BundleType.Zip, Bucket = settings.S3Bucket, Key = settings.S3Key, Version = settings.S3Version } }; // Check Response CreateDeploymentResponse response = await client.CreateDeploymentAsync(request, cancellationToken); if (response.HttpStatusCode == HttpStatusCode.OK) { _Log.Verbose("Successfully deployed application '{0}'", applicationName); return(true); } else { _Log.Error("Failed to deploy application '{0}'", applicationName); return(false); } }
public string GetBaseVersionString(string defaultVersion) { if (_arguments.HasArgument(BuildVersionArgumentName)) { return(_arguments.GetArgument(BuildVersionArgumentName)); } if (IsAppVeyor) { string version = _appVeyorProvider.Environment.Build.Version; _log.Verbose($"AppVeyor Build Version from Env Variable:{version}"); return(string.IsNullOrWhiteSpace(version) ? defaultVersion : version); } return(defaultVersion); }
public void Zip(DirectoryPath rootPath, FilePath outputPath, IEnumerable <FilePath> filePaths) { if (rootPath == null) { throw new ArgumentNullException("rootPath"); } if (outputPath == null) { throw new ArgumentNullException("outputPath"); } if (filePaths == null) { throw new ArgumentNullException("filePaths"); } // Make root path and output file path absolute. rootPath = rootPath.MakeAbsolute(_environment); outputPath = outputPath.MakeAbsolute(_environment); // Get the output file. var outputFile = _fileSystem.GetFile(outputPath); // Open up a stream to the output file. _log.Verbose("Creating zip file: {0}", outputPath.FullPath); using (var outputStream = outputFile.Open(FileMode.Create, FileAccess.Write, FileShare.None)) using (var archive = new ZipArchive(outputStream, ZipArchiveMode.Create)) { foreach (var inputPath in filePaths) { var absoluteInputPath = inputPath.MakeAbsolute(_environment); var file = _fileSystem.GetFile(absoluteInputPath); using (var inputStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read)) { // Get the relative filename to the rootPath. var relativeFilePath = GetRelativeFilePath(rootPath, absoluteInputPath); _log.Verbose("Adding file: {0}", relativeFilePath); // Create the zip archive entry. var entry = archive.CreateEntry(relativeFilePath.FullPath); using (var entryStream = entry.Open()) { // Copy the content of the input stream to the entry stream. inputStream.CopyTo(entryStream); } } } } _log.Verbose("Zip successfully created: {0}", outputPath.FullPath); }
internal void Send(string metricName, double value, DateTime timeStamp) { try { _log.Verbose($"Sending metric: '{PrefixMetricName(metricName)}' with value '{value}' and timestamp '{timeStamp.ToLongDateString()}'"); _client.Send(PrefixMetricName(metricName), value, timeStamp); } catch (Exception ex) { if (_settings.ThrowExceptions) { throw; } _log.Verbose($"{nameof(Send)} would have thrown an {ex.GetType()}"); } }
private void RunDotNetTool(PackageReference package, DirectoryPath toolsFolderDirectoryPath, DotNetToolOperation operation) { // Install the tool.... _log.Debug("Running dotnet tool with operation {0}: {1}...", operation, package.Package); var process = _processRunner.Start( "dotnet", new ProcessSettings { Arguments = GetArguments(package, operation, _log, toolsFolderDirectoryPath), RedirectStandardOutput = true, Silent = _log.Verbosity < Verbosity.Diagnostic, NoWorkingDirectory = true }); process.WaitForExit(); var exitCode = process.GetExitCode(); if (exitCode != 0) { _log.Warning("dotnet exited with {0}", exitCode); var output = string.Join(Environment.NewLine, process.GetStandardError()); _log.Verbose(Verbosity.Diagnostic, "Output:\r\n{0}", output); } }
private bool InstallPackage(PackageReference package, DirectoryPath path) { _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(false); } return(true); }
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(); }
public void Execute(Script script) { // Generate the script code. var generator = new RoslynCodeGenerator(); var code = generator.Generate(script); // Create the script options dynamically. var options = Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default .AddImports(Namespaces) .AddReferences(References) .AddReferences(ReferencePaths.Select(r => r.FullPath)) .WithEmitDebugInformation(_options.PerformDebug) .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(); if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)) { var errors = string.Join(Environment.NewLine, diagnostics.Select(x => x.ToString())); var message = string.Format(CultureInfo.InvariantCulture, "Error occurred when compiling build script: {0}", errors); throw new CakeException(message); } roslynScript.RunAsync(_host).Wait(); }
public void Execute(Script script) { if (script == null) { throw new ArgumentNullException("script"); } if (script.UsingAliasDirectives.Count > 0) { throw new CakeException("The Mono scripting engine do not support using alias directives."); } var code = MonoCodeGenerator.Generate(script); try { // Build the class we generated. _log.Verbose("Compiling build script..."); _evaluator.Run(code); // Actually execute it. _evaluator.Run("new CakeBuildScriptImpl (ScriptHost).Execute ();"); } catch (InternalErrorException) { // The error will be logged via the report printer. throw new CakeException("An error occured while executing build script."); } }
internal async Task <string> CreateNewVersionAsync(HockeyAppUploadSettings settings) { _log.Verbose($"Creating Version {settings.ShortVersion} ({settings.Version}) for {settings.AppId}."); var response = await _client.CreateNewVersionAsync(settings.ApiToken, settings.AppId, settings.Version, settings.ShortVersion); if (!response.Success) { throw new Exception(response.Message); } _log.Information($"Created Version {response.ShortVersion} ({response.Version}) for {response.Title}."); return(response.Id); }
public HockeyAppClient(ICakeLog log) { _log = log; _client = new HockeyAppApiClient(HockeyAppBaseUrl); _log.Verbose("Initialized HockeyApp Api at {0}", HockeyAppBaseUrl); }