Merge pull request #51325 from thaJeztah/refactor_client_network_step1

client: refactor NetworkConnect, NetworkDisconnect, NetworkRemove

client/client_interfaces.go

@@ -117,12 +117,12 @@ type ImageAPIClient interface {
 
 // NetworkAPIClient defines API client methods for the networks
 type NetworkAPIClient interface {
-	NetworkConnect(ctx context.Context, network, container string, config *network.EndpointSettings) error
+	NetworkConnect(ctx context.Context, network string, options NetworkConnectOptions) (NetworkConnectResult, error)
 	NetworkCreate(ctx context.Context, name string, options NetworkCreateOptions) (network.CreateResponse, error)
-	NetworkDisconnect(ctx context.Context, network, container string, force bool) error
+	NetworkDisconnect(ctx context.Context, network string, options NetworkDisconnectOptions) (NetworkDisconnectResult, error)
 	NetworkInspect(ctx context.Context, network string, options NetworkInspectOptions) (NetworkInspectResult, error)
 	NetworkList(ctx context.Context, options NetworkListOptions) (NetworkListResult, error)
-	NetworkRemove(ctx context.Context, network string) error
+	NetworkRemove(ctx context.Context, network string, options NetworkRemoveOptions) (NetworkRemoveResult, error)
 	NetworksPrune(ctx context.Context, opts NetworkPruneOptions) (NetworkPruneResult, error)
 }
 

client/network_connect.go

@@ -6,23 +6,35 @@ import (
 	"github.com/moby/moby/api/types/network"
 )
 
+// NetworkConnectOptions represents the data to be used to connect a container to the
+// network.
+type NetworkConnectOptions struct {
+	Container      string
+	EndpointConfig *network.EndpointSettings
+}
+
+// NetworkConnectResult represents the result of a NetworkConnect operation.
+type NetworkConnectResult struct {
+	// Currently empty; placeholder for future fields.
+}
+
 // NetworkConnect connects a container to an existent network in the docker host.
-func (cli *Client) NetworkConnect(ctx context.Context, networkID, containerID string, config *network.EndpointSettings) error {
+func (cli *Client) NetworkConnect(ctx context.Context, networkID string, options NetworkConnectOptions) (NetworkConnectResult, error) {
 	networkID, err := trimID("network", networkID)
 	if err != nil {
-		return err
+		return NetworkConnectResult{}, err
 	}
 
-	containerID, err = trimID("container", containerID)
+	containerID, err := trimID("container", options.Container)
 	if err != nil {
-		return err
+		return NetworkConnectResult{}, err
 	}
 
-	req := network.ConnectRequest{
+	nc := network.ConnectRequest{
 		Container:      containerID,
-		EndpointConfig: config,
+		EndpointConfig: options.EndpointConfig,
 	}
-	resp, err := cli.post(ctx, "/networks/"+networkID+"/connect", nil, req, nil)
+	resp, err := cli.post(ctx, "/networks/"+networkID+"/connect", nil, nc, nil)
 	defer ensureReaderClosed(resp)
-	return err
+	return NetworkConnectResult{}, err
 }

client/network_connect_opts.go

@@ -1,10 +0,0 @@
-package client
-
-import "github.com/moby/moby/api/types/network"
-
-// NetworkConnectOptions represents the data to be used to connect a container to the
-// network.
-type NetworkConnectOptions struct {
-	Container      string
-	EndpointConfig *network.EndpointSettings `json:",omitempty"`
-}

client/network_connect_test.go

@@ -17,15 +17,19 @@ func TestNetworkConnectError(t *testing.T) {
 	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
 	assert.NilError(t, err)
 
-	err = client.NetworkConnect(context.Background(), "network_id", "container_id", nil)
+	_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
+		Container: "container_id",
+	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 
 	// Empty network ID or container ID
-	err = client.NetworkConnect(context.Background(), "", "container_id", nil)
+	_, err = client.NetworkConnect(context.Background(), "", NetworkConnectOptions{
+		Container: "container_id",
+	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 
-	err = client.NetworkConnect(context.Background(), "network_id", "", nil)
+	_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 }
@@ -55,7 +59,9 @@ func TestNetworkConnectEmptyNilEndpointSettings(t *testing.T) {
 	}))
 	assert.NilError(t, err)
 
-	err = client.NetworkConnect(context.Background(), "network_id", "container_id", nil)
+	_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
+		Container: "container_id",
+	})
 	assert.NilError(t, err)
 }
 
@@ -67,7 +73,7 @@ func TestNetworkConnect(t *testing.T) {
 			return nil, err
 		}
 
-		var connect NetworkConnectOptions
+		var connect network.ConnectRequest
 		if err := json.NewDecoder(req.Body).Decode(&connect); err != nil {
 			return nil, err
 		}
@@ -88,8 +94,11 @@ func TestNetworkConnect(t *testing.T) {
 	}))
 	assert.NilError(t, err)
 
-	err = client.NetworkConnect(context.Background(), "network_id", "container_id", &network.EndpointSettings{
-		NetworkID: "NetworkID",
+	_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
+		Container: "container_id",
+		EndpointConfig: &network.EndpointSettings{
+			NetworkID: "NetworkID",
+		},
 	})
 	assert.NilError(t, err)
 }

