Fixed tests and included pending unmerged feature PRs

README.md

@@ -88,12 +88,12 @@ The code below pulls `fedora/memcached` image to your Docker instance using your
 anonymously download the image as well by passing `null` instead of AuthConfig object:
 
 ```csharp
-Stream stream  = await client.Images.CreateImageAsync(
+await _client.Images.CreateImageAsync(
     new ImagesCreateParameters
     {
-        Parent = "fedora/memcached",
+    	FromImage = "fedora/memcached",
         Tag = "alpha",
-    },
+    },    
     new AuthConfig
     {
         Email = "[email protected]",
@@ -102,6 +102,26 @@ Stream stream  = await client.Images.CreateImageAsync(
     });
 ```
 
+#### Example: Create an image and monitor progress messages
+
+```c#
+private static async Task Main(string[] args)
+{
+	var progress = new Progress<JSONMessage>(m => System.Diagnostics.Debug.WriteLine($"Create image status: {m.Status}"));
+
+	var _client = new Docker.DotNet.DockerClientConfiguration().CreateClient();
+
+	await _client.Images.CreateImageAsync(
+		new ImagesCreateParameters
+		{
+			FromImage = "hello-world",
+			Tag = "latest",
+		},
+		null,
+		progress);
+}
+```
+
 #### Example: Start a container
 
 The following code will start the created container with specified `HostConfig` object. This object is optional, therefore you can pass a null.
@@ -132,11 +152,9 @@ var stopped = await client.Containers.StopContainerAsync(
     CancellationToken.None);
 ```
 
-#### Example: Dealing with Stream responses
+#### Example: Processing stream messages using IProgress < Message >
 
-Some Docker API endpoints are designed to return stream responses. For example
-[Monitoring Docker events](https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/monitor-docker-s-events)
-continuously streams the status in a format like :
+Some Docker API endpoints are designed to stream response messages using IProgress< Message > for processing. For example [Monitoring Docker events](https://docs.docker.com/engine/reference/api/docker_remote_api_v1.24/#/monitor-docker-s-events) continuously streams the status in a format like :
 
 ```json
 {"status":"create","id":"dfdf82bd3881","from":"base:latest","time":1374067924}
@@ -146,15 +164,49 @@ continuously streams the status in a format like :
 ...
 ```
 
-To obtain this stream you can use:
+To capture messages from this stream you can use:
 
 ```csharp
