Support consul service meta data

.drone.yml

@@ -0,0 +1,69 @@
+kind: pipeline
+type: exec
+name: exec-runner
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+  - name: integration-tests
+    environment:
+    commands:
+      - make clean
+      - make build lint
+      - make test
+      - make integration
+    when:
+      event:
+        - pull_request
+        - push
+
+---
+kind: pipeline
+type: docker
+name: docker-runner
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+  - name: prepare-release
+    image: golang:1.18
+    commands:
+      - |
+        go build \
+          -o build/containerpilot \
+          -ldflags \
+            "-X github.com/greenbaum/containerpilot/version.GitHash=$(git rev-parse --short HEAD) \
+             -X github.com/greenbaum/containerpilot/version.Version=${DRONE_TAG}"
+      - mkdir release && cd build && tar -czf ../release/containerpilot-${DRONE_TAG}.tar.gz containerpilot
+      - cd ../release && sha1sum containerpilot-${DRONE_TAG}.tar.gz > containerpilot-${DRONE_TAG}.sha1.txt
+    when:
+      event:
+        - tag
+
+  - name: publish-release
+    image: plugins/github-release
+    settings:
+      api_key:
+        from_secret: github_api-key
+      files:
+        - release/containerpilot-${DRONE_TAG}.tar.gz
+        - release/containerpilot-${DRONE_TAG}.sha1.txt
+      title: "New release: version ${DRONE_TAG}"
+      base_url: greenbaum/containerpilot
+    when:
+      event:
+        - tag
+    depends_on:
+      - prepare-release
+
+---
+kind: secret
+name: github_api-key
+get:
+  path: secret/data/drone/github
+  name: api-key
+

.envrc

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# ^ added for shellcheck and file-type detection
+
+# Watch & reload direnv on change
+cd devshell || exit
+watch_file devshell.toml
+
+if [[ $(type -t use_flake) != function ]]; then
+  echo "ERROR: use_flake function missing."
+  echo "Please update direnv to v2.30.0 or later."
+  exit 1
+fi
+use flake

.gitignore

@@ -41,3 +41,6 @@ cover.html
 # IDE files
 .idea
 *.iml
+
+# Nix files
+.direnv

Dockerfile

@@ -1,15 +1,20 @@
-FROM golang:1.9
+FROM golang:1.19
 
-ENV CONSUL_VERSION=1.0.0
-ENV GLIDE_VERSION=0.12.3
+ENV CONSUL_VERSION=1.13.3
 
 RUN  apt-get update \
      && apt-get install -y unzip \
-     && go get github.com/golang/lint/golint \
-     && curl -Lo /tmp/glide.tgz "https://github.com/Masterminds/glide/releases/download/v${GLIDE_VERSION}/glide-v${GLIDE_VERSION}-linux-amd64.tar.gz" \
-     && tar -C /usr/bin -xzf /tmp/glide.tgz --strip=1 linux-amd64/glide \
-     && curl --fail -Lso consul.zip "https://releases.hashicorp.com/consul/${CONSUL_VERSION}/consul_${CONSUL_VERSION}_linux_amd64.zip" \
-     && unzip consul.zip -d /usr/bin
+     && go install honnef.co/go/tools/cmd/staticcheck@latest
+
+
+RUN export CONSUL_CHECKSUM=5370b0b5bf765530e28cb80f90dcb47bd7d6ba78176c1ab2430f56e460ed279c \
+    && export archive=consul_${CONSUL_VERSION}_linux_amd64.zip \
+    && curl -Lso /tmp/${archive} https://releases.hashicorp.com/consul/${CONSUL_VERSION}/${archive} \
+    && echo "${CONSUL_CHECKSUM}  /tmp/${archive}" | sha256sum -c \
+    && cd /bin \
+    && unzip /tmp/${archive} \
+    && chmod +x /bin/consul \
+    && rm /tmp/${archive}
 
 ENV CGO_ENABLED 0
-ENV GOPATH /go:/cp
+ENV GOPATH /go

README.md

@@ -2,7 +2,7 @@
 
 *An init system for cloud-native distributed applications that automates the process of service discovery, configuration, and lifecycle management inside the container, so you can focus on your apps.*
 
