private static async Task <bool> ResolveHostPort(IImageSettings settings)
{
ContainerInspectResponse inspectResponse = await _client
.Containers
.InspectContainerAsync(settings.ContainerId);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
string containerPort = $"{settings.ContainerPort}/tcp";
if (!inspectResponse.NetworkSettings.Ports.ContainsKey(containerPort))
{
throw new Exception($"Failed to resolve host port for {containerPort}");
}
PortBinding binding = inspectResponse
.NetworkSettings
.Ports[containerPort]
.FirstOrDefault();
if (binding == null || string.IsNullOrEmpty(binding.HostPort))
{
throw new Exception($"The resolved port binding is empty");
}
settings.HostPort = long.Parse(binding.HostPort);
}
else
{
settings.HostPort = settings.ContainerPort;
}
return(inspectResponse.State.Running);
}
private async void btnRun_Click(object sender, EventArgs e)
{
PortBinding binding = new PortBinding {
HostPort = "3838", HostIP = "localhost"
};
var exposedPorts = new Dictionary <string, EmptyStruct> {
{ "3838", default(EmptyStruct) }
};
var hostConfig = new HostConfig
{
PortBindings = new Dictionary <string, IList <PortBinding> > {
{ "3838", new List <PortBinding> {
binding
} }
}
};
CreateContainerResponse rsp = await _localEngineClient.Containers.CreateContainerAsync(
new CreateContainerParameters {
ExposedPorts = exposedPorts,
HostConfig = hostConfig,
Image = $"{comboTargetRegistry.Text}/{txtTargetTag.Text}"
});
Debug.WriteLine($"Created container with id {rsp.ID}");
foreach (string warning in rsp.Warnings)
{
Debug.WriteLine($" Created container warning {warning}");
}
await _localEngineClient.Containers.StartContainerAsync(rsp.ID, new ContainerStartParameters { });
_runningContainerId = rsp.ID;
}
public async Task StartContainer()
{
var hostCfg = new HostConfig();
var pb = new PortBinding
{
HostIP = "0.0.0.0",
HostPort = ExternalPort.ToString()
};
hostCfg.PortBindings = new Dictionary <string, IList <PortBinding> >();
hostCfg.PortBindings.Add($"{InternalPort}/tcp", new PortBinding[] { pb });
await PullImage(ImageName, ImageTag);
var container = await docker.Containers.CreateContainerAsync(new CreateContainerParameters()
{
Image = $"{ImageName}:{ImageTag}",
Name = $"{ContainerPrefix}-{Guid.NewGuid()}",
HostConfig = hostCfg,
Env = EnvironmentVariables
});
Debug.WriteLine("Starting docker container...");
var started = await docker.Containers.StartContainerAsync(container.ID, new ContainerStartParameters());
if (started)
{
containerId = container.ID;
PublishConnectionInfo();
Debug.WriteLine("Waiting service to start in the docker container...");
var ready = false;
var expiryTime = DateTime.Now.Add(TimeOut);
while ((DateTime.Now < expiryTime) && (!ready))
{
await Task.Delay(1000);
ready = TestReady();
}
if (ready)
{
Debug.WriteLine($"Docker container started: {container.ID}");
}
else
{
Debug.WriteLine("Docker container timeout waiting for service");
throw new TimeoutException();
}
}
else
{
Debug.WriteLine("Docker container failed");
}
}
/// <summary>
/// Constructs the port bindings for a MySQL container.
/// </summary>
/// <param name="hostPort">The host port to map the container to.</param>
/// <returns>The port mapping configuration.</returns>
private static Dictionary <string, IList <PortBinding> > PortBindings(uint hostPort)
{
var binding = new PortBinding
{
HostPort = hostPort.ToString()
};
return(new Dictionary <string, IList <PortBinding> >
{
{ "3306/tcp", new[] { binding } }
});
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="serializedData">The serialized data describing the model.</param>
/// <param name="stateHeaderBytes">
/// The number of bytes that should be reserved at the beginning of each state vector for the model checker tool.
/// </param>
internal RuntimeModel(SerializedRuntimeModel serializedData, int stateHeaderBytes = 0)
{
Requires.That(serializedData.Model != null, "Expected a valid model instance.");
var buffer = serializedData.Buffer;
var rootComponents = serializedData.Model.Roots;
var objectTable = serializedData.ObjectTable;
var formulas = serializedData.Formulas;
Requires.NotNull(buffer, nameof(buffer));
Requires.NotNull(rootComponents, nameof(rootComponents));
Requires.NotNull(objectTable, nameof(objectTable));
Requires.NotNull(formulas, nameof(formulas));
Requires.That(stateHeaderBytes % 4 == 0, nameof(stateHeaderBytes), "Expected a multiple of 4.");
Model = serializedData.Model;
SerializedModel = buffer;
RootComponents = rootComponents.Cast <Component>().ToArray();
Faults = objectTable.OfType <Fault>().Where(fault => fault.Activation == Activation.Nondeterministic && fault.IsUsed).ToArray();
ActivationSensitiveFaults = Faults.Where(fault => fault.RequiresActivationNotification).ToArray();
StateFormulas = objectTable.OfType <StateFormula>().ToArray();
Formulas = formulas;
// Create a local object table just for the objects referenced by the model; only these objects
// have to be serialized and deserialized. The local object table does not contain, for instance,
// the closure types of the state formulas
var objects = Model.ReferencedObjects;
var deterministicFaults = objectTable.OfType <Fault>().Where(fault => fault.Activation != Activation.Nondeterministic);
_serializedObjects = new ObjectTable(objects.Except(deterministicFaults, ReferenceEqualityComparer <object> .Default));
Objects = objectTable;
StateVectorLayout = SerializationRegistry.Default.GetStateVectorLayout(Model, _serializedObjects, SerializationMode.Optimized);
_deserialize = StateVectorLayout.CreateDeserializer(_serializedObjects);
_serialize = StateVectorLayout.CreateSerializer(_serializedObjects);
_restrictRanges = StateVectorLayout.CreateRangeRestrictor(_serializedObjects);
_stateHeaderBytes = stateHeaderBytes;
PortBinding.BindAll(objectTable);
_choiceResolver = new ChoiceResolver(objectTable);
ConstructionState = new byte[StateVectorSize];
fixed(byte *state = ConstructionState)
{
Serialize(state);
_restrictRanges();
}
FaultSet.CheckFaultCount(Faults.Length);
StateFormulaSet.CheckFormulaCount(StateFormulas.Length);
}
public DockerHostConfig PortBinding(string hostIp, string hostPort, string containerPort)
{
var portBinding = new PortBinding();
portBinding.HostIP = hostIp;
portBinding.HostPort = hostPort;
hostConfig.PortBindings.Add(containerPort, new List <PortBinding>()
{
portBinding
});
return(this);
}
private static KeyValuePair <string, IList <PortBinding> > GeneratePortBinding(string port)
{
var portSections = port.Split(':');
var containerPort = portSections.Last();
var hostPort = portSections.First();
var portBinding = new PortBinding {
HostPort = hostPort
};
var portBindings = new List <PortBinding> {
portBinding
};
return(new KeyValuePair <string, IList <PortBinding> >($"{containerPort}/tcp", portBindings));
}
public DockerSetup()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
docker = new DockerClientConfiguration(new Uri("npipe://./pipe/docker_engine")).CreateClient();
}
else
{
docker = new DockerClientConfiguration(new Uri("unix:///var/run/docker.sock")).CreateClient();
}
HostConfig hostCfg = new HostConfig();
PortBinding pb = new PortBinding();
pb.HostIP = "0.0.0.0";
pb.HostPort = Port.ToString();
hostCfg.PortBindings = new Dictionary <string, IList <PortBinding> >();
hostCfg.PortBindings.Add("5432/tcp", new PortBinding[] { pb });
docker.Images.PullImageAsync(new ImagesPullParameters()
{
Parent = "postgres", Tag = "latest"
}, null).Wait();
var container = docker.Containers.CreateContainerAsync(new CreateContainerParameters()
{
Image = "postgres:latest", Name = "workflow-postgres-tests", HostConfig = hostCfg
}).Result;
bool started = docker.Containers.StartContainerAsync(container.ID, new ContainerStartParameters()).Result;
if (started)
{
containerId = container.ID;
Console.WriteLine("Docker container started: " + containerId);
Console.Write("Waiting 10 seconds for Postgres to start in the docker container...");
Thread.Sleep(10000); //allow time for PG to start
Console.WriteLine("10 seconds are up.");
ConnectionString = $"Server=127.0.0.1;Port={Port};Database=workflow;User Id=postgres;";
}
else
{
Console.WriteLine("Docker container failed");
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="serializedData">The serialized data describing the model.</param>
/// <param name="stateHeaderBytes">
/// The number of bytes that should be reserved at the beginning of each state vector for the model checker tool.
/// </param>
internal SafetySharpRuntimeModel(SerializedRuntimeModel serializedData, int stateHeaderBytes = 0) : base(stateHeaderBytes)
{
Requires.That(serializedData.Model != null, "Expected a valid model instance.");
var buffer = serializedData.Buffer;
var rootComponents = serializedData.Model.Roots;
var objectTable = serializedData.ObjectTable;
var formulas = serializedData.Formulas;
Requires.NotNull(buffer, nameof(buffer));
Requires.NotNull(rootComponents, nameof(rootComponents));
Requires.NotNull(objectTable, nameof(objectTable));
Requires.NotNull(formulas, nameof(formulas));
Requires.That(stateHeaderBytes % 4 == 0, nameof(stateHeaderBytes), "Expected a multiple of 4.");
Model = serializedData.Model;
SerializedModel = buffer;
RootComponents = rootComponents.Cast <Component>().ToArray();
ExecutableStateFormulas = objectTable.OfType <ExecutableStateFormula>().ToArray();
Formulas = formulas;
StateConstraints = Model.Components.Cast <Component>().SelectMany(component => component.StateConstraints).ToArray();
// Create a local object table just for the objects referenced by the model; only these objects
// have to be serialized and deserialized. The local object table does not contain, for instance,
// the closure types of the state formulas.
Faults = objectTable.OfType <Fault>().Where(fault => fault.IsUsed).ToArray();
_serializedObjects = new ObjectTable(Model.ReferencedObjects);
Objects = objectTable;
StateVectorLayout = SerializationRegistry.Default.GetStateVectorLayout(Model, _serializedObjects, SerializationMode.Optimized);
UpdateFaultSets();
_deserialize = StateVectorLayout.CreateDeserializer(_serializedObjects);
_serialize = StateVectorLayout.CreateSerializer(_serializedObjects);
_restrictRanges = StateVectorLayout.CreateRangeRestrictor(_serializedObjects);
PortBinding.BindAll(objectTable);
InitializeConstructionState();
CheckConsistencyAfterInitialization();
}
public DockerSetup()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
docker = new DockerClientConfiguration(new Uri("npipe://./pipe/docker_engine")).CreateClient();
}
else
{
docker = new DockerClientConfiguration(new Uri("unix:///var/run/docker.sock")).CreateClient();
}
HostConfig hostCfg = new HostConfig();
PortBinding pb = new PortBinding();
pb.HostIP = "0.0.0.0";
pb.HostPort = Port.ToString();
hostCfg.PortBindings = new Dictionary <string, IList <PortBinding> >();
hostCfg.PortBindings.Add("27017/tcp", new PortBinding[] { pb });
docker.Images.PullImageAsync(new ImagesPullParameters()
{
Parent = "mongo", Tag = "latest"
}, null).Wait();
var container = docker.Containers.CreateContainerAsync(new CreateContainerParameters()
{
Image = "mongo:latest", Name = "workflow-mongo-tests", HostConfig = hostCfg
}).Result;
bool started = docker.Containers.StartContainerAsync(container.ID, new ContainerStartParameters()).Result;
if (started)
{
containerId = container.ID;
Console.WriteLine("Docker container started: " + containerId);
ConnectionString = $"mongodb://localhost:{Port}";
}
else
{
Console.WriteLine("Docker container failed");
}
}
private async Task ResolveHostAddressAsync()
{
ContainerInspectResponse inspectResponse = await _client
.Containers
.InspectContainerAsync(Instance.Id);
ContainerAddressMode addressMode = GetAddressMode();
if (addressMode == ContainerAddressMode.Port)
{
Instance.Address = "localhost";
string containerPort = $"{_settings.InternalPort}/tcp";
if (!inspectResponse.NetworkSettings.Ports.ContainsKey(containerPort))
{
throw new Exception($"Failed to resolve host port for {containerPort}");
}
PortBinding binding = inspectResponse
.NetworkSettings
.Ports[containerPort]
.FirstOrDefault();
if (binding == null || string.IsNullOrEmpty(binding.HostPort))
{
throw new Exception($"The resolved port binding is empty");
}
Instance.HostPort = int.Parse(binding.HostPort);
}
else
{
Instance.Address = inspectResponse.NetworkSettings.IPAddress;
Instance.HostPort = _settings.InternalPort;
}
Instance.IsRunning = inspectResponse.State.Running;
}
public PlcOpcUaServer()
{
Uri dockerUri = null;
try
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
dockerUri = new Uri("tcp://localhost:2375");
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
dockerUri = new Uri("unix:///var/run/docker.sock");
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
dockerUri = new Uri("not supported");
}
_dockerClient = new DockerClientConfiguration(dockerUri).CreateClient();
}
catch
{
throw new Exception($"Please adjust your docker deamon endpoint '{dockerUri}' for your configuration.");
}
// cleanup all PLC containers
CleanupContainerAsync().Wait();
// pull the latest image
ImagesCreateParameters createParameters = new ImagesCreateParameters();
createParameters.FromImage = _plcImage;
createParameters.Tag = "latest";
try
{
_dockerClient.Images.CreateImageAsync(createParameters, new AuthConfig(), new Progress <JSONMessage>()).Wait();
}
catch (Exception)
{
throw new Exception($"Cannot pull image '{_plcImage}");
}
ImageInspectResponse imageInspectResponse = _dockerClient.Images.InspectImageAsync(_plcImage).Result;
// create a new container
CreateContainerParameters containerParams = new CreateContainerParameters();
containerParams.Image = _plcImage;
containerParams.Hostname = "opcplc";
containerParams.Name = "opcplc";
containerParams.Cmd = new string[]
{
"--aa",
"--pn", $"{_plcPort}"
};
// workaround .NET2.1 issue for private key access
if (imageInspectResponse.Os.Equals("windows", StringComparison.InvariantCultureIgnoreCase))
{
containerParams.Cmd.Add("--at");
containerParams.Cmd.Add("X509Store");
}
containerParams.ExposedPorts = new Dictionary <string, EmptyStruct>();
containerParams.ExposedPorts.Add(new KeyValuePair <string, EmptyStruct>($"{_plcPort}/tcp", new EmptyStruct()));
containerParams.HostConfig = new HostConfig();
PortBinding portBinding = new PortBinding();
portBinding.HostPort = _plcPort;
portBinding.HostIP = null;
List <PortBinding> portBindings = new List <PortBinding>();
portBindings.Add(portBinding);
containerParams.HostConfig.PortBindings = new Dictionary <string, IList <PortBinding> >();
containerParams.HostConfig.PortBindings.Add($"{_plcPort}/tcp", portBindings);
CreateContainerResponse response = null;
try
{
response = _dockerClient.Containers.CreateContainerAsync(containerParams).Result;
_plcContainerId = response.ID;
}
catch (Exception)
{
throw;
}
try
{
_dockerClient.Containers.StartContainerAsync(_plcContainerId, new ContainerStartParameters()).Wait();
}
catch (Exception)
{
throw;
}
}
static async Task Test()
{
var docker = new DockerClientConfiguration(new Uri("npipe://./pipe/docker_engine")).CreateClient();
var net = await docker.Networks.CreateNetworkAsync(new NetworksCreateParameters()
{
Name = "testnet3"
});
var mongoContainerId = await StartMongo(docker, "conductor-tests-mongo");
await docker.Networks.ConnectNetworkAsync(net.ID, new NetworkConnectParameters()
{
Container = mongoContainerId
});
var ms = new FileStream(@"D:\dev\Conductor\Conductor.tar", FileMode.Open);
var build = await docker.Images.BuildImageFromDockerfileAsync(ms, new ImageBuildParameters()
{
Tags = new List <string>()
{
"poc"
}
});
using (StreamReader sr = new StreamReader(build))
{
string line;
// Read and display lines from the file until the end of
// the file is reached.
while ((line = sr.ReadLine()) != null)
{
Console.WriteLine(line);
}
}
var hostCfg = new HostConfig();
var pb = new PortBinding
{
HostIP = "0.0.0.0",
HostPort = "8001"
};
hostCfg.PortBindings = new Dictionary <string, IList <PortBinding> >();
hostCfg.PortBindings.Add($"{80}/tcp", new PortBinding[] { pb });
var container = await docker.Containers.CreateContainerAsync(new CreateContainerParameters()
{
Name = "conductor-tests",
Image = "poc",
Env = new List <string>()
{
$"DBHOST=mongodb://conductor-tests-mongo:27017/"
},
HostConfig = hostCfg,
NetworkingConfig = new NetworkingConfig()
{
EndpointsConfig = new Dictionary <string, EndpointSettings>()
{
{ "", new EndpointSettings()
{
Links = new List <string>()
{
mongoContainerId
},
NetworkID = net.ID
} },
}
}
});
await docker.Networks.ConnectNetworkAsync(net.ID, new NetworkConnectParameters()
{
Container = container.ID
});
var started = await docker.Containers.StartContainerAsync(container.ID, new ContainerStartParameters());
Console.WriteLine("YAY!!!!");
await Task.Delay(0);
//net.
}
