2016-04-20 03:37:53 +02:00
|
|
|
package agent
|
|
|
|
|
|
|
|
import (
|
2017-03-05 09:56:08 +02:00
|
|
|
"fmt"
|
|
|
|
"math"
|
2016-07-18 09:06:34 +02:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
2016-09-28 02:33:13 +02:00
|
|
|
"strings"
|
2016-04-20 03:37:53 +02:00
|
|
|
"sync"
|
2016-07-18 09:06:34 +02:00
|
|
|
"syscall"
|
2016-04-20 03:37:53 +02:00
|
|
|
"time"
|
|
|
|
|
2016-09-28 03:30:28 +02:00
|
|
|
"github.com/drone/drone/model"
|
2016-09-29 23:45:13 +02:00
|
|
|
"github.com/drone/mq/logger"
|
2016-09-26 10:29:05 +02:00
|
|
|
"github.com/drone/mq/stomp"
|
2016-09-29 23:45:13 +02:00
|
|
|
"github.com/tidwall/redlog"
|
2016-09-26 10:29:05 +02:00
|
|
|
|
2016-04-20 03:37:53 +02:00
|
|
|
"github.com/Sirupsen/logrus"
|
|
|
|
"github.com/codegangsta/cli"
|
2016-09-28 02:33:13 +02:00
|
|
|
"github.com/samalba/dockerclient"
|
2016-04-20 03:37:53 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// AgentCmd is the exported command for starting the drone agent.
|
|
|
|
var AgentCmd = cli.Command{
|
|
|
|
Name: "agent",
|
|
|
|
Usage: "starts the drone agent",
|
|
|
|
Action: start,
|
|
|
|
Flags: []cli.Flag{
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DOCKER_HOST",
|
|
|
|
Name: "docker-host",
|
2017-01-20 15:02:05 +02:00
|
|
|
Usage: "docker daemon address",
|
2016-04-20 03:37:53 +02:00
|
|
|
Value: "unix:///var/run/docker.sock",
|
|
|
|
},
|
|
|
|
cli.BoolFlag{
|
|
|
|
EnvVar: "DOCKER_TLS_VERIFY",
|
|
|
|
Name: "docker-tls-verify",
|
|
|
|
Usage: "docker daemon supports tlsverify",
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DOCKER_CERT_PATH",
|
|
|
|
Name: "docker-cert-path",
|
|
|
|
Usage: "docker certificate directory",
|
|
|
|
Value: "",
|
|
|
|
},
|
|
|
|
cli.IntFlag{
|
|
|
|
EnvVar: "DOCKER_MAX_PROCS",
|
|
|
|
Name: "docker-max-procs",
|
|
|
|
Usage: "limit number of running docker processes",
|
|
|
|
Value: 2,
|
|
|
|
},
|
2016-04-22 02:10:19 +02:00
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DOCKER_OS",
|
|
|
|
Name: "docker-os",
|
|
|
|
Usage: "docker operating system",
|
|
|
|
Value: "linux",
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DOCKER_ARCH",
|
|
|
|
Name: "docker-arch",
|
|
|
|
Usage: "docker architecture system",
|
|
|
|
Value: "amd64",
|
|
|
|
},
|
2016-04-20 03:37:53 +02:00
|
|
|
cli.StringFlag{
|
2017-03-05 09:56:08 +02:00
|
|
|
EnvVar: "DRONE_SERVER,DRONE_ENDPOINT",
|
2016-04-20 03:37:53 +02:00
|
|
|
Name: "drone-server",
|
|
|
|
Usage: "drone server address",
|
2016-09-26 10:29:05 +02:00
|
|
|
Value: "ws://localhost:8000/ws/broker",
|
2016-04-20 03:37:53 +02:00
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DRONE_TOKEN",
|
|
|
|
Name: "drone-token",
|
|
|
|
Usage: "drone authorization token",
|
|
|
|
},
|
2016-05-24 03:47:44 +02:00
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DRONE_SECRET,DRONE_AGENT_SECRET",
|
|
|
|
Name: "drone-secret",
|
|
|
|
Usage: "drone agent secret",
|
|
|
|
},
|
2016-04-20 03:37:53 +02:00
|
|
|
cli.DurationFlag{
|
2016-04-21 10:18:20 +02:00
|
|
|
EnvVar: "DRONE_BACKOFF",
|
|
|
|
Name: "backoff",
|
2016-04-20 03:37:53 +02:00
|
|
|
Usage: "drone server backoff interval",
|
|
|
|
Value: time.Second * 15,
|
|
|
|
},
|
2016-05-11 23:37:56 +02:00
|
|
|
cli.DurationFlag{
|
|
|
|
EnvVar: "DRONE_PING",
|
|
|
|
Name: "ping",
|
|
|
|
Usage: "drone server ping frequency",
|
|
|
|
Value: time.Minute * 5,
|
|
|
|
},
|
2016-04-20 03:37:53 +02:00
|
|
|
cli.BoolFlag{
|
2016-04-21 10:18:20 +02:00
|
|
|
EnvVar: "DRONE_DEBUG",
|
2016-04-20 03:37:53 +02:00
|
|
|
Name: "debug",
|
|
|
|
Usage: "start the agent in debug mode",
|
|
|
|
},
|
2016-05-12 22:24:51 +02:00
|
|
|
cli.DurationFlag{
|
|
|
|
EnvVar: "DRONE_TIMEOUT",
|
|
|
|
Name: "timeout",
|
|
|
|
Usage: "drone timeout due to log inactivity",
|
2016-11-19 17:27:12 +02:00
|
|
|
Value: time.Minute * 15,
|
2016-05-12 22:24:51 +02:00
|
|
|
},
|
2016-09-28 03:16:46 +02:00
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DRONE_FILTER",
|
|
|
|
Name: "filter",
|
|
|
|
Usage: "filter jobs processed by this agent",
|
|
|
|
},
|
2016-05-12 22:24:51 +02:00
|
|
|
cli.IntFlag{
|
|
|
|
EnvVar: "DRONE_MAX_LOGS",
|
|
|
|
Name: "max-log-size",
|
|
|
|
Usage: "drone maximum log size in megabytes",
|
|
|
|
Value: 5,
|
|
|
|
},
|
2016-04-21 10:18:20 +02:00
|
|
|
cli.StringSliceFlag{
|
2016-04-22 02:10:19 +02:00
|
|
|
EnvVar: "DRONE_PLUGIN_PRIVILEGED",
|
|
|
|
Name: "privileged",
|
2016-04-21 10:18:20 +02:00
|
|
|
Usage: "plugins that require privileged mode",
|
2016-04-22 02:10:19 +02:00
|
|
|
Value: &cli.StringSlice{
|
|
|
|
"plugins/docker",
|
|
|
|
"plugins/docker:*",
|
2016-05-02 19:22:04 +02:00
|
|
|
"plugins/gcr",
|
|
|
|
"plugins/gcr:*",
|
2016-04-22 02:10:19 +02:00
|
|
|
"plugins/ecr",
|
|
|
|
"plugins/ecr:*",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
EnvVar: "DRONE_PLUGIN_NAMESPACE",
|
|
|
|
Name: "namespace",
|
|
|
|
Value: "plugins",
|
|
|
|
Usage: "default plugin image namespace",
|
|
|
|
},
|
2016-05-13 07:14:33 +02:00
|
|
|
cli.BoolTFlag{
|
2016-05-11 07:19:45 +02:00
|
|
|
EnvVar: "DRONE_PLUGIN_PULL",
|
|
|
|
Name: "pull",
|
|
|
|
Usage: "always pull latest plugin images",
|
2016-04-21 10:18:20 +02:00
|
|
|
},
|
2017-01-13 09:53:13 +02:00
|
|
|
cli.StringSliceFlag{
|
2017-01-12 07:42:43 +02:00
|
|
|
EnvVar: "DRONE_YAML_EXTENSION",
|
|
|
|
Name: "extension",
|
|
|
|
Usage: "custom plugin extension endpoint",
|
|
|
|
},
|
2017-03-05 09:56:08 +02:00
|
|
|
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
|
|
|
|
cli.BoolFlag{
|
|
|
|
EnvVar: "DRONE_CANARY",
|
|
|
|
Name: "canary",
|
|
|
|
Usage: "enable experimental features at your own risk",
|
|
|
|
},
|
|
|
|
|
|
|
|
// cli.StringFlag{
|
|
|
|
// Name: "endpoint",
|
|
|
|
// EnvVar: "DRONE_ENDPOINT,DRONE_SERVER",
|
|
|
|
// Value: "ws://localhost:9999/ws/rpc",
|
|
|
|
// },
|
|
|
|
// cli.DurationFlag{
|
|
|
|
// Name: "backoff",
|
|
|
|
// EnvVar: "DRONE_BACKOFF",
|
|
|
|
// Value: time.Second * 15,
|
|
|
|
// },
|
|
|
|
cli.IntFlag{
|
|
|
|
Name: "retry-limit",
|
|
|
|
EnvVar: "DRONE_RETRY_LIMIT",
|
|
|
|
Value: math.MaxInt32,
|
|
|
|
},
|
|
|
|
cli.IntFlag{
|
|
|
|
Name: "max-procs",
|
|
|
|
EnvVar: "DRONE_MAX_PROCS",
|
|
|
|
Value: 1,
|
|
|
|
},
|
|
|
|
cli.StringFlag{
|
|
|
|
Name: "platform",
|
|
|
|
EnvVar: "DRONE_PLATFORM",
|
|
|
|
Value: "linux/amd64",
|
|
|
|
},
|
2016-04-20 03:37:53 +02:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
func start(c *cli.Context) {
|
|
|
|
|
2017-03-05 09:56:08 +02:00
|
|
|
if c.Bool("canary") {
|
|
|
|
if err := loop(c); err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-09-29 23:45:13 +02:00
|
|
|
log := redlog.New(os.Stderr)
|
|
|
|
log.SetLevel(0)
|
|
|
|
logger.SetLogger(log)
|
|
|
|
|
2016-04-20 03:37:53 +02:00
|
|
|
// debug level if requested by user
|
|
|
|
if c.Bool("debug") {
|
|
|
|
logrus.SetLevel(logrus.DebugLevel)
|
2016-09-29 23:45:13 +02:00
|
|
|
|
|
|
|
log.SetLevel(1)
|
2016-04-20 03:37:53 +02:00
|
|
|
} else {
|
|
|
|
logrus.SetLevel(logrus.WarnLevel)
|
|
|
|
}
|
2016-05-24 03:47:44 +02:00
|
|
|
|
|
|
|
var accessToken string
|
|
|
|
if c.String("drone-secret") != "" {
|
2016-09-26 10:29:05 +02:00
|
|
|
// secretToken := c.String("drone-secret")
|
|
|
|
accessToken = c.String("drone-secret")
|
|
|
|
// accessToken, _ = token.New(token.AgentToken, "").Sign(secretToken)
|
2016-05-24 03:47:44 +02:00
|
|
|
} else {
|
|
|
|
accessToken = c.String("drone-token")
|
|
|
|
}
|
|
|
|
|
2016-10-27 23:57:41 +02:00
|
|
|
logger.Noticef("connecting to server %s", c.String("drone-server"))
|
2016-04-20 03:37:53 +02:00
|
|
|
|
2016-09-26 10:29:05 +02:00
|
|
|
server := strings.TrimRight(c.String("drone-server"), "/")
|
2016-04-20 03:37:53 +02:00
|
|
|
|
2016-04-29 21:39:56 +02:00
|
|
|
tls, err := dockerclient.TLSConfigFromCertPath(c.String("docker-cert-path"))
|
|
|
|
if err == nil {
|
|
|
|
tls.InsecureSkipVerify = c.Bool("docker-tls-verify")
|
2016-04-20 03:37:53 +02:00
|
|
|
}
|
|
|
|
docker, err := dockerclient.NewDockerClient(c.String("docker-host"), tls)
|
|
|
|
if err != nil {
|
|
|
|
logrus.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2016-09-28 02:33:13 +02:00
|
|
|
var client *stomp.Client
|
|
|
|
|
2016-09-26 10:29:05 +02:00
|
|
|
handler := func(m *stomp.Message) {
|
|
|
|
running.Add(1)
|
|
|
|
defer func() {
|
|
|
|
running.Done()
|
|
|
|
client.Ack(m.Ack)
|
|
|
|
}()
|
|
|
|
|
2017-03-05 09:56:08 +02:00
|
|
|
r := pipelinet{
|
2016-09-26 10:29:05 +02:00
|
|
|
drone: client,
|
|
|
|
docker: docker,
|
|
|
|
config: config{
|
2016-11-17 03:08:25 +02:00
|
|
|
platform: c.String("docker-os") + "/" + c.String("docker-arch"),
|
|
|
|
timeout: c.Duration("timeout"),
|
|
|
|
namespace: c.String("namespace"),
|
|
|
|
privileged: c.StringSlice("privileged"),
|
|
|
|
pull: c.BoolT("pull"),
|
|
|
|
logs: int64(c.Int("max-log-size")) * 1000000,
|
2017-01-13 09:53:13 +02:00
|
|
|
extension: c.StringSlice("extension"),
|
2016-09-26 10:29:05 +02:00
|
|
|
},
|
2016-05-11 23:37:56 +02:00
|
|
|
}
|
|
|
|
|
2016-09-28 03:30:28 +02:00
|
|
|
work := new(model.Work)
|
2016-09-26 10:29:05 +02:00
|
|
|
m.Unmarshal(work)
|
|
|
|
r.run(work)
|
|
|
|
}
|
|
|
|
|
2016-07-18 09:06:34 +02:00
|
|
|
handleSignals()
|
2016-09-26 10:29:05 +02:00
|
|
|
|
2016-09-28 02:33:13 +02:00
|
|
|
backoff := c.Duration("backoff")
|
|
|
|
|
|
|
|
for {
|
|
|
|
// dial the drone server to establish a TCP connection.
|
|
|
|
client, err = stomp.Dial(server)
|
|
|
|
if err != nil {
|
2016-09-29 23:45:13 +02:00
|
|
|
logger.Warningf("connection failed, retry in %v. %s", backoff, err)
|
2016-09-28 02:33:13 +02:00
|
|
|
<-time.After(backoff)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
opts := []stomp.MessageOption{
|
|
|
|
stomp.WithCredentials("x-token", accessToken),
|
|
|
|
}
|
|
|
|
|
|
|
|
// initialize the stomp session and authenticate.
|
|
|
|
if err = client.Connect(opts...); err != nil {
|
2016-10-27 23:53:38 +02:00
|
|
|
logger.Warningf("session failed, retry in %v. %s", backoff, err)
|
2016-09-28 02:33:13 +02:00
|
|
|
<-time.After(backoff)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2016-09-28 03:16:46 +02:00
|
|
|
opts = []stomp.MessageOption{
|
2016-09-28 02:33:13 +02:00
|
|
|
stomp.WithAck("client"),
|
|
|
|
stomp.WithPrefetch(
|
|
|
|
c.Int("docker-max-procs"),
|
|
|
|
),
|
2016-09-28 03:16:46 +02:00
|
|
|
}
|
|
|
|
if filter := c.String("filter"); filter != "" {
|
|
|
|
opts = append(opts, stomp.WithSelector(filter))
|
|
|
|
}
|
|
|
|
|
|
|
|
// subscribe to the pending build queue.
|
|
|
|
client.Subscribe("/queue/pending", stomp.HandlerFunc(func(m *stomp.Message) {
|
|
|
|
go handler(m) // HACK until we a channel based Subscribe implementation
|
|
|
|
}), opts...)
|
2016-09-28 02:33:13 +02:00
|
|
|
|
2016-11-05 14:57:45 +02:00
|
|
|
logger.Noticef("connection established, ready to process builds.")
|
2016-09-28 02:33:13 +02:00
|
|
|
<-client.Done()
|
|
|
|
|
2016-09-29 23:45:13 +02:00
|
|
|
logger.Warningf("connection interrupted, attempting to reconnect.")
|
2016-09-28 02:33:13 +02:00
|
|
|
}
|
2016-04-20 03:37:53 +02:00
|
|
|
}
|
2016-07-18 09:06:34 +02:00
|
|
|
|
|
|
|
// tracks running builds
|
|
|
|
var running sync.WaitGroup
|
|
|
|
|
|
|
|
func handleSignals() {
|
|
|
|
// Graceful shut-down on SIGINT/SIGTERM
|
|
|
|
c := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(c, os.Interrupt)
|
|
|
|
signal.Notify(c, syscall.SIGTERM)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
<-c
|
2016-09-29 23:45:13 +02:00
|
|
|
logger.Warningf("SIGTERM received.")
|
|
|
|
logger.Warningf("wait for running builds to finish.")
|
2016-07-18 09:06:34 +02:00
|
|
|
running.Wait()
|
2016-09-29 23:45:13 +02:00
|
|
|
logger.Warningf("done.")
|
2016-07-18 09:06:34 +02:00
|
|
|
os.Exit(0)
|
|
|
|
}()
|
|
|
|
}
|