260 lines
6.8 KiB
Go
260 lines
6.8 KiB
Go
package main
|
|
|
|
import (
|
|
_ "expvar"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
_ "net/http/pprof"
|
|
"net/url"
|
|
"os"
|
|
"os/signal"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
|
|
gocontext "golang.org/x/net/context"
|
|
"google.golang.org/grpc"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"github.com/docker/containerd"
|
|
api "github.com/docker/containerd/api/execution"
|
|
"github.com/docker/containerd/events"
|
|
"github.com/docker/containerd/log"
|
|
"github.com/docker/containerd/supervisor"
|
|
"github.com/docker/containerd/utils"
|
|
metrics "github.com/docker/go-metrics"
|
|
"github.com/pkg/errors"
|
|
"github.com/urfave/cli"
|
|
|
|
natsd "github.com/nats-io/gnatsd/server"
|
|
"github.com/nats-io/go-nats"
|
|
stand "github.com/nats-io/nats-streaming-server/server"
|
|
)
|
|
|
|
const usage = `
|
|
__ _ __
|
|
_________ ____ / /_____ _(_)___ ___ _________/ /
|
|
/ ___/ __ \/ __ \/ __/ __ ` + "`" + `/ / __ \/ _ \/ ___/ __ /
|
|
/ /__/ /_/ / / / / /_/ /_/ / / / / / __/ / / /_/ /
|
|
\___/\____/_/ /_/\__/\__,_/_/_/ /_/\___/_/ \__,_/
|
|
|
|
high performance container runtime
|
|
`
|
|
|
|
const (
|
|
StanClusterID = "containerd"
|
|
stanClientID = "containerd"
|
|
)
|
|
|
|
func main() {
|
|
app := cli.NewApp()
|
|
app.Name = "containerd"
|
|
app.Version = containerd.Version
|
|
app.Usage = usage
|
|
app.Flags = []cli.Flag{
|
|
cli.BoolFlag{
|
|
Name: "debug",
|
|
Usage: "enable debug output in logs",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "root",
|
|
Usage: "containerd state directory",
|
|
Value: "/run/containerd",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "socket, s",
|
|
Usage: "socket path for containerd's GRPC server",
|
|
Value: "/run/containerd/containerd.sock",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "debug-socket, d",
|
|
Usage: "socket path for containerd's debug server",
|
|
Value: "/run/containerd/containerd-debug.sock",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "metrics-address, m",
|
|
Usage: "tcp address to serve metrics on",
|
|
Value: "127.0.0.1:7897",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "events-address, e",
|
|
Usage: "nats address to serve events on",
|
|
Value: nats.DefaultURL,
|
|
},
|
|
}
|
|
app.Before = func(context *cli.Context) error {
|
|
if context.GlobalBool("debug") {
|
|
logrus.SetLevel(logrus.DebugLevel)
|
|
}
|
|
return nil
|
|
}
|
|
app.Action = func(context *cli.Context) error {
|
|
signals := make(chan os.Signal, 2048)
|
|
signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1)
|
|
|
|
ctx := log.WithModule(gocontext.Background(), "containerd")
|
|
if address := context.GlobalString("metrics-address"); address != "" {
|
|
log.G(ctx).WithField("metrics-address", address).Info("listening and serving metrics")
|
|
go serveMetrics(ctx, address)
|
|
}
|
|
|
|
ea := context.GlobalString("events-address")
|
|
log.G(ctx).WithField("events-address", ea).Info("starting nats-streaming-server")
|
|
s, err := startNATSServer(ea)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer s.Shutdown()
|
|
|
|
debugPath := context.GlobalString("debug-socket")
|
|
if debugPath == "" {
|
|
return errors.New("--debug-socket path cannot be empty")
|
|
}
|
|
d, err := utils.CreateUnixSocket(debugPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
//publish profiling and debug socket.
|
|
log.G(ctx).WithField("socket", debugPath).Info("starting profiler handlers")
|
|
log.G(ctx).WithFields(logrus.Fields{"expvars": "/debug/vars", "socket": debugPath}).Debug("serving expvars requests")
|
|
log.G(ctx).WithFields(logrus.Fields{"pprof": "/debug/pprof", "socket": debugPath}).Debug("serving pprof requests")
|
|
go serveProfiler(ctx, d)
|
|
|
|
path := context.GlobalString("socket")
|
|
if path == "" {
|
|
return errors.New("--socket path cannot be empty")
|
|
}
|
|
l, err := utils.CreateUnixSocket(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Get events publisher
|
|
natsPoster, err := events.NewNATSPoster(StanClusterID, stanClientID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
execCtx := log.WithModule(ctx, "execution")
|
|
execCtx = events.WithPoster(execCtx, natsPoster)
|
|
execService, err := supervisor.New(execCtx, context.GlobalString("root"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Intercept the GRPC call in order to populate the correct module path
|
|
interceptor := func(ctx gocontext.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
|
|
ctx = log.WithModule(ctx, "containerd")
|
|
switch info.Server.(type) {
|
|
case api.ExecutionServiceServer:
|
|
ctx = log.WithModule(ctx, "execution")
|
|
ctx = events.WithPoster(ctx, natsPoster)
|
|
default:
|
|
fmt.Printf("Unknown type: %#v\n", info.Server)
|
|
}
|
|
return handler(ctx, req)
|
|
}
|
|
server := grpc.NewServer(grpc.UnaryInterceptor(interceptor))
|
|
api.RegisterExecutionServiceServer(server, execService)
|
|
log.G(ctx).WithField("socket", l.Addr()).Info("start serving GRPC API")
|
|
go serveGRPC(ctx, server, l)
|
|
|
|
for s := range signals {
|
|
switch s {
|
|
case syscall.SIGUSR1:
|
|
dumpStacks(ctx)
|
|
default:
|
|
log.G(ctx).WithField("signal", s).Info("stopping GRPC server")
|
|
server.Stop()
|
|
return nil
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
if err := app.Run(os.Args); err != nil {
|
|
fmt.Fprintf(os.Stderr, "containerd: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func serveMetrics(ctx gocontext.Context, address string) {
|
|
m := http.NewServeMux()
|
|
m.Handle("/metrics", metrics.Handler())
|
|
if err := http.ListenAndServe(address, m); err != nil {
|
|
log.G(ctx).WithError(err).Fatal("metrics server failure")
|
|
}
|
|
}
|
|
|
|
func serveGRPC(ctx gocontext.Context, server *grpc.Server, l net.Listener) {
|
|
defer l.Close()
|
|
if err := server.Serve(l); err != nil {
|
|
log.G(ctx).WithError(err).Fatal("GRPC server failure")
|
|
}
|
|
}
|
|
|
|
func serveProfiler(ctx gocontext.Context, l net.Listener) {
|
|
defer l.Close()
|
|
if err := http.Serve(l, nil); err != nil {
|
|
log.G(ctx).WithError(err).Fatal("profiler server failure")
|
|
}
|
|
}
|
|
|
|
// DumpStacks dumps the runtime stack.
|
|
func dumpStacks(ctx gocontext.Context) {
|
|
var (
|
|
buf []byte
|
|
stackSize int
|
|
)
|
|
bufferLen := 16384
|
|
for stackSize == len(buf) {
|
|
buf = make([]byte, bufferLen)
|
|
stackSize = runtime.Stack(buf, true)
|
|
bufferLen *= 2
|
|
}
|
|
buf = buf[:stackSize]
|
|
log.G(ctx).Infof("=== BEGIN goroutine stack dump ===\n%s\n=== END goroutine stack dump ===", buf)
|
|
}
|
|
|
|
func startNATSServer(address string) (s *stand.StanServer, err error) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
s = nil
|
|
if _, ok := r.(error); !ok {
|
|
err = fmt.Errorf("failed to start NATS server: %v", r)
|
|
} else {
|
|
err = r.(error)
|
|
}
|
|
}
|
|
}()
|
|
so, no, err := getServerOptions(address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s = stand.RunServerWithOpts(so, no)
|
|
|
|
return s, err
|
|
}
|
|
|
|
func getServerOptions(address string) (*stand.Options, *natsd.Options, error) {
|
|
url, err := url.Parse(address)
|
|
if err != nil {
|
|
return nil, nil, errors.Wrapf(err, "failed to parse address url %q", address)
|
|
}
|
|
|
|
no := stand.DefaultNatsServerOptions
|
|
parts := strings.Split(url.Host, ":")
|
|
if len(parts) == 2 {
|
|
no.Port, err = strconv.Atoi(parts[1])
|
|
} else {
|
|
no.Port = nats.DefaultPort
|
|
}
|
|
no.Host = parts[0]
|
|
|
|
so := stand.GetDefaultOptions()
|
|
so.ID = StanClusterID
|
|
|
|
return so, &no, nil
|
|
}
|