Exemplo n.º 1
0
        async Task <ServiceUpdateResponse> ISwarmOperations.UpdateServiceAsync(string id, ServiceUpdateParameters parameters, CancellationToken cancellationToken)
        {
            if (string.IsNullOrEmpty(id))
            {
                throw new ArgumentNullException(nameof(id));
            }
            if (parameters == null)
            {
                throw new ArgumentNullException(nameof(parameters));
            }

            var query    = new QueryString <ServiceUpdateParameters>(parameters);
            var body     = new JsonRequestContent <ServiceSpec>(parameters.Service ?? throw new ArgumentNullException(nameof(parameters.Service)), this._client.JsonSerializer);
            var response = await this._client.MakeRequestAsync(new[] { SwarmResponseHandler }, HttpMethod.Post, $"services/{id}/update", query, body, RegistryAuthHeaders(parameters.RegistryAuth), cancellationToken).ConfigureAwait(false);

            return(this._client.JsonSerializer.DeserializeObject <ServiceUpdateResponse>(response.Body));
        }
Exemplo n.º 2
0
        public async Task <bool> Update(string FileBase64)
        {
            try
            {
                Logger.Log($"updating service id : {Id} with DockerId {DockerServiceId}");
                this.FilePath = CombineProgram(Id, UserId, FileBase64);
                var serviceInfo = await Client.Docker.Swarm.InspectServiceAsync(DockerServiceId);

                var Image = this.Image();
                Logger.Log($"Service info gotten! Name is : {Name}, Version is: {serviceInfo.Version.Index}, Network ID is {Network.ID}, Image Id : {Image.ID}, Port: {Port}, this.FilePath: {this.FilePath}");
                NetworkAttachmentConfig networkConfig = new NetworkAttachmentConfig()
                {
                    Target = Network.ID
                };
                EndpointSpec endpointSpec = new EndpointSpec()
                {
                    Ports = new List <PortConfig>()
                    {
                        new PortConfig()
                        {
                            Protocol      = "tcp",
                            PublishedPort = uint.Parse(Port),
                            TargetPort    = uint.Parse(Port)
                        }
                    }
                };
                Logger.Log("Endpoint created");
                IList <Mount> mounts = new List <Mount>
                {
                    new Mount()
                    {
                        Target = "/home/node/",
                        Source = this.FilePath,
                    }
                };
                Logger.Log("Mounts created");
                TaskSpec taskSpec = new TaskSpec()
                {
                    ForceUpdate   = 1,
                    RestartPolicy = new SwarmRestartPolicy()
                    {
                        Condition   = "any",
                        MaxAttempts = 0
                    },
                    ContainerSpec = new ContainerSpec()
                    {
                        Image = Image.ID,
                        Env   = new List <string>()
                        {
                            $"PORT={Port}"
                        },
                        Hosts = new List <string>()
                        {
                            $"{Port}:{Port}"
                        },
                        Mounts  = mounts,
                        Dir     = "/home/node/",
                        Command = new List <string>()
                        {
                            "/bin/bash", "build.sh"
                        },
                    },
                };
                Logger.Log("Task spec created!");
                ServiceSpec serviceSpec = new ServiceSpec()
                {
                    Name     = Name,
                    Networks = new List <NetworkAttachmentConfig>()
                    {
                        networkConfig
                    },
                    EndpointSpec = endpointSpec,
                    TaskTemplate = taskSpec,
                };
                Logger.Log("Service spec created!");
                var serviceParams = new ServiceUpdateParameters()
                {
                    Version = Convert.ToInt64(serviceInfo.Version.Index),
                    Service = serviceSpec
                };
                Logger.Log("Configuration is ready, updating...");
                await Client.Docker.Swarm.UpdateServiceAsync(DockerServiceId, serviceParams);

                Logger.Success($"Updated successful!");
                return(true);
            }
            catch (Exception e)
            {
                Logger.Fail($"Cant update service {DockerServiceId} : {e.Message}");
                return(false);
            }
        }