Merge pull request #12 from docker/golint

Remove golint warnings

libnetwork/drivers.go

@@ -7,6 +7,7 @@ import (
 	"github.com/docker/libnetwork/pkg/options"
 )
 
+// DriverParams are a generic structure to hold driver specific settings.
 type DriverParams options.Generic
 
 var drivers = map[string]struct {

libnetwork/drivers/bridge/bridge.go

@@ -7,10 +7,11 @@ import (
 )
 
 const (
-	NetworkType = "simplebridge"
-	VethPrefix  = "veth"
+	networkType = "simplebridge"
+	vethPrefix  = "veth"
 )
 
+// Configuration info for the "simplebridge" driver.
 type Configuration struct {
 	BridgeName         string
 	AddressIPv4        *net.IPNet
@@ -22,58 +23,59 @@ type Configuration struct {
 }
 
 func init() {
-	libnetwork.RegisterNetworkType(NetworkType, Create, &Configuration{})
+	libnetwork.RegisterNetworkType(networkType, Create, &Configuration{})
 }
 
+// Create a new Network managed by the "simplebridge" driver.
 func Create(name string, config *Configuration) (libnetwork.Network, error) {
-	bridgeIntfc := NewInterface(config)
-	bridgeSetup := NewBridgeSetup(bridgeIntfc)
+	bridgeIntfc := newInterface(config)
+	bridgeSetup := newBridgeSetup(bridgeIntfc)
 
 	// If the bridge interface doesn't exist, we need to start the setup steps
 	// by creating a new device and assigning it an IPv4 address.
-	bridgeAlreadyExists := bridgeIntfc.Exists()
+	bridgeAlreadyExists := bridgeIntfc.exists()
 	if !bridgeAlreadyExists {
-		bridgeSetup.QueueStep(SetupDevice)
-		bridgeSetup.QueueStep(SetupBridgeIPv4)
+		bridgeSetup.queueStep(setupDevice)
+		bridgeSetup.queueStep(setupBridgeIPv4)
 	}
 
 	// Conditionnally queue setup steps depending on configuration values.
 	for _, step := range []struct {
 		Condition bool
-		Fn        SetupStep
+		Fn        setupStep
 	}{
 		// Enable IPv6 on the bridge if required. We do this even for a
 		// previously  existing bridge, as it may be here from a previous
 		// installation where IPv6 wasn't supported yet and needs to be
 		// assigned an IPv6 link-local address.
-		{config.EnableIPv6, SetupBridgeIPv6},
+		{config.EnableIPv6, setupBridgeIPv6},
 
 		// We ensure that the bridge has the expectedIPv4 and IPv6 addresses in
 		// the case of a previously existing device.
-		{bridgeAlreadyExists, SetupVerifyConfiguredAddresses},
+		{bridgeAlreadyExists, setupVerifyConfiguredAddresses},
 
 		// Setup the bridge to allocate containers IPv4 addresses in the
 		// specified subnet.
-		{config.FixedCIDR != nil, SetupFixedCIDRv4},
+		{config.FixedCIDR != nil, setupFixedCIDRv4},
 
 		// Setup the bridge to allocate containers global IPv6 addresses in the
 		// specified subnet.
-		{config.FixedCIDRv6 != nil, SetupFixedCIDRv6},
+		{config.FixedCIDRv6 != nil, setupFixedCIDRv6},
 
 		// Setup IPTables.
-		{config.EnableIPTables, SetupIPTables},
+		{config.EnableIPTables, setupIPTables},
 
 		// Setup IP forwarding.
-		{config.EnableIPForwarding, SetupIPForwarding},
+		{config.EnableIPForwarding, setupIPForwarding},
 	} {
 		if step.Condition {
-			bridgeSetup.QueueStep(step.Fn)
+			bridgeSetup.queueStep(step.Fn)
 		}
 	}
 
 	// Apply the prepared list of steps, and abort at the first error.
-	bridgeSetup.QueueStep(SetupDeviceUp)
-	if err := bridgeSetup.Apply(); err != nil {
+	bridgeSetup.queueStep(setupDeviceUp)
+	if err := bridgeSetup.apply(); err != nil {
 		return nil, err
 	}
 

libnetwork/drivers/bridge/bridge_test.go

@@ -16,7 +16,7 @@ func TestCreate(t *testing.T) {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
 
-	if expected := NetworkType; netw.Type() != NetworkType {
+	if expected := networkType; netw.Type() != expected {
 		t.Fatalf("Expected networkType %q, got %q", expected, netw.Type())
 	}
 }
@@ -47,7 +47,7 @@ func TestCreateFullOptions(t *testing.T) {
 		t.Fatalf("Failed to create bridge: %v", err)
 	}
 
-	if expected := NetworkType; netw.Type() != NetworkType {
+	if expected := networkType; netw.Type() != expected {
 		t.Fatalf("Expected networkType %q, got %q", expected, netw.Type())
 	}
 }

libnetwork/drivers/bridge/interface.go

@@ -3,16 +3,23 @@ package bridge
 import "github.com/vishvananda/netlink"
 
 const (
+	// DefaultBridgeName is the default name for the bridge interface managed
+	// by the driver when unspecified by the caller.
 	DefaultBridgeName = "docker0"
 )
 
-type Interface struct {
+// Interface models the bridge network device.
+type bridgeInterface struct {
 	Config *Configuration
 	Link   netlink.Link
 }
 
-func NewInterface(config *Configuration) *Interface {
-	i := &Interface{
+// NewInterface creates a new bridge interface structure. It attempts to find
+// an already existing device identified by the Configuration BridgeName field,
+// or the default bridge name when unspecified), but doesn't attempt to create
+// on when missing
+func newInterface(config *Configuration) *bridgeInterface {
+	i := &bridgeInterface{
 		Config: config,
 	}
 
@@ -27,13 +34,13 @@ func NewInterface(config *Configuration) *Interface {
 }
 
 // Exists indicates if the existing bridge interface exists on the system.
-func (i *Interface) Exists() bool {
+func (i *bridgeInterface) exists() bool {
 	return i.Link != nil
 }
 
 // Addresses returns a single IPv4 address and all IPv6 addresses for the
 // bridge interface.
-func (i *Interface) Addresses() (netlink.Addr, []netlink.Addr, error) {
+func (i *bridgeInterface) addresses() (netlink.Addr, []netlink.Addr, error) {
 	v4addr, err := netlink.AddrList(i.Link, netlink.FAMILY_V4)
 	if err != nil {
 		return netlink.Addr{}, nil, err

libnetwork/drivers/bridge/interface_test.go

@@ -10,7 +10,7 @@ import (
 func TestInterfaceDefaultName(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	if inf := NewInterface(&Configuration{}); inf.Config.BridgeName != DefaultBridgeName {
+	if inf := newInterface(&Configuration{}); inf.Config.BridgeName != DefaultBridgeName {
 		t.Fatalf("Expected default interface name %q, got %q", DefaultBridgeName, inf.Config.BridgeName)
 	}
 }
@@ -18,8 +18,8 @@ func TestInterfaceDefaultName(t *testing.T) {
 func TestAddressesEmptyInterface(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	inf := NewInterface(&Configuration{})
-	addrv4, addrsv6, err := inf.Addresses()
+	inf := newInterface(&Configuration{})
+	addrv4, addrsv6, err := inf.addresses()
 	if err != nil {
 		t.Fatalf("Failed to get addresses of default interface: %v", err)
 	}

libnetwork/drivers/bridge/network.go

@@ -12,7 +12,7 @@ func (b *bridgeNetwork) Name() string {
 }
 
 func (b *bridgeNetwork) Type() string {
-	return NetworkType
+	return networkType
 }
 
 func (b *bridgeNetwork) Link(name string) ([]*libnetwork.Interface, error) {

libnetwork/drivers/bridge/setup.go

@@ -1,17 +1,17 @@
 package bridge
 
-type SetupStep func(*Interface) error
+type setupStep func(*bridgeInterface) error
 
-type BridgeSetup struct {
-	bridge *Interface
-	steps  []SetupStep
+type bridgeSetup struct {
+	bridge *bridgeInterface
+	steps  []setupStep
 }
 
-func NewBridgeSetup(i *Interface) *BridgeSetup {
-	return &BridgeSetup{bridge: i}
+func newBridgeSetup(i *bridgeInterface) *bridgeSetup {
+	return &bridgeSetup{bridge: i}
 }
 
-func (b *BridgeSetup) Apply() error {
+func (b *bridgeSetup) apply() error {
 	for _, fn := range b.steps {
 		if err := fn(b.bridge); err != nil {
 			return err
@@ -20,12 +20,12 @@ func (b *BridgeSetup) Apply() error {
 	return nil
 }
 
-func (b *BridgeSetup) QueueStep(step SetupStep) {
+func (b *bridgeSetup) queueStep(step setupStep) {
 	b.steps = append(b.steps, step)
 }
 
 //---------------------------------------------------------------------------//
 
-func SetupIPTables(i *Interface) error {
+func setupIPTables(i *bridgeInterface) error {
 	return nil
 }

libnetwork/drivers/bridge/setup_device.go

@@ -11,14 +11,14 @@ import (
 )
 
 // SetupDevice create a new bridge interface/
-func SetupDevice(i *Interface) error {
+func setupDevice(i *bridgeInterface) error {
 	// We only attempt to create the bridge when the requested device name is
 	// the default one.
 	if i.Config.BridgeName != DefaultBridgeName {
 		return fmt.Errorf("bridge device with non default name %q must be created manually", i.Config.BridgeName)
 	}
 
-	// Set the Interface netlink.Bridge.
+	// Set the bridgeInterface netlink.Bridge.
 	i.Link = &netlink.Bridge{
 		LinkAttrs: netlink.LinkAttrs{
 			Name: i.Config.BridgeName,
@@ -38,7 +38,7 @@ func SetupDevice(i *Interface) error {
 }
 
 // SetupDeviceUp ups the given bridge interface.
-func SetupDeviceUp(i *Interface) error {
+func setupDeviceUp(i *bridgeInterface) error {
 	err := netlink.LinkSetUp(i.Link)
 	if err != nil {
 		return err

libnetwork/drivers/bridge/setup_device_test.go

@@ -13,34 +13,34 @@ import (
 func TestSetupNewBridge(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName: DefaultBridgeName,
 		},
 	}
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
 	if br.Link == nil {
-		t.Fatal("Interface link is nil (expected valid link)")
+		t.Fatal("bridgeInterface link is nil (expected valid link)")
 	}
 	if _, err := netlink.LinkByName(DefaultBridgeName); err != nil {
 		t.Fatalf("Failed to retrieve bridge device: %v", err)
 	}
 	if br.Link.Attrs().Flags&net.FlagUp == net.FlagUp {
-		t.Fatalf("Interface should be created down")
+		t.Fatalf("bridgeInterface should be created down")
 	}
 }
 
 func TestSetupNewNonDefaultBridge(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName: "test0",
 		},
 	}
-	if err := SetupDevice(br); err == nil || !strings.Contains(err.Error(), "non default name") {
+	if err := setupDevice(br); err == nil || !strings.Contains(err.Error(), "non default name") {
 		t.Fatalf("Expected bridge creation failure with \"non default name\", got: %v", err)
 	}
 }
@@ -48,21 +48,21 @@ func TestSetupNewNonDefaultBridge(t *testing.T) {
 func TestSetupDeviceUp(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName: DefaultBridgeName,
 		},
 	}
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
-	if err := SetupDeviceUp(br); err != nil {
+	if err := setupDeviceUp(br); err != nil {
 		t.Fatalf("Failed to up bridge device: %v", err)
 	}
 
 	lnk, _ := netlink.LinkByName(DefaultBridgeName)
 	if lnk.Attrs().Flags&net.FlagUp != net.FlagUp {
-		t.Fatalf("Interface should be up")
+		t.Fatalf("bridgeInterface should be up")
 	}
 }
 

libnetwork/drivers/bridge/setup_fixedcidrv4.go

@@ -7,8 +7,8 @@ import (
 	"github.com/docker/docker/daemon/networkdriver/ipallocator"
 )
 
-func SetupFixedCIDRv4(i *Interface) error {
-	addrv4, _, err := i.Addresses()
+func setupFixedCIDRv4(i *bridgeInterface) error {
+	addrv4, _, err := i.addresses()
 	if err != nil {
 		return err
 	}

libnetwork/drivers/bridge/setup_fixedcidrv4_test.go

@@ -11,21 +11,21 @@ import (
 func TestSetupFixedCIDRv4(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName:  DefaultBridgeName,
 			AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(16, 32)},
 			FixedCIDR:   &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)},
 		},
 	}
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
-	if err := SetupBridgeIPv4(br); err != nil {
+	if err := setupBridgeIPv4(br); err != nil {
 		t.Fatalf("Assign IPv4 to bridge failed: %v", err)
 	}
 
-	if err := SetupFixedCIDRv4(br); err != nil {
+	if err := setupFixedCIDRv4(br); err != nil {
 		t.Fatalf("Failed to setup bridge FixedCIDRv4: %v", err)
 	}
 
@@ -39,21 +39,21 @@ func TestSetupFixedCIDRv4(t *testing.T) {
 func TestSetupBadFixedCIDRv4(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName:  DefaultBridgeName,
 			AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(24, 32)},
 			FixedCIDR:   &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)},
 		},
 	}
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
-	if err := SetupBridgeIPv4(br); err != nil {
+	if err := setupBridgeIPv4(br); err != nil {
 		t.Fatalf("Assign IPv4 to bridge failed: %v", err)
 	}
 
-	if err := SetupFixedCIDRv4(br); err == nil {
+	if err := setupFixedCIDRv4(br); err == nil {
 		t.Fatal("Setup bridge FixedCIDRv4 should have failed")
 	}
 }

libnetwork/drivers/bridge/setup_fixedcidrv6.go

@@ -7,7 +7,7 @@ import (
 	"github.com/docker/docker/daemon/networkdriver/ipallocator"
 )
 
-func SetupFixedCIDRv6(i *Interface) error {
+func setupFixedCIDRv6(i *bridgeInterface) error {
 	log.Debugf("Using IPv6 subnet: %v", i.Config.FixedCIDRv6)
 	if err := ipallocator.RegisterSubnet(i.Config.FixedCIDRv6, i.Config.FixedCIDRv6); err != nil {
 		return fmt.Errorf("Setup FixedCIDRv6 failed for subnet %s in %s: %v", i.Config.FixedCIDRv6, i.Config.FixedCIDRv6, err)

libnetwork/drivers/bridge/setup_fixedcidrv6_test.go

@@ -11,21 +11,21 @@ import (
 func TestSetupFixedCIDRv6(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
-	br := NewInterface(&Configuration{})
+	br := newInterface(&Configuration{})
 
 	_, br.Config.FixedCIDRv6, _ = net.ParseCIDR("2002:db8::/48")
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
-	if err := SetupBridgeIPv4(br); err != nil {
+	if err := setupBridgeIPv4(br); err != nil {
 		t.Fatalf("Assign IPv4 to bridge failed: %v", err)
 	}
 
-	if err := SetupBridgeIPv6(br); err != nil {
+	if err := setupBridgeIPv6(br); err != nil {
 		t.Fatalf("Assign IPv4 to bridge failed: %v", err)
 	}
 
-	if err := SetupFixedCIDRv6(br); err != nil {
+	if err := setupFixedCIDRv6(br); err != nil {
 		t.Fatalf("Failed to setup bridge FixedCIDRv6: %v", err)
 	}
 

libnetwork/drivers/bridge/setup_ip_forwarding.go

@@ -6,18 +6,18 @@ import (
 )
 
 const (
-	IPV4_FORW_CONF_FILE = "/proc/sys/net/ipv4/ip_forward"
-	PERM                = 0644
+	ipv4ForwardConf     = "/proc/sys/net/ipv4/ip_forward"
+	ipv4ForwardConfPerm = 0644
 )
 
-func SetupIPForwarding(i *Interface) error {
+func setupIPForwarding(i *bridgeInterface) error {
 	// Sanity Check
 	if i.Config.EnableIPForwarding == false {
 		return fmt.Errorf("Unexpected request to enable IP Forwarding for: %v", *i)
 	}
 
 	// Enable IPv4 forwarding
-	if err := ioutil.WriteFile(IPV4_FORW_CONF_FILE, []byte{'1', '\n'}, PERM); err != nil {
+	if err := ioutil.WriteFile(ipv4ForwardConf, []byte{'1', '\n'}, ipv4ForwardConfPerm); err != nil {
 		return fmt.Errorf("Setup IP forwarding failed: %v", err)
 	}
 

libnetwork/drivers/bridge/setup_ip_forwarding_test.go

@@ -18,7 +18,7 @@ func TestSetupIPForwarding(t *testing.T) {
 	}
 
 	// Create test interface with ip forwarding setting enabled
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName:         DefaultBridgeName,
 			EnableIPForwarding: true,
@@ -26,7 +26,7 @@ func TestSetupIPForwarding(t *testing.T) {
 	}
 
 	// Set IP Forwarding
-	if err := SetupIPForwarding(br); err != nil {
+	if err := setupIPForwarding(br); err != nil {
 		t.Fatalf("Failed to setup IP forwarding: %v", err)
 	}
 
@@ -43,7 +43,7 @@ func TestUnexpectedSetupIPForwarding(t *testing.T) {
 	defer reconcileIPForwardingSetting(t, procSetting)
 
 	// Create test interface without ip forwarding setting enabled
-	br := &Interface{
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName:         DefaultBridgeName,
 			EnableIPForwarding: false,
@@ -51,7 +51,7 @@ func TestUnexpectedSetupIPForwarding(t *testing.T) {
 	}
 
 	// Attempt Set IP Forwarding
-	if err := SetupIPForwarding(br); err == nil {
+	if err := setupIPForwarding(br); err == nil {
 		t.Fatal("Setup IP forwarding was expected to fail")
 	} else if !strings.Contains(err.Error(), "Unexpected request") {
 		t.Fatalf("Setup IP forwarding failed with unexpected error: %v", err)
@@ -59,7 +59,7 @@ func TestUnexpectedSetupIPForwarding(t *testing.T) {
 }
 
 func readCurrentIPForwardingSetting(t *testing.T) []byte {
-	procSetting, err := ioutil.ReadFile(IPV4_FORW_CONF_FILE)
+	procSetting, err := ioutil.ReadFile(ipv4ForwardConf)
 	if err != nil {
 		t.Fatalf("Can't execute test: Failed to read current IP forwarding setting: %v", err)
 	}
@@ -67,7 +67,7 @@ func readCurrentIPForwardingSetting(t *testing.T) []byte {
 }
 
 func writeIPForwardingSetting(t *testing.T, chars []byte) {
-	err := ioutil.WriteFile(IPV4_FORW_CONF_FILE, chars, PERM)
+	err := ioutil.WriteFile(ipv4ForwardConf, chars, ipv4ForwardConfPerm)
 	if err != nil {
 		t.Fatalf("Can't execute or cleanup after test: Failed to reset IP forwarding: %v", err)
 	}

libnetwork/drivers/bridge/setup_ipv4.go

@@ -40,7 +40,7 @@ func init() {
 	}
 }
 
-func SetupBridgeIPv4(i *Interface) error {
+func setupBridgeIPv4(i *bridgeInterface) error {
 	bridgeIPv4, err := electBridgeIPv4(i.Config)
 	if err != nil {
 		return err

libnetwork/drivers/bridge/setup_ipv4_test.go

@@ -8,13 +8,13 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func setupTestInterface(t *testing.T) *Interface {
-	br := &Interface{
+func setupTestInterface(t *testing.T) *bridgeInterface {
+	br := &bridgeInterface{
 		Config: &Configuration{
 			BridgeName: DefaultBridgeName,
 		},
 	}
-	if err := SetupDevice(br); err != nil {
+	if err := setupDevice(br); err != nil {
 		t.Fatalf("Bridge creation failed: %v", err)
 	}
 	return br
@@ -30,7 +30,7 @@ func TestSetupBridgeIPv4Fixed(t *testing.T) {
 
 	br := setupTestInterface(t)
 	br.Config.AddressIPv4 = &net.IPNet{IP: ip, Mask: netw.Mask}
-	if err := SetupBridgeIPv4(br); err != nil {
+	if err := setupBridgeIPv4(br); err != nil {
 		t.Fatalf("Failed to setup bridge IPv4: %v", err)
 	}
 
@@ -56,7 +56,7 @@ func TestSetupBridgeIPv4Auto(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
 	br := setupTestInterface(t)
-	if err := SetupBridgeIPv4(br); err != nil {
+	if err := setupBridgeIPv4(br); err != nil {
 		t.Fatalf("Failed to setup bridge IPv4: %v", err)
 	}
 

libnetwork/drivers/bridge/setup_ipv6.go

@@ -8,29 +8,29 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-var BridgeIPv6 *net.IPNet
+var bridgeIPv6 *net.IPNet
 
-const BridgeIPv6Str = "fe80::1/64"
+const bridgeIPv6Str = "fe80::1/64"
 
 func init() {
 	// We allow ourselves to panic in this special case because we indicate a
 	// failure to parse a compile-time define constant.
-	if ip, netw, err := net.ParseCIDR(BridgeIPv6Str); err == nil {
-		BridgeIPv6 = &net.IPNet{IP: ip, Mask: netw.Mask}
+	if ip, netw, err := net.ParseCIDR(bridgeIPv6Str); err == nil {
+		bridgeIPv6 = &net.IPNet{IP: ip, Mask: netw.Mask}
 	} else {
-		panic(fmt.Sprintf("Cannot parse default bridge IPv6 address %q: %v", BridgeIPv6Str, err))
+		panic(fmt.Sprintf("Cannot parse default bridge IPv6 address %q: %v", bridgeIPv6Str, err))
 	}
 }
 
-func SetupBridgeIPv6(i *Interface) error {
+func setupBridgeIPv6(i *bridgeInterface) error {
 	// Enable IPv6 on the bridge
 	procFile := "/proc/sys/net/ipv6/conf/" + i.Config.BridgeName + "/disable_ipv6"
 	if err := ioutil.WriteFile(procFile, []byte{'0', '\n'}, 0644); err != nil {
 		return fmt.Errorf("Unable to enable IPv6 addresses on bridge: %v", err)
 	}
 
-	if err := netlink.AddrAdd(i.Link, &netlink.Addr{BridgeIPv6, ""}); err != nil {
-		return fmt.Errorf("Failed to add IPv6 address %s to bridge: %v", BridgeIPv6, err)
+	if err := netlink.AddrAdd(i.Link, &netlink.Addr{bridgeIPv6, ""}); err != nil {
+		return fmt.Errorf("Failed to add IPv6 address %s to bridge: %v", bridgeIPv6, err)
 	}
 
 	return nil

libnetwork/drivers/bridge/setup_ipv6_test.go

@@ -14,7 +14,7 @@ func TestSetupIPv6(t *testing.T) {
 	defer libnetwork.SetupTestNetNS(t)()
 
 	br := setupTestInterface(t)
-	if err := SetupBridgeIPv6(br); err != nil {
+	if err := setupBridgeIPv6(br); err != nil {
 		t.Fatalf("Failed to setup bridge IPv6: %v", err)
 	}
 
@@ -34,14 +34,14 @@ func TestSetupIPv6(t *testing.T) {
 
 	var found bool
 	for _, addr := range addrsv6 {
-		if BridgeIPv6Str == addr.IPNet.String() {
+		if bridgeIPv6Str == addr.IPNet.String() {
 			found = true
 			break
 		}
 	}
 
 	if !found {
-		t.Fatalf("Bridge device does not have requested IPv6 address %v", BridgeIPv6Str)
+		t.Fatalf("Bridge device does not have requested IPv6 address %v", bridgeIPv6Str)
 	}
 
 }

libnetwork/drivers/bridge/setup_verify.go

@@ -6,9 +6,9 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func SetupVerifyConfiguredAddresses(i *Interface) error {
+func setupVerifyConfiguredAddresses(i *bridgeInterface) error {
 	// Fetch a single IPv4 and a slice of IPv6 addresses from the bridge.
-	addrv4, addrsv6, err := i.Addresses()
+	addrv4, addrsv6, err := i.addresses()
 	if err != nil {
 		return err
 	}
@@ -25,8 +25,8 @@ func SetupVerifyConfiguredAddresses(i *Interface) error {
 
 	// Verify that one of the bridge IPv6 addresses matches the requested
 	// configuration.
-	if i.Config.EnableIPv6 && !findIPv6Address(netlink.Addr{IPNet: BridgeIPv6}, addrsv6) {
-		return fmt.Errorf("Bridge IPv6 addresses do not match the expected bridge configuration %s", BridgeIPv6)
+	if i.Config.EnableIPv6 && !findIPv6Address(netlink.Addr{IPNet: bridgeIPv6}, addrsv6) {
+		return fmt.Errorf("Bridge IPv6 addresses do not match the expected bridge configuration %s", bridgeIPv6)
 	}
 
 	return nil

libnetwork/drivers/bridge/setup_verify_test.go

@@ -8,8 +8,8 @@ import (
 	"github.com/vishvananda/netlink"
 )
 
-func setupVerifyTest(t *testing.T) *Interface {
-	inf := &Interface{Config: &Configuration{}}
+func setupVerifyTest(t *testing.T) *bridgeInterface {
+	inf := &bridgeInterface{Config: &Configuration{}}
 
 	br := netlink.Bridge{}
 	br.LinkAttrs.Name = "default0"
@@ -33,7 +33,7 @@ func TestSetupVerify(t *testing.T) {
 		t.Fatalf("Failed to assign IPv4 %s to interface: %v", inf.Config.AddressIPv4, err)
 	}
 
-	if err := SetupVerifyConfiguredAddresses(inf); err != nil {
+	if err := setupVerifyConfiguredAddresses(inf); err != nil {
 		t.Fatalf("Address verification failed: %v", err)
 	}
 }
@@ -50,7 +50,7 @@ func TestSetupVerifyBad(t *testing.T) {
 		t.Fatalf("Failed to assign IPv4 %s to interface: %v", ipnet, err)
 	}
 
-	if err := SetupVerifyConfiguredAddresses(inf); err == nil {
+	if err := setupVerifyConfiguredAddresses(inf); err == nil {
 		t.Fatal("Address verification was expected to fail")
 	}
 }
@@ -62,7 +62,7 @@ func TestSetupVerifyMissing(t *testing.T) {
 	inf := setupVerifyTest(t)
 	inf.Config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 
-	if err := SetupVerifyConfiguredAddresses(inf); err == nil {
+	if err := setupVerifyConfiguredAddresses(inf); err == nil {
 		t.Fatal("Address verification was expected to fail")
 	}
 }
@@ -75,14 +75,14 @@ func TestSetupVerifyIPv6(t *testing.T) {
 	inf.Config.AddressIPv4 = &net.IPNet{IP: addrv4, Mask: addrv4.DefaultMask()}
 	inf.Config.EnableIPv6 = true
 
-	if err := netlink.AddrAdd(inf.Link, &netlink.Addr{IPNet: BridgeIPv6}); err != nil {
-		t.Fatalf("Failed to assign IPv6 %s to interface: %v", BridgeIPv6, err)
+	if err := netlink.AddrAdd(inf.Link, &netlink.Addr{IPNet: bridgeIPv6}); err != nil {
+		t.Fatalf("Failed to assign IPv6 %s to interface: %v", bridgeIPv6, err)
 	}
 	if err := netlink.AddrAdd(inf.Link, &netlink.Addr{IPNet: inf.Config.AddressIPv4}); err != nil {
 		t.Fatalf("Failed to assign IPv4 %s to interface: %v", inf.Config.AddressIPv4, err)
 	}
 
-	if err := SetupVerifyConfiguredAddresses(inf); err != nil {
+	if err := setupVerifyConfiguredAddresses(inf); err != nil {
 		t.Fatalf("Address verification failed: %v", err)
 	}
 }
@@ -99,7 +99,7 @@ func TestSetupVerifyIPv6Missing(t *testing.T) {
 		t.Fatalf("Failed to assign IPv4 %s to interface: %v", inf.Config.AddressIPv4, err)
 	}
 
-	if err := SetupVerifyConfiguredAddresses(inf); err == nil {
+	if err := setupVerifyConfiguredAddresses(inf); err == nil {
 		t.Fatal("Address verification was expected to fail")
 	}
 }

libnetwork/network.go

@@ -96,13 +96,14 @@ type Namespace interface {
 	AddInterface(*Interface) error
 }
 
-// Create a new network of the specified networkType. The options are driver
-// specific and modeled in a generic way.
+// NewNetwork creates a new network of the specified networkType. The options
+// are driver specific and modeled in a generic way.
 func NewNetwork(networkType, name string, options DriverParams) (Network, error) {
 	return createNetwork(networkType, name, options)
 }
 
-// Create a new network namespace mounted on the specified path.
+// NewNetworkNamespace creates a new network namespace mounted on the specified
+// path.
 func NewNetworkNamespace(path string) (Namespace, error) {
 	return createNetworkNamespace(path)
 }

libnetwork/pkg/options/options.go

@@ -1,4 +1,4 @@
-// The options package provides a way to pass unstructured sets of options to a
+// Package options provides a way to pass unstructured sets of options to a
 // component expecting a strongly-typed configuration structure.
 package options
 
@@ -7,6 +7,8 @@ import (
 	"reflect"
 )
 
+// NoSuchFieldError is the error returned when the generic parameters hold a
+// value for a field absent from the destination structure.
 type NoSuchFieldError struct {
 	Field string
 	Type  string
@@ -16,6 +18,8 @@ func (e NoSuchFieldError) Error() string {
 	return fmt.Sprintf("no field %q in type %q", e.Field, e.Type)
 }
 
+// CannotSetFieldError is the error returned when the generic parameters hold a
+// value for a field that cannot be set in the destination structure.
 type CannotSetFieldError struct {
 	Field string
 	Type  string
@@ -25,12 +29,20 @@ func (e CannotSetFieldError) Error() string {
 	return fmt.Sprintf("cannot set field %q of type %q", e.Field, e.Type)
 }
 
+// Generic is an basic type to store arbitrary settings.
 type Generic map[string]interface{}
 
+// NewGeneric returns a new Generic instance.
 func NewGeneric() Generic {
 	return make(Generic)
 }
 
+// GenerateFromModel takes the generic options, and tries to build a new
+// instance of the model's type by matching keys from the generic options to
+// fields in the model.
+//
+// The return value is of the same type than the model (including a potential
+// pointer qualifier).
 func GenerateFromModel(options Generic, model interface{}) (interface{}, error) {
 	modType := reflect.TypeOf(model)
 

libnetwork/reexec_move_interface.go

@@ -64,7 +64,7 @@ func setupInNS(nsPath string, settings *Interface) error {
 
 	// Move the executing code to the destination namespace so we can start
 	// configure the interface.
-	if err := Setns(nsFD, syscall.CLONE_NEWNET); err != nil {
+	if err := setns(nsFD, syscall.CLONE_NEWNET); err != nil {
 		return err
 	}
 

libnetwork/system.go

@@ -19,7 +19,7 @@ var setNsMap = map[string]uintptr{
 	"linux/s390x":   339,
 }
 
-func Setns(fd uintptr, flags uintptr) error {
+func setns(fd uintptr, flags uintptr) error {
 	ns, exists := setNsMap[fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)]
 	if !exists {
 		return fmt.Errorf("unsupported platform %s/%s", runtime.GOOS, runtime.GOARCH)