Merge branch 'master' of github.com:dotnet/Docker.DotNet into ssh-transport

Author: mdarocha

.gitattributes

@@ -1,5 +1,3 @@
 # Autodetect text files
 * text=auto
 
-# Definitively text files
-*.cs text

src/Docker.DotNet/DockerClient.cs

@@ -39,6 +39,7 @@ internal DockerClient(DockerClientConfiguration configuration, Version requested
             System = new SystemOperations(this);
             Networks = new NetworkOperations(this);
             Secrets = new SecretsOperations(this);
+            Configs = new ConfigOperations(this);
             Swarm = new SwarmOperations(this);
             Tasks = new TasksOperations(this);
             Volumes = new VolumeOperations(this);
@@ -152,6 +153,8 @@ await sock.ConnectAsync(new Microsoft.Net.Http.Client.UnixDomainSocketEndPoint(p
 
         public ISecretsOperations Secrets { get; }
 
+        public IConfigOperations Configs { get; }
+
         public ISwarmOperations Swarm { get; }
 
         public ITasksOperations Tasks { get; }

src/Docker.DotNet/Endpoints/ConfigsOperations.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Docker.DotNet.Models;
+
+namespace Docker.DotNet
+{
+    internal class ConfigOperations : IConfigOperations
+    {
+        private readonly DockerClient _client;
+
+        internal ConfigOperations(DockerClient client)
+        {
+            this._client = client;
+        }
+
+        async Task<IList<SwarmConfig>> IConfigOperations.ListConfigsAsync(CancellationToken cancellationToken)
+        {
+            var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Get, "configs", cancellationToken).ConfigureAwait(false);
+            return this._client.JsonSerializer.DeserializeObject<IList<SwarmConfig>>(response.Body);
+        }
+
+        async Task<SwarmCreateConfigResponse> IConfigOperations.CreateConfigAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken)
+        {
+            if (body == null)
+            {
+                throw new ArgumentNullException(nameof(body));
+            }
+
+            var data = new JsonRequestContent<SwarmConfigSpec>(body.Config, this._client.JsonSerializer);
+            var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Post, "configs/create", null, data, cancellationToken).ConfigureAwait(false);
+            return this._client.JsonSerializer.DeserializeObject<SwarmCreateConfigResponse>(response.Body);
+        }
+
+        async Task<SwarmConfig> IConfigOperations.InspectConfigAsync(string id, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            var response = await this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Get, $"configs/{id}", cancellationToken).ConfigureAwait(false);
+            return this._client.JsonSerializer.DeserializeObject<SwarmConfig>(response.Body);
+        }
+
+        Task IConfigOperations.RemoveConfigAsync(string id, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            return this._client.MakeRequestAsync(this._client.NoErrorHandlers, HttpMethod.Delete, $"configs/{id}", cancellationToken);
+        }
+    }
+}

src/Docker.DotNet/Endpoints/IConfigsOperations.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Docker.DotNet.Models;
+
+namespace Docker.DotNet
+{
+    public interface IConfigOperations
+    {
+        /// <summary>
+        /// List configs
+        /// </summary>
+        /// <remarks>
+        /// 200 - No error.
+        /// 500 - Server error.
+        /// </remarks>
+        Task<IList<SwarmConfig>> ListConfigsAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+        /// <summary>
+        /// Create a configs
+        /// </summary>
+        /// <remarks>
+        /// 201 - No error.
+        /// 406 - Server error or node is not part of a swarm.
+        /// 409 - Name conflicts with an existing object.
+        /// 500 - Server error.
+        /// </remarks>
+        Task<SwarmCreateConfigResponse> CreateConfigAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken = default(CancellationToken));
+
+        /// <summary>
+        /// Inspect a configs
+        /// </summary>
+        /// <remarks>
+        /// 200 - No error.
+        /// 404 - Secret not found.
+        /// 406 - Node is not part of a swarm.
+        /// 500 - Server error.
+        /// </remarks>
+        /// <param name="id">ID of the config.</param>
+        Task<SwarmConfig> InspectConfigAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
+
+        /// <summary>
+        /// Remove a configs
+        /// </summary>
+        /// <remarks>
+        /// 204 - No error.
+        /// 404 - Secret not found.
+        /// 500 - Server error.
+        /// </remarks>
+        /// <param name="id">ID of the config.</param>
+        Task RemoveConfigAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
+    }
+}

src/Docker.DotNet/Endpoints/ISwarmOperations.cs

@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using Docker.DotNet.Models;
 using System.Threading;
