func (vb *VXLANBackend) handleSubnetEvents(batch subnet.EventBatch) { for _, evt := range batch { switch evt.Type { case subnet.SubnetAdded: log.Info("Subnet added: ", evt.Lease.Network) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } if err := vb.dev.AddL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error adding L2 entry: ", err) } if err := vb.dev.AddL3(neigh{IP: evt.Lease.Network.IP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error adding L3 entry: ", err) } if err := vb.dev.AddRoute(evt.Lease.Network); err != nil { log.Error("Error adding route: ", err) } case subnet.SubnetRemoved: log.Info("Subnet removed: ", evt.Lease.Network) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } if err := vb.dev.DelRoute(evt.Lease.Network); err != nil { log.Error("Error deleting route: ", err) } if len(attrs.VtepMAC) > 0 { if err := vb.dev.DelL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error deleting L2 entry: ", err) } if err := vb.dev.DelL3(neigh{IP: evt.Lease.Network.IP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error deleting L3 entry: ", err) } } default: log.Error("Internal error: unknown event type: ", int(evt.Type)) } } }
func main() { // glog will log to tmp files by default. override so all entries // can flow into journald (if running under systemd) flag.Set("logtostderr", "true") // now parse command line args flag.Parse() if opts.help { fmt.Fprintf(os.Stderr, "Usage: %s [OPTION]...\n", os.Args[0]) flag.PrintDefaults() os.Exit(0) } if opts.version { fmt.Fprintln(os.Stderr, version.String()) os.Exit(0) } flagsFromEnv("FLANNELD", flag.CommandLine) be, sm, err := newBackend() if err != nil { log.Info(err) os.Exit(1) } // Register for SIGINT and SIGTERM and wait for one of them to arrive log.Info("Installing signal handlers") sigs := make(chan os.Signal, 1) signal.Notify(sigs, os.Interrupt, syscall.SIGTERM) exit := make(chan int) go run(be, sm, exit) for { select { case <-sigs: // unregister to get default OS nuke behaviour in case we don't exit cleanly signal.Stop(sigs) log.Info("Exiting...") be.Stop() case code := <-exit: log.Infof("%s mode exited", be.Name()) os.Exit(code) } } }
func lookupIface() (*net.Interface, net.IP, error) { var iface *net.Interface var ipaddr net.IP var err error if len(opts.iface) > 0 { if ipaddr = net.ParseIP(opts.iface); ipaddr != nil { iface, err = ip.GetInterfaceByIP(ipaddr) if err != nil { return nil, nil, fmt.Errorf("Error looking up interface %s: %s", opts.iface, err) } } else { iface, err = net.InterfaceByName(opts.iface) if err != nil { return nil, nil, fmt.Errorf("Error looking up interface %s: %s", opts.iface, err) } } } else { log.Info("Determining IP address of default interface") if iface, err = ip.GetDefaultGatewayIface(); err != nil { return nil, nil, fmt.Errorf("Failed to get default interface: %s", err) } } if ipaddr == nil { ipaddr, err = ip.GetIfaceIP4Addr(iface) if err != nil { return nil, nil, fmt.Errorf("Failed to find IPv4 address for interface %s", iface.Name) } } return iface, ipaddr, nil }
func (sm *SubnetManager) LeaseRenewer(cancel chan bool) { for { dur := sm.leaseExp.Sub(time.Now()) - renewMargin select { case <-time.After(dur): sm.mtx.RLock() attrBytes, err := json.Marshal(&sm.myLease.Attrs) sm.mtx.RUnlock() if err != nil { log.Error("Error renewing lease (trying again in 1 min): ", err) dur = time.Minute continue } sm.mtx.RLock() resp, err := sm.registry.UpdateSubnet(sm.myLease.Network.StringSep(".", "-"), string(attrBytes), subnetTTL) sm.mtx.RUnlock() if err != nil { log.Error("Error renewing lease (trying again in 1 min): ", err) dur = time.Minute continue } sm.leaseExp = *resp.Expiration log.Info("Lease renewed, new expiration: ", sm.leaseExp) dur = sm.leaseExp.Sub(time.Now()) - renewMargin case <-cancel: return } } }
func (vb *VXLANBackend) Run() { vb.wg.Add(1) go func() { vb.sm.LeaseRenewer(vb.stop) vb.wg.Done() }() log.Info("Watching for new subnet leases") evts := make(chan subnet.EventBatch) vb.wg.Add(1) go func() { vb.sm.WatchLeases(evts, vb.stop) vb.wg.Done() }() defer vb.wg.Wait() for { select { case evtBatch := <-evts: vb.handleSubnetEvents(evtBatch) case <-vb.stop: return } } }
func (rb *HostgwBackend) Run() { rb.wg.Add(1) go func() { rb.sm.LeaseRenewer(rb.stop) rb.wg.Done() }() log.Info("Watching for new subnet leases") evts := make(chan subnet.EventBatch) rb.wg.Add(1) go func() { rb.sm.WatchLeases(evts, rb.stop) rb.wg.Done() }() defer rb.wg.Wait() for { select { case evtBatch := <-evts: rb.handleSubnetEvents(evtBatch) case <-rb.stop: return } } }
func setupIpMasq(localNet ip.IP4Net, overlayNet ip.IP4Net) error { ipt, err := ip.NewIPTables() if err != nil { return err } err = ipt.ClearChain("nat", "FLANNEL") if err != nil { return fmt.Errorf("Failed to create/clear FLANNEL chain in NAT table: %v", err) } rules := [][]string{ {"FLANNEL", "-s", localNet.String(), "-o", "lo", "-j", "ACCEPT"}, {"FLANNEL", "-s", localNet.String(), "!", "-d", overlayNet.String(), "-j", "MASQUERADE"}, {"POSTROUTING", "-s", localNet.String(), "-j", "FLANNEL"}, } for _, args := range rules { log.Info("Adding iptables rule: ", strings.Join(args, " ")) if err := ipt.AppendUnique("nat", args...); err != nil { return fmt.Errorf("Failed to insert IP masquerade rule: %v", err) } } return nil }
func (rb *HostgwBackend) handleSubnetEvents(batch subnet.EventBatch) { for _, evt := range batch { switch evt.Type { case subnet.SubnetAdded: log.Infof("Subnet added: %v via %v", evt.Lease.Network, evt.Lease.Attrs.PublicIP) if evt.Lease.Attrs.BackendType != "host-gw" { log.Warningf("Ignoring non-host-gw subnet: type=%v", evt.Lease.Attrs.BackendType) continue } route := netlink.Route{ Dst: evt.Lease.Network.ToIPNet(), Gw: evt.Lease.Attrs.PublicIP.ToIP(), LinkIndex: rb.extIface.Index, } if err := netlink.RouteAdd(&route); err != nil { log.Errorf("Error adding route to %v via %v: %v", evt.Lease.Network, evt.Lease.Attrs.PublicIP, err) continue } case subnet.SubnetRemoved: log.Info("Subnet removed: ", evt.Lease.Network) if evt.Lease.Attrs.BackendType != "host-gw" { log.Warningf("Ignoring non-host-gw subnet: type=%v", evt.Lease.Attrs.BackendType) continue } route := netlink.Route{ Dst: evt.Lease.Network.ToIPNet(), Gw: evt.Lease.Attrs.PublicIP.ToIP(), LinkIndex: rb.extIface.Index, } if err := netlink.RouteDel(&route); err != nil { log.Errorf("Error deleting route to %v: %v", evt.Lease.Network, err) continue } default: log.Error("Internal error: unknown event type: ", int(evt.Type)) } } }
func (sm *SubnetManager) AcquireLease(attrs *LeaseAttrs, cancel chan bool) (ip.IP4Net, error) { for { sn, err := sm.acquireLeaseOnce(attrs, cancel) switch { case err == nil: log.Info("Subnet lease acquired: ", sn) return sn, nil case err == task.ErrCanceled: return ip.IP4Net{}, err default: log.Error("Failed to acquire subnet: ", err) } select { case <-time.After(time.Second): case <-cancel: return ip.IP4Net{}, task.ErrCanceled } } }