protected override async Task <int> ExecuteAsync(CommandContext context, CancellationToken cancellationToken)
        {
            var deviceType = await context.FindDeviceTypeAsync(DeviceType, cancellationToken);

            if (deviceType == null)
            {
                return(1);
            }

            var agentVersion = await context.FindAgentVersion(deviceType.Id, Version, cancellationToken);

            if (agentVersion == null)
            {
                return(1);
            }

            using (IDockerClient sourceDockerClient = new DockerClientConfiguration(new Uri(Source)).CreateClient())
                using (IDockerClient targetDockerClient = new DockerClientConfiguration(new Uri(Target)).CreateClient())
                {
                    Console.WriteLine("Saving image to target...");

                    //Copy the image.
                    using (var sourceImageStream = await sourceDockerClient.Images.SaveImageAsync(agentVersion.ImageId, cancellationToken))
                    {
                        await targetDockerClient.Images.LoadImageAsync(new ImageLoadParameters(), sourceImageStream,
                                                                       new Progress <JSONMessage>(p => Console.WriteLine(p.Status)), cancellationToken);
                    }

                    Console.WriteLine("Removing target agent container(s)...");

                    //Ditch the containers that might cause a problem.
                    await targetDockerClient.ObliterateContainerAsync(DockerContainerNames.AgentA, cancellationToken : cancellationToken);

                    await targetDockerClient.ObliterateContainerAsync(DockerContainerNames.AgentB, cancellationToken : cancellationToken);

                    Console.WriteLine("Creating agent container...");

                    //Create the container factory
                    var containerFactory = new AgentDockerContainerFactory();

                    //Create the container itself
                    var createContainerResponse = await containerFactory.CreateContainerForDirectAsync(targetDockerClient, agentVersion.ImageId, cancellationToken);

                    Console.WriteLine($"Container '{createContainerResponse.ID}' created. Starting container...");

                    //Start the container.
                    bool started = await targetDockerClient.Containers.StartContainerAsync(createContainerResponse.ID,
                                                                                           new ContainerStartParameters(), cancellationToken);

                    if (started)
                    {
                        Console.WriteLine("Agent container started.");
                        return(0);
                    }

                    Console.Error.WriteLine("Agent container failed to start.");
                    return(1);
                }
        }
Exemple #2
0
 public AgentUpdateService(
     IDockerClient dockerClient,
     AgentDockerContainerFactory dockerContainerFactory,
     IPlatformDetector platformDetecter,
     DeviceApiClient deviceApiClient,
     ILogger logger) : base(logger, dockerClient)
 {
     _dockerClient           = dockerClient ?? throw new ArgumentNullException(nameof(dockerClient));
     _dockerContainerFactory = dockerContainerFactory ?? throw new ArgumentNullException(nameof(dockerContainerFactory));
     _platformDetecter       = platformDetecter;
     _deviceApiClient        = deviceApiClient ?? throw new ArgumentNullException(nameof(deviceApiClient));
 }
Exemple #3
0
 public BootstrapHost(
     IDockerClient dockerClient,
     DeviceApiClient deviceApiClient,
     AgentDockerContainerFactory agentDockerContainerFactory,
     AgentUpdateService agentUpdateService,
     ILogger logger)
 {
     _dockerClient                = dockerClient;
     _deviceApiClient             = deviceApiClient;
     _agentDockerContainerFactory = agentDockerContainerFactory;
     _agentUpdateService          = agentUpdateService;
     Logger = logger.ForContext(GetType());
 }