public MsBuildSiteBuilder(IBuildPropertyProvider propertyProvider, string workingDirectory, string tempPath, string nugetCachePath) { _propertyProvider = propertyProvider; _msbuildExe = new Executable(PathUtility.ResolveMSBuildPath(), workingDirectory); _msbuildExe.EnvironmentVariables[NuGetCachePathKey] = nugetCachePath; _tempPath = tempPath; }
public Executable BuildExternalCommandExecutable(string workingDirectory, string deploymentTargetPath) { // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(StarterScriptPath, workingDirectory, _deploymentSettings.GetCommandIdleTimeout()); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); exe.EnvironmentVariables[SourcePath] = _repositoryPath; exe.EnvironmentVariables[TargetPath] = deploymentTargetPath; exe.EnvironmentVariables[MSBuildPath] = PathUtility.ResolveMSBuildPath(); exe.EnvironmentVariables[KuduSyncCommandKey] = KuduSyncCommand; exe.EnvironmentVariables[SelectNodeVersionCommandKey] = SelectNodeVersionCommand; exe.EnvironmentVariables[NpmJsPathKey] = PathUtility.ResolveNpmJsPath(); // Disable this for now // exe.EnvironmentVariables[NuGetCachePathKey] = Environment.NuGetCachePath; // NuGet.exe 1.8 will require an environment variable to make package restore work exe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; exe.SetHomePath(_environment.SiteRootPath); // Set the path so we can add more variables exe.EnvironmentVariables["PATH"] = System.Environment.GetEnvironmentVariable("PATH"); // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new[] { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()) }; exe.AddToPath(toolsPaths); return exe; }
public void ProcessRequest(HttpContext context) { string loopValue = context.Request["l"]; int loops; if (!Int32.TryParse(loopValue, out loops)) { loops = 1; } string wwwroot = Path.Combine(HttpRuntime.AppDomainAppPath, "wwwroot"); string nodeDir = Path.Combine(wwwroot, "node_modules"); var npmPath = ResolveNpmPath(); var exe = new Executable(npmPath, wwwroot); for (int i = 0; i < loops; i++) { try { var result = exe.Execute("install"); context.Response.Write(@"<div style=""font-weight:bold;color:green"">Run " + (i + 1) + " success! </div>"); context.Response.Flush(); FileSystemHelpers.DeleteDirectorySafe(nodeDir); } catch (Exception ex) { context.Response.Write(@"<div style=""font-weight:bold;color:red"">Run " + (i + 1) + " failed!</div>"); context.Response.Write(@"<pre>" + ex.Message + "</pre>"); context.Response.Flush(); break; } } }
public Executable BuildCommandExecutable(string commandPath, string workingDirectory, TimeSpan idleTimeout, ILogger logger) { // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(commandPath, workingDirectory, idleTimeout); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.WebRootPath, _environment.WebRootPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.MSBuildPath, PathUtility.ResolveMSBuildPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.KuduSyncCommandKey, KuduSyncCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NuGetExeCommandKey, NuGetExeCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NpmJsPathKey, PathUtility.ResolveNpmJsPath(), logger); exe.SetHomePath(_environment); // Set the path so we can add more variables string path = System.Environment.GetEnvironmentVariable("PATH"); exe.EnvironmentVariables["PATH"] = path; // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new List<string> { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()), Path.GetDirectoryName(PathUtility.ResolveVsTestPath()), Path.GetDirectoryName(PathUtility.ResolveSQLCmdPath()), _environment.ScriptPath }; toolsPaths.AddRange(PathUtility.ResolveNodeNpmPaths()); toolsPaths.Add(PathUtility.ResolveNpmGlobalPrefix()); exe.PrependToPath(toolsPaths); return exe; }
protected MsBuildSiteBuilder(IDeploymentSettingsManager settings, IBuildPropertyProvider propertyProvider, string workingDirectory) { _settings = settings; _propertyProvider = propertyProvider; _msbuildExe = new Executable(PathUtility.ResolveMSBuildPath(), workingDirectory, settings.GetCommandIdleTimeout()); // NuGet.exe 1.8 will require an environment variable to make package restore work _msbuildExe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; }
public static void Install(string packageToInstall, string installToPath) { using (new LatencyLogger("npm install " + packageToInstall + " to " + installToPath)) { var exe = new Executable(PathUtility.ResolveNpmPath(), installToPath, idleTimeout: TimeSpan.FromSeconds(3600)); var result = exe.Execute("install {0} .", packageToInstall); TestTracer.Trace(" stdout: {0}", result.Item1); TestTracer.Trace(" stderr: {0}", result.Item2); } }
public static void Install(string packageToInstall, string installToPath) { using (new LatencyLogger("npm install " + packageToInstall + " to " + installToPath)) { string programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86); string npmPath = Path.Combine(programFiles, "nodejs", "npm.cmd"); var exe = new Executable(npmPath, installToPath, idleTimeout: TimeSpan.FromSeconds(3600)); var result = exe.Execute("install {0} .", packageToInstall); TestTracer.Trace(" stdout: {0}", result.Item1); TestTracer.Trace(" stderr: {0}", result.Item2); } }
public MsBuildSiteBuilder(IBuildPropertyProvider propertyProvider, string workingDirectory, string tempPath, string nugetCachePath) { _propertyProvider = propertyProvider; _msbuildExe = new Executable(PathUtility.ResolveMSBuildPath(), workingDirectory); // Disable this for now // _msbuildExe.EnvironmentVariables[NuGetCachePathKey] = nugetCachePath; // NuGet.exe 1.8 will require an environment variable to make package restore work _msbuildExe.EnvironmentVariables[NuGetPackageRestoreKey] = "true"; _tempPath = tempPath; }
public static void Execute(string workingDirectory, string commandFormat, params object[] args) { var command = String.Format(commandFormat, args); using (new LatencyLogger(NodeExe + " " + command)) { var exe = new Executable(NodeExe, workingDirectory, idleTimeout: TimeSpan.FromSeconds(3600)); exe.SetHomePath(Environment.GetEnvironmentVariable("USERPROFILE")); var result = exe.Execute(command); TestTracer.Trace(" stdout: {0}", result.Item1); TestTracer.Trace(" stderr: {0}", result.Item2); } }
public Executable BuildExternalCommandExecutable(string workingDirectory, string deploymentTargetPath, ILogger logger) { string sourcePath = _repositoryPath; string targetPath = deploymentTargetPath; // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(StarterScriptPath, workingDirectory, _deploymentSettings.GetCommandIdleTimeout()); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.SourcePath, sourcePath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.TargetPath, targetPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.WebRootPath, _environment.WebRootPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.MSBuildPath, PathUtility.ResolveMSBuildPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.KuduSyncCommandKey, KuduSyncCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.SelectNodeVersionCommandKey, SelectNodeVersionCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NpmJsPathKey, PathUtility.ResolveNpmJsPath(), logger); if (PathUtility.PathsEquals(sourcePath, targetPath)) { UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.InPlaceDeployment, "1", logger); } // Disable this for now // exe.EnvironmentVariables[NuGetCachePathKey] = Environment.NuGetCachePath; // NuGet.exe 1.8 will require an environment variable to make package restore work exe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; exe.SetHomePath(_environment.SiteRootPath); // Set the path so we can add more variables exe.EnvironmentVariables["PATH"] = System.Environment.GetEnvironmentVariable("PATH"); // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new[] { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()), Path.GetDirectoryName(PathUtility.ResolveVsTestPath()) }; exe.AddToPath(toolsPaths); return exe; }
public static string SelectNodeVersion(IFileSystem fileSystem, string scriptPath, string sourcePath, ITracer tracer) { // The node.js version selection logic is implemented in selectNodeVersion.js. // run with default node.js version which is on the path Executable executor = new Executable("node.exe", String.Empty); try { return executor.ExecuteWithConsoleOutput( tracer, "\"{0}\\selectNodeVersion.js\" \"{1}\" \"{1}\"", scriptPath, sourcePath).Item1; } catch (Exception e) { throw new InvalidOperationException(Resources.Error_UnableToSelectNodeVersion, e); } }
public Executable BuildCommandExecutable(string commandPath, string workingDirectory, TimeSpan idleTimeout, ILogger logger) { // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(commandPath, workingDirectory, idleTimeout); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.WebRootPath, _environment.WebRootPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.MSBuildPath, PathUtility.ResolveMSBuildPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.KuduSyncCommandKey, KuduSyncCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NuGetExeCommandKey, NuGetExeCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NpmJsPathKey, PathUtility.ResolveNpmJsPath(), logger); exe.SetHomePath(_environment); // Set the path so we can add more variables string path = System.Environment.GetEnvironmentVariable("PATH"); exe.EnvironmentVariables["PATH"] = path; // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new List<string> { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()), Path.GetDirectoryName(PathUtility.ResolveVsTestPath()), Path.GetDirectoryName(PathUtility.ResolveSQLCmdPath()), _environment.ScriptPath }; string nodeExePath = PathUtility.ResolveNodePath(); if (!String.IsNullOrEmpty(nodeExePath)) { // If IIS node path is available prepend it to the path list so that it's discovered before any other node versions in the path. toolsPaths.Add(Path.GetDirectoryName(nodeExePath)); } string npmExePath = PathUtility.ResolveNpmCmdPath(); if (!String.IsNullOrEmpty(npmExePath)) { toolsPaths.Add(Path.GetDirectoryName(npmExePath)); } exe.PrependToPath(toolsPaths); return exe; }
private void GenerateScript(DeploymentContext context, ILogger buildLogger) { try { using (context.Tracer.Step("Generating deployment script")) { var scriptGenerator = new Executable(DeploymentScriptGeneratorToolPath, RepositoryPath, DeploymentSettings.GetCommandIdleTimeout()); // Set home path to the user profile so cache directories created by azure-cli are created there scriptGenerator.SetHomePath(System.Environment.GetEnvironmentVariable("APPDATA")); var scriptGeneratorCommand = String.Format(ScriptGeneratorCommandFormat, RepositoryPath, Environment.DeploymentToolsPath, ScriptGeneratorCommandArguments); bool cacheUsed = UseCachedDeploymentScript(scriptGeneratorCommand, context); if (!cacheUsed) { buildLogger.Log(Resources.Log_DeploymentScriptGeneratorCommand, scriptGeneratorCommand); scriptGenerator.ExecuteWithProgressWriter(buildLogger, context.Tracer, scriptGeneratorCommand); CacheDeploymentScript(scriptGeneratorCommand, context); } else { buildLogger.Log(Resources.Log_DeploymentScriptGeneratorUsingCache, scriptGeneratorCommand); } } } catch (Exception ex) { context.Tracer.TraceError(ex); // HACK: Log an empty error to the global logger (post receive hook console output). // The reason we don't log the real exception is because the 'live output' running // msbuild has already been captured. context.GlobalLogger.LogError(); throw; } }
public Executable BuildCommandExecutable(string commandPath, string workingDirectory, TimeSpan idleTimeout, ILogger logger) { // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(commandPath, workingDirectory, idleTimeout); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.WebRootPath, _environment.WebRootPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.MSBuildPath, PathUtility.ResolveMSBuildPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.KuduSyncCommandKey, KuduSyncCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NuGetExeCommandKey, NuGetExeCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NpmJsPathKey, PathUtility.ResolveNpmJsPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.DnvmPath, DnvmPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.GypMsvsVersion, Constants.VCVersion, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.VCTargetsPath, PathUtility.ResolveVCTargetsPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.VCInstallDir140, PathUtility.ResolveVCInstallDirPath(), logger); exe.SetHomePath(_environment); // Set the path so we can add more variables string path = System.Environment.GetEnvironmentVariable("PATH"); exe.EnvironmentVariables["PATH"] = path; return exe; }
// TODO: add specific support in script for this: //protected string GetMSBuildExtraArguments() //{ //if (_settings == null) return String.Empty; //return _settings.GetValue(SettingsKeys.BuildArgs); //} protected void RunCommand(DeploymentContext context, string command) { ILogger customLogger = context.Logger.Log("Running deployment command..."); customLogger.Log("Command: " + command); // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable("cmd", RepositoryPath); exe.AddDeploymentSettingsAsEnvironmentVariables(DeploymentSettings); exe.EnvironmentVariables[SourcePath] = RepositoryPath; exe.EnvironmentVariables[TargetPath] = context.OutputPath; exe.EnvironmentVariables[MSBuildPath] = PathUtility.ResolveMSBuildPath(); exe.EnvironmentVariables[PreviousManifestPath] = context.PreviousManifestFilePath ?? String.Empty; exe.EnvironmentVariables[NextManifestPath] = context.NextManifestFilePath; exe.EnvironmentVariables["KUDU_SYNC_COMMAND"] = KuduSyncPath; // Disable this for now // exe.EnvironmentVariables[NuGetCachePathKey] = Environment.NuGetCachePath; // NuGet.exe 1.8 will require an environment variable to make package restore work exe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; exe.SetHomePath(HomePath); // Create a directory for the script output temporary artifacts string buildTempPath = Path.Combine(Environment.TempPath, Guid.NewGuid().ToString()); FileSystemHelpers.EnsureDirectory(buildTempPath); exe.EnvironmentVariables[BuildTempPath] = buildTempPath; // Populate the enviornment with the build propeties foreach (var property in PropertyProvider.GetProperties()) { exe.EnvironmentVariables[property.Key] = property.Value; } // Set the path so we can add more variables exe.EnvironmentVariables["PATH"] = System.Environment.GetEnvironmentVariable("PATH"); // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new[] { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()) }; exe.AddToPath(toolsPaths); try { exe.ExecuteWithProgressWriter(customLogger, context.Tracer, ShouldFilterOutMsBuildWarnings, "/c " + command, String.Empty); } catch (CommandLineException ex) { context.Tracer.TraceError(ex); // HACK: Log an empty error to the global logger (post receive hook console output). // The reason we don't log the real exception is because the 'live output' running // msbuild has already been captured. context.GlobalLogger.LogError(); // Add the output stream and the error stream to the log for better // debugging customLogger.Log(ex.Output, LogEntryType.Error); customLogger.Log(ex.Error, LogEntryType.Error); throw new CommandLineException(ex.Message, ex); } finally { // Clean the temp folder up CleanBuild(context.Tracer, buildTempPath); FileSystemHelpers.DeleteDirectorySafe(buildTempPath); } }
public HgRepository(string path) { _repository = new Repository(path); _hgExe = new Executable(Client.ClientPath, path); }
public Executable BuildExternalCommandExecutable(string workingDirectory, string deploymentTargetPath, ILogger logger) { string sourcePath = _repositoryPath; string targetPath = deploymentTargetPath; // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(StarterScriptPath, workingDirectory, _deploymentSettings.GetCommandIdleTimeout()); exe.AddDeploymentSettingsAsEnvironmentVariables(_deploymentSettings); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.SourcePath, sourcePath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.TargetPath, targetPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.WebRootPath, _environment.WebRootPath, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.MSBuildPath, PathUtility.ResolveMSBuildPath(), logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.KuduSyncCommandKey, KuduSyncCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NuGetExeCommandKey, NuGetExeCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.PostDeploymentActionsCommandKey, PostDeploymentActionsCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.PostDeploymentActionsDirectoryKey, PostDeploymentActionsDir, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.SelectNodeVersionCommandKey, SelectNodeVersionCommand, logger); UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.NpmJsPathKey, PathUtility.ResolveNpmJsPath(), logger); bool isInPlace = false; string project = _deploymentSettings.GetValue(SettingsKeys.Project); if (!String.IsNullOrEmpty(project)) { isInPlace = PathUtility.PathsEquals(Path.Combine(sourcePath, project), targetPath); } else { isInPlace = PathUtility.PathsEquals(sourcePath, targetPath); } if (isInPlace) { UpdateToDefaultIfNotSet(exe, WellKnownEnvironmentVariables.InPlaceDeployment, "1", logger); } // NuGet.exe 1.8 will require an environment variable to make package restore work exe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; exe.SetHomePath(_environment.SiteRootPath); // Set the path so we can add more variables string path = System.Environment.GetEnvironmentVariable("PATH"); exe.EnvironmentVariables["PATH"] = path; // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new List<string> { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()), Path.GetDirectoryName(PathUtility.ResolveVsTestPath()) }; string nodeExePath = PathUtility.ResolveNodePath(); if (!String.IsNullOrEmpty(nodeExePath)) { // If IIS node path is available prepend it to the path list so that it's discovered before any other node versions in the path. toolsPaths.Add(Path.GetDirectoryName(nodeExePath)); } exe.PrependToPath(toolsPaths); return exe; }
private void UpdateToDefaultIfNotSet(Executable exe, string key, string defaultValue, ILogger logger) { var value = _deploymentSettings.GetValue(key); if (string.IsNullOrEmpty(value)) { exe.EnvironmentVariables[key] = defaultValue; } else { logger.Log("Using custom deployment setting for {0} custom value is '{1}'.", key, value); exe.EnvironmentVariables[key] = value; } }
private static Server GetServer(IEnvironment environment) { string configFile = EnsureConfiguration(environment); string pidFilePath = Path.Combine(environment.ApplicationRootPath, "serverpid"); var hgExe = new Executable(Client.ClientPath, environment.RepositoryPath); return new Server(hgExe, environment.AppName, configFile, pidFilePath); }
public SolutionBasedSiteBuilder(string repositoryPath, string solutionPath) { SolutionPath = solutionPath; _msbuildExe = new Executable(ResolveMSBuildPath(), repositoryPath); }
protected virtual bool MapPath(string path, out string driveName) { var cmd = new Executable("cmd", GetWindowsFolder()); driveName = null; foreach (var letter in DriveLetters) { try { // There's probably an API for this as well but this is easy to do // Not as easy to parse out the results of net use cmd.Execute("/c net use {0}: {1}", letter, path); driveName = letter + @":\"; return true; } catch { } } return false; }
public static void GCDump(this Process process, string dumpFile, string resourcePath, int maxDumpCountK, ITracer tracer, TimeSpan idleTimeout) { var exe = new Executable(_gcDumpExe.Value, Path.GetDirectoryName(dumpFile), idleTimeout); exe.Execute(tracer, "\"{0}\" \"{1}\" \"{2}\" \"{3}\"", process.Id, dumpFile, resourcePath, maxDumpCountK); }
private void GenerateScript(DeploymentContext context, ILogger buildLogger) { try { using (context.Tracer.Step("Generating deployment script")) { var scriptGenerator = new Executable(DeploymentScriptGeneratorToolPath, RepositoryPath, DeploymentSettings.GetCommandIdleTimeout()); scriptGenerator.SetHomePath(HomePath); var scriptGeneratorCommand = String.Format(ScriptGeneratorCommandFormat, RepositoryPath, ScriptGeneratorCommandArguments); buildLogger.Log(Resources.Log_DeploymentScriptGeneratorCommand, scriptGeneratorCommand); scriptGenerator.ExecuteWithProgressWriter(buildLogger, context.Tracer, _ => false, scriptGeneratorCommand); } } catch (CommandLineException ex) { context.Tracer.TraceError(ex); // HACK: Log an empty error to the global logger (post receive hook console output). // The reason we don't log the real exception is because the 'live output' running // msbuild has already been captured. context.GlobalLogger.LogError(); // Add the output stream and the error stream to the log for better // debugging buildLogger.Log(ex.Output, LogEntryType.Error); buildLogger.Log(ex.Error, LogEntryType.Error); throw; } }
public MsBuildSiteBuilder(IBuildPropertyProvider propertyProvider, string workingDirectory) { _propertyProvider = propertyProvider; _msbuildExe = new Executable(ResolveMSBuildPath(), workingDirectory); }
public string SelectNodeVersion(ITracer tracer) { // The node.js version selection logic is implemented in selectNodeVersion.js. // run with default node.js version which is on the path Executable executor = new Executable("node.exe", String.Empty, _settings.GetCommandIdleTimeout()); try { return executor.ExecuteWithConsoleOutput( tracer, "\"{0}\\selectNodeVersion.js\" \"{1}\" \"{2}\"", _scriptPath, _repoFolder, _siteFolder).Item1; } catch (Exception e) { throw new InvalidOperationException(Resources.Error_UnableToSelectNodeVersion, e); } }
public MSBuildDeployer(IEnvironment environment) { _environment = environment; _msbuildExe = new Executable(ResolveMSBuildPath(), environment.RepositoryPath); }
public void CleanWwwRoot() { var tracer = _traceFactory.GetTracer(); using (tracer.Step("Cleaning wwwroot")) { string activeDeploymentId = _status.ActiveDeploymentId; // Clean only required if there is an actual deployment (active deployment id is not null) if (activeDeploymentId != null) { string emptyTempPath = Path.Combine(_environment.TempPath, Guid.NewGuid().ToString()); try { // Create an empty temporary directory FileSystemHelpers.EnsureDirectory(emptyTempPath); string from = emptyTempPath; string to = _environment.WebRootPath; string previousManifest = GetDeploymentManifestPath(activeDeploymentId); string nextManifest = Path.Combine(emptyTempPath, "manifest"); // Run kudu sync from the empty directory to wwwroot using the current manifest // This will cause all previously deployed files to be removed from wwwroot var exe = new Executable(Path.Combine(_environment.ScriptPath, "kudusync.cmd"), emptyTempPath, _settings.GetCommandIdleTimeout()); Tuple<string, string> result = exe.Execute(tracer, "-f {0} -t {1} -p {2} -n {3} -v 50", from, to, previousManifest, nextManifest); if (!String.IsNullOrEmpty(result.Item1)) { tracer.Trace("Process output: {0}", result.Item1); } if (!String.IsNullOrEmpty(result.Item2)) { tracer.Trace("Process error: {0}", result.Item2); } } finally { FileSystemHelpers.DeleteDirectorySafe(emptyTempPath); } } else { tracer.Trace("No active deployment to clean"); } } }
public Task Build(DeploymentContext context) { var tcs = new TaskCompletionSource<object>(); ILogger customLogger = context.Logger.Log("Running custom deployment command..."); // Creates an executable pointing to cmd and the working directory being // the repository root var exe = new Executable(StarterScriptPath, _repositoryPath, _settings.GetCommandIdleTimeout()); exe.AddDeploymentSettingsAsEnvironmentVariables(_settings); exe.EnvironmentVariables[ExternalCommandFactory.SourcePath] = _repositoryPath; exe.EnvironmentVariables[ExternalCommandFactory.TargetPath] = context.OutputPath; exe.EnvironmentVariables[ExternalCommandBuilder.PreviousManifestPath] = (context.PreviousManifest != null) ? context.PreviousManifest.ManifestFilePath : String.Empty; exe.EnvironmentVariables[ExternalCommandBuilder.NextManifestPath] = context.ManifestWriter.ManifestFilePath; exe.EnvironmentVariables[ExternalCommandFactory.MSBuildPath] = PathUtility.ResolveMSBuildPath(); exe.EnvironmentVariables[ExternalCommandFactory.KuduSyncCommandKey] = KuduSyncCommand; exe.EnvironmentVariables[ExternalCommandFactory.SelectNodeVersionCommandKey] = SelectNodeVersionCommand; exe.EnvironmentVariables[ExternalCommandFactory.NpmJsPathKey] = PathUtility.ResolveNpmJsPath(); exe.EnvironmentVariables[WellKnownEnvironmentVariables.NuGetPackageRestoreKey] = "true"; exe.SetHomePath(_homePath); // Create a directory for the script output temporary artifacts string buildTempPath = Path.Combine(_tempPath, Guid.NewGuid().ToString()); FileSystemHelpers.EnsureDirectory(buildTempPath); exe.EnvironmentVariables[ExternalCommandBuilder.BuildTempPath] = buildTempPath; // Populate the enviornment with the build propeties foreach (var property in _propertyProvider.GetProperties()) { exe.EnvironmentVariables[property.Key] = property.Value; } // Set the path so we can add more variables exe.EnvironmentVariables["PATH"] = System.Environment.GetEnvironmentVariable("PATH"); // Add the msbuild path and git path to the %PATH% so more tools are available var toolsPaths = new[] { Path.GetDirectoryName(PathUtility.ResolveMSBuildPath()), Path.GetDirectoryName(PathUtility.ResolveGitPath()) }; exe.AddToPath(toolsPaths); try { exe.ExecuteWithProgressWriter(customLogger, context.Tracer, _command, String.Empty); tcs.SetResult(null); } catch (CommandLineException ex) { context.Tracer.TraceError(ex); // HACK: Log an empty error to the global logger (post receive hook console output). // The reason we don't log the real exception is because the 'live output' running // msbuild has already been captured. context.GlobalLogger.LogError(); // Add the output stream and the error stream to the log for better // debugging customLogger.Log(ex.Output, LogEntryType.Error); customLogger.Log(ex.Error, LogEntryType.Error); tcs.SetException(ex); } finally { // Clean the temp folder up FileSystemHelpers.DeleteDirectorySafe(buildTempPath); } return tcs.Task; }
private void SetupAcls(string appName, string appPoolName) { // Setup Acls for this user var icacls = new Executable(@"C:\Windows\System32\icacls.exe", Directory.GetCurrentDirectory()); // Make sure the application path exists string applicationPath = _pathResolver.GetApplicationPath(appName); Directory.CreateDirectory(applicationPath); try { // Give full control to the app folder (we can make it minimal later) icacls.Execute(@"""{0}\*"" /grant ""IIS AppPool\{1}:F"" /C /Q /T", applicationPath, appPoolName); } catch (Exception ex) { Debug.WriteLine(ex.Message); } try { // Give full control to the temp folder string windowsTemp = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Temp"); icacls.Execute(@"""{0}"" /grant ""IIS AppPool\{1}:F"" /C /Q /T", windowsTemp, appPoolName); } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
internal Server(Executable hgExe, string appName, string configFile, string pidFile) { _hgExe = hgExe; _appName = appName; _configFile = configFile; _pidFile = pidFile; }