docker_plugin

build.sh

#!/bin/sh

set -x

name=${1:-"wreulicke/test"}
docker build -t "$name" .

id=$(docker create "$name")

rm -rf rootfs
mkdir -p rootfs
docker export "$id" | tar -xvf - -C rootfs
docker rm "$id"

rm -rf rootfs/proc rootfs/sys rootfs/go rootfs/etc rootfs/dev
docker plugin rm "$name"
docker plugin create "$name" .

Dockerfile

FROM golang AS plugin
WORKDIR /go/src/github.com/wreulicke/docker-hooks
COPY . ./
RUN CGO_ENABLED=0 go build -tags netgo -o main
RUN mkdir -p /run/docker

FROM scratch
COPY --from=plugin /go/src/github.com/wreulicke/docker-hooks /
COPY --from=plugin /run/docker /run/docker
ENTRYPOINT ["/main"]

main.go

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"sync"
	"time"

	"github.com/docker/go-plugins-helpers/sdk"
	"github.com/tv42/httpunix"
)

const (
	version = "0.1.0"
)

var (
	started bool
	mu      sync.Mutex
	ch      chan string
)

func Pusher() {
	for s := range ch {
		fmt.Println(s)
	}
}

func main() {
	fmt.Printf(">>>> Start plugin v%s\n", version)
	ch = make(chan string, 1024)
	go Pusher()
	h := sdk.NewHandler(`{"Implements": ["MetricsCollector"]}`)
	handlers(&h)
	if err := h.ServeUnix("metrics", 0); err != nil {
		panic(err)
	}
}

func PushForward() {
	ticker := time.NewTicker(time.Duration(2) * time.Second).C
	for {
		select {
		case <-ticker:
			u := &httpunix.Transport{
				DialTimeout:           100 * time.Millisecond,
				RequestTimeout:        500 * time.Millisecond,
				ResponseHeaderTimeout: 500 * time.Millisecond,
			}
			u.RegisterLocation("docker", "/run/docker/metrics.sock")

			var client = http.Client{
				Transport: u,
			}

			resp, err := client.Get("http+unix://docker/metrics")
			if err != nil {
				log.Fatal(err)
			}
			bytes, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				fmt.Println(err)
			} else {
				ch <- string(bytes)
			}
		}
	}
}

func handlers(h *sdk.Handler) {
	h.HandleFunc("/MetricsCollector.StartMetrics", func(w http.ResponseWriter, r *http.Request) {
		fmt.Println(">>>>>>> Got /MetricsCollector.StartMetrics")
		var err error
		defer func() {
			var res struct{ Err string }
			if err != nil {
				res.Err = err.Error()
			}
			json.NewEncoder(w).Encode(&res)
		}()
		mu.Lock()
		defer mu.Unlock()
		if !started {
			started = true
			go PushForward()
		}
	})

	h.HandleFunc("/MetricsCollector.StopMetrics", func(w http.ResponseWriter, r *http.Request) {
		fmt.Println(">>>>>>> Got /MetricsCollector.StopMetrics")
		json.NewEncoder(w).Encode(map[string]string{})
	})
}