Repository: moby/moby
File: client/network_create.go (Go)

Code before:
import (
	"context"
	"encoding/json"

	"github.com/moby/moby/api/types/network"
)

// NetworkCreateOptions holds options to create a network.
type NetworkCreateOptions struct {
	Driver     string                   // Driver is the driver-name used to create the network (e.g. `bridge`, `overlay`)
	Scope      string                   // Scope describes the level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level).
	EnableIPv4 *bool                    // EnableIPv4 represents whether to enable IPv4.
	EnableIPv6 *bool                    // EnableIPv6 represents whether to enable IPv6.
	IPAM       *network.IPAM            // IPAM is the network's IP Address Management.
	Internal   bool                     // Internal represents if the network is used internal only.
	Attachable bool                     // Attachable represents if the global scope is manually attachable by regular containers from workers in swarm mode.
	Ingress    bool                     // Ingress indicates the network is providing the routing-mesh for the swarm cluster.
	ConfigOnly bool                     // ConfigOnly creates a config-only network. Config-only networks are place-holder networks for network configurations to be used by other networks. ConfigOnly networks cannot be used directly to run containers or services.
	ConfigFrom *network.ConfigReference // ConfigFrom specifies the source which will provide the configuration for this network. The specified network must be a config-only network; see [CreateOptions.ConfigOnly].
	Options    map[string]string        // Options specifies the network-specific options to use for when creating the network.
	Labels     map[string]string        // Labels holds metadata specific to the network being created.
}

// NetworkCreateResult represents the result of a network create operation.
type NetworkCreateResult struct {
	NetworkID string

	Warning string
}

// NetworkCreate creates a new network in the docker host.
func (cli *Client) NetworkCreate(ctx context.Context, name string, options NetworkCreateOptions) (NetworkCreateResult, error) {
	req := network.CreateRequest{
		Name:       name,
		Driver:     options.Driver,
		Scope:      options.Scope,
		EnableIPv4: options.EnableIPv4,
		EnableIPv6: options.EnableIPv6,
		IPAM:       options.IPAM,
		Internal:   options.Internal,
		Attachable: options.Attachable,
		Ingress:    options.Ingress,
		ConfigOnly: options.ConfigOnly,
		ConfigFrom: options.ConfigFrom,
		Options:    options.Options,
		Labels:     options.Labels,
	}

	resp, err := cli.post(ctx, "/networks/create", nil, req, nil)
	defer ensureReaderClosed(resp)
	if err != nil {

Review comment (suggestion):
We can name this `ID`, as it should be clear from it being a `NetworkCreateResult` that it's about a network.

In future, if we want to have "generated" names (like we do for containers, etc), we could even  add `Name` fields to these (so that clients can decide what to present to users, and to show (generated) names of things created).

Code after:
import (
	"context"
	"encoding/json"

	"github.com/moby/moby/api/types/network"
)

// NetworkCreateOptions holds options to create a network.
type NetworkCreateOptions struct {
	Driver     string            // Driver is the driver-name used to create the network (e.g. `bridge`, `overlay`)
	Scope      string            // Scope describes the level at which the network exists (e.g. `swarm` for cluster-wide or `local` for machine level).
	EnableIPv4 *bool             // EnableIPv4 represents whether to enable IPv4.
	EnableIPv6 *bool             // EnableIPv6 represents whether to enable IPv6.
	IPAM       *network.IPAM     // IPAM is the network's IP Address Management.
	Internal   bool              // Internal represents if the network is used internal only.
	Attachable bool              // Attachable represents if the global scope is manually attachable by regular containers from workers in swarm mode.
	Ingress    bool              // Ingress indicates the network is providing the routing-mesh for the swarm cluster.
	ConfigOnly bool              // ConfigOnly creates a config-only network. Config-only networks are place-holder networks for network configurations to be used by other networks. ConfigOnly networks cannot be used directly to run containers or services.
	ConfigFrom string            // ConfigFrom specifies the source which will provide the configuration for this network. The specified network must be a config-only network; see [CreateOptions.ConfigOnly].
	Options    map[string]string // Options specifies the network-specific options to use for when creating the network.
	Labels     map[string]string // Labels holds metadata specific to the network being created.
}

// NetworkCreateResult represents the result of a network create operation.
type NetworkCreateResult struct {
	ID string

	Warning []string
}

// NetworkCreate creates a new network in the docker host.
func (cli *Client) NetworkCreate(ctx context.Context, name string, options NetworkCreateOptions) (NetworkCreateResult, error) {
	req := network.CreateRequest{
		Name:       name,
		Driver:     options.Driver,
		Scope:      options.Scope,
		EnableIPv4: options.EnableIPv4,
		EnableIPv6: options.EnableIPv6,
		IPAM:       options.IPAM,
		Internal:   options.Internal,
		Attachable: options.Attachable,
		Ingress:    options.Ingress,
		ConfigOnly: options.ConfigOnly,
		Options:    options.Options,
		Labels:     options.Labels,
	}

	if options.ConfigFrom != "" {
		req.ConfigFrom = &network.ConfigReference{Network: options.ConfigFrom}
	}