feat: not create network if already exist

cmd/kubevpn/cmds/dev.go

@@ -25,16 +25,18 @@ import (
 
 func CmdDev(f cmdutil.Factory) *cobra.Command {
 	var devOptions = dev.Options{
-		Factory:    f,
+		Factory:      f,
-		Entrypoint: "",
+		Entrypoint:   "",
-		Publish:    opts.NewListOpts(nil),
+		Publish:      opts.NewListOpts(nil),
-		Expose:     opts.NewListOpts(nil),
+		Expose:       opts.NewListOpts(nil),
-		Env:        opts.NewListOpts(nil),
+		Env:          opts.NewListOpts(nil),
-		Volumes:    opts.NewListOpts(nil),
+		Volumes:      opts.NewListOpts(nil),
-		ExtraHosts: opts.NewListOpts(nil),
+		ExtraHosts:   opts.NewListOpts(nil),
-		Aliases:    opts.NewListOpts(nil),
+		Aliases:      opts.NewListOpts(nil),
-		NoProxy:    false,
+		Links:        opts.NewListOpts(nil),
-		ExtraCIDR:  []string{},
+		LinkLocalIPs: opts.NewListOpts(nil),
+		NoProxy:      false,
+		ExtraCIDR:    []string{},
 	}
 	var sshConf = &util.SshConfig{}
 	cmd := &cobra.Command{
@@ -163,6 +165,8 @@ Startup your kubernetes workloads in local Docker container with same volume、e
 	cmd.Flags().Var(&devOptions.NetMode, "net", "Connect a container to a network, eg: [default|bridge|host|none|container:$CONTAINER_ID]")
 	cmd.Flags().Var(&devOptions.NetMode, "network", "Connect a container to a network")
 	cmd.Flags().MarkHidden("net")
+	cmd.Flags().Var(&devOptions.Links, "link", "Add link to another container")
+	cmd.Flags().Var(&devOptions.LinkLocalIPs, "link-local-ip", "Container IPv4/IPv6 link-local addresses")
 	// We allow for both "--net-alias" and "--network-alias", although the latter is the recommended way.
 	cmd.Flags().Var(&devOptions.Aliases, "net-alias", "Add network-scoped alias for the container")
 	cmd.Flags().Var(&devOptions.Aliases, "network-alias", "Add network-scoped alias for the container")

pkg/dev/main.go

@@ -7,6 +7,7 @@ import (
 	"net"
 	"os"
 	"path/filepath"
+	"reflect"
 	"sort"
 	"time"
 
@@ -58,6 +59,8 @@ type Options struct {
 	ExtraHosts   opts.ListOpts
 	NetMode      opts.NetworkOpt
 	Aliases      opts.ListOpts
+	Links        opts.ListOpts
+	LinkLocalIPs opts.ListOpts
 	Env          opts.ListOpts
 	Mounts       opts.MountOpt
 	Volumes      opts.ListOpts
@@ -134,74 +137,46 @@ func (d Options) Main(ctx context.Context) error {
 	}
 	mode := container.NetworkMode(d.NetMode.NetworkMode())
 	if mode.IsBridge() || mode.IsHost() || mode.IsContainer() || mode.IsNone() {
-		for _, config := range list[:] {
+		for _, runConfig := range list[:] {
 			// remove expose port
-			config.config.ExposedPorts = nil
+			runConfig.config.ExposedPorts = nil
-			config.hostConfig.NetworkMode = mode
+			runConfig.hostConfig.NetworkMode = mode
 			if mode.IsContainer() {
-				config.hostConfig.PidMode = containertypes.PidMode(d.NetMode.NetworkMode())
+				runConfig.hostConfig.PidMode = containertypes.PidMode(d.NetMode.NetworkMode())
 			}
-			config.hostConfig.PortBindings = nil
+			runConfig.hostConfig.PortBindings = nil
 
 			// remove dns
-			config.hostConfig.DNS = nil
+			runConfig.hostConfig.DNS = nil
-			config.hostConfig.DNSOptions = nil
+			runConfig.hostConfig.DNSOptions = nil
-			config.hostConfig.DNSSearch = nil
+			runConfig.hostConfig.DNSSearch = nil
-			config.hostConfig.PublishAllPorts = false
+			runConfig.hostConfig.PublishAllPorts = false
-			config.config.Hostname = ""
+			runConfig.config.Hostname = ""
 		}
 	} else {
-		getInterface, err := tun.GetInterface()
+		var networkID string
+		networkID, err = createNetwork(ctx, cli, list[0].containerName)
 		if err != nil {
 			return err
 		}
-		addrs, err := getInterface.Addrs()
-		if err != nil {
-			return err
-		}
-		cidr, _, err := net.ParseCIDR(addrs[0].String())
-		if err != nil {
-			return err
-		}
-		create, err := cli.NetworkCreate(ctx, list[0].containerName, types.NetworkCreate{
-			Driver: "bridge",
-			Scope:  "local",
-			IPAM: &network.IPAM{
-				Driver:  "",
-				Options: nil,
-				Config: []network.IPAMConfig{
-					{
-						Subnet:  config.CIDR.String(),
-						Gateway: cidr.String(),
-					},
-				},
-			},
-			Internal: true,
-		})
-		if err != nil {
-			if errdefs.IsForbidden(err) {
-				_, _ = cli.NetworkList(ctx, types.NetworkListOptions{})
-			}
-			return err
-		}
 
 		list[0].networkingConfig.EndpointsConfig[list[0].containerName] = &network.EndpointSettings{
-			NetworkID: create.ID,
+			NetworkID: networkID,
 		}
 		// skip first
-		for _, config := range list[1:] {
+		for _, runConfig := range list[1:] {
 			// remove expose port
-			config.config.ExposedPorts = nil
+			runConfig.config.ExposedPorts = nil
-			config.hostConfig.NetworkMode = containertypes.NetworkMode("container:" + list[0].containerName)
+			runConfig.hostConfig.NetworkMode = containertypes.NetworkMode("container:" + list[0].containerName)
-			config.hostConfig.PidMode = containertypes.PidMode("container:" + list[0].containerName)
+			runConfig.hostConfig.PidMode = containertypes.PidMode("container:" + list[0].containerName)
-			config.hostConfig.PortBindings = nil
+			runConfig.hostConfig.PortBindings = nil
 
 			// remove dns
-			config.hostConfig.DNS = nil
+			runConfig.hostConfig.DNS = nil
-			config.hostConfig.DNSOptions = nil
+			runConfig.hostConfig.DNSOptions = nil
-			config.hostConfig.DNSSearch = nil
+			runConfig.hostConfig.DNSSearch = nil
-			config.hostConfig.PublishAllPorts = false
+			runConfig.hostConfig.PublishAllPorts = false
-			config.config.Hostname = ""
+			runConfig.config.Hostname = ""
 		}
 	}
 
@@ -215,6 +190,50 @@ func (d Options) Main(ctx context.Context) error {
 	return terminal(list[0].containerName, dockerCli)
 }
 
+func createNetwork(ctx context.Context, cli *client.Client, networkName string) (string, error) {
+	getInterface, err := tun.GetInterface()
+	if err != nil {
+		return "", err
+	}
+	addrs, err := getInterface.Addrs()
+	if err != nil {
+		return "", err
+	}
+	cidr, _, err := net.ParseCIDR(addrs[0].String())
+	if err != nil {
+		return "", err
+	}
+	by := map[string]string{"created_by": config.ConfigMapPodTrafficManager}
+	create, err := cli.NetworkCreate(ctx, networkName, types.NetworkCreate{
+		Driver: "bridge",
+		Scope:  "local",
+		IPAM: &network.IPAM{
+			Driver:  "",
+			Options: nil,
+			Config: []network.IPAMConfig{
+				{
+					Subnet:  config.CIDR.String(),
+					Gateway: cidr.String(),
+				},
+			},
+		},
+		Internal: true,
+		Labels:   by,
+	})
+	if err != nil {
+		if errdefs.IsForbidden(err) {
+			list, _ := cli.NetworkList(ctx, types.NetworkListOptions{})
+			for _, resource := range list {
+				if reflect.DeepEqual(resource.Labels, by) {
+					return resource.ID, nil
+				}
+			}
+		}
+		return "", err
+	}
+	return create.ID, nil
+}
+
 type Run []*RunConfig
 
 func (r Run) Remove(ctx context.Context) error {
@@ -223,22 +242,22 @@ func (r Run) Remove(ctx context.Context) error {
 		return err
 	}
 
-	for _, config := range r {
+	for _, runConfig := range r {
-		err = cli.NetworkDisconnect(ctx, config.containerName, config.containerName, true)
+		err = cli.NetworkDisconnect(ctx, runConfig.containerName, runConfig.containerName, true)
 		if err != nil {
-			log.Errorln(err)
+			log.Debug(err)
 		}
-		err = cli.ContainerRemove(ctx, config.containerName, types.ContainerRemoveOptions{Force: true})
+		err = cli.ContainerRemove(ctx, runConfig.containerName, types.ContainerRemoveOptions{Force: true})
 		if err != nil {
-			log.Errorln(err)
+			log.Debug(err)
 		}
 	}
-	for _, config := range r {
+	for _, runConfig := range r {
-		_, err = cli.NetworkInspect(ctx, config.containerName, types.NetworkInspectOptions{})
+		_, err = cli.NetworkInspect(ctx, runConfig.containerName, types.NetworkInspectOptions{})
 		if err == nil {
-			err = cli.NetworkRemove(ctx, config.containerName)
+			err = cli.NetworkRemove(ctx, runConfig.containerName)
 			if err != nil {
-				log.Errorln(err)
+				log.Debug(err)
 			}
 		}
 	}