Skip to content

Modern Docker Management, Designed for Everyone

6.4 KB
Raw Blame
package podman

import (
	"cmp"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/url"
	"strings"

	podmantypes "github.com/getarcaneapp/arcane/types/v2/podman"
	kit "go.getarcane.app/kit/pkg"
	"golang.org/x/mod/semver"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
)

const apiPrefix = "/v4.0.0/libpod"

type Client struct {
	baseURL    string
	httpClient *http.Client
}

type Runtime struct {
	Client   *Client
	Version  podmantypes.Version
	Rootless bool
	Systemd  Systemd
}

type Features struct {
	QuadletsSupported    bool
	QuadletAppsSupported bool
	AutoUpdateMode       podmantypes.AutoUpdateMode
}

type request struct {
	method      string
	path        string
	query       url.Values
	body        io.Reader
	contentType string
}

type apiError struct {
	Cause    string `json:"cause"`
	Message  string `json:"message"`
	Response int    `json:"response"`
}

func NewClient(host string) (*Client, error) {
	parsed, err := url.Parse(host)
	if err != nil {
		return nil, fmt.Errorf("parse podman host %q: %w", host, err)
	}

	switch parsed.Scheme {
	case "unix":
		return &Client{
			baseURL: "http://podman",
			httpClient: &http.Client{
				Transport: &http.Transport{
					DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
						return (&net.Dialer{}).DialContext(ctx, "unix", parsed.Path)
					},
				},
			},
		}, nil
	case "tcp", "http":
		return &Client{
			baseURL:    "http://" + parsed.Host,
			httpClient: &http.Client{},
		}, nil
	case "https":
		return &Client{
			baseURL:    "https://" + parsed.Host,
			httpClient: &http.Client{},
		}, nil
	default:
		return nil, common.Classify(common.ErrBadRequest, fmt.Errorf("unsupported podman host scheme %q", parsed.Scheme))
	}
}

func DetectFeatures(version string, systemdAvailable bool) Features {
	v := kit.EnsurePrefix(strings.TrimSpace(version), "v")
	return Features{
		QuadletsSupported:    semver.Compare(v, "v5.8.0") >= 0,
		QuadletAppsSupported: semver.Compare(v, "v6.1.0") >= 0,
		AutoUpdateMode: func() podmantypes.AutoUpdateMode {
			switch {
			case semver.Compare(v, "v6.2.0") >= 0:
				return podmantypes.AutoUpdateModeREST
			case systemdAvailable:
				return podmantypes.AutoUpdateModeSystemd
			default:
				return podmantypes.AutoUpdateModeUnavailable
			}
		}(),
	}
}

func (c *Client) Version(ctx context.Context) (podmantypes.Version, error) {
	return c.doJSON[podmantypes.Version](ctx, request{method: http.MethodGet, path: "/version"})
}

func (c *Client) Info(ctx context.Context) (podmantypes.Info, error) {
	return c.doJSON[podmantypes.Info](ctx, request{method: http.MethodGet, path: "/info"})
}

type containerResponse struct {
	podmantypes.Container
	Ports []PodPortMapping `json:"Ports"`
}

func (c *Client) ContainerList(ctx context.Context, labels, pods []string) ([]podmantypes.Container, error) {
	query, err := filtersQuery(url.Values{"all": {"true"}}, map[string][]string{
		"label": labels,
		"pod":   pods,
	})
	if err != nil {
		return nil, err
	}

	raw, err := c.doJSON[[]containerResponse](ctx, request{
		method: http.MethodGet,
		path:   "/containers/json",
		query:  query,
	})
	if err != nil {
		return nil, err
	}

	containers := make([]podmantypes.Container, 0, len(raw))
	for _, item := range raw {
		ports := make([]podmantypes.PodPortMapping, 0, len(item.Ports))
		for _, port := range item.Ports {
			ports = append(ports, podmantypes.PodPortMapping(port))
		}
		containers = append(containers, podmantypes.Container{
			ID:        item.ID,
			Names:     item.Names,
			Image:     item.Image,
			ImageID:   item.ImageID,
			State:     item.State,
			Status:    item.Status,
			Created:   item.Created,
			StartedAt: item.StartedAt,
			ExitCode:  item.ExitCode,
			Exited:    item.Exited,
			Labels:    item.Labels,
			Pod:       item.Pod,
			PodName:   item.PodName,
			IsInfra:   item.IsInfra,
			Ports:     ports,
		})
	}
	return containers, nil
}

func (c *Client) doJSON[T any](ctx context.Context, req request) (T, error) {
	var out T
	body, err := c.do(ctx, req)
	if err != nil {
		return out, err
	}
	defer func() { _ = body.Close() }()

	if decodeErr := json.NewDecoder(body).Decode(&out); decodeErr != nil && !errors.Is(decodeErr, io.EOF) {
		return out, fmt.Errorf("decode podman %s %s: %w", req.method, req.path, decodeErr)
	}
	return out, nil
}

func (c *Client) doText(ctx context.Context, req request) (string, error) {
	body, err := c.do(ctx, req)
	if err != nil {
		return "", err
	}
	defer func() { _ = body.Close() }()

	data, err := io.ReadAll(body)
	if err != nil {
		return "", fmt.Errorf("read podman %s %s: %w", req.method, req.path, err)
	}
	return string(data), nil
}

func (c *Client) do(ctx context.Context, req request) (io.ReadCloser, error) {
	target := c.baseURL + apiPrefix + req.path
	if len(req.query) > 0 {
		target += "?" + req.query.Encode()
	}

	httpReq, err := http.NewRequestWithContext(ctx, req.method, target, req.body)
	if err != nil {
		return nil, fmt.Errorf("build podman request: %w", err)
	}
	if req.contentType != "" {
		httpReq.Header.Set("Content-Type", req.contentType)
	}

	resp, err := c.httpClient.Do(httpReq)
	if err != nil {
		return nil, common.Classify(common.ErrUnavailable, fmt.Errorf("podman %s %s: %w", req.method, req.path, err))
	}
	if resp.StatusCode < http.StatusBadRequest {
		return resp.Body, nil
	}
	defer func() { _ = resp.Body.Close() }()

	data, _ := io.ReadAll(io.LimitReader(resp.Body, 64<<10))
	var apiErr apiError
	message := strings.TrimSpace(string(data))
	if json.Unmarshal(data, &apiErr) == nil {
		message = cmp.Or(apiErr.Message, apiErr.Cause, message)
	}
	err = fmt.Errorf("podman %s %s: %s", req.method, req.path, cmp.Or(message, resp.Status))

	switch resp.StatusCode {
	case http.StatusBadRequest:
		return nil, common.Classify(common.ErrBadRequest, err)
	case http.StatusNotFound:
		return nil, common.Classify(common.ErrNotFound, err)
	case http.StatusConflict:
		return nil, common.Classify(common.ErrConflict, err)
	case http.StatusServiceUnavailable:
		return nil, common.Classify(common.ErrUnavailable, err)
	default:
		return nil, err
	}
}

func filtersQuery(query url.Values, filters map[string][]string) (url.Values, error) {
	set := make(map[string][]string, len(filters))
	for key, values := range filters {
		if len(values) > 0 {
			set[key] = values
		}
	}
	if len(set) == 0 {
		return query, nil
	}

	encoded, err := json.Marshal(set)
	if err != nil {
		return nil, fmt.Errorf("encode podman filters: %w", err)
	}
	query.Set("filters", string(encoded))
	return query, nil
}