| package libnetwork |
| |
| import ( |
| "fmt" |
| "strings" |
| |
| "github.com/docker/libnetwork/netlabel" |
| "github.com/docker/libnetwork/types" |
| "github.com/sirupsen/logrus" |
| ) |
| |
| const ( |
| gwEPlen = 12 |
| ) |
| |
| var procGwNetwork = make(chan (bool), 1) |
| |
| /* |
| libnetwork creates a bridge network "docker_gw_bridge" for providing |
| default gateway for the containers if none of the container's endpoints |
| have GW set by the driver. ICC is set to false for the GW_bridge network. |
| |
| If a driver can't provide external connectivity it can choose to not set |
| the GW IP for the endpoint. |
| |
| endpoint on the GW_bridge network is managed dynamically by libnetwork. |
| ie: |
| - its created when an endpoint without GW joins the container |
| - its deleted when an endpoint with GW joins the container |
| */ |
| |
| func (sb *sandbox) setupDefaultGW() error { |
| |
| // check if the container already has a GW endpoint |
| if ep := sb.getEndpointInGWNetwork(); ep != nil { |
| return nil |
| } |
| |
| c := sb.controller |
| |
| // Look for default gw network. In case of error (includes not found), |
| // retry and create it if needed in a serialized execution. |
| n, err := c.NetworkByName(libnGWNetwork) |
| if err != nil { |
| if n, err = c.defaultGwNetwork(); err != nil { |
| return err |
| } |
| } |
| |
| createOptions := []EndpointOption{CreateOptionAnonymous()} |
| |
| var gwName string |
| if len(sb.containerID) <= gwEPlen { |
| gwName = "gateway_" + sb.containerID |
| } else { |
| gwName = "gateway_" + sb.id[:gwEPlen] |
| } |
| |
| sbLabels := sb.Labels() |
| |
| if sbLabels[netlabel.PortMap] != nil { |
| createOptions = append(createOptions, CreateOptionPortMapping(sbLabels[netlabel.PortMap].([]types.PortBinding))) |
| } |
| |
| if sbLabels[netlabel.ExposedPorts] != nil { |
| createOptions = append(createOptions, CreateOptionExposedPorts(sbLabels[netlabel.ExposedPorts].([]types.TransportPort))) |
| } |
| |
| epOption := getPlatformOption() |
| if epOption != nil { |
| createOptions = append(createOptions, epOption) |
| } |
| |
| newEp, err := n.CreateEndpoint(gwName, createOptions...) |
| if err != nil { |
| return fmt.Errorf("container %s: endpoint create on GW Network failed: %v", sb.containerID, err) |
| } |
| |
| defer func() { |
| if err != nil { |
| if err2 := newEp.Delete(true); err2 != nil { |
| logrus.Warnf("Failed to remove gw endpoint for container %s after failing to join the gateway network: %v", |
| sb.containerID, err2) |
| } |
| } |
| }() |
| |
| epLocal := newEp.(*endpoint) |
| |
| if err = epLocal.sbJoin(sb); err != nil { |
| return fmt.Errorf("container %s: endpoint join on GW Network failed: %v", sb.containerID, err) |
| } |
| |
| return nil |
| } |
| |
| // If present, detach and remove the endpoint connecting the sandbox to the default gw network. |
| func (sb *sandbox) clearDefaultGW() error { |
| var ep *endpoint |
| |
| if ep = sb.getEndpointInGWNetwork(); ep == nil { |
| return nil |
| } |
| if err := ep.sbLeave(sb, false); err != nil { |
| return fmt.Errorf("container %s: endpoint leaving GW Network failed: %v", sb.containerID, err) |
| } |
| if err := ep.Delete(false); err != nil { |
| return fmt.Errorf("container %s: deleting endpoint on GW Network failed: %v", sb.containerID, err) |
| } |
| return nil |
| } |
| |
| // Evaluate whether the sandbox requires a default gateway based |
| // on the endpoints to which it is connected. It does not account |
| // for the default gateway network endpoint. |
| |
| func (sb *sandbox) needDefaultGW() bool { |
| var needGW bool |
| |
| for _, ep := range sb.getConnectedEndpoints() { |
| if ep.endpointInGWNetwork() { |
| continue |
| } |
| if ep.getNetwork().Type() == "null" || ep.getNetwork().Type() == "host" { |
| continue |
| } |
| if ep.getNetwork().Internal() { |
| continue |
| } |
| // During stale sandbox cleanup, joinInfo may be nil |
| if ep.joinInfo != nil && ep.joinInfo.disableGatewayService { |
| continue |
| } |
| // TODO v6 needs to be handled. |
| if len(ep.Gateway()) > 0 { |
| return false |
| } |
| for _, r := range ep.StaticRoutes() { |
| if r.Destination != nil && r.Destination.String() == "0.0.0.0/0" { |
| return false |
| } |
| } |
| needGW = true |
| } |
| |
| return needGW |
| } |
| |
| func (sb *sandbox) getEndpointInGWNetwork() *endpoint { |
| for _, ep := range sb.getConnectedEndpoints() { |
| if ep.getNetwork().name == libnGWNetwork && strings.HasPrefix(ep.Name(), "gateway_") { |
| return ep |
| } |
| } |
| return nil |
| } |
| |
| func (ep *endpoint) endpointInGWNetwork() bool { |
| if ep.getNetwork().name == libnGWNetwork && strings.HasPrefix(ep.Name(), "gateway_") { |
| return true |
| } |
| return false |
| } |
| |
| func (sb *sandbox) getEPwithoutGateway() *endpoint { |
| for _, ep := range sb.getConnectedEndpoints() { |
| if ep.getNetwork().Type() == "null" || ep.getNetwork().Type() == "host" { |
| continue |
| } |
| if len(ep.Gateway()) == 0 { |
| return ep |
| } |
| } |
| return nil |
| } |
| |
| // Looks for the default gw network and creates it if not there. |
| // Parallel executions are serialized. |
| func (c *controller) defaultGwNetwork() (Network, error) { |
| procGwNetwork <- true |
| defer func() { <-procGwNetwork }() |
| |
| n, err := c.NetworkByName(libnGWNetwork) |
| if _, ok := err.(types.NotFoundError); ok { |
| n, err = c.createGWNetwork() |
| } |
| return n, err |
| } |
| |
| // Returns the endpoint which is providing external connectivity to the sandbox |
| func (sb *sandbox) getGatewayEndpoint() *endpoint { |
| for _, ep := range sb.getConnectedEndpoints() { |
| if ep.getNetwork().Type() == "null" || ep.getNetwork().Type() == "host" { |
| continue |
| } |
| if len(ep.Gateway()) != 0 { |
| return ep |
| } |
| } |
| return nil |
| } |