init monlet repo with stage 0-2 (docs, contract, agent MVP)

agent/internal/client/client.go

@@ -0,0 +1,135 @@
+package client
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/monlet/agent/internal/scheduler"
+)
+
+const (
+	MaxBatchEvents = 200
+)
+
+type Client struct {
+	baseURL string
+	token   string
+	agentID string
+	version string
+	http    *http.Client
+}
+
+func New(baseURL, token, agentID, version string) *Client {
+	return &Client{
+		baseURL: strings.TrimRight(baseURL, "/"),
+		token:   token,
+		agentID: agentID,
+		version: version,
+		http:    &http.Client{Timeout: 15 * time.Second},
+	}
+}
+
+type HeartbeatRequest struct {
+	AgentID    string            `json:"agent_id"`
+	ObservedAt time.Time         `json:"observed_at"`
+	Hostname   string            `json:"hostname"`
+	Version    string            `json:"version"`
+	Mode       string            `json:"mode,omitempty"`
+	Labels     map[string]string `json:"labels,omitempty"`
+}
+
+type EventBatchRequest struct {
+	AgentID string            `json:"agent_id"`
+	Events  []scheduler.Event `json:"events"`
+}
+
+type EventBatchResponse struct {
+	Accepted     int `json:"accepted"`
+	Deduplicated int `json:"deduplicated"`
+}
+
+func (c *Client) SendHeartbeat(ctx context.Context, hb HeartbeatRequest) error {
+	return c.post(ctx, "/api/v1/heartbeat", hb, nil)
+}
+
+func (c *Client) SendEvents(ctx context.Context, events []scheduler.Event) (*EventBatchResponse, error) {
+	if len(events) == 0 {
+		return &EventBatchResponse{}, nil
+	}
+	if len(events) > MaxBatchEvents {
+		return nil, fmt.Errorf("batch exceeds %d events", MaxBatchEvents)
+	}
+	req := EventBatchRequest{AgentID: c.agentID, Events: events}
+	var resp EventBatchResponse
+	if err := c.post(ctx, "/api/v1/events", req, &resp); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+func (c *Client) post(ctx context.Context, path string, body any, out any) error {
+	b, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+path, bytes.NewReader(b))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", "Bearer "+c.token)
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode/100 != 2 {
+		msg, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+		return &HTTPError{Status: resp.StatusCode, Body: string(msg)}
+	}
+	if out != nil {
+		return json.NewDecoder(resp.Body).Decode(out)
+	}
+	return nil
+}
+
+type HTTPError struct {
+	Status int
+	Body   string
+}
+
+func (e *HTTPError) Error() string { return fmt.Sprintf("http %d: %s", e.Status, e.Body) }
+
+// Retryable reports whether the error should trigger a retry (network errors
+// and 5xx are retryable; 4xx are dropped to avoid hot-loop on bad payload).
+func Retryable(err error) bool {
+	if err == nil {
+		return false
+	}
+	var he *HTTPError
+	if asErr(err, &he) {
+		return he.Status >= 500
+	}
+	return true
+}
+
+func asErr(err error, target **HTTPError) bool {
+	for e := err; e != nil; {
+		if h, ok := e.(*HTTPError); ok {
+			*target = h
+			return true
+		}
+		u, ok := e.(interface{ Unwrap() error })
+		if !ok {
+			return false
+		}
+		e = u.Unwrap()
+	}
+	return false
+}