-[![Build Status](https://travis-ci.org/joyent/containerpilot.svg)](https://travis-ci.org/joyent/containerpilot)
+[![Build Status](https://drone.greenbaum.cloud/api/badges/greenbaum.cloud/containerpilot/status.svg)](https://drone.greenbaum.cloud/greenbaum.cloud/containerpilot)
 [![MPL licensed](https://img.shields.io/badge/license-MPL_2.0-blue.svg)](https://github.com/joyent/containerpilot/blob/master/LICENSE)
 [![GoDoc](https://godoc.org/github.com/joyent/containerpilot?status.svg)](https://godoc.org/github.com/joyent/containerpilot)
 

client/client.go

@@ -14,7 +14,8 @@ import (
 // requests out to a ContainerPilot process's control socket.
 type HTTPClient struct {
 	http.Client
-	socketPath string
+	// staticcheck U1000 field is unused
+	//socketPath string
 }
 
 var socketType = "unix"

commands/commands.go

@@ -30,6 +30,8 @@ type Command struct {
 	logger  log.Entry
 	lock    *sync.Mutex
 	fields  log.Fields
+	UID     int
+	GID     int
 }
 
 // NewCommand parses JSON config into a Command
@@ -101,7 +103,20 @@ func (c *Command) Run(pctx context.Context, bus *events.EventBus) {
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 	}
+
 	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	if os.Getuid() == 0 {
+		if c.UID != 0 && c.GID != 0 {
+			cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(c.UID), Gid: uint32(c.GID)}
+		} else if c.UID != 0 {
+			cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(c.UID)}
+		} else if c.GID != 0 {
+			cmd.SysProcAttr.Credential = &syscall.Credential{Gid: uint32(c.GID)}
+		}
+	} else {
+		log.Debugf("%s.Skipping uid and gid (ContainerPilot is not running as root)", c.Name)
+	}
+
 	c.Cmd = cmd
 	ctx, cancel := getContext(pctx, c.Timeout)
 
@@ -126,8 +141,8 @@ func (c *Command) Run(pctx context.Context, bus *events.EventBus) {
 		defer log.Debugf("%s.Run end", c.Name)
 		if err := c.Cmd.Start(); err != nil {
 			log.Errorf("unable to start %s: %v", c.Name, err)
-			bus.Publish(events.Event{events.ExitFailed, c.Name})
-			bus.Publish(events.Event{events.Error, err.Error()})
+			bus.Publish(events.Event{Code: events.ExitFailed, Source: c.Name})
+			bus.Publish(events.Event{Code: events.Error, Source: err.Error()})
 			return
 		}
 
@@ -150,12 +165,12 @@ func (c *Command) Run(pctx context.Context, bus *events.EventBus) {
 		// we'll return from Wait() and publish events
 		if err := c.Cmd.Wait(); err != nil {
 			log.Errorf("%s exited with error: %v", c.Name, err)
-			bus.Publish(events.Event{events.ExitFailed, c.Name})
-			bus.Publish(events.Event{events.Error,
-				fmt.Errorf("%s: %s", c.Name, err).Error()})
+			bus.Publish(events.Event{Code: events.ExitFailed, Source: c.Name})
+			bus.Publish(events.Event{Code: events.Error,
+				Source: fmt.Errorf("%s: %s", c.Name, err).Error()})
 		} else {
 			log.Debugf("%s exited without error", c.Name)
-			bus.Publish(events.Event{events.ExitSuccess, c.Name})
+			bus.Publish(events.Event{Code: events.ExitSuccess, Source: c.Name})
 		}
 	}()
 }

commands/commands_test.go

@@ -15,7 +15,7 @@ import (
 func TestCommandRunWithTimeoutZero(t *testing.T) {
 	cmd, _ := NewCommand("sleep 2", time.Duration(0), nil)
 	got := runtestCommandRun(cmd)
-	timedout := events.Event{events.ExitFailed, "sleep"}
+	timedout := events.Event{Code: events.ExitFailed, Source: "sleep"}
 	if got[timedout] != 1 {
 		t.Fatalf("stopped command prior to test timeout, got events %v", got)
 	}
@@ -25,9 +25,9 @@ func TestCommandRunWithTimeoutKilled(t *testing.T) {
 	cmd, _ := NewCommand("sleep 2", time.Duration(100*time.Millisecond), nil)
 	cmd.Name = t.Name()
 	got := runtestCommandRun(cmd)
-	testTimeout := events.Event{events.TimerExpired, "DebugSubscriberTimeout"}
-	expired := events.Event{events.ExitFailed, t.Name()}
-	errMsg := events.Event{events.Error, fmt.Sprintf("%s: signal: killed", cmd.Name)}
+	testTimeout := events.Event{Code: events.TimerExpired, Source: "DebugSubscriberTimeout"}
+	expired := events.Event{Code: events.ExitFailed, Source: t.Name()}
+	errMsg := events.Event{Code: events.Error, Source: fmt.Sprintf("%s: signal: killed", cmd.Name)}
 	if got[testTimeout] > 0 || got[expired] != 1 || got[errMsg] != 1 {
 		t.Fatalf("expected:\n%v\n%v\ngot events:\n%v", expired, errMsg, got)
 	}
@@ -38,9 +38,9 @@ func TestCommandRunChildrenKilled(t *testing.T) {
 		time.Duration(100*time.Millisecond), nil)
 	cmd.Name = t.Name()
 	got := runtestCommandRun(cmd)
-	testTimeout := events.Event{events.TimerExpired, "DebugSubscriberTimeout"}
-	expired := events.Event{events.ExitFailed, t.Name()}
-	errMsg := events.Event{events.Error, fmt.Sprintf("%s: signal: killed", cmd.Name)}
+	testTimeout := events.Event{Code: events.TimerExpired, Source: "DebugSubscriberTimeout"}
+	expired := events.Event{Code: events.ExitFailed, Source: t.Name()}
+	errMsg := events.Event{Code: events.Error, Source: fmt.Sprintf("%s: signal: killed", cmd.Name)}
 	if got[testTimeout] > 0 || got[expired] != 1 || got[errMsg] != 1 {
 		t.Fatalf("expected:\n%v\n%v\ngot events:\n%v", expired, errMsg, got)
 	}
@@ -49,8 +49,8 @@ func TestCommandRunChildrenKilled(t *testing.T) {
 func TestCommandRunExecFailed(t *testing.T) {
 	cmd, _ := NewCommand("./testdata/test.sh failStuff --debug", time.Duration(0), nil)
 	got := runtestCommandRun(cmd)
-	failed := events.Event{events.ExitFailed, "./testdata/test.sh"}
-	errMsg := events.Event{events.Error, "./testdata/test.sh: exit status 255"}
+	failed := events.Event{Code: events.ExitFailed, Source: "./testdata/test.sh"}
+	errMsg := events.Event{Code: events.Error, Source: "./testdata/test.sh: exit status 255"}
 	if got[failed] != 1 || got[errMsg] != 1 {
 		t.Fatalf("expected:\n%v\n%v\ngot events:\n%v", failed, errMsg, got)
 	}
@@ -59,9 +59,9 @@ func TestCommandRunExecFailed(t *testing.T) {
 func TestCommandRunExecInvalid(t *testing.T) {
 	cmd, _ := NewCommand("./testdata/invalidCommand", time.Duration(0), nil)
 	got := runtestCommandRun(cmd)
-	failed := events.Event{events.ExitFailed, "./testdata/invalidCommand"}
-	errMsg := events.Event{events.Error,
-		"fork/exec ./testdata/invalidCommand: no such file or directory"}
+	failed := events.Event{Code: events.ExitFailed, Source: "./testdata/invalidCommand"}
+	errMsg := events.Event{Code: events.Error,
+		Source: "fork/exec ./testdata/invalidCommand: no such file or directory"}
 	if got[failed] != 1 || got[errMsg] != 1 {
 		t.Fatalf("expected:\n%v\n%v\ngot events:\n%v", failed, errMsg, got)
 	}

commands/testdata/test.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 trap 'exit 2' SIGTERM
 

config/config.go

@@ -6,7 +6,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"os"
 	"strings"
 
 	"github.com/flynn/json5"
@@ -79,7 +79,7 @@ func RenderConfig(configFlag, renderFlag string) error {
 		fmt.Printf("%s", renderedConfig)
 	} else {
 		var err error
-		if err = ioutil.WriteFile(renderFlag, renderedConfig, 0644); err != nil {
+		if err = os.WriteFile(renderFlag, renderedConfig, 0644); err != nil {
 			return fmt.Errorf("could not write config file: %s", err)
 		}
 	}
@@ -108,7 +108,7 @@ func loadConfigFile(configFlag string) ([]byte, error) {
 	if configFlag == "" {
 		return nil, errors.New("-config flag is required")
 	}
-	data, err := ioutil.ReadFile(configFlag)
+	data, err := os.ReadFile(configFlag)
 	if err != nil {
 		return nil, fmt.Errorf("could not read config file: %s", err)
 	}

config/config_test.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"
@@ -33,6 +32,7 @@ func TestValidConfigJobs(t *testing.T) {
 	assert.Equal(job0.Port, 8080, "config for job0.Port")
 	assert.Equal(job0.Exec, "/bin/serviceA", "config for job0.Exec")
 	assert.Equal(job0.Tags, []string{"tag1", "tag2"}, "config for job0.Tags")
+	assert.Equal(job0.Meta, map[string]string{"keyA": "A"}, "config for job0.Meta")
 	assert.Equal(job0.Restarts, nil, "config for job1.Restarts")
 
 	job1 := cfg.Jobs[1]
@@ -184,8 +184,8 @@ func TestRenderConfigFileStdout(t *testing.T) {
 	temp.Close()
 	os.Stdout = old
 
-	renderedOut, _ := ioutil.ReadFile(fname)
-	renderedFile, _ := ioutil.ReadFile("testJSON.json")
+	renderedOut, _ := os.ReadFile(fname)
+	renderedFile, _ := os.ReadFile("testJSON.json")
 	if string(renderedOut) != string(renderedFile) {
 		t.Fatalf("expected the rendered file and stdout to be identical")
 	}

config/decode/decode.go

@@ -71,7 +71,7 @@ func interfaceToString(raw interface{}) string {
 }
 
 func interfaceToStringArray(rawArray []interface{}) []string {
-	if rawArray == nil || len(rawArray) == 0 {
+	if len(rawArray) == 0 {
 		return nil
 	}
 	var stringArray []string

config/logger/logging.go

@@ -49,7 +49,7 @@ func (l *Config) Init() error {
 	}
 	level, err := logrus.ParseLevel(strings.ToLower(l.Level))
 	if err != nil {
-		return fmt.Errorf("Unknown log level '%s': %s", l.Level, err)
+		return fmt.Errorf("unknown log level '%s': %s", l.Level, err)
 	}
 	var formatter logrus.Formatter
 	var output io.Writer
@@ -65,19 +65,19 @@ func (l *Config) Init() error {
 			TimestampFormat: time.RFC3339Nano,
 		}
 	default:
-		return fmt.Errorf("Unknown log format '%s'", l.Format)
+		return fmt.Errorf("unknown log format '%s'", l.Format)
 	}
 	switch strings.ToLower(l.Output) {
 	case "stderr":
 		output = os.Stderr
 	case "stdout":
 		output = os.Stdout
 	case "":
-		return fmt.Errorf("Unknown output type '%s'", l.Output)
+		return fmt.Errorf("unknown output type '%s'", l.Output)
 	default:
 		f, err := reopen.NewFileWriter(l.Output)
 		if err != nil {
-			return fmt.Errorf("Error initializing log file '%s': %s", l.Output, err)
+			return fmt.Errorf("error initializing log file '%s': %s", l.Output, err)
 		}
 		initializeSignal(f)
 		output = f

config/logger/logging_test.go

@@ -1,7 +1,6 @@
 package logger
 
 import (
-	"io/ioutil"
 	"os"
 	"reflect"
 	"strings"
@@ -84,7 +83,7 @@ func TestFileLogger(t *testing.T) {
 	// write a log message
 	logMsg := "this is a test"
 	logrus.Info(logMsg)
-	content, err := ioutil.ReadFile(filename)
+	content, err := os.ReadFile(filename)
 	if err != nil {
 		t.Errorf("Did not expect error: %v", err)
 	}