func RunServer(ctx context.Context, sm subnet.Manager, listenAddr, cafile, certfile, keyfile string) {
// {network} is always required a the API level but to
// keep backward compat, special "_" network is allowed
// that means "no network"
r := mux.NewRouter()
r.HandleFunc("/v1/{network}/config", bindHandler(handleGetNetworkConfig, ctx, sm)).Methods("GET")
r.HandleFunc("/v1/{network}/leases", bindHandler(handleAcquireLease, ctx, sm)).Methods("POST")
r.HandleFunc("/v1/{network}/leases/{subnet}", bindHandler(handleRenewLease, ctx, sm)).Methods("PUT")
r.HandleFunc("/v1/{network}/leases", bindHandler(handleWatchLeases, ctx, sm)).Methods("GET")
r.HandleFunc("/v1/", bindHandler(handleNetworks, ctx, sm)).Methods("GET")
l, err := listener(listenAddr, cafile, certfile, keyfile)
if err != nil {
log.Errorf("Error listening on %v: %v", listenAddr, err)
return
}
c := make(chan error, 1)
go func() {
c <- http.Serve(l, httpLogger(r))
}()
daemon.SdNotify("READY=1")
select {
case <-ctx.Done():
l.Close()
<-c
case err := <-c:
log.Errorf("Error serving on %v: %v", listenAddr, err)
}
}
func run(be backend.Backend, exit chan int) {
var err error
defer func() {
if err == nil || err == task.ErrCanceled {
exit <- 0
} else {
log.Error(err)
exit <- 1
}
}()
iface, ipaddr, err := lookupIface()
if err != nil {
return
}
if iface.MTU == 0 {
err = fmt.Errorf("Failed to determine MTU for %s interface", ipaddr)
return
}
log.Infof("Using %s as external interface", ipaddr)
sn, err := be.Init(iface, ipaddr, opts.ipMasq)
if err != nil {
log.Error("Could not init %v backend: %v", be.Name(), err)
return
}
writeSubnetFile(sn)
daemon.SdNotify("READY=1")
log.Infof("%s mode initialized", be.Name())
be.Run()
}
func initAndRun(ctx context.Context, sm subnet.Manager, netnames []string) {
iface, iaddr, err := lookupIface()
if err != nil {
log.Error(err)
return
}
if iface.MTU == 0 {
log.Errorf("Failed to determine MTU for %s interface", iaddr)
return
}
var eaddr net.IP
if len(opts.publicIP) > 0 {
eaddr = net.ParseIP(opts.publicIP)
}
if eaddr == nil {
eaddr = iaddr
}
log.Infof("Using %s as external interface", iaddr)
log.Infof("Using %s as external endpoint", eaddr)
nets := []*network.Network{}
for _, n := range netnames {
nets = append(nets, network.New(sm, n, opts.ipMasq))
}
wg := sync.WaitGroup{}
for _, n := range nets {
go func(n *network.Network) {
wg.Add(1)
defer wg.Done()
sn := n.Init(ctx, iface, iaddr, eaddr)
if sn != nil {
if isMultiNetwork() {
path := filepath.Join(opts.subnetDir, n.Name) + ".env"
if err := writeSubnetFile(path, n.Config.Network, sn); err != nil {
return
}
} else {
if err := writeSubnetFile(opts.subnetFile, n.Config.Network, sn); err != nil {
return
}
daemon.SdNotify("READY=1")
}
n.Run(ctx)
log.Infof("%v exited", n.Name)
}
}(n)
}
wg.Wait()
}
func (m *Manager) runNetwork(n *Network) {
n.Run(m.extIface, func(bn backend.Network) {
if m.isMultiNetwork() {
path := filepath.Join(opts.subnetDir, n.Name) + ".env"
if err := writeSubnetFile(path, n.Config.Network, m.ipMasq, bn); err != nil {
log.Warningf("%v failed to write subnet file: %s", n.Name, err)
return
}
} else {
if err := writeSubnetFile(opts.subnetFile, n.Config.Network, m.ipMasq, bn); err != nil {
log.Warningf("%v failed to write subnet file: %s", n.Name, err)
return
}
daemon.SdNotify("READY=1")
}
})
m.delNetwork(n)
}
func (m *Manager) RunNetwork(net *Network) {
sn := net.Init(m.extIface, m.iaddr, m.eaddr)
if sn != nil {
if m.isMultiNetwork() {
path := filepath.Join(opts.subnetDir, net.Name) + ".env"
if err := writeSubnetFile(path, net.Config.Network, m.ipMasq, sn); err != nil {
log.Warningf("%v failed to write subnet file: %s", net.Name, err)
return
}
} else {
if err := writeSubnetFile(opts.subnetFile, net.Config.Network, m.ipMasq, sn); err != nil {
log.Warningf("%v failed to write subnet file: %s", net.Name, err)
return
}
daemon.SdNotify("READY=1")
}
log.Infof("Running network %v", net.Name)
net.Run()
log.Infof("%v exited", net.Name)
}
}