2016-11-30 00:10:41 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2017-01-30 06:00:57 +00:00
|
|
|
_ "expvar"
|
2016-11-30 00:10:41 +00:00
|
|
|
"fmt"
|
2016-12-11 19:07:32 +00:00
|
|
|
"net/http"
|
2017-01-30 06:00:57 +00:00
|
|
|
_ "net/http/pprof"
|
2016-11-30 00:10:41 +00:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
|
|
|
"syscall"
|
2017-02-13 18:23:28 +00:00
|
|
|
"time"
|
2016-11-30 00:10:41 +00:00
|
|
|
|
2016-12-12 22:26:51 +00:00
|
|
|
gocontext "golang.org/x/net/context"
|
2016-11-30 00:10:41 +00:00
|
|
|
"google.golang.org/grpc"
|
|
|
|
|
2017-01-19 06:14:37 +00:00
|
|
|
"github.com/Sirupsen/logrus"
|
2016-11-30 00:10:41 +00:00
|
|
|
"github.com/docker/containerd"
|
2017-02-09 07:31:26 +00:00
|
|
|
api "github.com/docker/containerd/api/services/execution"
|
2017-02-13 18:23:28 +00:00
|
|
|
_ "github.com/docker/containerd/linux"
|
2016-12-12 22:26:51 +00:00
|
|
|
"github.com/docker/containerd/log"
|
2017-02-13 18:23:28 +00:00
|
|
|
"github.com/docker/containerd/services/execution"
|
2017-01-19 22:16:50 +00:00
|
|
|
"github.com/docker/containerd/utils"
|
2016-12-11 19:07:32 +00:00
|
|
|
metrics "github.com/docker/go-metrics"
|
2017-02-06 22:57:43 +00:00
|
|
|
"github.com/pkg/errors"
|
2016-11-30 00:10:41 +00:00
|
|
|
"github.com/urfave/cli"
|
|
|
|
)
|
|
|
|
|
2017-01-19 22:16:50 +00:00
|
|
|
const usage = `
|
2016-11-30 00:10:41 +00:00
|
|
|
__ _ __
|
|
|
|
_________ ____ / /_____ _(_)___ ___ _________/ /
|
2016-12-05 22:15:03 +00:00
|
|
|
/ ___/ __ \/ __ \/ __/ __ ` + "`" + `/ / __ \/ _ \/ ___/ __ /
|
|
|
|
/ /__/ /_/ / / / / /_/ /_/ / / / / / __/ / / /_/ /
|
|
|
|
\___/\____/_/ /_/\__/\__,_/_/_/ /_/\___/_/ \__,_/
|
|
|
|
|
2016-11-30 00:10:41 +00:00
|
|
|
high performance container runtime
|
|
|
|
`
|
2017-01-19 22:16:50 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
var global = log.WithModule(gocontext.Background(), "containerd")
|
2017-02-06 22:57:43 +00:00
|
|
|
|
2017-01-19 22:16:50 +00:00
|
|
|
func main() {
|
|
|
|
app := cli.NewApp()
|
|
|
|
app.Name = "containerd"
|
|
|
|
app.Version = containerd.Version
|
|
|
|
app.Usage = usage
|
2016-11-30 00:10:41 +00:00
|
|
|
app.Flags = []cli.Flag{
|
2017-01-24 10:16:16 +00:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "log-level",
|
|
|
|
Usage: "Set the logging level [debug, info, warn, error, fatal, panic]",
|
|
|
|
Value: "info",
|
|
|
|
},
|
2016-12-02 19:33:58 +00:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "root",
|
|
|
|
Usage: "containerd state directory",
|
|
|
|
Value: "/run/containerd",
|
|
|
|
},
|
2016-11-30 00:10:41 +00:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "socket, s",
|
|
|
|
Usage: "socket path for containerd's GRPC server",
|
|
|
|
Value: "/run/containerd/containerd.sock",
|
|
|
|
},
|
2017-01-30 06:00:57 +00:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "debug-socket, d",
|
|
|
|
Usage: "socket path for containerd's debug server",
|
|
|
|
Value: "/run/containerd/containerd-debug.sock",
|
|
|
|
},
|
2016-12-01 18:34:42 +00:00
|
|
|
cli.StringFlag{
|
|
|
|
Name: "metrics-address, m",
|
|
|
|
Usage: "tcp address to serve metrics on",
|
|
|
|
Value: "127.0.0.1:7897",
|
|
|
|
},
|
2016-11-30 00:10:41 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
app.Before = before
|
2016-11-30 00:10:41 +00:00
|
|
|
app.Action = func(context *cli.Context) error {
|
2017-02-13 18:23:28 +00:00
|
|
|
start := time.Now()
|
|
|
|
// start the signal handler as soon as we can to make sure that
|
|
|
|
// we don't miss any signals during boot
|
2016-11-30 00:10:41 +00:00
|
|
|
signals := make(chan os.Signal, 2048)
|
2016-12-11 19:07:32 +00:00
|
|
|
signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1)
|
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
log.G(global).Info("starting containerd boot...")
|
|
|
|
runtimes, err := loadRuntimes(context)
|
2017-01-30 06:00:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
supervisor, err := containerd.NewSupervisor(log.WithModule(global, "execution"), runtimes)
|
2016-11-30 00:10:41 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
// start debug and metrics APIs
|
|
|
|
if err := serveDebugAPI(context); err != nil {
|
2017-01-12 18:32:09 +00:00
|
|
|
return err
|
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
serveMetricsAPI(context)
|
|
|
|
// start the GRPC api with the execution service registered
|
|
|
|
server := newGRPCServer(execution.New(supervisor))
|
|
|
|
if err := serveGRPC(context, server); err != nil {
|
2016-12-02 19:33:58 +00:00
|
|
|
return err
|
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
log.G(global).Infof("containerd successfully booted in %fs", time.Now().Sub(start).Seconds())
|
|
|
|
return handleSignals(signals, server)
|
2016-11-30 00:10:41 +00:00
|
|
|
}
|
|
|
|
if err := app.Run(os.Args); err != nil {
|
|
|
|
fmt.Fprintf(os.Stderr, "containerd: %s\n", err)
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func before(context *cli.Context) error {
|
|
|
|
if l := context.GlobalString("log-level"); l != "" {
|
|
|
|
lvl, err := logrus.ParseLevel(l)
|
|
|
|
if err != nil {
|
|
|
|
lvl = logrus.InfoLevel
|
|
|
|
fmt.Fprintf(os.Stderr, "Unable to parse logging level: %s\n, and being defaulted to info", l)
|
|
|
|
}
|
|
|
|
logrus.SetLevel(lvl)
|
|
|
|
}
|
|
|
|
return nil
|
2016-12-11 19:07:32 +00:00
|
|
|
}
|
2016-12-01 18:34:42 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func serveMetricsAPI(context *cli.Context) {
|
|
|
|
if addr := context.GlobalString("metrics-address"); addr != "" {
|
|
|
|
log.G(global).WithField("metrics", addr).Info("starting metrics API...")
|
|
|
|
h := newMetricsHandler()
|
|
|
|
go func() {
|
|
|
|
if err := http.ListenAndServe(addr, h); err != nil {
|
|
|
|
log.G(global).WithError(err).Fatal("serve metrics API")
|
|
|
|
}
|
|
|
|
}()
|
2016-11-30 00:10:41 +00:00
|
|
|
}
|
|
|
|
}
|
2016-12-11 19:07:32 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func newMetricsHandler() http.Handler {
|
|
|
|
m := http.NewServeMux()
|
|
|
|
m.Handle("/metrics", metrics.Handler())
|
|
|
|
return m
|
2017-01-30 06:00:57 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func serveDebugAPI(context *cli.Context) error {
|
|
|
|
path := context.GlobalString("debug-socket")
|
|
|
|
if path == "" {
|
|
|
|
return errors.New("--debug-socket path cannot be empty")
|
|
|
|
}
|
|
|
|
l, err := utils.CreateUnixSocket(path)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2016-12-11 19:07:32 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
log.G(global).WithField("debug", path).Info("starting debug API...")
|
|
|
|
go func() {
|
|
|
|
defer l.Close()
|
|
|
|
// pprof and expvars are imported and automatically register their endpoints
|
|
|
|
// under /debug
|
|
|
|
if err := http.Serve(l, nil); err != nil {
|
|
|
|
log.G(global).WithError(err).Fatal("serve debug API")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
return nil
|
2016-12-11 19:07:32 +00:00
|
|
|
}
|
2016-12-12 22:26:51 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func loadRuntimes(context *cli.Context) (map[string]containerd.Runtime, error) {
|
|
|
|
var (
|
|
|
|
root = context.GlobalString("root")
|
|
|
|
o = make(map[string]containerd.Runtime)
|
|
|
|
)
|
|
|
|
for _, name := range containerd.Runtimes() {
|
|
|
|
r, err := containerd.NewRuntime(name, root)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2016-12-12 22:26:51 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
o[name] = r
|
|
|
|
log.G(global).WithField("runtime", name).Info("load runtime")
|
2017-02-06 22:57:43 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
return o, nil
|
|
|
|
}
|
2016-12-12 22:26:51 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func newGRPCServer(service api.ContainerServiceServer) *grpc.Server {
|
|
|
|
s := grpc.NewServer(grpc.UnaryInterceptor(interceptor))
|
|
|
|
api.RegisterContainerServiceServer(s, service)
|
|
|
|
return s
|
2016-12-12 22:26:51 +00:00
|
|
|
}
|
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func serveGRPC(context *cli.Context, server *grpc.Server) error {
|
|
|
|
path := context.GlobalString("socket")
|
|
|
|
if path == "" {
|
|
|
|
return errors.New("--socket path cannot be empty")
|
|
|
|
}
|
|
|
|
l, err := utils.CreateUnixSocket(path)
|
2016-12-12 22:26:51 +00:00
|
|
|
if err != nil {
|
2017-02-13 18:23:28 +00:00
|
|
|
return err
|
2016-12-12 22:26:51 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
go func() {
|
|
|
|
defer l.Close()
|
|
|
|
if err := server.Serve(l); err != nil {
|
|
|
|
log.G(global).WithError(err).Fatal("serve GRPC")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
return nil
|
|
|
|
}
|
2017-02-06 22:57:43 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func interceptor(ctx gocontext.Context,
|
|
|
|
req interface{},
|
|
|
|
info *grpc.UnaryServerInfo,
|
|
|
|
handler grpc.UnaryHandler,
|
|
|
|
) (interface{}, error) {
|
|
|
|
ctx = log.WithModule(ctx, "containerd")
|
|
|
|
switch info.Server.(type) {
|
|
|
|
case api.ContainerServiceServer:
|
|
|
|
ctx = log.WithModule(global, "execution")
|
|
|
|
default:
|
|
|
|
fmt.Printf("unknown GRPC server type: %#v\n", info.Server)
|
2016-12-12 22:26:51 +00:00
|
|
|
}
|
2017-02-13 18:23:28 +00:00
|
|
|
return handler(global, req)
|
|
|
|
}
|
2016-12-12 22:26:51 +00:00
|
|
|
|
2017-02-13 18:23:28 +00:00
|
|
|
func handleSignals(signals chan os.Signal, server *grpc.Server) error {
|
|
|
|
for s := range signals {
|
|
|
|
log.G(global).WithField("signal", s).Debug("received signal")
|
|
|
|
switch s {
|
|
|
|
default:
|
|
|
|
server.Stop()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
2016-12-12 22:26:51 +00:00
|
|
|
}
|