rename to standard

add logging test

revert unneeded changes

more lr fixes

Author: ACoderLife

src/Docker.DotNet/Endpoints/ConfigsOperations.cs

@@ -16,13 +16,13 @@ internal ConfigsOperations(DockerClient client)
             this._client = client;
         }
 
-        async Task<IList<SwarmConfig>> IConfigsOperations.ListAsync(CancellationToken cancellationToken)
+        async Task<IList<SwarmConfig>> IConfigsOperations.ListConfigAsync(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> IConfigsOperations.CreateAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken)
+        async Task<SwarmCreateConfigResponse> IConfigsOperations.CreateConfigAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken)
         {
             if (body == null)
             {
@@ -34,7 +34,7 @@ async Task<SwarmCreateConfigResponse> IConfigsOperations.CreateAsync(SwarmCreate
             return this._client.JsonSerializer.DeserializeObject<SwarmCreateConfigResponse>(response.Body);
         }
 
-        async Task<SwarmConfig> IConfigsOperations.InspectAsync(string id, CancellationToken cancellationToken)
+        async Task<SwarmConfig> IConfigsOperations.InspectConfigAsync(string id, CancellationToken cancellationToken)
         {
             if (string.IsNullOrEmpty(id))
             {
@@ -45,7 +45,7 @@ async Task<SwarmConfig> IConfigsOperations.InspectAsync(string id, CancellationT
             return this._client.JsonSerializer.DeserializeObject<SwarmConfig>(response.Body);
         }
 
-        Task IConfigsOperations.DeleteAsync(string id, CancellationToken cancellationToken)
+        Task IConfigsOperations.RemoveConfigAsync(string id, CancellationToken cancellationToken)
         {
             if (string.IsNullOrEmpty(id))
             {

src/Docker.DotNet/Endpoints/IConfigsOperations.cs

@@ -8,27 +8,27 @@ namespace Docker.DotNet
     public interface IConfigsOperations
     {
         /// <summary>
-        /// List secrets
+        /// List configs
         /// </summary>
         /// <remarks>
         /// 200 - No error.
         /// 500 - Server error.
         /// </remarks>
-        Task<IList<SwarmConfig>> ListAsync(CancellationToken cancellationToken = default(CancellationToken));
+        Task<IList<SwarmConfig>> ListConfigAsync(CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
-        /// Create a secret
+        /// 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> CreateAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken = default(CancellationToken));
+        Task<SwarmCreateConfigResponse> CreateConfigAsync(SwarmCreateConfigParameters body, CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
-        /// Inspect a secret
+        /// Inspect a configs
         /// </summary>
         /// <remarks>
         /// 200 - No error.
@@ -37,17 +37,17 @@ public interface IConfigsOperations
         /// 500 - Server error.
         /// </remarks>
         /// <param name="id">ID of the config.</param>
-        Task<SwarmConfig> InspectAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
+        Task<SwarmConfig> InspectConfigAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
-        /// Delete a secret
+        /// 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 DeleteAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
+        Task RemoveConfigAsync(string id, CancellationToken cancellationToken = default(CancellationToken));
     }
 }

src/Docker.DotNet/Endpoints/SwarmOperations.cs

@@ -192,7 +192,7 @@ async Task<ServiceUpdateResponse> ISwarmOperations.UpdateServiceAsync(string id,
             return new MultiplexedStream(result, !tty);
         }
 
-       async Task ISwarmOperations.UpdateSwarmAsync(SwarmUpdateParameters parameters, CancellationToken cancellationToken)
+        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);
@@ -247,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);
         }

test/Docker.DotNet.Tests/ISwarmOperationsTests.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Docker.DotNet.Models;
@@ -10,11 +12,18 @@ namespace Docker.DotNet.Tests
     [Collection(nameof(TestCollection))]
     public class ISwarmOperationsTests
     {
+        private readonly CancellationTokenSource _cts;
+
         private readonly DockerClient _dockerClient;
         private readonly string _imageId;
 
         public ISwarmOperationsTests(TestFixture testFixture)
         {
+            // Do not wait forever in case it gets stuck
+            _cts = CancellationTokenSource.CreateLinkedTokenSource(testFixture.Cts.Token);
+            _cts.CancelAfter(TimeSpan.FromMinutes(5));
+            _cts.Token.Register(() => throw new TimeoutException("SwarmOperationTests timeout"));
+
             _dockerClient = testFixture.DockerClient;
             _imageId = testFixture.Image.ID;
         }
@@ -148,5 +157,65 @@ public async Task GetServices_Succeeds()
             await _dockerClient.Swarm.RemoveServiceAsync(secondServiceId, default);
             await _dockerClient.Swarm.RemoveServiceAsync(thirdServiceid, default);
         }
+
+        [Fact]
+        public async Task GetServiceLogs_Succeeds()
+        {
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token);
+
+            var serviceName = $"service-withLogs-{Guid.NewGuid().ToString().Substring(1, 10)}";
+            var serviceId = _dockerClient.Swarm.CreateServiceAsync(new ServiceCreateParameters
+            {
+                Service = new ServiceSpec
+                {
+                    Name = serviceName,
+                    TaskTemplate = new TaskSpec { ContainerSpec = new ContainerSpec { Image = _imageId } }
+                }
+            }).Result.ID;
+
+            var _stream = await _dockerClient.Swarm.GetServiceLogsAsync(serviceName, false, new ServiceLogsParameters
+            {
+                Follow = true,
+                ShowStdout = true,
+                ShowStderr = true
+            });
+
+            TimeSpan delay = TimeSpan.FromSeconds(10);
+            cts.CancelAfter(delay);
+
+            var logLines = new List<string>();
+            while (!cts.IsCancellationRequested)
+            {
+                var line = new List<byte>();
+                var buffer = new byte[1];
+
+                while (!cts.IsCancellationRequested)
+                {
+                    var res = await _stream.ReadOutputAsync(buffer, 0, 1, default);
+
+                    if (res.Count == 0)
+                    {
+                        continue;
+                    }
+
+                    else if (buffer[0] == '\n')
+                    {
+                        break;
+                    }
+
+                    else
+                    {
+                        line.Add(buffer[0]);
+                    }
+                }
+
+                logLines.Add(Encoding.UTF8.GetString(line.ToArray()));                
+            }
+
+            Assert.True(logLines.Any());
+            Assert.Contains("[INF]", logLines.First());
+
+            await _dockerClient.Swarm.RemoveServiceAsync(serviceId, default);
+        }
     }
 }