+using System.IO;
 
 namespace Docker.DotNet
 {
@@ -154,6 +155,42 @@ public interface ISwarmOperations
         /// <param name="id">ID or name of service.</param>
         Task RemoveServiceAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
 
+        /// <summary>
+        /// Gets <c>stdout</c> and <c>stderr</c> logs from services.
+        /// </summary>
+        /// <param name="id">The ID or name of the service.</param>
+        /// <param name="parameters">Specifics of how to perform the operation.</param>
+        /// <param name="cancellationToken">When triggered, the operation will stop at the next available time, if possible.</param>
+        /// <returns>A <see cref="Task"/> that will complete once all log lines have been read.</returns>
+        /// <remarks>
+        /// This method is only suited for services with the <c>json-file</c> or <c>journald</c> logging driver.
+        ///
+        /// HTTP GET /services/(id)/logs
+        ///
+        /// 101 - Logs returned as a stream.
+        /// 200 - Logs returned as a string in response body.
+        /// 404 - No such service.
+        /// 500 - Server error.
+        /// 503 - Node is not part of a swarm.
+        /// </remarks>
+        Task<Stream> GetServiceLogsAsync(string id, ServiceLogsParameters parameters, CancellationToken cancellationToken = default(CancellationToken));
+
+        /// <summary>
+        /// Gets <c>stdout</c> and <c>stderr</c> logs from services.
+        /// </summary>
+        /// <param name="id">The ID or name of the service.</param>
+        /// <param name="tty">Indicates whether the service was created with a TTY. If <see langword="false"/>, the returned stream is multiplexed.</param>
+        /// <param name="parameters">Specifics of how to perform the operation.</param>
+        /// <param name="cancellationToken">When triggered, the operation will stop at the next available time, if possible.</param>
+        /// <returns>
+        /// A <see cref="Task{TResult}"/> that resolves to a <see cref="MultiplexedStream"/>, which provides the log information.
+        /// If the service wasn't created with a TTY, this stream is multiplexed.
+        /// </returns>
+        /// <remarks>
+        /// This method is only suited for services with the <c>json-file</c> or <c>journald</c> logging driver.
+        /// </remarks>
+        Task<MultiplexedStream> GetServiceLogsAsync(string id, bool tty, ServiceLogsParameters parameters, CancellationToken cancellationToken = default(CancellationToken));
+
         #endregion Services
 
         #region Nodes

src/Docker.DotNet/Endpoints/SwarmOperations.cs

@@ -8,6 +8,7 @@ namespace Docker.DotNet
     using System.Threading.Tasks;
     using System.Threading;
     using Models;
+    using System.IO;
 
     internal class SwarmOperations : ISwarmOperations
     {
@@ -156,7 +157,42 @@ async Task<ServiceUpdateResponse> ISwarmOperations.UpdateServiceAsync(string id,
             return this._client.JsonSerializer.DeserializeObject<ServiceUpdateResponse>(response.Body);
         }
 
-       async Task ISwarmOperations.UpdateSwarmAsync(SwarmUpdateParameters parameters, CancellationToken cancellationToken)
+        public Task<Stream> GetServiceLogsAsync(string id, ServiceLogsParameters parameters, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            if (parameters == null)
+            {
+                throw new ArgumentNullException(nameof(parameters));
+            }
+
+            IQueryString queryParameters = new QueryString<ServiceLogsParameters>(parameters);
+            return this._client.MakeRequestForStreamAsync(new[] { SwarmResponseHandler }, HttpMethod.Get, $"services/{id}/logs", queryParameters, cancellationToken);
+        }
+
+        public async Task<MultiplexedStream> GetServiceLogsAsync(string id, bool tty, ServiceLogsParameters parameters, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            if (parameters == null)
+            {
+                throw new ArgumentNullException(nameof(parameters));
+            }
+
+            IQueryString queryParameters = new QueryString<ServiceLogsParameters>(parameters);
+
+            Stream result = await this._client.MakeRequestForStreamAsync(new[] { SwarmResponseHandler }, HttpMethod.Get, $"services/{id}/logs", queryParameters, cancellationToken).ConfigureAwait(false);
+
+            return new MultiplexedStream(result, !tty);
+        }
+
+        async Task ISwarmOperations.UpdateSwarmAsync(SwarmUpdateParameters parameters, CancellationToken cancellationToken)
         {
             var query = new QueryString<SwarmUpdateParameters>(parameters ?? throw new ArgumentNullException(nameof(parameters)));
             var body = new JsonRequestContent<Spec>(parameters.Spec ?? throw new ArgumentNullException(nameof(parameters.Spec)), this._client.JsonSerializer);
@@ -211,7 +247,7 @@ async Task<NodeListResponse> ISwarmOperations.InspectNodeAsync(string id, Cancel
         async Task ISwarmOperations.RemoveNodeAsync(string id, bool force, CancellationToken cancellationToken)
         {
             if (string.IsNullOrEmpty(id)) throw new ArgumentNullException(nameof(id));
-            var parameters = new NodeRemoveParameters {Force = force};
+            var parameters = new NodeRemoveParameters { Force = force };
             var query = new QueryString<NodeRemoveParameters>(parameters);
             await this._client.MakeRequestAsync(new[] { SwarmResponseHandler }, HttpMethod.Delete, $"nodes/{id}", query, cancellationToken).ConfigureAwait(false);
         }

src/Docker.DotNet/IDockerClient.cs

@@ -20,6 +20,8 @@ public interface IDockerClient : IDisposable
 
         ISecretsOperations Secrets { get; }
 
+        IConfigOperations Configs { get; }
+
         ISwarmOperations Swarm { get; }
 
         ITasksOperations Tasks { get; }

src/Docker.DotNet/Microsoft.Net.Http.Client/ContentLengthReadStream.cs

@@ -93,6 +93,12 @@ public override int Read(byte[] buffer, int offset, int count)
             {
                 return 0;
             }
+
+            if (_bytesRemaining == 0)
+            {
+                return 0;
+            }
+
             int toRead = (int)Math.Min(count, _bytesRemaining);
             int read = _inner.Read(buffer, offset, toRead);
             UpdateBytesRemaining(read);
@@ -106,6 +112,12 @@ public async override Task<int> ReadAsync(byte[] buffer, int offset, int count,
             {
                 return 0;
             }
+
+            if (_bytesRemaining == 0)
+            {
+                return 0;
+            }
+
             cancellationToken.ThrowIfCancellationRequested();
             int toRead = (int)Math.Min(count, _bytesRemaining);
             int read = await _inner.ReadAsync(buffer, offset, toRead, cancellationToken);

test/Docker.DotNet.Tests/IConfigOperationsTests.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using Docker.DotNet.Models;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Docker.DotNet.Tests
+{
+    [Collection(nameof(TestCollection))]
+    public class IConfigOperationsTests
+    {
+        private readonly DockerClientConfiguration _dockerClientConfiguration;
+        private readonly DockerClient _dockerClient;
+        private readonly TestOutput _output;
+        public IConfigOperationsTests(TestFixture testFixture, ITestOutputHelper outputHelper)
+        {
+            _dockerClientConfiguration = testFixture.DockerClientConfiguration;
+            _dockerClient = _dockerClientConfiguration.CreateClient();
+            _output = new TestOutput(outputHelper);
+        }
+
+        [Fact]
+        public async void SwarmConfig_CanCreateAndRead()
+        {
+            var currentConfigs = await _dockerClient.Configs.ListConfigsAsync();
+
+            _output.WriteLine($"Current Configs: {currentConfigs.Count}");
+          
+            var testConfigSpec = new SwarmConfigSpec
+            {
+                Name = $"Config-{Guid.NewGuid().ToString().Substring(1, 10)}",
+                Labels = new Dictionary<string, string> { { "key", "value" } },
+                Data = new List<byte> { 1, 2, 3, 4, 5 }
+            };
+
+            var configParameters = new SwarmCreateConfigParameters
+            {
+                Config = testConfigSpec
+            };
+
+            var createdConfig = await _dockerClient.Configs.CreateConfigAsync(configParameters);
+            Assert.NotNull(createdConfig.ID);
+            _output.WriteLine($"Config created: {createdConfig.ID}");
+
+            var configs = await _dockerClient.Configs.ListConfigsAsync();
+            Assert.Contains(configs, c => c.ID == createdConfig.ID);
+            _output.WriteLine($"Current Configs: {configs.Count}");
+
+            var configResponse = await _dockerClient.Configs.InspectConfigAsync(createdConfig.ID);
+
+            Assert.NotNull(configResponse);
+
+            Assert.Equal(configResponse.Spec.Name, testConfigSpec.Name);
+            Assert.Equal(configResponse.Spec.Data, testConfigSpec.Data);
+            Assert.Equal(configResponse.Spec.Labels, testConfigSpec.Labels);
+            Assert.Equal(configResponse.Spec.Templating, testConfigSpec.Templating);
+
+
+            _output.WriteLine($"Config created is the same.");
+
+            await _dockerClient.Configs.RemoveConfigAsync(createdConfig.ID);
+            
+            await Assert.ThrowsAsync<Docker.DotNet.DockerApiException>(() => _dockerClient.Configs.InspectConfigAsync(createdConfig.ID));
+
+
+            
+        }
+    }
+}
+