1
0
mirror of https://github.com/woodpecker-ci/woodpecker.git synced 2024-12-12 08:23:48 +02:00
woodpecker/drone/agent/agent.go

318 lines
7.1 KiB
Go
Raw Normal View History

2016-04-20 03:37:53 +02:00
package agent
import (
2017-03-05 09:56:08 +02:00
"fmt"
"math"
"os"
"os/signal"
2016-09-28 02:33:13 +02:00
"strings"
2016-04-20 03:37:53 +02:00
"sync"
"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",
},
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,
},
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",
},
cli.DurationFlag{
EnvVar: "DRONE_TIMEOUT",
Name: "timeout",
Usage: "drone timeout due to log inactivity",
Value: time.Minute * 15,
},
cli.StringFlag{
EnvVar: "DRONE_FILTER",
Name: "filter",
Usage: "filter jobs processed by this agent",
},
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",
},
cli.BoolTFlag{
EnvVar: "DRONE_PLUGIN_PULL",
Name: "pull",
Usage: "always pull latest plugin images",
2016-04-21 10:18:20 +02:00
},
cli.StringSliceFlag{
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)
}
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)
} 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{
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,
extension: c.StringSlice("extension"),
2016-09-26 10:29:05 +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)
}
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
}
opts = []stomp.MessageOption{
2016-09-28 02:33:13 +02:00
stomp.WithAck("client"),
stomp.WithPrefetch(
c.Int("docker-max-procs"),
),
}
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
}
// 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.")
running.Wait()
2016-09-29 23:45:13 +02:00
logger.Warningf("done.")
os.Exit(0)
}()
}