-CancellationTokenSource cancellation = new CancellationTokenSource();
-Stream stream = await client.System.MonitorEventsAsync(new ContainerEventsParameters(), new Progress<JSONMessage>(), cancellation.Token);
-// Initialize a StreamReader...
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Docker.DotNet.Models;
+
+internal class Program
+{
+    private static async Task Main(string[] args)
+    {
+        var progress = new Progress()
+        {
+            _onCalled = (m) =>
+            {
+                Console.WriteLine($"Received event: {m.Type} -> {m.Action}");
+            }
+        };
+
+        var _client = new Docker.DotNet.DockerClientConfiguration().CreateClient();
+        using var cts = new CancellationTokenSource();
+
+        var task = Task.Run(() => _client.System.MonitorEventsAsync(new EventsParameters(), progress, cts.Token));
+
+        await _client.Images.TagImageAsync("hello-world", new ImageTagParameters { RepositoryName = "hello-world", Tag = "test" }, cts.Token);
+        cts.Cancel();
+        await task;
+    }
+
+    private class Progress : IProgress<Message>
+    {
+        internal Action<Message> _onCalled;
+
+        void IProgress<Message>.Report(Message value)
+        {
+            _onCalled(value);
+        }
+    }
+}
 ```
 
-You can cancel streaming using the CancellationToken. On the other hand, if you wish to continuously stream, you can simply pass `CancellationToken.None`.
+You can cancel message processing using the CancellationToken. On the other hand, if you wish to continuously process messages, you can simply pass `CancellationToken.None`.
 
 #### Example: HTTPS Authentication to Docker
 

src/Docker.DotNet.BasicAuth/Docker.DotNet.BasicAuth.csproj

@@ -7,4 +7,10 @@
   <ItemGroup>
     <ProjectReference Include="..\Docker.DotNet\Docker.DotNet.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Update="Nerdbank.GitVersioning" Version="3.3.37">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 </Project>

src/Docker.DotNet.X509/Docker.DotNet.X509.csproj

@@ -8,4 +8,10 @@
   <ItemGroup>
     <ProjectReference Include="..\Docker.DotNet\Docker.DotNet.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Update="Nerdbank.GitVersioning" Version="3.3.37">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 </Project>

src/Docker.DotNet/Docker.DotNet.csproj

@@ -2,10 +2,16 @@
   <PropertyGroup>
     <PackageId>Docker.DotNet</PackageId>
     <Description>Docker.DotNet is a library that allows you to interact with the Docker Remote API programmatically with fully asynchronous, non-blocking and object-oriented code in your .NET applications.</Description>
-    <AssemblyName>Docker.DotNet</AssemblyName>
+    <AssemblyName>Docker.DotNet</AssemblyName>    
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="System.Buffers" Version="4.5.1" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Update="Nerdbank.GitVersioning" Version="3.3.37">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 </Project>

src/Docker.DotNet/DockerApiResponse.cs

@@ -2,7 +2,7 @@
 
 namespace Docker.DotNet
 {
-    internal class DockerApiResponse
+    public class DockerApiResponse
     {
         public HttpStatusCode StatusCode { get; private set; }
 
@@ -14,4 +14,4 @@ public DockerApiResponse(HttpStatusCode statusCode, string body)
             this.Body = body;
         }
     }
-}
+}

src/Docker.DotNet/DockerClient.cs

@@ -10,7 +10,9 @@
 using Microsoft.Net.Http.Client;
 
 #if (NETSTANDARD1_6 || NETSTANDARD2_0)
+
 using System.Net.Sockets;
+
 #endif
 
 namespace Docker.DotNet
@@ -39,6 +41,7 @@ internal DockerClient(DockerClientConfiguration configuration, Version requested
             System = new SystemOperations(this);
             Networks = new NetworkOperations(this);
             Secrets = new SecretsOperations(this);
+            Configs = new ConfigsOperations(this);
             Swarm = new SwarmOperations(this);
             Tasks = new TasksOperations(this);
             Volumes = new VolumeOperations(this);
@@ -121,6 +124,7 @@ internal DockerClient(DockerClientConfiguration configuration, Version requested
             _endpointBaseUri = uri;
 
             _client = new HttpClient(Configuration.Credentials.GetHandler(handler), true);
+            _client.DefaultRequestHeaders.Add(nameof(_endpointBaseUri.Host), _endpointBaseUri.Host);
             DefaultTimeout = Configuration.DefaultTimeout;
             _client.Timeout = s_InfiniteTimeout;
         }
@@ -139,6 +143,8 @@ internal DockerClient(DockerClientConfiguration configuration, Version requested
 
         public ISecretsOperations Secrets { get; }
 
+        public IConfigsOperations Configs { get; }
+
         public ISwarmOperations Swarm { get; }
 
         public ITasksOperations Tasks { get; }
@@ -327,8 +333,8 @@ internal async Task<WriteClosableStream> MakeRequestForHijackedStreamAsync(
 
             await HandleIfErrorResponseAsync(response.StatusCode, response, errorHandlers);
 
-            var content = response.Content as HttpConnectionResponseContent;
-            if (content == null)
+			var content = response.Content as HttpConnectionResponseContent;
+            if (content == null)            
             {
                 throw new NotSupportedException("message handler does not support hijacked streams");
             }
@@ -364,7 +370,7 @@ private async Task<HttpResponseMessage> PrivateMakeRequestAsync(
             return await _client.SendAsync(request, completionOption, cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task HandleIfErrorResponseAsync(HttpStatusCode statusCode, HttpResponseMessage response, IEnumerable<ApiResponseErrorHandlingDelegate> handlers)
+        private async static Task HandleIfErrorResponseAsync(HttpStatusCode statusCode, HttpResponseMessage response, IEnumerable<ApiResponseErrorHandlingDelegate> handlers)
         {
             bool isErrorResponse = statusCode < HttpStatusCode.OK || statusCode >= HttpStatusCode.BadRequest;
 
@@ -394,7 +400,7 @@ private async Task HandleIfErrorResponseAsync(HttpStatusCode statusCode, HttpRes
             }
         }
 
-        public async Task HandleIfErrorResponseAsync(HttpStatusCode statusCode, HttpResponseMessage response)
+        public async static Task HandleIfErrorResponseAsync(HttpStatusCode statusCode, HttpResponseMessage response)
         {
             bool isErrorResponse = statusCode < HttpStatusCode.OK || statusCode >= HttpStatusCode.BadRequest;
 
@@ -423,7 +429,7 @@ internal HttpRequestMessage PrepareRequest(HttpMethod method, string path, IQuer
             }
 
             var request = new HttpRequestMessage(method, HttpUtility.BuildUri(_endpointBaseUri, this._requestedApiVersion, path, queryString));
-
+			
             request.Version = new Version(1, 1);
 
             request.Headers.Add("User-Agent", UserAgent);
@@ -452,4 +458,4 @@ public void Dispose()
     }
 
     internal delegate void ApiResponseErrorHandlingDelegate(HttpStatusCode statusCode, string responseBody);
-}
+}

src/Docker.DotNet/DockerClientConfiguration.cs

@@ -16,23 +16,28 @@ public class DockerClientConfiguration : IDisposable
 
         private static Uri LocalDockerUri()
         {
-            var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-            return isWindows ? new Uri("npipe://./pipe/docker_engine") : new Uri("unix:/var/run/docker.sock");
+            var dockerHostVar = Environment.GetEnvironmentVariable("DOCKER_HOST");
+            var defaultDockerUrl = !string.IsNullOrEmpty(dockerHostVar)
+                ? dockerHostVar
+                : !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                    ? "unix:///var/run/docker.sock"
+                    : "npipe://./pipe/docker_engine";
+
+            return new Uri(defaultDockerUrl);
         }
 
         public DockerClientConfiguration(Credentials credentials = null, TimeSpan defaultTimeout = default(TimeSpan))
             : this(LocalDockerUri(), credentials, defaultTimeout)
         {
         }
 
-        public DockerClientConfiguration(Uri endpoint, Credentials credentials = null,
-            TimeSpan defaultTimeout = default(TimeSpan))
+        public DockerClientConfiguration(Uri endpoint, Credentials credentials = null, TimeSpan defaultTimeout = default(TimeSpan))
         {
             if (endpoint == null)
                 throw new ArgumentNullException(nameof(endpoint));
 
-
             Credentials = credentials ?? new AnonymousCredentials();
+
             EndpointBaseUri = endpoint;
             if (defaultTimeout != TimeSpan.Zero)
             {
@@ -44,19 +49,14 @@ public DockerClientConfiguration(Uri endpoint, Credentials credentials = null,
             }
         }
 
-        public DockerClient CreateClient()
-        {
-            return this.CreateClient(null);
-        }
+        public DockerClient CreateClient() => this.CreateClient(null);
 
-        public DockerClient CreateClient(Version requestedApiVersion)
-        {
-            return new DockerClient(this, requestedApiVersion);
-        }
+        public DockerClient CreateClient(Version requestedApiVersion) => new DockerClient(this, requestedApiVersion);
 
         public void Dispose()
         {
             Credentials.Dispose();
+            GC.SuppressFinalize(this);
         }
     }
-}
+}

src/Docker.DotNet/DockerPipeStream.cs

@@ -145,4 +145,4 @@ protected override void Dispose(bool disposing)
             }
         }
     }
-}
+}

src/Docker.DotNet/Endpoints/ConfigsOperations.cs

@@ -0,0 +1,53 @@
+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 ConfigsOperations : IConfigsOperations
+    {
+        private readonly DockerClient _client;
+
+        internal ConfigsOperations(DockerClient client)
+        {
+            _client = client;
+        }
+
+        async Task<IList<SwarmConfig>> IConfigsOperations.ListAsync(CancellationToken cancellationToken)
+        {
+            var response = await _client.MakeRequestAsync(_client.NoErrorHandlers, HttpMethod.Get, "configs", cancellationToken).ConfigureAwait(false);
+            return _client.JsonSerializer.DeserializeObject<IList<SwarmConfig>>(response.Body);
+        }
+
+        async Task<SwarmCreateConfigResponse> IConfigsOperations.CreateAsync(ConfigSpec body, CancellationToken cancellationToken)
+        {
+            var data = new JsonRequestContent<ConfigSpec>(body ?? throw new ArgumentNullException(nameof(body)), _client.JsonSerializer);
+            var response = await _client.MakeRequestAsync(_client.NoErrorHandlers, HttpMethod.Post, "configs/create", null, data, cancellationToken).ConfigureAwait(false);
+            return _client.JsonSerializer.DeserializeObject<SwarmCreateConfigResponse>(response.Body);
+        }
+
+        async Task<SwarmConfig> IConfigsOperations.InspectAsync(string id, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            var response = await _client.MakeRequestAsync(_client.NoErrorHandlers, HttpMethod.Get, $"configs/{id}", cancellationToken).ConfigureAwait(false);
+            return _client.JsonSerializer.DeserializeObject<SwarmConfig>(response.Body);
+        }
+
+        Task IConfigsOperations.DeleteAsync(string id, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            return _client.MakeRequestAsync(_client.NoErrorHandlers, HttpMethod.Delete, $"configs/{id}", cancellationToken);
+        }
+    }
+}

src/Docker.DotNet/Endpoints/ContainerOperations.cs

@@ -236,7 +236,6 @@ public Task<Stream> GetContainerStatsAsync(string id, ContainerStatsParameters p
                 throw new ArgumentNullException(nameof(parameters));
             }
 
-
             IQueryString queryParameters = new QueryString<ContainerRestartParameters>(parameters);
             // since specified wait timespan can be greater than HttpClient's default, we set the
             // client timeout to infinite and provide a cancellation token.
@@ -413,4 +412,4 @@ public async Task<ContainersPruneResponse> PruneContainersAsync(ContainersPruneP
             return this._client.JsonSerializer.DeserializeObject<ContainerUpdateResponse>(response.Body);
         }
     }
-}
+}