Merge pull request #8457 from afbjorklund/bridge-mtu

Add podman network create flag for bridge mtu

cmd/podman/networks/create.go

@@ -30,6 +30,7 @@ var (
 var (
 	networkCreateOptions entities.NetworkCreateOptions
 	labels               []string
+	opts                 []string
 )
 
 func networkCreateFlags(cmd *cobra.Command) {
@@ -39,6 +40,10 @@ func networkCreateFlags(cmd *cobra.Command) {
 	flags.StringVarP(&networkCreateOptions.Driver, driverFlagName, "d", "bridge", "driver to manage the network")
 	_ = cmd.RegisterFlagCompletionFunc(driverFlagName, common.AutocompleteNetworkDriver)
 
+	optFlagName := "opt"
+	flags.StringArrayVarP(&opts, optFlagName, "o", []string{}, "Set driver specific options (default [])")
+	_ = cmd.RegisterFlagCompletionFunc(optFlagName, completion.AutocompleteNone)
+
 	gatewayFlagName := "gateway"
 	flags.IPVar(&networkCreateOptions.Gateway, gatewayFlagName, nil, "IPv4 or IPv6 gateway for the subnet")
 	_ = cmd.RegisterFlagCompletionFunc(gatewayFlagName, completion.AutocompleteNone)
@@ -93,6 +98,10 @@ func networkCreate(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return errors.Wrap(err, "failed to parse labels")
 	}
+	networkCreateOptions.Options, err = parse.GetAllLabels([]string{}, opts)
+	if err != nil {
+		return errors.Wrapf(err, "unable to process options")
+	}
 	response, err := registry.ContainerEngine().NetworkCreate(registry.Context(), name, networkCreateOptions)
 	if err != nil {
 		return err

docs/source/markdown/podman-network-create.1.md

@@ -26,6 +26,14 @@ resolution.
 
 Driver to manage the network (default "bridge").  Currently only `bridge` is supported.
 
+#### **--opt**=*option*, **-o**
+
+Set driver specific options.
+
+For the `bridge` driver the following options are supported: `mtu` and `vlan`.
+The `mtu` option sets the Maximum Transmission Unit (MTU) and takes an integer value.
+The `vlan` option assign VLAN tag and enables vlan\_filtering. Defaults to none.
+
 #### **--gateway**
 
 Define a gateway for the subnet. If you want to provide a gateway address, you must also provide a

libpod/network/create.go

@@ -6,6 +6,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strconv"
 
 	"github.com/containernetworking/cni/pkg/version"
 	"github.com/containers/common/pkg/config"
@@ -76,6 +77,29 @@ func validateBridgeOptions(options entities.NetworkCreateOptions) error {
 
 }
 
+// parseMTU parses the mtu option
+func parseMTU(mtu string) (int, error) {
+	if mtu == "" {
+		return 0, nil // default
+	}
+	m, err := strconv.Atoi(mtu)
+	if err != nil {
+		return 0, err
+	}
+	if m < 0 {
+		return 0, errors.Errorf("the value %d for mtu is less than zero", m)
+	}
+	return m, nil
+}
+
+// parseVlan parses the vlan option
+func parseVlan(vlan string) (int, error) {
+	if vlan == "" {
+		return 0, nil // default
+	}
+	return strconv.Atoi(vlan)
+}
+
 // createBridge creates a CNI network
 func createBridge(name string, options entities.NetworkCreateOptions, runtimeConfig *config.Config) (string, error) {
 	var (
@@ -149,6 +173,28 @@ func createBridge(name string, options entities.NetworkCreateOptions, runtimeCon
 		ipMasq = false
 	}
 
+	var mtu int
+	var vlan int
+	for k, v := range options.Options {
+		var err error
+		switch k {
+		case "mtu":
+			mtu, err = parseMTU(v)
+			if err != nil {
+				return "", err
+			}
+
+		case "vlan":
+			vlan, err = parseVlan(v)
+			if err != nil {
+				return "", err
+			}
+
+		default:
+			return "", errors.Errorf("unsupported option %s", k)
+		}
+	}
+
 	// obtain host bridge name
 	bridgeDeviceName, err := GetFreeDeviceName(runtimeConfig)
 	if err != nil {
@@ -172,7 +218,7 @@ func createBridge(name string, options entities.NetworkCreateOptions, runtimeCon
 	ncList := NewNcList(name, version.Current(), options.Labels)
 	var plugins []CNIPlugins
 	// TODO need to iron out the role of isDefaultGW and IPMasq
-	bridge := NewHostLocalBridge(bridgeDeviceName, isGateway, false, ipMasq, ipamConfig)
+	bridge := NewHostLocalBridge(bridgeDeviceName, isGateway, false, ipMasq, mtu, vlan, ipamConfig)
 	plugins = append(plugins, bridge)
 	plugins = append(plugins, NewPortMapPlugin())
 	plugins = append(plugins, NewFirewallPlugin())

libpod/network/netconflist.go

@@ -41,12 +41,14 @@ func NewNcList(name, version string, labels NcLabels) NcList {
 }
 
 // NewHostLocalBridge creates a new LocalBridge for host-local
-func NewHostLocalBridge(name string, isGateWay, isDefaultGW, ipMasq bool, ipamConf IPAMHostLocalConf) *HostLocalBridge {
+func NewHostLocalBridge(name string, isGateWay, isDefaultGW, ipMasq bool, mtu int, vlan int, ipamConf IPAMHostLocalConf) *HostLocalBridge {
 	hostLocalBridge := HostLocalBridge{
 		PluginType:  "bridge",
 		BrName:      name,
 		IPMasq:      ipMasq,
+		MTU:         mtu,
 		HairpinMode: true,
+		Vlan:        vlan,
 		IPAM:        ipamConf,
 	}
 	if isGateWay {

pkg/domain/entities/network.go

@@ -45,6 +45,8 @@ type NetworkCreateOptions struct {
 	Range      net.IPNet
 	Subnet     net.IPNet
 	IPv6       bool
+	// Mapping of driver options and values.
+	Options map[string]string
 }
 
 // NetworkCreateReport describes a created network for the cli

test/e2e/network_create_test.go

@@ -329,4 +329,37 @@ var _ = Describe("Podman network create", func() {
 		Expect(nc).To(ExitWithError())
 	})
 
+	It("podman network create with mtu option", func() {
+		net := "mtu-test"
+		nc := podmanTest.Podman([]string{"network", "create", "--opt", "mtu=9000", net})
+		nc.WaitWithDefaultTimeout()
+		Expect(nc.ExitCode()).To(BeZero())
+		defer podmanTest.removeCNINetwork(net)
+
+		nc = podmanTest.Podman([]string{"network", "inspect", net})
+		nc.WaitWithDefaultTimeout()
+		Expect(nc.ExitCode()).To(BeZero())
+		Expect(nc.OutputToString()).To(ContainSubstring(`"mtu": 9000,`))
+	})
+
+	It("podman network create with vlan option", func() {
+		net := "vlan-test"
+		nc := podmanTest.Podman([]string{"network", "create", "--opt", "vlan=9", net})
+		nc.WaitWithDefaultTimeout()
+		Expect(nc.ExitCode()).To(BeZero())
+		defer podmanTest.removeCNINetwork(net)
+
+		nc = podmanTest.Podman([]string{"network", "inspect", net})
+		nc.WaitWithDefaultTimeout()
+		Expect(nc.ExitCode()).To(BeZero())
+		Expect(nc.OutputToString()).To(ContainSubstring(`"vlan": 9`))
+	})
+
+	It("podman network create with invalid option", func() {
+		net := "invalid-test"
+		nc := podmanTest.Podman([]string{"network", "create", "--opt", "foo=bar", net})
+		nc.WaitWithDefaultTimeout()
+		Expect(nc).To(ExitWithError())
+	})
+
 })