func initEnv(ctx *cli.Context) error {
if ctx.GlobalBool("debug") {
common.SetupLOG(log, "DEBUG")
} else {
common.SetupLOG(log, "INFO")
}
if noDaemon {
client = NewLBClient()
} else {
var (
c *cnc.Client
err error
)
if host := ctx.GlobalString("host"); host == "" {
c, err = cnc.NewDefaultClient()
} else {
c, err = cnc.NewClient(host, nil)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error while creating cilium-client: %s\n", err)
return fmt.Errorf("Error while creating cilium-client: %s", err)
}
client = c
}
return nil
}
// NewDriver creates and returns a new Driver for the given ctx.
func NewDriver(ctx *cli.Context) (Driver, error) {
var nodeAddress string
c, err := cnc.NewDefaultClient()
if err != nil {
log.Fatalf("Error while starting cilium-client: %s", err)
}
for tries := 0; tries < 10; tries++ {
if res, err := c.Ping(); err != nil {
if tries == 9 {
log.Fatalf("Unable to reach cilium daemon: %s", err)
} else {
log.Warningf("Waiting for cilium daemon to come up...")
}
time.Sleep(time.Duration(tries) * time.Second)
} else {
nodeAddress = res.NodeAddress
log.Infof("Received node address from daemon: %s", nodeAddress)
break
}
}
d := &driver{
client: c,
nodeAddress: net.ParseIP(nodeAddress),
}
log.Infof("New Cilium networking instance on node %s", nodeAddress)
return d, nil
}
func cmdDel(args *skel.CmdArgs) error {
c, err := cnc.NewDefaultClient()
if err != nil {
return fmt.Errorf("error while starting cilium-client: %s", err)
}
ep, err := c.EndpointGetByDockerID(args.ContainerID)
if err != nil {
return fmt.Errorf("error while retrieving endpoint from cilium daemon: %s", err)
}
if ep == nil {
return fmt.Errorf("endpoint with container ID %s not found", args.ContainerID)
}
ipv6addr := ep.IPv6.IP()
if err = c.ReleaseIP(ipam.CNIIPAMType, ipam.IPAMReq{IP: &ipv6addr}); err != nil {
log.Warningf("failed to release allocated IPv6 of container ID %q: %s", args.ContainerID, err)
}
ipv4addr := ep.IPv4.IP()
if ep.IPv4 != nil {
if err = c.ReleaseIP(ipam.CNIIPAMType, ipam.IPAMReq{IP: &ipv4addr}); err != nil {
log.Warningf("failed to release allocated IPv4 of container ID %q: %s", args.ContainerID, err)
}
}
if err := c.EndpointLeave(ep.ID); err != nil {
log.Warningf("leaving the endpoint failed: %s\n", err)
}
return ns.WithNetNSPath(args.Netns, func(_ ns.NetNS) error {
return plugins.DelLinkByName(args.IfName)
})
}
func statusDaemon(ctx *cli.Context) {
var (
client *cnc.Client
err error
)
if host := ctx.GlobalString("host"); host == "" {
client, err = cnc.NewDefaultClient()
} else {
client, err = cnc.NewClient(host, nil)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error while creating cilium-client: %s\n", err)
os.Exit(1)
}
if sr, err := client.GlobalStatus(); err != nil {
fmt.Fprintf(os.Stderr, "Status: ERROR - Unable to reach out daemon: %s\n", err)
os.Exit(1)
} else {
w := tabwriter.NewWriter(os.Stdout, 2, 0, 3, ' ', 0)
fmt.Fprintf(w, "KVStore:\t%s\n", sr.KVStore)
fmt.Fprintf(w, "Docker:\t%s\n", sr.Docker)
fmt.Fprintf(w, "Kubernetes:\t%s\n", sr.Kubernetes)
fmt.Fprintf(w, "Cilium:\t%s\n", sr.Cilium)
w.Flush()
if sr.IPAMStatus != nil {
fmt.Printf("V4 addresses reserved:\n")
for _, ipv4 := range sr.IPAMStatus["4"] {
fmt.Printf(" %s\n", ipv4)
}
fmt.Printf("V6 addresses reserved:\n")
for _, ipv6 := range sr.IPAMStatus["6"] {
fmt.Printf(" %s\n", ipv6)
}
w.Flush()
}
os.Exit(int(sr.Cilium.Code))
}
}
func configDaemon(ctx *cli.Context) {
var (
client *cnc.Client
err error
)
first := ctx.Args().First()
if first == "list" {
for k, s := range daemon.DaemonOptionLibrary {
fmt.Printf("%-24s %s\n", k, s.Description)
}
return
}
if host := ctx.GlobalString("host"); host == "" {
client, err = cnc.NewDefaultClient()
} else {
client, err = cnc.NewClient(host, nil)
}
if err != nil {
fmt.Fprintf(os.Stderr, "Error while creating cilium-client: %s\n", err)
os.Exit(1)
}
res, err := client.Ping()
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to reach daemon: %s\n", err)
os.Exit(1)
}
if res == nil {
fmt.Fprintf(os.Stderr, "Empty response from daemon\n")
os.Exit(1)
}
opts := ctx.Args()
if len(opts) == 0 {
res.Opts.Dump()
return
}
dOpts := make(option.OptionMap, len(opts))
for k := range opts {
name, value, err := option.ParseOption(opts[k], &daemon.DaemonOptionLibrary)
if err != nil {
fmt.Printf("%s\n", err)
os.Exit(1)
}
dOpts[name] = value
err = client.Update(dOpts)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to update daemon: %s\n", err)
os.Exit(1)
}
}
}
func cmdAdd(args *skel.CmdArgs) error {
n, err := loadNetConf(args.StdinData)
if err != nil {
return err
}
log.Debugf("Args %s", args)
c, err := cnc.NewDefaultClient()
if err != nil {
return fmt.Errorf("error while starting cilium-client: %s", err)
}
netNs, err := ns.GetNS(args.Netns)
if err != nil {
return fmt.Errorf("failed to open netns %q: %s", args.Netns, err)
}
defer netNs.Close()
if err := removeIfFromNSIfExists(netNs, args.IfName); err != nil {
return fmt.Errorf("failed removing interface %q from namespace %q: %s",
args.IfName, args.Netns, err)
}
var ep endpoint.Endpoint
veth, peer, tmpIfName, err := plugins.SetupVeth(args.ContainerID, n.MTU, &ep)
if err != nil {
return err
}
defer func() {
if err != nil {
if err = netlink.LinkDel(veth); err != nil {
log.Warningf("failed to clean up veth %q: %s", veth.Name, err)
}
}
}()
if err = netlink.LinkSetNsFd(*peer, int(netNs.Fd())); err != nil {
return fmt.Errorf("unable to move veth pair %q to netns: %s", peer, err)
}
err = netNs.Do(func(_ ns.NetNS) error {
err := renameLink(tmpIfName, args.IfName)
if err != nil {
return fmt.Errorf("failed to rename %q to %q: %s", tmpIfName, args.IfName, err)
}
return nil
})
req := ipam.IPAMReq{}
ipamConf, err := c.AllocateIP(ipam.CNIIPAMType, req)
if err != nil {
return err
}
defer func() {
if err != nil && ipamConf != nil {
if ipamConf.IP6 != nil {
req := ipam.IPAMReq{IP: &ipamConf.IP6.IP.IP}
if err = c.ReleaseIP(ipam.CNIIPAMType, req); err != nil {
log.Warningf("failed to release allocated IPv6 of container ID %q: %s", args.ContainerID, err)
}
}
if ipamConf.IP4 != nil {
req := ipam.IPAMReq{IP: &ipamConf.IP4.IP.IP}
if err = c.ReleaseIP(ipam.CNIIPAMType, req); err != nil {
log.Warningf("failed to release allocated IPv4 of container ID %q: %s", args.ContainerID, err)
}
}
}
}()
if err = netNs.Do(func(_ ns.NetNS) error {
return configureIface(args.IfName, ipamConf)
}); err != nil {
return err
}
ep.IPv6 = addressing.DeriveCiliumIPv6(ipamConf.IP6.IP.IP)
if ipamConf.IP4 != nil {
ep.IPv4 = addressing.DeriveCiliumIPv4(ipamConf.IP4.IP.IP)
}
ep.NodeIP = ipamConf.IP6.Gateway
ep.DockerID = args.ContainerID
ep.SetID()
if err = c.EndpointJoin(ep); err != nil {
return fmt.Errorf("unable to create eBPF map: %s", err)
}
return createCNIReply(ipamConf)
}