feat(orbit): implement Cosmos Orbit (Module 03) container PaaS engine and console
This commit is contained in:
+496
@@ -0,0 +1,496 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// DockerClient returns an http.Client communicating directly with the Docker daemon unix socket.
|
||||
func DockerClient() *http.Client {
|
||||
return &http.Client{
|
||||
Transport: &http.Transport{
|
||||
DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
|
||||
return net.Dial("unix", "/var/run/docker.sock")
|
||||
},
|
||||
},
|
||||
Timeout: 0, // Infinite timeout for long-lived operations (build, stream logs)
|
||||
}
|
||||
}
|
||||
|
||||
// DockerPing verifies the Docker daemon is reachable.
|
||||
func DockerPing(ctx context.Context) error {
|
||||
client := DockerClient()
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", "http://localhost/v1.45/_ping", nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("docker ping failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("docker ping returned status %d", resp.StatusCode)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DockerContainerSummary represents basic container metadata from Docker API.
|
||||
type DockerContainerSummary struct {
|
||||
ID string `json:"Id"`
|
||||
Names []string `json:"Names"`
|
||||
Image string `json:"Image"`
|
||||
State string `json:"State"`
|
||||
Status string `json:"Status"`
|
||||
Created int64 `json:"Created"`
|
||||
Labels map[string]string `json:"Labels"`
|
||||
Ports []struct {
|
||||
PrivatePort int `json:"PrivatePort"`
|
||||
PublicPort int `json:"PublicPort"`
|
||||
Type string `json:"Type"`
|
||||
IP string `json:"IP"`
|
||||
} `json:"Ports"`
|
||||
}
|
||||
|
||||
// ListOrbitContainers returns all containers managed by Orbit (labeled with orbit=true).
|
||||
func ListOrbitContainers(ctx context.Context) ([]DockerContainerSummary, error) {
|
||||
client := DockerClient()
|
||||
u := "http://localhost/v1.45/containers/json?all=1"
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
var all []DockerContainerSummary
|
||||
if err := json.NewDecoder(resp.Body).Decode(&all); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var orbitContainers []DockerContainerSummary
|
||||
for _, c := range all {
|
||||
if c.Labels != nil && c.Labels["cosmos.orbit"] == "true" {
|
||||
orbitContainers = append(orbitContainers, c)
|
||||
}
|
||||
}
|
||||
return orbitContainers, nil
|
||||
}
|
||||
|
||||
// InspectDockerContainer returns detailed information about a container.
|
||||
func InspectDockerContainer(ctx context.Context, containerID string) (map[string]interface{}, error) {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/json", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode == http.StatusNotFound {
|
||||
return nil, fmt.Errorf("container not found")
|
||||
}
|
||||
|
||||
var data map[string]interface{}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return data, nil
|
||||
}
|
||||
|
||||
// StartDockerContainer starts a stopped container.
|
||||
func StartDockerContainer(ctx context.Context, containerID string) error {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/start", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", u, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusNotModified {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("failed to start container: %s", string(body))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// StopDockerContainer gracefully stops a container (10s timeout).
|
||||
func StopDockerContainer(ctx context.Context, containerID string) error {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/stop?t=10", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", u, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusNotModified {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("failed to stop container: %s", string(body))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RestartDockerContainer restarts a container.
|
||||
func RestartDockerContainer(ctx context.Context, containerID string) error {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/restart?t=10", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", u, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("failed to restart container: %s", string(body))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RemoveDockerContainer stops and removes a container.
|
||||
func RemoveDockerContainer(ctx context.Context, containerID string) error {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s?force=true&v=true", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "DELETE", u, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusNotFound {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("failed to remove container: %s", string(body))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// OrbitContainerSpec holds configuration for spawning a container.
|
||||
type OrbitContainerSpec struct {
|
||||
Name string
|
||||
Image string
|
||||
Env []string
|
||||
AppID string
|
||||
InternalPort int // e.g. 3000, 8080
|
||||
ExposedPort int // e.g. 4100
|
||||
MemLimitMB int // e.g. 512
|
||||
CPULimit float64 // e.g. 1.0
|
||||
}
|
||||
|
||||
// CreateAndStartOrbitContainer creates and starts an Orbit-managed container.
|
||||
func CreateAndStartOrbitContainer(ctx context.Context, spec OrbitContainerSpec) (string, error) {
|
||||
client := DockerClient()
|
||||
|
||||
intPortStr := fmt.Sprintf("%d/tcp", spec.InternalPort)
|
||||
hostPortStr := fmt.Sprintf("%d", spec.ExposedPort)
|
||||
|
||||
memBytes := int64(spec.MemLimitMB) * 1024 * 1024
|
||||
if memBytes <= 0 {
|
||||
memBytes = 512 * 1024 * 1024 // 512MB default
|
||||
}
|
||||
|
||||
nanoCPUs := int64(spec.CPULimit * 1e9)
|
||||
if nanoCPUs <= 0 {
|
||||
nanoCPUs = 1e9 // 1 CPU default
|
||||
}
|
||||
|
||||
createPayload := map[string]interface{}{
|
||||
"Image": spec.Image,
|
||||
"Env": spec.Env,
|
||||
"Labels": map[string]string{
|
||||
"cosmos.orbit": "true",
|
||||
"cosmos.app_id": spec.AppID,
|
||||
"cosmos.app_name": spec.Name,
|
||||
},
|
||||
"ExposedPorts": map[string]interface{}{
|
||||
intPortStr: map[string]interface{}{},
|
||||
},
|
||||
"HostConfig": map[string]interface{}{
|
||||
"PortBindings": map[string]interface{}{
|
||||
intPortStr: []map[string]string{
|
||||
{
|
||||
"HostIp": "0.0.0.0",
|
||||
"HostPort": hostPortStr,
|
||||
},
|
||||
},
|
||||
},
|
||||
"RestartPolicy": map[string]string{
|
||||
"Name": "unless-stopped",
|
||||
},
|
||||
"Memory": memBytes,
|
||||
"NanoCpus": nanoCPUs,
|
||||
},
|
||||
}
|
||||
|
||||
payloadBytes, err := json.Marshal(createPayload)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
createURL := fmt.Sprintf("http://localhost/v1.45/containers/create?name=%s", url.QueryEscape("orbit-"+spec.AppID))
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", createURL, bytes.NewReader(payloadBytes))
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("create container request failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return "", fmt.Errorf("docker create returned %d: %s", resp.StatusCode, string(body))
|
||||
}
|
||||
|
||||
var res struct {
|
||||
ID string `json:"Id"`
|
||||
}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Start the container
|
||||
if err := StartDockerContainer(ctx, res.ID); err != nil {
|
||||
// Clean up on failure
|
||||
_ = RemoveDockerContainer(ctx, res.ID)
|
||||
return "", fmt.Errorf("failed to start container: %w", err)
|
||||
}
|
||||
|
||||
return res.ID, nil
|
||||
}
|
||||
|
||||
// BuildDockerImage builds a Docker image from a tar stream of the build context.
|
||||
func BuildDockerImage(ctx context.Context, tarStream io.Reader, tag string, logWriter io.Writer) error {
|
||||
client := DockerClient()
|
||||
buildURL := fmt.Sprintf("http://localhost/v1.45/build?t=%s&rm=1&forcerm=1", url.QueryEscape(tag))
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", buildURL, tarStream)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/x-tar")
|
||||
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("build request failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
// Stream build JSON messages: {"stream": "Step 1/5 : FROM alpine\n"}
|
||||
dec := json.NewDecoder(resp.Body)
|
||||
for {
|
||||
var msg struct {
|
||||
Stream string `json:"stream"`
|
||||
Error string `json:"error"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
if err := dec.Decode(&msg); err != nil {
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
return err
|
||||
}
|
||||
if msg.Error != "" {
|
||||
if logWriter != nil {
|
||||
fmt.Fprintf(logWriter, "ERROR: %s\n", msg.Error)
|
||||
}
|
||||
return fmt.Errorf("docker build error: %s", msg.Error)
|
||||
}
|
||||
if msg.Stream != "" && logWriter != nil {
|
||||
io.WriteString(logWriter, msg.Stream)
|
||||
} else if msg.Status != "" && logWriter != nil {
|
||||
fmt.Fprintf(logWriter, "%s\n", msg.Status)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// ContainerLiveStats holds live CPU, RAM, and network metrics.
|
||||
type ContainerLiveStats struct {
|
||||
CPUPct float64 `json:"cpu_percent"`
|
||||
MemUsageMB float64 `json:"mem_usage_mb"`
|
||||
MemLimitMB float64 `json:"mem_limit_mb"`
|
||||
MemPct float64 `json:"mem_percent"`
|
||||
NetRxMB float64 `json:"net_rx_mb"`
|
||||
NetTxMB float64 `json:"net_tx_mb"`
|
||||
}
|
||||
|
||||
// GetContainerStats queries live resource utilization for a container.
|
||||
func GetContainerStats(ctx context.Context, containerID string) (*ContainerLiveStats, error) {
|
||||
client := DockerClient()
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/stats?stream=false", url.PathEscape(containerID))
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("docker stats returned status %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
var s struct {
|
||||
CPUStats struct {
|
||||
CPUUsage struct {
|
||||
TotalUsage uint64 `json:"total_usage"`
|
||||
PercpuUsage []uint64 `json:"percpu_usage"`
|
||||
} `json:"cpu_usage"`
|
||||
SystemCPUUsage uint64 `json:"system_cpu_usage"`
|
||||
OnlineCPUs int `json:"online_cpus"`
|
||||
} `json:"cpu_stats"`
|
||||
PreCPUStats struct {
|
||||
CPUUsage struct {
|
||||
TotalUsage uint64 `json:"total_usage"`
|
||||
} `json:"cpu_usage"`
|
||||
SystemCPUUsage uint64 `json:"system_cpu_usage"`
|
||||
} `json:"precpu_stats"`
|
||||
MemoryStats struct {
|
||||
Usage uint64 `json:"usage"`
|
||||
Limit uint64 `json:"limit"`
|
||||
} `json:"memory_stats"`
|
||||
Networks map[string]struct {
|
||||
RxBytes uint64 `json:"rx_bytes"`
|
||||
TxBytes uint64 `json:"tx_bytes"`
|
||||
} `json:"networks"`
|
||||
}
|
||||
|
||||
if err := json.NewDecoder(resp.Body).Decode(&s); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Calculate CPU %
|
||||
cpuDelta := float64(s.CPUStats.CPUUsage.TotalUsage) - float64(s.PreCPUStats.CPUUsage.TotalUsage)
|
||||
systemDelta := float64(s.CPUStats.SystemCPUUsage) - float64(s.PreCPUStats.SystemCPUUsage)
|
||||
cpuPct := 0.0
|
||||
numCPUs := s.CPUStats.OnlineCPUs
|
||||
if numCPUs <= 0 {
|
||||
numCPUs = len(s.CPUStats.CPUUsage.PercpuUsage)
|
||||
}
|
||||
if numCPUs <= 0 {
|
||||
numCPUs = 1
|
||||
}
|
||||
if systemDelta > 0 && cpuDelta > 0 {
|
||||
cpuPct = (cpuDelta / systemDelta) * float64(numCPUs) * 100.0
|
||||
}
|
||||
|
||||
// Memory
|
||||
memMB := float64(s.MemoryStats.Usage) / (1024 * 1024)
|
||||
limitMB := float64(s.MemoryStats.Limit) / (1024 * 1024)
|
||||
memPct := 0.0
|
||||
if limitMB > 0 {
|
||||
memPct = (memMB / limitMB) * 100.0
|
||||
}
|
||||
|
||||
// Network
|
||||
var rxTotal, txTotal uint64
|
||||
for _, n := range s.Networks {
|
||||
rxTotal += n.RxBytes
|
||||
txTotal += n.TxBytes
|
||||
}
|
||||
|
||||
return &ContainerLiveStats{
|
||||
CPUPct: cpuPct,
|
||||
MemUsageMB: memMB,
|
||||
MemLimitMB: limitMB,
|
||||
MemPct: memPct,
|
||||
NetRxMB: float64(rxTotal) / (1024 * 1024),
|
||||
NetTxMB: float64(txTotal) / (1024 * 1024),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// StreamDockerLogs streams container stdout/stderr. Docker demultiplexes with 8-byte frames.
|
||||
func StreamDockerLogs(ctx context.Context, containerID string, tail string, follow bool, w io.Writer) error {
|
||||
client := DockerClient()
|
||||
followVal := "0"
|
||||
if follow {
|
||||
followVal = "1"
|
||||
}
|
||||
if tail == "" {
|
||||
tail = "200"
|
||||
}
|
||||
|
||||
u := fmt.Sprintf("http://localhost/v1.45/containers/%s/logs?stdout=1&stderr=1&tail=%s&follow=%s×tamps=1",
|
||||
url.PathEscape(containerID), url.QueryEscape(tail), followVal)
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, "GET", u, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
return fmt.Errorf("failed to fetch logs: %s", string(body))
|
||||
}
|
||||
|
||||
// Demultiplex Docker log stream:
|
||||
// Header: 8 bytes -> [STREAM_TYPE, 0, 0, 0, SIZE1, SIZE2, SIZE3, SIZE4]
|
||||
hdr := make([]byte, 8)
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil
|
||||
default:
|
||||
}
|
||||
|
||||
_, err := io.ReadFull(resp.Body, hdr)
|
||||
if err != nil {
|
||||
if err == io.EOF || strings.Contains(err.Error(), "closed") {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
payloadSize := binary.BigEndian.Uint32(hdr[4:8])
|
||||
if payloadSize > 0 {
|
||||
// Read payload
|
||||
lr := io.LimitReader(resp.Body, int64(payloadSize))
|
||||
if _, err := io.Copy(w, lr); err != nil {
|
||||
return err
|
||||
}
|
||||
if f, ok := w.(http.Flusher); ok {
|
||||
f.Flush()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user