/// <summary> /// Configure the optimizer /// </summary> /// <param name="environment">The environment.</param> public void Configure(ICakeEnvironment environment) { this.Key = environment.GetEnvironmentVariable("PUNYPNG_KEY"); this.Timeout = Convert.ToInt32(environment.GetEnvironmentVariable("PUNYPNG_TIMEOUT")); this.FileSize = Convert.ToInt32(environment.GetEnvironmentVariable("PUNYPNG_FILESIZE")); }
public static bool SupportsAnsi(ICakeEnvironment environment) { // Github action doesn't setup a correct PTY but supports ANSI. if (!string.IsNullOrWhiteSpace(environment.GetEnvironmentVariable("GITHUB_ACTION"))) { return(true); } // Running on Windows? if (environment.Platform.Family == PlatformFamily.Windows) { // Running under ConEmu? var conEmu = environment.GetEnvironmentVariable("ConEmuANSI"); if (!string.IsNullOrEmpty(conEmu) && conEmu.Equals("On", StringComparison.OrdinalIgnoreCase)) { return(true); } return(Windows.SupportsAnsi()); } // Check if the terminal is of type ANSI/VT100/xterm compatible. var term = environment.GetEnvironmentVariable("TERM"); if (!string.IsNullOrWhiteSpace(term)) { if (_regexes.Any(regex => regex.IsMatch(term))) { return(true); } } return(false); }
/// <summary> /// Collects all the files for the given dotnet Tool Package. /// </summary> /// <param name="package">The dotnet Tool Package.</param> /// <param name="type">The type of dotnet Tool Package.</param> /// <returns>All the files for the Package.</returns> public IReadOnlyCollection <IFile> GetFiles(PackageReference package, PackageType type) { if (type == PackageType.Addin) { throw new InvalidOperationException("DotNetTool Module does not support Addins'"); } if (type == PackageType.Tool) { if (package.Parameters.ContainsKey("global")) { if (_environment.Platform.IsUnix()) { return(GetToolFiles(new DirectoryPath(_environment.GetEnvironmentVariable("HOME")).Combine(".dotnet/tools"), package)); } else { return(GetToolFiles(new DirectoryPath(_environment.GetEnvironmentVariable("USERPROFILE")).Combine(".dotnet/tools"), package)); } } else { return(GetToolFiles(_config.GetToolPath(_environment.WorkingDirectory, _environment), package)); } } throw new InvalidOperationException("Unknown resource type."); }
/// <summary> /// Helper method to get the AWS Credentials from environment variables /// </summary> /// <param name="environment">The cake environment.</param> /// <param name="settings">The S3 settings.</param> /// <returns>The same <see cref="S3Settings"/> instance so that multiple calls can be chained.</returns> private static T SetSettings <T>(this ICakeEnvironment environment, T settings) where T : S3Settings { if (environment == null) { throw new ArgumentNullException("environment"); } //AWS Fallback AWSCredentials creds = FallbackCredentialsFactory.GetCredentials(); if (creds != null) { settings.Credentials = creds; } //Environment Variables settings.EncryptionKey = environment.GetEnvironmentVariable("AWS_ENCRYPTION_KEY"); string region = environment.GetEnvironmentVariable("AWS_REGION"); if (!String.IsNullOrEmpty(region)) { settings.Region = RegionEndpoint.GetBySystemName(region); } return(settings); }
/// <summary> /// Gets the alternative tool paths for the tool /// </summary> /// <param name="settings"></param> /// <returns>The alternate tool paths</returns> protected override IEnumerable <FilePath> GetAlternativeToolPaths(CoverletSettings settings) { var globalToolLocation = _environment.Platform.IsUnix() ? new DirectoryPath(_environment.GetEnvironmentVariable("HOME")) : new DirectoryPath(_environment.GetEnvironmentVariable("USERPROFILE")); return(GetToolExecutableNames() .Select(name => globalToolLocation.Combine(".dotnet/tools").GetFilePath(name))); }
/// <summary> /// Resolves the path to upack.exe. /// </summary> /// <returns>The path to upack.exe.</returns> public FilePath ResolvePath() { // Check if path allready resolved if (_cachedPath != null && _cachedPath.Exists) { return(_cachedPath.Path); } // Try to resolve it with the regular tool resolver. var toolsExe = _tools.Resolve(UPackExe); if (toolsExe != null) { var toolsFile = _fileSystem.GetFile(toolsExe); if (toolsFile.Exists) { _cachedPath = toolsFile; return(_cachedPath.Path); } } // Check if path set to environment variable var upackInstallationFolder = _environment.GetEnvironmentVariable("UPackInstall"); if (!string.IsNullOrWhiteSpace(upackInstallationFolder)) { var envFile = _fileSystem.GetFile(System.IO.Path.Combine(upackInstallationFolder, UPackExe)); if (envFile.Exists) { _cachedPath = envFile; return(_cachedPath.Path); } } // Last resort try path var envPath = _environment.GetEnvironmentVariable("path"); if (!string.IsNullOrWhiteSpace(envPath)) { var pathFile = envPath .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(path => _fileSystem.GetDirectory(path)) .Where(path => path.Exists) .Select(path => path.Path.CombineWithFilePath(UPackExe)) .Select(_fileSystem.GetFile) .FirstOrDefault(file => file.Exists); if (pathFile != null) { _cachedPath = pathFile; return(_cachedPath.Path); } } throw new CakeException("Could not locate upack.exe."); }
/// <summary> /// Configure the optimizer /// </summary> /// <param name="environment">The environment.</param> public void Configure(ICakeEnvironment environment) { this.ApiKey = environment.GetEnvironmentVariable("KRAKEN_API_KEY"); this.SecretKey = environment.GetEnvironmentVariable("KRAKEN_SECRET_KEY"); this.Lossy = Convert.ToBoolean(environment.GetEnvironmentVariable("KRAKEN_LOSSY")); this.Timeout = Convert.ToInt32(environment.GetEnvironmentVariable("KRAKEN_TIMEOUT")); this.FileSize = Convert.ToInt32(environment.GetEnvironmentVariable("KRAKEN_FILESIZE")); }
public BitbucketPipelinesInfoFixture() { Environment = Substitute.For <ICakeEnvironment>(); // BitbucketPipelines RepositoryInfo Environment.GetEnvironmentVariable("BITBUCKET_COMMIT").Returns("4efbc1ffb993dfbcf024e6a9202865cc0b6d9c50"); Environment.GetEnvironmentVariable("BITBUCKET_REPO_SLUG").Returns("cake"); Environment.GetEnvironmentVariable("BITBUCKET_REPO_OWNER").Returns("cakebuild"); Environment.GetEnvironmentVariable("BITBUCKET_BRANCH").Returns("develop"); Environment.GetEnvironmentVariable("BITBUCKET_TAG").Returns("BitbucketPipelines"); }
public TeamCityInfoFixture() { Environment = Substitute.For <ICakeEnvironment>(); Environment.GetEnvironmentVariable("TEAMCITY_BUILDCONF_NAME").Returns(@"Cake Build"); Environment.GetEnvironmentVariable("BUILD_NUMBER").Returns("10-Foo"); Environment.GetEnvironmentVariable("TEAMCITY_PROJECT_NAME").Returns("Cake"); Environment.GetEnvironmentVariable("Git_Branch").Returns("refs/pull-requests/7/from"); }
/// <summary> /// Resolves the tool path. /// </summary> /// <returns> /// The tool path. /// </returns> /// <exception cref="CakeException">No nuget.exe found by resolver.</exception> public FilePath ResolveToolPath() { // Check if path allready resolved if (_nugetExeFile != null && _nugetExeFile.Exists) { return(_nugetExeFile.Path); } // Check if path set to environment variable var environmentExe = _environment.GetEnvironmentVariable("NUGET_EXE"); if (!string.IsNullOrWhiteSpace(environmentExe)) { var envFile = _fileSystem.GetFile(environmentExe); if (envFile.Exists) { return((_nugetExeFile = envFile).Path); } } // Check if tool exists in tool folder const string expression = "./tools/**/NuGet.exe"; var toolsExe = _globber.GetFiles(expression).FirstOrDefault(); if (toolsExe != null) { var toolsFile = _fileSystem.GetFile(toolsExe); if (toolsFile.Exists) { return((_nugetExeFile = toolsFile).Path); } } // Last resort try path var envPath = _environment.GetEnvironmentVariable("path"); if (!string.IsNullOrWhiteSpace(envPath)) { var pathFile = envPath .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(path => _fileSystem.GetDirectory(path)) .Where(path => path.Exists) .Select(path => path.Path.CombineWithFilePath("nuget.exe")) .Select(_fileSystem.GetFile) .FirstOrDefault(file => file.Exists); if (pathFile != null) { return((_nugetExeFile = pathFile).Path); } } throw new CakeException("No nuget.exe found by resolver."); }
/// <summary> /// Resolves the path to vsce.. /// </summary> /// <returns>The path to vsce.</returns> public FilePath ResolvePath() { // Check if path allready resolved if (_cachedPath != null && _cachedPath.Exists) { return(_cachedPath.Path); } // Last resort try path var envPath = _environment.GetEnvironmentVariable("path"); if (!string.IsNullOrWhiteSpace(envPath)) { var pathFile = envPath .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(path => _fileSystem.GetDirectory(path)) .Where(path => path.Exists) .Select(path => path.Path.CombineWithFilePath("vsce.cmd")) .Select(_fileSystem.GetFile) .FirstOrDefault(file => file.Exists); if (pathFile != null) { _cachedPath = pathFile; return(_cachedPath.Path); } } throw new CakeException("Could not locate vsce."); }
public void ExecuteExpression(string cakeExpression, CakeSettings settings = null) { if (string.IsNullOrWhiteSpace(cakeExpression)) { throw new ArgumentNullException("cakeExpression"); } DirectoryPath tempPath = _environment.GetEnvironmentVariable("TEMP") ?? "./"; var tempScriptFile = _fileSystem.GetFile(tempPath .CombineWithFilePath(string.Format(CultureInfo.InvariantCulture, "{0}.cake", Guid.NewGuid())) .MakeAbsolute(_environment)); try { using (var stream = tempScriptFile.OpenWrite()) { using (var streamWriter = new StreamWriter(stream, Encoding.UTF8)) { streamWriter.WriteLine(cakeExpression); } } ExecuteScript(tempScriptFile.Path.FullPath, settings); } finally { if (tempScriptFile.Exists) { tempScriptFile.Delete(); } } }
/// <summary> /// Helper method to get the AWS Credentials from environment variables /// </summary> /// <param name="environment">The cake environment.</param> /// <returns>A new <see cref="EC2Settings"/> instance to be used in calls to the <see cref="IEC2Manager"/>.</returns> public static EC2Settings CreateEC2Settings(this ICakeEnvironment environment) { if (environment == null) { throw new ArgumentNullException("environment"); } EC2Settings settings = new EC2Settings(); //AWS Fallback AWSCredentials creds = FallbackCredentialsFactory.GetCredentials(); if (creds != null) { settings.Credentials = creds; } //Environment Variables string region = environment.GetEnvironmentVariable("AWS_REGION"); if (!String.IsNullOrEmpty(region)) { settings.Region = RegionEndpoint.GetBySystemName(region); } return(settings); }
/// <summary> /// Uploads test results XML file to AppVeyor. Results type can be one of the following: mstest, xunit, nunit, nunit3, junit. /// </summary> /// <param name="path">The file path of the test results XML to upload.</param> /// <param name="resultsType">The results type. Can be mstest, xunit, nunit, nunit3 or junit.</param> public void UploadTestResults(FilePath path, AppVeyorTestResultsType resultsType) { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (!IsRunningOnAppVeyor) { throw new CakeException("The current build is not running on AppVeyor."); } var baseUri = _environment.GetEnvironmentVariable("APPVEYOR_URL").TrimEnd('/'); if (string.IsNullOrWhiteSpace(baseUri)) { throw new CakeException("Failed to get AppVeyor API url."); } var url = new Uri(string.Format(CultureInfo.InvariantCulture, "{0}/api/testresults/{1}/{2}", baseUri, resultsType, Environment.JobId).ToLowerInvariant()); _cakeLog.Write(Verbosity.Diagnostic, LogLevel.Verbose, "Uploading [{0}] to [{1}]", path.FullPath, url); Task.Run(async() => { using (var client = new HttpClient()) { var response = await client.UploadFileAsync(url, path.FullPath, "text/xml"); var content = await response.Content.ReadAsStringAsync(); _cakeLog.Write(Verbosity.Diagnostic, LogLevel.Verbose, "Server response [{0}:{1}]:\n\r{2}", response.StatusCode, response.ReasonPhrase, content); } }).Wait(); }
/// <summary> /// Uploads test results XML file to AppVeyor. Results type can be one of the following: mstest, xunit, nunit, nunit3, junit. /// </summary> /// <param name="path">The file path of the test results XML to upload.</param> /// <param name="resultsType">The results type. Can be mstest, xunit, nunit, nunit3 or junit.</param> public void UploadTestResults(FilePath path, AppVeyorTestResultsType resultsType) { if (path == null) { throw new ArgumentNullException("path"); } if (!IsRunningOnAppVeyor) { throw new CakeException("The current build is not running on AppVeyor."); } var baseUri = _environment.GetEnvironmentVariable("APPVEYOR_URL").TrimEnd('/'); if (string.IsNullOrWhiteSpace(baseUri)) { throw new CakeException("Failed to get AppVeyor API url."); } var url = string.Format(CultureInfo.InvariantCulture, "{0}/api/testresults/{1}/{2}", baseUri, resultsType, Environment.JobId); using (var stream = File.OpenRead(path.FullPath)) using (var client = new HttpClient()) { client.PostAsync(url, new StreamContent(stream)).Wait(); } }
private IFile SafeResolvePath() { // Try to resolve it with the regular tool resolver. var toolsExe = _tools.Resolve(AmmExe); if (toolsExe != null) { var toolsFile = _fileSystem.GetFile(toolsExe); if (toolsFile.Exists) { return(toolsFile); } } // Check if path set to environment variable var acsFolder = _environment.GetEnvironmentVariable("ApprendaAMMInstall"); if (!string.IsNullOrWhiteSpace(acsFolder)) { var envFile = _fileSystem.GetFile(System.IO.Path.Combine(acsFolder, AmmExe)); if (envFile.Exists) { return(envFile); } } // try looking in locationes defined in PATH var envPath = _environment.GetEnvironmentVariable("path"); if (!string.IsNullOrWhiteSpace(envPath)) { var pathFile = envPath .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(path => _fileSystem.GetDirectory(path)) .Where(path => path.Exists) .Select(path => path.Path.CombineWithFilePath(AmmExe)) .Select(_fileSystem.GetFile) .FirstOrDefault(file => file.Exists); if (pathFile != null) { return(pathFile); } } throw new CakeException($"Could not locate {AmmExe}."); }
protected FilePath GetToolPath(TSettings settings, FilePath toolPath) { if (toolPath != null) { return(toolPath.MakeAbsolute(_environment)); } var toolExeNames = GetToolExecutableNames(); string[] pathDirs = null; // Look for each possible executable name in various places. foreach (var toolExeName in toolExeNames) { // First look in ./tools/ toolPath = _globber.GetFiles("./tools/**/" + toolExeName).FirstOrDefault(); if (toolPath != null) { return(toolPath.MakeAbsolute(_environment)); } // Cache the PATH directory list if we didn't already. if (pathDirs == null) { var pathEnv = _environment.GetEnvironmentVariable("PATH"); if (!string.IsNullOrEmpty(pathEnv)) { pathDirs = pathEnv.Split(new[] { _environment.IsUnix() ? ':' : ';' }, StringSplitOptions.RemoveEmptyEntries); } else { pathDirs = new string[] { }; } } // Look in every PATH directory for the file. foreach (var pathDir in pathDirs) { var file = new DirectoryPath(pathDir).CombineWithFilePath(toolExeName); if (_fileSystem.Exist(file)) { return(file.MakeAbsolute(_environment)); } } } // Look through all the alternative directories for the tool. var alternativePaths = GetAlternativeToolPaths(settings) ?? Enumerable.Empty <FilePath>(); foreach (var altPath in alternativePaths) { if (_fileSystem.Exist(altPath)) { return(altPath.MakeAbsolute(_environment)); } } return(null); }
public EnvironmentExtensionsTests() { environment = A.Fake <ICakeEnvironment>(); A.CallTo(() => environment.GetEnvironmentVariable(TestVariableName)).Returns(TestVariableValue); cakeContext = A.Fake <ICakeContext>(); A.CallTo(() => cakeContext.Environment).Returns(environment); }
private FilePath GetCommonToolPath(string environmentVariable) { var visualStudioCommonToolsPath = _environment.GetEnvironmentVariable(environmentVariable); if (string.IsNullOrWhiteSpace(visualStudioCommonToolsPath)) { return(null); } var root = new DirectoryPath(visualStudioCommonToolsPath).Combine("../IDE").Collapse(); return(root.CombineWithFilePath("mstest.exe")); }
private List <DirectoryPath> GetPathDirectories() { var result = new List <DirectoryPath>(); var path = _environment.GetEnvironmentVariable("PATH"); if (!string.IsNullOrEmpty(path)) { var separator = new[] { _environment.Platform.IsUnix() ? ':' : ';' }; var paths = path.Split(separator, StringSplitOptions.RemoveEmptyEntries); result.AddRange(paths.Select(p => new DirectoryPath(p))); } return(result); }
public static bool SupportsAnsi(ICakeEnvironment environment) { // Prevents the addition of ANSI color if NO_COLOR env. variable is present // https://no-color.org if (!string.IsNullOrWhiteSpace(environment.GetEnvironmentVariable("NO_COLOR"))) { return(false); } // Github action doesn't setup a correct PTY but supports ANSI. if (!string.IsNullOrWhiteSpace(environment.GetEnvironmentVariable("GITHUB_ACTION"))) { return(true); } // Azure Pipelines doesn't set the TERM environment variable but supports ANSI // https://github.com/microsoft/azure-pipelines-agent/issues/1569 if (!string.IsNullOrWhiteSpace(environment.GetEnvironmentVariable("TF_BUILD"))) { return(true); } // TeamCity doesn't set the TERM environment variable but supports ANSI since 9.1 // https://blog.jetbrains.com/teamcity/2015/07/teamcity-9-1-release-truly-historical-and-very-personal-builds/ var teamCityVersion = environment.GetEnvironmentVariable("TEAMCITY_VERSION"); if (!string.IsNullOrWhiteSpace(teamCityVersion) && _teamCityVersionWithAnsiSupportRegEx.IsMatch(teamCityVersion)) { return(true); } // Check if the terminal is of type ANSI/VT100/xterm compatible. var term = environment.GetEnvironmentVariable("TERM"); if (!string.IsNullOrWhiteSpace(term)) { if (_regexes.Any(regex => regex.IsMatch(term))) { return(true); } } // Running on Windows? if (environment.Platform.Family == PlatformFamily.Windows) { // Running under ConEmu? var conEmu = environment.GetEnvironmentVariable("ConEmuANSI"); if (!string.IsNullOrEmpty(conEmu) && conEmu.Equals("On", StringComparison.OrdinalIgnoreCase)) { return(true); } return(Windows.SupportsAnsi()); } return(false); }
/// <summary> /// Resolves the path to nuget.exe. /// </summary> /// <returns>The path to nuget.exe.</returns> public FilePath ResolvePath() { // Check if path already resolved if (_cachedPath != null && _cachedPath.Exists) { return(_cachedPath.Path); } // Try to resolve it with the regular tool resolver. var toolsExe = _tools.Resolve("nuget.exe"); if (toolsExe != null) { var toolsFile = _fileSystem.GetFile(toolsExe); if (toolsFile.Exists) { _cachedPath = toolsFile; return(_cachedPath.Path); } } // Check if path set to environment variable var environmentExe = _environment.GetEnvironmentVariable("NUGET_EXE"); if (!string.IsNullOrWhiteSpace(environmentExe)) { var envFile = _fileSystem.GetFile(environmentExe); if (envFile.Exists) { _cachedPath = envFile; return(_cachedPath.Path); } } // On Unix /usr/bin/nuget or /usr/local/bin/nuget are viable options if (_environment.IsUnix()) { foreach (var systemPath in _unixSystemPaths) { if (_fileSystem.Exist(systemPath)) { _cachedPath = _fileSystem.GetFile(systemPath); return(_cachedPath.Path); } } } throw new CakeException("Could not locate nuget.exe."); }
public string GetEnvironmentVariable(string name, string defaultValue = null) { if (!(_overrides is null) && _overrides.TryGetValue(name, out var value)) { return(string.IsNullOrWhiteSpace(value) ? defaultValue : value); } value = _cakeEnvironment.GetEnvironmentVariable(name); if (!string.IsNullOrWhiteSpace(value)) { return(value); } return(defaultValue); }
private DirectoryPath GetCakePath(DirectoryPath toolPath) { // Check for local cake in tools path var pattern = string.Concat(toolPath.FullPath, "/**/Cake.exe"); var cakeCorePath = _globber.GetFiles(pattern).FirstOrDefault(); if (cakeCorePath != null) { return(cakeCorePath.GetDirectory().MakeAbsolute(_environment)); } pattern = string.Concat(toolPath.FullPath, "/**/Cake.dll"); cakeCorePath = _globber.GetFiles(pattern).FirstOrDefault(); if (cakeCorePath != null) { return(cakeCorePath.GetDirectory().MakeAbsolute(_environment)); } // Check path for cake.exe var separatorChar = _environment.Platform.Family == PlatformFamily.Windows ? ';' : ':'; var directoriesInPath = (_environment.GetEnvironmentVariable("PATH") ?? string.Empty) .Split(new[] { separatorChar }, StringSplitOptions.RemoveEmptyEntries) .Select(x => (DirectoryPath)x).ToArray(); var cakeExePath = directoriesInPath.FirstOrDefault(x => _fileSystem.Exist(x.CombineWithFilePath("Cake.exe"))); if (cakeExePath != null) { return(cakeExePath.MakeAbsolute(_environment)); } // Check path for dotnet-cake.exe var dotnetCakePath = directoriesInPath.FirstOrDefault(x => _fileSystem.Exist(x.CombineWithFilePath("dotnet-cake.exe"))) ?? directoriesInPath.FirstOrDefault(x => _fileSystem.Exist(x.CombineWithFilePath("dotnet-cake"))); if (dotnetCakePath != null) { pattern = string.Concat(dotnetCakePath.FullPath, "/.store/**/Cake.dll"); var cakeDllPath = _globber.GetFiles(pattern).FirstOrDefault(); if (cakeDllPath != null) { return(cakeDllPath.GetDirectory().MakeAbsolute(_environment)); } } return(toolPath.Combine("Cake").Collapse()); }
/// <summary> /// Resolves the path to GitReleaseManager.exe. /// </summary> /// <returns>The path to GitReleaseManager.exe.</returns> public FilePath ResolvePath() { // Check if path already resolved if (_cachedPath != null && _cachedPath.Exists) { return(_cachedPath.Path); } // Check if tool exists in tool folder const string expression = "./tools/**/GitReleaseManager.exe"; var toolsExe = _globber.GetFiles(expression).FirstOrDefault(); if (toolsExe != null) { var toolsFile = _fileSystem.GetFile(toolsExe); if (toolsFile.Exists) { _cachedPath = toolsFile; return(_cachedPath.Path); } } // Last resort try path var envPath = _environment.GetEnvironmentVariable("path"); if (!string.IsNullOrWhiteSpace(envPath)) { var pathFile = envPath .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(path => _fileSystem.GetDirectory(path)) .Where(path => path.Exists) .Select(path => path.Path.CombineWithFilePath("GitReleaseManager.exe")) .Select(_fileSystem.GetFile) .FirstOrDefault(file => file.Exists); if (pathFile != null) { _cachedPath = pathFile; return(_cachedPath.Path); } } throw new CakeException("Could not locate GitReleaseManager.exe."); }
private IReadOnlyCollection <IFile> GetToolFiles(PackageReference package) { var result = new List <IFile>(); var chocoInstallLocation = _environment.GetEnvironmentVariable("ChocolateyInstall"); if (string.IsNullOrWhiteSpace(chocoInstallLocation)) { throw new InvalidOperationException("Chocolatey does not appear to be installed."); } var toolDirectory = _fileSystem.GetDirectory(chocoInstallLocation + "/lib/" + package.Package); if (toolDirectory.Exists) { result.AddRange(GetFiles(toolDirectory.Path.FullPath, package)); } return(result); }
protected override IEnumerable <FilePath> GetAlternativeToolPaths(AndroidEmulatorToolSettings settings) { var results = new List <FilePath>(); var ext = environment.Platform.Family == PlatformFamily.Windows ? ".exe" : ""; var androidHome = settings.SdkRoot?.MakeAbsolute(environment)?.FullPath; if (string.IsNullOrEmpty(androidHome) || !System.IO.Directory.Exists(androidHome)) { androidHome = environment.GetEnvironmentVariable("ANDROID_HOME"); } if (!string.IsNullOrEmpty(androidHome) && System.IO.Directory.Exists(androidHome)) { var exe = new DirectoryPath(androidHome).Combine("emulator").CombineWithFilePath("emulator" + ext); results.Add(exe); } return(results); }
protected override IEnumerable <FilePath> GetAlternativeToolPaths(AndroidSdkManagerToolSettings settings) { var results = new List <FilePath>(); var ext = environment.Platform.IsUnix() ? "" : ".bat"; var androidHome = settings.SdkRoot.MakeAbsolute(environment).FullPath; if (!System.IO.Directory.Exists(androidHome)) { androidHome = environment.GetEnvironmentVariable("ANDROID_HOME"); } if (!string.IsNullOrEmpty(androidHome) && System.IO.Directory.Exists(androidHome)) { var exe = new DirectoryPath(androidHome).Combine("tools").Combine("bin").CombineWithFilePath("sdkmanager" + ext); results.Add(exe); } return(results); }
private List <DirectoryPath> GetPathDirectories() { var result = new List <DirectoryPath>(); var path = _environment.GetEnvironmentVariable("PATH"); if (!string.IsNullOrEmpty(path)) { var separator = new[] { _environment.Platform.IsUnix() ? ':' : ';' }; var paths = path.Split(separator, StringSplitOptions.RemoveEmptyEntries); foreach (var p in paths) { try { result.Add(new DirectoryPath(p.Trim(' ', '"', '\''))); } catch { } } } return(result); }
/// <summary> /// Helper method to get the AWS Credentials from environment variables /// </summary> /// <param name="environment">The cake environment.</param> /// <param name="settings">The Labda settings.</param> /// <returns>The same <see cref="ClientSettings"/> instance so that multiple calls can be chained.</returns> private static T Initialize <T>(this T settings, ICakeEnvironment environment) where T : ClientSettings { if (environment == null) { throw new ArgumentNullException(nameof(environment)); } //AWS Fallback AWSCredentials creds = FallbackCredentialsFactory.GetCredentials(); if (creds != null) { settings.Credentials = creds; } string region = environment.GetEnvironmentVariable("AWS_REGION"); if (!String.IsNullOrEmpty(region)) { settings.Region = RegionEndpoint.GetBySystemName(region); } return(settings); }