Пример #1
0
        public async Task Publish()
        {
            Console.WriteLine("Publish");

            // https://stackoverflow.com/questions/28349392/how-to-push-a-docker-image-to-a-private-repository
            //docker tag [OPTIONS] IMAGE[:TAG] [REGISTRYHOST/][USERNAME/]NAME[:TAG]
            //Then docker push using that same tag.
            //docker push NAME[:TAG]
            using (var client = dockerWrapper.GetClient())
            {
                var parameters = new ImageTagParameters();
                parameters.RepositoryName = "privateregistry.mynetwork.local:5443/" + ImageName;
                parameters.Tag            = "1";
                Console.WriteLine("Tag");
                await client.Images.TagImageAsync(ImageName + ":1", parameters);

                Console.WriteLine("try to find : " + ImageName + ":1");
                var foundImage = await dockerWrapper.FindImage(ImageName + ":1");

                var p = new ImagePushParameters();
                p.ImageID = foundImage.ID;
                p.Tag     = "1";

                var progress = new DockerProgress(m => {
                    if (m.Progress != null)
                    {
                        Console.WriteLine(m.ID + " " + m.ProgressMessage /*+ " : " + m.Progress.Current + "/" + m.Progress.Total*/);
                    }
                });
                var authConfig = new AuthConfig();
                await client.Images.PushImageAsync("privateregistry.mynetwork.local:5443/" + ImageName + ":1", p, authConfig, progress);
            }
        }
Пример #2
0
        public Task TagImageAsync(string name, ImageTagParameters parameters)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (parameters == null)
            {
                throw new ArgumentNullException(nameof(parameters));
            }

            IQueryString queryParameters = new QueryString <ImageTagParameters>(parameters);

            return(this._client.MakeRequestAsync(new[] { NoSuchImageHandler }, HttpMethod.Post, $"images/{name}/tag", queryParameters));
        }
Пример #3
0
        public Task TagImageAsync(string name, ImageTagParameters parameters)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            string       path            = string.Format(CultureInfo.InvariantCulture, "images/{0}/tag", name);
            IQueryString queryParameters = new QueryString <ImageTagParameters>(parameters);

            return(this.Client.MakeRequestAsync(new[] { NoSuchImageHandler }, HttpMethod.Post, path, queryParameters));
        }
Пример #4
0
        protected override async Task ProcessRecordAsync()
        {
            foreach (var id in ParameterResolvers.GetImageIds(Image, Id))
            {
                var tagParams = new ImageTagParameters()
                {
                    RepositoryName = Repository
                };

                if (!string.IsNullOrEmpty(Tag))
                {
                    tagParams.Tag = Tag;
                }

                if (Force)
                {
                    tagParams.Force = true;
                }

                await DkrClient.Images.TagImageAsync(id, tagParams);
            }
        }
Пример #5
0
        protected override async Task <int> ExecuteAsync(CommandContext context, CancellationToken cancellationToken)
        {
            //Look up the device type
            var deviceType = await context.FindDeviceTypeAsync(DeviceType, cancellationToken);

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

            //create the docker instance
            using (var dockerClient = CreateDockerClient())
            {
                string fromImage = $"{FromRepository}:{Tag}";

                Console.WriteLine($"Pulling from '{fromImage}'...");

                var imageCreateParameters = new ImagesCreateParameters
                {
                    FromImage = fromImage,
                };

                var localAuthConfig = new AuthConfig
                {
                };

                //Pull the agent version
                await dockerClient.Images.CreateImageAsync(
                    imageCreateParameters,
                    localAuthConfig,
                    new Progress <JSONMessage>(m => Console.WriteLine(m.ProgressMessage)), cancellationToken);

                var imageInspection = await dockerClient.Images.InspectImageAsync(fromImage, cancellationToken);

                if (imageInspection == null)
                {
                    Console.WriteLine($"Unable to find image '{fromImage}' for inspection.");
                    return(1);
                }

                var getAgentUploadInfoRequest = new GetAgentUploadInfoRequest
                {
                    ImageId      = imageInspection.ID,
                    DeviceTypeId = deviceType.Id,
                    Name         = Tag
                };

                var agentUploadInfo =
                    await context.Client.AgentUploadInfo.GetAgentUploadInfo(getAgentUploadInfoRequest,
                                                                            cancellationToken);

                if (!agentUploadInfo.CanUpload)
                {
                    Console.WriteLine($"Unable to upload: {agentUploadInfo.Reason}");
                    return(1);
                }

                string registryHost = RegistryHost ?? agentUploadInfo.RegistryHost;

                //Create the image tag paramters
                var imageTagParameters = new ImageTagParameters
                {
                    RepositoryName = $"{registryHost}/{agentUploadInfo.Repository}",
                    Tag            = Tag,
                };

                Console.WriteLine($"Tagging the image with '{imageTagParameters}'...");

                //Tag the image
                await dockerClient.Images.TagImageAsync(fromImage, imageTagParameters, cancellationToken);

                string toImage = $"{registryHost}/{agentUploadInfo.Repository}:{Tag}";

                Console.WriteLine($"Pushing '{toImage}'...");

                //Push to our registry
                await dockerClient.Images.PushImageAsync(
                    toImage,
                    new ImagePushParameters(),
                    localAuthConfig,
                    new Progress <JSONMessage>(m => Console.WriteLine(m.ProgressMessage)),
                    cancellationToken);

                //TODO: Let the management service know that we uploaded it
                var createAgentVersionRequest = new CreateAgentVersionRequest
                {
                    DeviceTypeId = deviceType.Id,
                    ImageId      = imageInspection.ID,
                    MakeCurrent  = false,
                    Name         = Tag,
                    Logs         = "Imported"
                };

                //Create the version
                AgentVersion agentVersion = await context.Client.AgentVersions.CreateAgentVersion(createAgentVersionRequest, cancellationToken);

                //And we're done
                Console.WriteLine($"Version {agentVersion.Id} created.");
            }

            return(0);
        }