/// <summary>
/// Creates an instance of <see cref="DeploymentParameters"/>.
/// </summary>
/// <param name="applicationPath">Source code location of the target location to be deployed.</param>
/// <param name="serverType">Where to be deployed on.</param>
/// <param name="runtimeFlavor">Flavor of the clr to run against.</param>
/// <param name="runtimeArchitecture">Architecture of the runtime to be used.</param>
public DeploymentParameters(
string applicationPath,
ServerType serverType,
RuntimeFlavor runtimeFlavor,
RuntimeArchitecture runtimeArchitecture)
{
if (string.IsNullOrEmpty(applicationPath))
{
throw new ArgumentException("Value cannot be null.", nameof(applicationPath));
}
if (!Directory.Exists(applicationPath))
{
throw new DirectoryNotFoundException(string.Format("Application path {0} does not exist.", applicationPath));
}
if (runtimeArchitecture == RuntimeArchitecture.x86)
{
throw new NotSupportedException("32 bit compilation is not yet supported. Don't remove the tests, just disable them for now.");
}
ApplicationPath = applicationPath;
ServerType = serverType;
RuntimeFlavor = runtimeFlavor;
EnvironmentVariables.Add(new KeyValuePair <string, string>("ASPNETCORE_DETAILEDERRORS", "true"));
}
private void PrepareTestEnvironment()
{
var homeDir = RootDir.CreateDirectory(".home");
var xdgDir = RootDir.CreateDirectory(".xdg");
EnvironmentVariables.Add("XDG_CONFIG_HOME", xdgDir.Path);
EnvironmentVariables.Add("HOME", homeDir.Path);
if (PathUtils.IsUnixLikePlatform)
{
EnvironmentVariables.Add("MICROSOFT_SOURCELINK_TEST_ENVIRONMENT_ETC_DIR", homeDir.Path);
xdgDir.CreateDirectory("git").CreateFile("config").WriteAllText(@"[remote ""origin2""]url = http://github.com/test-org/test-repo2");
}
else
{
var gitInstallDir = RootDir.CreateDirectory(".gitinstall");
var gitExeDir = gitInstallDir.CreateDirectory("bin");
gitExeDir.CreateFile("git.exe");
var etcDir = gitInstallDir.CreateDirectory("mingw64").CreateDirectory("etc");
etcDir.CreateFile("gitconfig").WriteAllText(@"[remote ""origin2""]url = http://github.com/test-org/test-repo2");
var programDataDir = RootDir.CreateDirectory(".programdata");
EnvironmentVariables.Add("USERPROFILE", homeDir.Path);
EnvironmentVariables.Add("PATH", gitExeDir.Path);
EnvironmentVariables.Add("PROGRAMDATA", programDataDir.Path);
}
}
protected override void Read(IPropertySet pset)
{
base.Read(pset);
ExternalConsole = pset.GetValue(nameof(ExternalConsole), false);
// read from run config if CurrentProfile.* is empty, for backward compatibility
if (!pset.HasProperty(nameof(EnvironmentVariables)) && EnvironmentVariables.Count == 0)
{
EnvironmentVariables.Add("ASPNETCORE_ENVIRONMENT", "Development");
}
#pragma warning disable CS0618 //disables warnings threw by obsolete methods used in nameof()
if (CurrentProfile.LaunchBrowser == null)
{
CurrentProfile.LaunchBrowser = pset.GetValue(nameof(LaunchBrowser), true);
}
if (string.IsNullOrEmpty(CurrentProfile.TryGetApplicationUrl()))
{
if (CurrentProfile.OtherSettings == null)
{
CurrentProfile.OtherSettings = new Dictionary <string, object> (StringComparer.Ordinal);
}
CurrentProfile.OtherSettings ["applicationUrl"] = pset.GetValue(nameof(ApplicationURL), "http://localhost:5000/");
}
if (string.IsNullOrEmpty(CurrentProfile.LaunchUrl))
{
CurrentProfile.LaunchUrl = pset.GetValue(nameof(LaunchUrl), null);
}
#pragma warning restore CS0618
}
protected override void Initialize(Project project)
{
webProject = project.GetFlavor <DotNetCoreProjectExtension> ()?.IsWeb ?? false;
base.Initialize(project);
ExternalConsole = !webProject;
if (!webProject)
{
return;
}
// Pick up/import default values from "launchSettings.json"
var launchSettingsJsonPath = Path.Combine(project.BaseDirectory, "Properties", "launchSettings.json");
var launchSettingsJson = File.Exists(launchSettingsJsonPath) ? JObject.Parse(File.ReadAllText(launchSettingsJsonPath)) : null;
var settings = (launchSettingsJson?.GetValue("profiles") as JObject)?.GetValue(project.Name) as JObject;
LaunchBrowser = settings?.GetValue("launchBrowser")?.Value <bool?> () ?? true;
LaunchUrl = settings?.GetValue("launchUrl")?.Value <string> () ?? null;
foreach (var pair in (settings?.GetValue("environmentVariables") as JObject)?.Properties() ?? Enumerable.Empty <JProperty> ())
{
if (!EnvironmentVariables.ContainsKey(pair.Name))
{
EnvironmentVariables.Add(pair.Name, pair.Value.Value <string> ());
}
}
ApplicationURL = settings?.GetValue("applicationUrl")?.Value <string> () ?? "http://localhost:5000/";
}
internal void AddEnvironmentVariablesFromProject(IProject project)
{
foreach (var environmentVariable in project.EnvironmentVariables)
{
EnvironmentVariables.Add(environmentVariable.Key, environmentVariable.Value);
}
}
internal VcProjectConfigurationItem(string name = "") : base(name)
{
IsActivate = false;
ProjectPropertyGroup = new VcProjectPropertyGroup(name);
EnvironmentVariables.Add("$(Configuration)", string.Empty);
EnvironmentVariables.Add("$(Platform)", string.Empty);
}
protected override void Start()
{
if (!ROS_Node.Instance.ROS2)
{
EnvironmentVariables.Add("ROS_MASTER_URI", ROS_Node.Config.ros_master_uri);
EnvironmentVariables.Add("ROS_IP", ROS_Node.Config.ros_ip);
}
base.Start();
}
public EnvironmentData()
{
CurrentDirectory = Environment.CurrentDirectory;
foreach (DictionaryEntry e in Environment.GetEnvironmentVariables())
{
EnvironmentVariables.Add(e.Key.ToString(), e.Value.ToString());
}
}
protected override void Read(IPropertySet pset)
{
base.Read(pset);
ExternalConsole = pset.GetValue(nameof(ExternalConsole), false);
if (!pset.HasProperty(nameof(EnvironmentVariables)))
{
EnvironmentVariables.Add("ASPNETCORE_ENVIRONMENT", "Development");
}
LaunchBrowser = pset.GetValue(nameof(LaunchBrowser), true);
ApplicationURL = pset.GetValue(nameof(ApplicationURL), "http://localhost:5000/");
LaunchUrl = pset.GetValue(nameof(LaunchUrl), null);
}
internal VcProject(string name = "", string guid = "") : base(name, guid)
{
ConfigurationItems = new List <VcProjectConfigurationItem>();
HeaderFileItems = new List <HeaderFile>();
SourceFileItems = new List <SourceFile>();
EnvironmentVariables.Add("$(ProjectDir)", string.Empty);
EnvironmentVariables.Add("$(ProjectName)", string.Empty);
EnvironmentVariables.Add("$(ProjectExt)", string.Empty);
EnvironmentVariables.Add("$(ProjectFileName)", string.Empty);
EnvironmentVariables.Add("$(ProjectGuid)", string.Empty);
EnvironmentVariables.Add("$(ProjectPath)", string.Empty);
}
protected override void Initialize(Project project)
{
base.Initialize(project);
ExternalConsole = true;
if (project.GetFlavor <DotNetCoreProjectExtension> ()?.IsWeb ?? false && string.IsNullOrEmpty(ApplicationURL))
{
var tcpListner = new TcpListener(IPAddress.Loopback, 0);
tcpListner.Start();
ApplicationURL = $"http://localhost:{((IPEndPoint)tcpListner.LocalEndpoint).Port}";
tcpListner.Stop();
EnvironmentVariables.Add("ASPNETCORE_ENVIRONMENT", "Development");
}
}
/// <summary>
/// Set the environment variables
/// </summary>
protected override void ExecuteTask()
{
if (EnvName != null && _value != null)
{
// add single environment variable
EnvironmentVariables.Add(new EnvironmentVariable(EnvName, _value));
}
foreach (EnvironmentVariable env in EnvironmentVariables)
{
SetSingleEnvironmentVariable(env.VariableName, env.Value);
}
}
public RhinoDebuggerStartInfo(RhinoExecutionCommand cmd)
: base(new Mono.Debugging.Soft.SoftDebuggerListenArgs("Rhino", System.Net.IPAddress.Loopback, 0))
{
Command = cmd.Command;
Arguments = cmd.Arguments;
RhinoVersion = cmd.RhinoVersion;
foreach (var env in cmd.EnvironmentVariables)
{
EnvironmentVariables.Add(env.Key, env.Value);
}
ApplicationPath = cmd.ApplicationPath;
ExecutablePath = cmd.ExecutablePath;
WorkingDirectory = cmd.WorkingDirectory;
}
public override async Task Setup(DotNetInstallation dotNetInstall, string outputDir, bool useExistingSetup, ITestOutputHelper output)
{
if (!useExistingSetup)
{
using (var setupSection = new IndentedTestOutputHelper("Setup " + Name, output))
{
await CloneAspNetJitBenchRepo(outputDir, setupSection);
await CreateStore(dotNetInstall, outputDir, setupSection);
await Publish(dotNetInstall, outputDir, setupSection);
}
}
string tfm = DotNetSetup.GetTargetFrameworkMonikerForFrameworkVersion(dotNetInstall.FrameworkVersion);
WorkingDirPath = GetWebAppPublishDirectory(dotNetInstall, outputDir, tfm);
EnvironmentVariables.Add("DOTNET_SHARED_STORE", GetWebAppStoreDir(outputDir));
}
public override async Task Setup(DotNetInstallation dotNetInstall, string outputDir, bool useExistingSetup, ITestOutputHelper output)
{
if (!useExistingSetup)
{
using (var setupSection = new IndentedTestOutputHelper("Setup " + Name, output))
{
await SetupSourceToCompile(outputDir, dotNetInstall.FrameworkDir, useExistingSetup, setupSection);
await Publish(dotNetInstall, outputDir, setupSection);
}
}
string tfm = DotNetSetup.GetTargetFrameworkMonikerForFrameworkVersion(dotNetInstall.FrameworkVersion);
WorkingDirPath = GetAppPublishDirectory(dotNetInstall, outputDir, tfm);
EnvironmentVariables.Add("DOTNET_MULTILEVEL_LOOKUP", "0");
EnvironmentVariables.Add("UseSharedCompilation", "false");
}
protected override void Read(IPropertySet pset)
{
base.Read(pset);
ExternalConsole = pset.GetValue(nameof(ExternalConsole), !webProject);
if (!webProject)
{
return;
}
if (!pset.HasProperty(nameof(EnvironmentVariables)))
{
EnvironmentVariables.Add("ASPNETCORE_ENVIRONMENT", "Development");
}
#pragma warning disable CS0618 // Type or member is obsolete
LaunchBrowser = pset.GetValue(nameof(LaunchBrowser), true);
ApplicationURL = pset.GetValue(nameof(ApplicationURL), "http://localhost:5000/");
LaunchUrl = pset.GetValue(nameof(LaunchUrl), null);
#pragma warning restore CS0618 // Type or member is obsolete
}
/// <summary>
/// Adds an environment variable specification of the form <b>NAME</b> or
/// <b>NAME=VALUE</b> to the shim to be passed on to the Docker container.
/// </summary>
/// <param name="variable">The variable specification.</param>
public void AddEnvironmentVariable(string variable)
{
Covenant.Requires <ArgumentNullException>(!string.IsNullOrWhiteSpace(variable));
var fields = variable.Split(new char[] { '=' }, 2);
if (fields.Length == 2)
{
var name = fields[0];
if (string.IsNullOrWhiteSpace(name) || name.Contains(' '))
{
throw new ArgumentException($"Environment variable [{variable}] specification is not valid.");
}
}
EnvironmentVariables.Add(variable);
}
public DeploymentParameters(DeploymentParameters parameters)
{
foreach (var propertyInfo in typeof(DeploymentParameters).GetProperties())
{
if (propertyInfo.CanWrite)
{
propertyInfo.SetValue(this, propertyInfo.GetValue(parameters));
}
}
foreach (var kvp in parameters.EnvironmentVariables)
{
EnvironmentVariables.Add(kvp);
}
foreach (var kvp in parameters.PublishEnvironmentVariables)
{
PublishEnvironmentVariables.Add(kvp);
}
}
protected override void Initialize(Project project)
{
base.Initialize(project);
ExternalConsole = false;
// Pick up/import default values from "launchSettings.json"
var launchSettingsJsonPath = Path.Combine(project.BaseDirectory, "Properties", "launchSettings.json");
var launchSettingsJson = File.Exists(launchSettingsJsonPath) ? JObject.Parse(File.ReadAllText(launchSettingsJsonPath)) : null;
var settings = (launchSettingsJson?.GetValue("profiles") as JObject)?.GetValue(project.Name) as JObject;
LaunchBrowser = settings?.GetValue("launchBrowser")?.Value <bool?> () ?? true;
LaunchUrl = settings?.GetValue("launchUrl")?.Value <string> () ?? null;
foreach (var pair in (settings?.GetValue("environmentVariables") as JObject)?.Properties() ?? Enumerable.Empty <JProperty> ())
{
if (!EnvironmentVariables.ContainsKey(pair.Name))
{
EnvironmentVariables.Add(pair.Name, pair.Value.Value <string> ());
}
}
ApplicationURL = GetApplicationUrl(settings, EnvironmentVariables);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Do the job
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void ExecuteTask()
{
try
{
if (VariableName != null && Value != null)
{
// add single environment variable
EnvironmentVariables.Add(new EnvironmentVariable(VariableName, Value));
}
foreach (EnvironmentVariable env in EnvironmentVariables)
{
SetSingleEnvironmentVariable(env.VariableName, env.Value);
}
if (m_fGlobal)
{
SetGlobalEnvironmentVariables();
}
}
catch (Exception e)
{
BuildException buildEx = e as BuildException;
if (buildEx != null)
{
throw new BuildException(
string.Format("Exception setting environment variable {1}: {0}", e.Message,
buildEx.Data["Name"]), Location, e);
}
else
{
throw new BuildException(
string.Format("Exception setting environment variables: {0}", e.Message),
Location, e);
}
}
}
public void AddEnvironmentVariable()
{
EnvironmentVariables.Add(new EnvironmentVariableListItemModel());
}
public CreateContainerParametersBuilder AddEnvironmentVariable(string variable)
{
EnvironmentVariables.Add(variable);
return(this);
}
