client.go

package main

import (
	"bytes"
	"context"
	"encoding/binary"
	"io"
	"log"
	"sort"
	"strings"

	"github.com/moby/moby/api/types/events"
	"github.com/moby/moby/client"
)

// Container represents an internal representation of docker containers
type Container struct {
	ID             string   `json:"id"`
	Names          []string `json:"names"`
	Name           string   `json:"name"`
	Image          string   `json:"image"`
	ImageID        string   `json:"imageId"`
	Command        string   `json:"command"`
	Created        int64    `json:"created"`
	State          string   `json:"state"`
	Status         string   `json:"status"`
	ComposeProject string   `json:"compose_project"`
	ComposeService string   `json:"compose_service"`
}

type Client struct {
	cli *client.Client
}

// NewClient creates a new instance of Client
func NewClient() *Client {
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		log.Fatal(err)
	}
	return &Client{cli}
}

func (d *Client) ListContainers(ctx context.Context) ([]Container, error) {
	list, err := d.cli.ContainerList(ctx, client.ContainerListOptions{})
	if err != nil {
		return nil, err
	}

	var containers []Container

	for _, c := range list.Items {

		container := Container{
			ID:             c.ID,
			Names:          c.Names,
			Name:           strings.TrimPrefix(c.Names[0], "/"),
			Image:          c.Image,
			ImageID:        c.ImageID,
			Command:        c.Command,
			Created:        c.Created,
			State:          string(c.State),
			Status:         c.Status,
			ComposeProject: c.Labels["com.docker.compose.project"],
			ComposeService: c.Labels["com.docker.compose.service"],
		}
		containers = append(containers, container)
	}

	sort.Slice(containers, func(i, j int) bool {
		return containers[i].Name < containers[j].Name
	})

	if containers == nil {
		containers = []Container{}
	}

	return containers, nil
}

func (d *Client) GetContainer(ctx context.Context, id string) (*Container, error) {
	inspect, err := d.cli.ContainerInspect(ctx, id, client.ContainerInspectOptions{})
	if err != nil {
		return nil, err
	}

	return &Container{
		ID:             inspect.Container.ID,
		Names:          []string{inspect.Container.Name},
		Name:           strings.TrimPrefix(inspect.Container.Name, "/"),
		Image:          inspect.Container.Config.Image,
		ImageID:        inspect.Container.Image,
		Command:        strings.Join(inspect.Container.Config.Cmd, " "),
		Created:        0,
		State:          string(inspect.Container.State.Status),
		Status:         string(inspect.Container.State.Status),
		ComposeProject: inspect.Container.Config.Labels["com.docker.compose.project"],
		ComposeService: inspect.Container.Config.Labels["com.docker.compose.service"],
	}, nil
}

func (d *Client) ContainerLogs(ctx context.Context, id string, options client.ContainerLogsOptions) (<-chan string, <-chan error) {
	reader, err := d.cli.ContainerLogs(ctx, id, options)
	errChannel := make(chan error, 1)

	if err != nil {
		errChannel <- err
		close(errChannel)
		return nil, errChannel
	}

	messages := make(chan string)
	go func() {
		<-ctx.Done()
		reader.Close()
	}()

	go func() {
		defer close(messages)
		defer close(errChannel)
		defer reader.Close()

		hdr := make([]byte, 8)
		var buffer bytes.Buffer
		for {
			_, err := reader.Read(hdr)
			if err != nil {
				errChannel <- err
				break
			}
			count := binary.BigEndian.Uint32(hdr[4:])
			_, err = io.CopyN(&buffer, reader, int64(count))
			if err != nil {
				errChannel <- err
				break
			}
			select {
			case messages <- buffer.String():
			case <-ctx.Done():
				// return // TODO: maybe return here
			}
			buffer.Reset()
		}
	}()

	return messages, errChannel
}

func (d *Client) Events(ctx context.Context) (<-chan events.Message, <-chan error) {
	filters := make(client.Filters)
	filters.Add("event", string(events.ActionStart))
	filters.Add("event", string(events.ActionDie))
	filters.Add("event", string(events.ActionKill))
	filters.Add("event", string(events.ActionStop))
	filters.Add("event", string(events.ActionDestroy))
	res := d.cli.Events(ctx, client.EventsListOptions{Filters: filters})
	return res.Messages, res.Err
}