130 lines
3.6 KiB
Go
130 lines
3.6 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"google.golang.org/grpc"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"github.com/docker/containerd"
|
|
apishim "github.com/docker/containerd/api/shim"
|
|
"github.com/docker/containerd/shim"
|
|
"github.com/docker/containerd/sys"
|
|
"github.com/docker/containerd/utils"
|
|
"github.com/urfave/cli"
|
|
)
|
|
|
|
const usage = `
|
|
__ _ __ __ _
|
|
_________ ____ / /_____ _(_)___ ___ _________/ / _____/ /_ (_)___ ___
|
|
/ ___/ __ \/ __ \/ __/ __ ` + "`" + `/ / __ \/ _ \/ ___/ __ /_____/ ___/ __ \/ / __ ` + "`" + `__ \
|
|
/ /__/ /_/ / / / / /_/ /_/ / / / / / __/ / / /_/ /_____(__ ) / / / / / / / / /
|
|
\___/\____/_/ /_/\__/\__,_/_/_/ /_/\___/_/ \__,_/ /____/_/ /_/_/_/ /_/ /_/
|
|
|
|
shim for container lifecycle and reconnection
|
|
`
|
|
|
|
func main() {
|
|
app := cli.NewApp()
|
|
app.Name = "containerd-shim"
|
|
app.Version = containerd.Version
|
|
app.Usage = usage
|
|
app.Flags = []cli.Flag{
|
|
cli.BoolFlag{
|
|
Name: "debug",
|
|
Usage: "enable debug output in logs",
|
|
},
|
|
}
|
|
app.Before = func(context *cli.Context) error {
|
|
if context.GlobalBool("debug") {
|
|
logrus.SetLevel(logrus.DebugLevel)
|
|
}
|
|
return nil
|
|
}
|
|
app.Action = func(context *cli.Context) error {
|
|
// start handling signals as soon as possible so that things are properly reaped
|
|
// or if runtime exits before we hit the handler
|
|
signals, err := setupSignals()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var (
|
|
server = grpc.NewServer()
|
|
sv = shim.NewService()
|
|
)
|
|
logrus.Debug("registering grpc server")
|
|
apishim.RegisterShimServer(server, sv)
|
|
if err := serve(server, "shim.sock"); err != nil {
|
|
return err
|
|
}
|
|
return handleSignals(signals, server, sv)
|
|
}
|
|
if err := app.Run(os.Args); err != nil {
|
|
fmt.Fprintf(os.Stderr, "containerd-shim: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// setupSignals creates a new signal handler for all signals and sets the shim as a
|
|
// sub-reaper so that the container processes are reparented
|
|
func setupSignals() (chan os.Signal, error) {
|
|
signals := make(chan os.Signal, 2048)
|
|
signal.Notify(signals)
|
|
// set the shim as the subreaper for all orphaned processes created by the container
|
|
if err := sys.SetSubreaper(1); err != nil {
|
|
return nil, err
|
|
}
|
|
return signals, nil
|
|
}
|
|
|
|
// serve serves the grpc API over a unix socket at the provided path
|
|
// this function does not block
|
|
func serve(server *grpc.Server, path string) error {
|
|
l, err := utils.CreateUnixSocket(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
logrus.WithField("socket", path).Debug("serving api on unix socket")
|
|
go func() {
|
|
defer l.Close()
|
|
if err := server.Serve(l); err != nil &&
|
|
!strings.Contains(err.Error(), "use of closed network connection") {
|
|
l.Close()
|
|
logrus.WithError(err).Fatal("containerd-shim: GRPC server failure")
|
|
}
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func handleSignals(signals chan os.Signal, server *grpc.Server, service *shim.Service) error {
|
|
for s := range signals {
|
|
logrus.WithField("signal", s).Debug("received signal")
|
|
switch s {
|
|
case syscall.SIGCHLD:
|
|
exits, err := utils.Reap(false)
|
|
if err != nil {
|
|
logrus.WithError(err).Error("reap exit status")
|
|
}
|
|
for _, e := range exits {
|
|
logrus.WithFields(logrus.Fields{
|
|
"status": e.Status,
|
|
"pid": e.Pid,
|
|
}).Debug("process exited")
|
|
if err := service.ProcessExit(e); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
case syscall.SIGTERM, syscall.SIGINT:
|
|
// TODO: should we forward signals to the processes if they are still running?
|
|
// i.e. machine reboot
|
|
server.Stop()
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|