mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
614d82390c
In the present code, each driver package provides a `New()` method which constructs a driver of its type, which is then registered with the controller. However, this is not suitable for the `drivers/remote` package, since it does not provide a (singleton) driver, but a mechanism for drivers to be added dynamically. As a result, the implementation is oddly dual-purpose, and a spurious `"remote"` driver is added to the controller's list of available drivers. Instead, it is better to provide the registration callback to each package and let it register its own driver or drivers. That way, the singleton driver packages can construct one and register it, and the remote package can hook the callback up with whatever the dynamic driver mechanism turns out to be. NB there are some method signature changes; in particular to controller.New, which can return an error if the built-in driver packages fail to initialise. Signed-off-by: Michael Bridgen <mikeb@squaremobius.net> |
||
|---|---|---|
| .. | ||
| readme.go | ||
package main
import (
"fmt"
"github.com/docker/libnetwork"
"github.com/docker/libnetwork/netutils"
"github.com/docker/libnetwork/pkg/netlabel"
"github.com/docker/libnetwork/pkg/options"
)
func main() {
// Create a new controller instance
controller, err := libnetwork.New()
if err != nil {
return
}
// Select and configure the network driver
networkType := "bridge"
driverOptions := options.Generic{}
genericOption := make(map[string]interface{})
genericOption[netlabel.GenericData] = driverOptions
err = controller.ConfigureNetworkDriver(networkType, genericOption)
if err != nil {
return
}
// Create a network for containers to join.
// NewNetwork accepts Variadic optional arguments that libnetwork and Drivers can make of
network, err := controller.NewNetwork(networkType, "network1")
if err != nil {
return
}
// For each new container: allocate IP and interfaces. The returned network
// settings will be used for container infos (inspect and such), as well as
// iptables rules for port publishing. This info is contained or accessible
// from the returned endpoint.
ep, err := network.CreateEndpoint("Endpoint1")
if err != nil {
return
}
// A container can join the endpoint by providing the container ID to the join
// api which returns the sandbox key which can be used to access the sandbox
// created for the container during join.
// Join acceps Variadic arguments which will be made use of by libnetwork and Drivers
_, err = ep.Join("container1",
libnetwork.JoinOptionHostname("test"),
libnetwork.JoinOptionDomainname("docker.io"))
if err != nil {
return
}
// libentwork client can check the endpoint's operational data via the Info() API
epInfo, err := ep.Info()
mapData, ok := epInfo[netlabel.PortMap]
if ok {
portMapping, ok := mapData.([]netutils.PortBinding)
if ok {
fmt.Printf("Current port mapping for endpoint %s: %v", ep.Name(), portMapping)
}
}
}