client/network_disconnect.go

@@ -6,23 +6,35 @@ import (
 	"github.com/moby/moby/api/types/network"
 )
 
+// NetworkDisconnectOptions represents the data to be used to disconnect a container
+// from the network.
+type NetworkDisconnectOptions struct {
+	Container string
+	Force     bool
+}
+
+// NetworkDisconnectResult represents the result of a NetworkDisconnect operation.
+type NetworkDisconnectResult struct {
+	// Currently empty; placeholder for future fields.
+}
+
 // NetworkDisconnect disconnects a container from an existent network in the docker host.
-func (cli *Client) NetworkDisconnect(ctx context.Context, networkID, containerID string, force bool) error {
+func (cli *Client) NetworkDisconnect(ctx context.Context, networkID string, options NetworkDisconnectOptions) (NetworkDisconnectResult, error) {
 	networkID, err := trimID("network", networkID)
 	if err != nil {
-		return err
+		return NetworkDisconnectResult{}, err
 	}
 
-	containerID, err = trimID("container", containerID)
+	containerID, err := trimID("container", options.Container)
 	if err != nil {
-		return err
+		return NetworkDisconnectResult{}, err
 	}
 
 	req := network.DisconnectRequest{
 		Container: containerID,
-		Force:     force,
+		Force:     options.Force,
 	}
 	resp, err := cli.post(ctx, "/networks/"+networkID+"/disconnect", nil, req, nil)
 	defer ensureReaderClosed(resp)
-	return err
+	return NetworkDisconnectResult{}, err
 }

client/network_disconnect_opts.go

@@ -1,8 +0,0 @@
-package client
-
-// NetworkDisconnectOptions represents the data to be used to disconnect a container
-// from the network.
-type NetworkDisconnectOptions struct {
-	Container string
-	Force     bool
-}

client/network_disconnect_test.go

@@ -17,15 +17,19 @@ func TestNetworkDisconnectError(t *testing.T) {
 	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
 	assert.NilError(t, err)
 
-	err = client.NetworkDisconnect(context.Background(), "network_id", "container_id", false)
+	_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{
+		Container: "container_id",
+	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 
 	// Empty network ID or container ID
-	err = client.NetworkDisconnect(context.Background(), "", "container_id", false)
+	_, err = client.NetworkDisconnect(context.Background(), "", NetworkDisconnectOptions{
+		Container: "container_id",
+	})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 
-	err = client.NetworkDisconnect(context.Background(), "network_id", "", false)
+	_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 }
@@ -55,6 +59,6 @@ func TestNetworkDisconnect(t *testing.T) {
 	}))
 	assert.NilError(t, err)
 
-	err = client.NetworkDisconnect(context.Background(), "network_id", "container_id", true)
+	_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{Container: "container_id", Force: true})
 	assert.NilError(t, err)
 }

client/network_remove.go

@@ -1,14 +1,26 @@
 package client
 
-import "context"
+import (
+	"context"
+)
+
+// NetworkRemoveOptions specifies options for removing a network.
+type NetworkRemoveOptions struct {
+	// No options currently; placeholder for future use.
+}
+
+// NetworkRemoveResult represents the result of a network removal operation.
+type NetworkRemoveResult struct {
+	// No fields currently; placeholder for future use.
+}
 
 // NetworkRemove removes an existent network from the docker host.
-func (cli *Client) NetworkRemove(ctx context.Context, networkID string) error {
+func (cli *Client) NetworkRemove(ctx context.Context, networkID string, options NetworkRemoveOptions) (NetworkRemoveResult, error) {
 	networkID, err := trimID("network", networkID)
 	if err != nil {
-		return err
+		return NetworkRemoveResult{}, err
 	}
 	resp, err := cli.delete(ctx, "/networks/"+networkID, nil, nil)
 	defer ensureReaderClosed(resp)
-	return err
+	return NetworkRemoveResult{}, err
 }

client/network_remove_test.go

@@ -14,14 +14,14 @@ func TestNetworkRemoveError(t *testing.T) {
 	client, err := NewClientWithOpts(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
 	assert.NilError(t, err)
 
-	err = client.NetworkRemove(context.Background(), "network_id")
+	_, err = client.NetworkRemove(context.Background(), "network_id", NetworkRemoveOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
 
-	err = client.NetworkRemove(context.Background(), "")
+	_, err = client.NetworkRemove(context.Background(), "", NetworkRemoveOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 
-	err = client.NetworkRemove(context.Background(), "    ")
+	_, err = client.NetworkRemove(context.Background(), "    ", NetworkRemoveOptions{})
 	assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
 	assert.Check(t, is.ErrorContains(err, "value is empty"))
 }
@@ -37,6 +37,6 @@ func TestNetworkRemove(t *testing.T) {
 	}))
 	assert.NilError(t, err)
 
-	err = client.NetworkRemove(context.Background(), "network_id")
+	_, err = client.NetworkRemove(context.Background(), "network_id", NetworkRemoveOptions{})
 	assert.NilError(t, err)
 }