public void CanProxiseByAppid()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.On("/call1", "hello!");
var result = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(100);
result = new HttpClient().GetString("http://127.0.0.1:14990/call1");
}
finally
{
h1.Stop();
h2.Stop();
}
Assert.AreEqual("hello!", result);
}
public override void InitHostConifg(HostConfig config)
{
if (config.HandlerFactoryPath == null)
{
InferHttpHandlerPath(config);
}
}
private static void InferHttpHandlerPath(HostConfig config)
{
try
{
var webConfig = GetAppConfig();
if (webConfig == null) return;
SetPathsFromConfiguration(config, webConfig, null);
if (config.MetadataRedirectPath == null)
{
foreach (ConfigurationLocation location in webConfig.Locations)
{
SetPathsFromConfiguration(config, location.OpenConfiguration(), (location.Path ?? "").ToLower());
if (config.MetadataRedirectPath != null) { break; }
}
}
if (HostContext.IsAspNetHost && config.MetadataRedirectPath == null)
{
throw new ConfigurationErrorsException(
"Unable to infer ServiceStack's <httpHandler.Path/> from the Web.Config\n"
+ "Check with https://github.com/ServiceStack/ServiceStack/wiki/Create-your-first-webservice to ensure you have configured ServiceStack properly.\n"
+ "Otherwise you can explicitly set your httpHandler.Path by setting: EndpointHostConfig.ServiceStackPath");
}
}
catch (Exception) { }
}
protected override void When()
{
FakeMessageChannel.Reset();
LogManager.Configure(new TraceLoggerFactory(), LogLevel.All);
var objectFactory = ObjectFactoryResolver.GetObjectFactory();
objectFactory.Register<ISubscriptionStorage, InMemorySubscriptionStorage>(LifeCycle.Unique);
var hostConfig = new HostConfig();
var host = new Host(hostConfig);
host.Start();
}
public void CanCheckoutConfigUsingMachineNameToResolve() {
const string code = @"
class local
connection a y
class remote
machine t use=^local
connection b z
";
var ctx = BSharpCompiler.Compile(code);
var local = ctx["local"].Compiled;
var remote = ctx["remote"].Compiled;
var config = new HostConfig(remote, ctx, "t");
Assert.AreSame(local, config.Definition);
}
public void CanProxisePost()
{
var aconfig1 = new HostConfig();
aconfig1.AddQorpentBinding(98);
var aconfig2 = new HostConfig();
aconfig2.AddQorpentBinding(99);
aconfig2.Proxize["/call1"] = "appid=98";
var h1 = new HostServer(aconfig1);
var h2 = new HostServer(aconfig2);
h1.OnContext("/call1", _ => {
if (_.Method == "POST") {
_.Finish(new StreamReader(_.Request.Stream).ReadToEnd());
}
else {
_.Finish("hello!");
}
});
var result = "";
var resultDirect = "";
try
{
h1.Start();
h2.Start();
Thread.Sleep(1000);
resultDirect = new HttpClient().GetString("http://127.0.0.1:14980/call1", "hello2");
result = new HttpClient().GetString("http://127.0.0.1:14990/call1", "hello2");
}
finally
{
h1.Stop();
h2.Stop();
}
Console.WriteLine(result);
Assert.AreEqual("hello2", resultDirect);
Assert.AreEqual("hello2", result);
}
private static void LogHostInfo(ServerParameters arg, HostConfig config) {
Console.WriteLine("BinRoot: "+config.DllFolder);
foreach (var assembly in config.AutoconfigureAssemblies) {
arg.Log.Trace("Lib: " + assembly);
}
foreach (var hostBinding in config.Bindings) {
arg.Log.Info("Binding: " + hostBinding);
}
arg.Log.Trace("RootFolder: " + config.RootFolder);
foreach (var contentFolder in config.ContentFolders) {
arg.Log.Trace("ContentFolder: " + contentFolder);
}
foreach (var map in config.StaticContentMap) {
arg.Log.Trace("Map: "+map.Key+" : "+map.Value);
}
foreach (var map in config.Proxize)
{
arg.Log.Trace("Proxize: " + map.Key + " : " + map.Value);
}
foreach (var e in config.StaticContentCacheMap) {
arg.Log.Trace(e.Value.ToString());
}
}
private static void EnsureRequiredApplications(ServerParameters serverParameters, HostConfig config) {
var requires = config.Definition.Elements("require");
foreach (var require in requires) {
if(!string.IsNullOrWhiteSpace(require.Attr("server")))continue; //external service
var name = require.IdCodeOrValue()+require.Attr("suffix");
var shadow = EnvironmentInfo.GetShadowDirectory(name);
var processes = Process.GetProcessesByName("qh");
Console.WriteLine(string.Join("; ",processes.Select(_=>_.ProcessName)));
var required =
processes.FirstOrDefault(_ => _.MainModule.FileName.NormalizePath().StartsWith(shadow.NormalizePath()));
if (null != required) {
config.Log.Info("Required '" + name + "' found, PID: " + required.Id);
}
else {
var args = name;
if (serverParameters.Get("hidden", false)) {
args += " --hidden";
}
required = Process.Start(EnvironmentInfo.ResolvePath("@repos@/.build/bin/all/qh.exe"), args);
config.Log.Info("Required '" + name + "' started, PID: " + required.Id);
}
}
}
public Repository(HostConfig config)
{
_dataFolder = config.Data;
}
private static void SetPaths(HostConfig config, string handlerPath, string locationPath)
{
if (handlerPath == null) return;
if (locationPath == null)
{
handlerPath = handlerPath.Replace("*", String.Empty);
}
config.HandlerFactoryPath = locationPath ??
(String.IsNullOrEmpty(handlerPath) ? null : handlerPath);
config.MetadataRedirectPath = "metadata";
}
private static void SetPathsFromConfiguration(HostConfig config, System.Configuration.Configuration webConfig, string locationPath)
{
if (webConfig == null)
return;
//standard config
var handlersSection = webConfig.GetSection("system.web/httpHandlers") as HttpHandlersSection;
if (handlersSection != null)
{
for (var i = 0; i < handlersSection.Handlers.Count; i++)
{
var httpHandler = handlersSection.Handlers[i];
if (!httpHandler.Type.StartsWith("ServiceStack"))
continue;
SetPaths(config, httpHandler.Path, locationPath);
break;
}
}
//IIS7+ integrated mode system.webServer/handlers
var pathsNotSet = config.MetadataRedirectPath == null;
if (pathsNotSet)
{
var webServerSection = webConfig.GetSection("system.webServer");
var rawXml = webServerSection?.SectionInformation.GetRawXml();
if (!String.IsNullOrEmpty(rawXml))
{
SetPaths(config, ExtractHandlerPathFromWebServerConfigurationXml(rawXml), locationPath);
}
//In some MVC Hosts auto-inferencing doesn't work, in these cases assume the most likely default of "/api" path
pathsNotSet = config.MetadataRedirectPath == null;
if (pathsNotSet)
{
var isMvcHost = Type.GetType("System.Web.Mvc.Controller") != null;
if (isMvcHost)
{
SetPaths(config, "api", null);
}
}
}
}
private async Task CreateContainerAsync()
{
var hostConfig = new HostConfig
{
PublishAllPorts = true
};
if (_settings.ExternalPort > 0)
{
hostConfig.PublishAllPorts = false;
hostConfig.PortBindings = new Dictionary <string, IList <PortBinding> > {
{
_settings.InternalPort + "/tcp", new List <PortBinding> {
new PortBinding {
HostPort = _settings.ExternalPort.ToString()
}
}
}
};
}
var startParams = new CreateContainerParameters
{
Name = _settings.UniqueContainerName,
Image = _settings.ImageFullname,
Volumes = _settings.Volumes.ToDictionary(k => k, v => new EmptyStruct()),
AttachStdout = true,
AttachStderr = true,
AttachStdin = false,
Tty = false,
HostConfig = hostConfig,
Env = _settings.EnvironmentVariables,
Cmd = _settings.Cmd
};
try
{
await retryPolicy
.ExecuteAsync(async() =>
{
CreateContainerResponse response = await _client
.Containers
.CreateContainerAsync(startParams);
if (string.IsNullOrEmpty(response.ID))
{
throw new ContainerException(
"Could not create the container");
}
Instance.Id = response.ID;
Instance.Name = startParams.Name;
});
foreach (CopyContext copyContext in _settings.FilesToCopy)
{
await CopyToContainerAsync(copyContext, true);
}
}
catch (Exception ex)
{
throw new ContainerException(
$"Error in CreateContainer: {_settings.UniqueContainerName}", ex);
}
}
public AADTokenHelper(ClientConfig clientConfig, HostConfig hostConfig)
{
this.clientConfig = clientConfig;
this.hostConfig = hostConfig;
}
public SshConnector(HostConfig hostConfig)
{
this.HostConfig = hostConfig;
}
/// <summary>
/// Initializes a new instance of the <see cref="ContainerInspectResponse" /> class.
/// </summary>
/// <param name="id">The ID of the container.</param>
/// <param name="created">The time the container was created.</param>
/// <param name="path">The path to the command being run.</param>
/// <param name="args">The arguments to the command being run.</param>
/// <param name="state">state.</param>
/// <param name="image">The container's image.</param>
/// <param name="resolvConfPath">resolvConfPath.</param>
/// <param name="hostnamePath">hostnamePath.</param>
/// <param name="hostsPath">hostsPath.</param>
/// <param name="logPath">logPath.</param>
/// <param name="node">TODO.</param>
/// <param name="name">name.</param>
/// <param name="restartCount">restartCount.</param>
/// <param name="driver">driver.</param>
/// <param name="mountLabel">mountLabel.</param>
/// <param name="processLabel">processLabel.</param>
/// <param name="appArmorProfile">appArmorProfile.</param>
/// <param name="execIDs">IDs of exec instances that are running in the container..</param>
/// <param name="hostConfig">hostConfig.</param>
/// <param name="graphDriver">graphDriver.</param>
/// <param name="sizeRw">The size of files that have been created or changed by this container..</param>
/// <param name="sizeRootFs">The total size of all the files in this container..</param>
/// <param name="mounts">mounts.</param>
/// <param name="config">config.</param>
/// <param name="networkSettings">networkSettings.</param>
public ContainerInspectResponse(string id = default(string), string created = default(string), string path = default(string), List <string> args = default(List <string>), ContainerInspectResponseState state = default(ContainerInspectResponseState), string image = default(string), string resolvConfPath = default(string), string hostnamePath = default(string), string hostsPath = default(string), string logPath = default(string), Object node = default(Object), string name = default(string), int?restartCount = default(int?), string driver = default(string), string mountLabel = default(string), string processLabel = default(string), string appArmorProfile = default(string), List <string> execIDs = default(List <string>), HostConfig hostConfig = default(HostConfig), GraphDriverData graphDriver = default(GraphDriverData), long?sizeRw = default(long?), long?sizeRootFs = default(long?), List <MountPoint> mounts = default(List <MountPoint>), ContainerConfig config = default(ContainerConfig), NetworkSettings networkSettings = default(NetworkSettings))
{
this.Id = id;
this.Created = created;
this.Path = path;
this.Args = args;
this.State = state;
this.Image = image;
this.ResolvConfPath = resolvConfPath;
this.HostnamePath = hostnamePath;
this.HostsPath = hostsPath;
this.LogPath = logPath;
this.Node = node;
this.Name = name;
this.RestartCount = restartCount;
this.Driver = driver;
this.MountLabel = mountLabel;
this.ProcessLabel = processLabel;
this.AppArmorProfile = appArmorProfile;
this.ExecIDs = execIDs;
this.HostConfig = hostConfig;
this.GraphDriver = graphDriver;
this.SizeRw = sizeRw;
this.SizeRootFs = sizeRootFs;
this.Mounts = mounts;
this.Config = config;
this.NetworkSettings = networkSettings;
}
public void CanSetupValidProxyModeFromBSharp() {
const string code = @"
class myapp
proxize /others appid=15
proxize /others2 appid=16 secure=true
proxize /others3 url='http://yandex.ru'
";
var xml = BSharpCompiler.Compile(code)["myapp"].Compiled;
var config = new HostConfig(xml);
Assert.AreEqual("appid=15;",config.Proxize["/others"]);
Assert.AreEqual("appid=16;secure=true;",config.Proxize["/others2"]);
Assert.AreEqual("http://yandex.ru", config.Proxize["/others3"]);
}
private async Task StartRedisContainer()
{
try
{
var dockerConnection = System.Environment.OSVersion.Platform.ToString().Contains("Win") ?
"npipe://./pipe/docker_engine" :
"unix:///var/run/docker.sock";
System.Console.WriteLine("Starting container");
using (var conf = new DockerClientConfiguration(new Uri(dockerConnection))) // localhost
using (var client = conf.CreateClient())
{
System.Console.WriteLine("On Premise execution detected");
System.Console.WriteLine("Starting container...");
var containers = await client.Containers.ListContainersAsync(new ContainersListParameters()
{
All = true
});
System.Console.WriteLine("listing container...");
var container = containers.FirstOrDefault(c => c.Names.Contains("/" + ContainerName));
// Download image
await client.Images.CreateImageAsync(new ImagesCreateParameters()
{
FromImage = ImageName, Tag = ImageTag
}, new AuthConfig(), new Progress <JSONMessage>());
// Create the container
var config = new Config()
{
Hostname = "localhost"
};
this.redisPort = Interlocked.Increment(ref uniqueRedisPort);
System.Console.WriteLine(this.redisPort);
// Configure the ports to expose
var hostConfig = new HostConfig()
{
PortBindings = new Dictionary <string, IList <PortBinding> >
{
{
$"6379/tcp", new List <PortBinding> {
new PortBinding {
HostIP = "127.0.0.1", HostPort = this.redisPort.ToString()
}
}
}
}
};
System.Console.WriteLine("Creating container...");
// Create the container
var response = await client.Containers.CreateContainerAsync(new CreateContainerParameters(config)
{
Image = ImageName + ":" + ImageTag,
Name = ContainerName + this.redisPort,
Tty = false,
HostConfig = hostConfig
});
this.containerId = response.ID;
System.Console.WriteLine("Starting container...");
var started = await client.Containers.StartContainerAsync(this.containerId, new ContainerStartParameters());
if (!started)
{
Assert.False(true, "Cannot start the docker container");
}
System.Console.WriteLine("Finish booting sequence container...");
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.ToString());
}
}
public CreateDeploymentHandler(Repository repository, HostConfig config)
{
_repository = repository;
_config = config;
}
public void ValidatePodPropertyTranslation()
{
var identity = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "Module1", Mock.Of <ICredentials>());
var labels = new Dictionary <string, string>
{
// Add a label
{ "demo", "test" }
};
var hostConfig = new HostConfig
{
// Make container privileged
Privileged = true,
// Add a readonly mount
Binds = new List <string> {
"/home/blah:/home/blah2:ro"
}
};
var config = new KubernetesConfig("image", CreatePodParameters.Create(labels: labels, hostConfig: hostConfig), Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, Constants.DefaultStartupOrder, DefaultConfigurationInfo, EnvVarsDict);
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var moduleLabels = new Dictionary <string, string>();
var mapper = CreateMapper();
var deployment = mapper.CreateDeployment(identity, module, moduleLabels);
var pod = deployment.Spec.Template;
Assert.NotNull(pod);
// Validate annotation
Assert.True(pod.Metadata.Annotations.ContainsKey("demo"));
// Two containers should exist - proxy and the module
Assert.Equal(2, pod.Spec.Containers.Count);
// There should only be one module container
var moduleContainer = pod.Spec.Containers.Single(p => p.Name != "proxy");
// We made this container privileged
Assert.True(moduleContainer.SecurityContext.Privileged);
// Validate that there are 1 mounts for module container
Assert.Equal(1, moduleContainer.VolumeMounts.Count);
// Validate the custom mount that we added
Assert.Contains(moduleContainer.VolumeMounts, vm => vm.Name.Equals("homeblah"));
var mount = moduleContainer.VolumeMounts.Single(vm => vm.Name.Equals("homeblah"));
// Lets make sure that it is read only
Assert.True(mount.ReadOnlyProperty);
// Validate proxy container
var proxyContainer = pod.Spec.Containers.Single(p => p.Name == "proxy");
// Validate that there are 2 mounts for proxy container: config and trust-bundle
Assert.Equal(2, proxyContainer.VolumeMounts.Count);
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("configVolumeName"));
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("trustBundleVolumeName"));
// Validate pod volumes
Assert.Equal(3, pod.Spec.Volumes.Count);
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("homeblah"));
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("configVolumeName"));
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("trustBundleVolumeName"));
// Validate no image pull secrets for public images
Assert.Null(pod.Spec.ImagePullSecrets);
// Validate null pod security context by default
Assert.Null(pod.Spec.SecurityContext);
}
public void CanSetupRequireWithProxying()
{
const string code = @"
class app1
appid 76
service /myserv1
class app2
appid 78
require app1 proxize
";
var ctx = BSharpCompiler.Compile(code);
var app = ctx["app2"].Compiled;
var config = new HostConfig(app,ctx);
Assert.AreEqual("appid=76;", config.Proxize["/myserv1"]);
}
public RenderContext(HostConfig hostConfig, Dictionary <Type, Func <TypedElement, RenderContext, HtmlTag> > elementRenderers)
{
// clone it
this.Config = JsonConvert.DeserializeObject <HostConfig>(JsonConvert.SerializeObject(hostConfig));
this.ElementRenderers = elementRenderers;
}
public async Task <string> RunAsync(TestcontainersConfiguration config, CancellationToken ct = default)
{
var image = config.Container.Image;
var imageExistsTask = DockerApiClientImage.Instance.ExistsWithNameAsync(image);
var pullImageTask = Task.CompletedTask;
if (!await imageExistsTask)
{
pullImageTask = Docker.Images.CreateImageAsync(new ImagesCreateParameters {
FromImage = image
}, null, DebugProgress.Instance, ct);
}
var name = config.Container.Name;
var workingDir = config.Container.WorkingDirectory;
var converter = new TestcontainersConfigurationConverter(config);
var entrypoint = converter.Entrypoint;
var cmd = converter.Command;
var env = converter.Environments;
var labels = converter.Labels;
var exposedPorts = converter.ExposedPorts;
var portBindings = converter.PortBindings;
var mounts = converter.Mounts;
var hostConfig = new HostConfig
{
PortBindings = portBindings,
Mounts = mounts,
};
var createParameters = new CreateContainerParameters
{
Image = image,
Name = name,
WorkingDir = workingDir,
Entrypoint = entrypoint,
Env = env,
Labels = labels,
Cmd = cmd,
ExposedPorts = exposedPorts,
HostConfig = hostConfig,
};
await pullImageTask;
var id = (await Docker.Containers.CreateContainerAsync(createParameters, ct)).ID;
TestcontainersRegistryService.Register(id, config.CleanUp);
return(id);
}
private static void EnsureRequiredApplications(ServerParameters serverParameters, HostConfig config)
{
var requires = config.Definition.Elements("require");
foreach (var require in requires)
{
if (!string.IsNullOrWhiteSpace(require.Attr("server")))
{
continue; //external service
}
var name = require.IdCodeOrValue() + require.Attr("suffix");
var shadow = EnvironmentInfo.GetShadowDirectory(name);
var processes = Process.GetProcessesByName("qh");
Console.WriteLine(string.Join("; ", processes.Select(_ => _.ProcessName)));
var required =
processes.FirstOrDefault(_ => _.MainModule.FileName.NormalizePath().StartsWith(shadow.NormalizePath()));
if (null != required)
{
config.Log.Info("Required '" + name + "' found, PID: " + required.Id);
}
else
{
var args = name;
if (serverParameters.Get("hidden", false))
{
args += " --hidden";
}
required = Process.Start(EnvironmentInfo.ResolvePath("@repos@/.build/bin/all/qh.exe"), args);
config.Log.Info("Required '" + name + "' started, PID: " + required.Id);
}
}
}
public Host Build()
{
var hostConfig = new HostConfig();
return new Host(hostConfig);
}
private async Task <string> CreateContainer(
string imageName,
IList <string> environmentVariables,
IList <string> volumeBindings,
IList <PortMapping> portMappings,
IList <string> startCmd,
HostConfig hostConfigOverrides,
string workingDirectory)
{
HostConfig hostConfig = hostConfigOverrides ?? new HostConfig();
hostConfig.NetworkMode = SessionHostContainerConfiguration.DockerNetworkName;
hostConfig.Binds = volumeBindings;
hostConfig.PortBindings = portMappings?.ToDictionary(p => $"{p.GamePort.Number}/{p.GamePort.Protocol}",
p => (IList <PortBinding>)(new List <PortBinding>()
{
new PortBinding()
{
HostPort = $"{p.NodePort}/{p.GamePort.Protocol}"
}
}));
hostConfig.CapAdd ??= new List <string>();
if (_systemOperations.IsOSPlatform(OSPlatform.Linux))
{
hostConfig.CapAdd.Add("SYS_PTRACE");
}
if (hostConfig.LogConfig == null)
{
hostConfig.LogConfig = new LogConfig();
hostConfig.LogConfig.Type = "json-file";
hostConfig.LogConfig.Config = new Dictionary <string, string>()
{
{ "max-size", "200m" }
};
}
CreateContainerParameters containerParams = new CreateContainerParameters
{
Image = imageName,
Env = environmentVariables,
ExposedPorts = portMappings?.ToDictionary(p => $"{p.GamePort.Number}/{p.GamePort.Protocol}", p => new EmptyStruct()),
HostConfig = hostConfig,
WorkingDir = workingDirectory,
Cmd = startCmd
};
_logger.LogInformation($"Creating container. Image='{imageName}'");
CreateContainerResponse response =
await TaskUtil.TimedExecute(
async() => await _dockerClient.Containers.CreateContainerAsync(containerParams).ConfigureAwait(false),
_logger,
MetricConstants.ContainerStats,
MetricConstants.ContainerCreationTime);
_logger.LogInformation($"Created a container with session host id: {response.ID}");
return(response.ID);
}
