client.go

package catteryClient

import (
	"bytes"
	"cattery/lib/agents"
	"cattery/lib/messages"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"

	"github.com/sirupsen/logrus"
)

type CatteryClient struct {
	httpClient *http.Client
	baseURL    string
	logger     *logrus.Entry
	agentId    string
}

func NewCatteryClient(baseURL string, agentId string) *CatteryClient {
	return &CatteryClient{
		httpClient: &http.Client{},
		baseURL:    baseURL,
		logger:     logrus.WithField("name", "catteryClient"),
		agentId:    agentId,
	}
}

// RegisterAgent requests just-in-time runner configuration from the Cattery server.
// Returns the full RegisterResponse so callers can read the JIT config, agent info,
// and runner version (used for runner bootstrap).
//
// https://docs.github.com/en/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-organization
func (c *CatteryClient) RegisterAgent(id string) (*messages.RegisterResponse, error) {

	client := c.httpClient

	requestUrl, err := url.JoinPath(c.baseURL, "/agent", "register/", id)
	if err != nil {
		return nil, err
	}

	request, err := http.NewRequest("GET", requestUrl, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}
	response, err := client.Do(request)
	if err != nil {
		return nil, err
	}

	defer response.Body.Close()

	if response.StatusCode != http.StatusOK {
		bodyBytes, _ := io.ReadAll(response.Body)
		return nil, fmt.Errorf("response status code: %s body: %s", response.Status, string(bodyBytes))
	}

	registerResponse := &messages.RegisterResponse{}
	err = json.NewDecoder(response.Body).Decode(registerResponse)
	if err != nil {
		return nil, err
	}

	return registerResponse, nil
}

// UnregisterAgent sends a POST request to the Cattery server to unregister the agent
func (c *CatteryClient) UnregisterAgent(agent *agents.Agent, reason messages.UnregisterReason, message string) error {

	client := c.httpClient

	requestJson, err := json.Marshal(messages.UnregisterRequest{
		Agent:   *agent,
		Reason:  reason,
		Message: message,
	})
	if err != nil {
		return err
	}

	requestUrl, err := url.JoinPath(c.baseURL, "/agent", "unregister/", agent.AgentId)
	if err != nil {
		return err
	}

	request, err := http.NewRequest("POST", requestUrl, bytes.NewBuffer(requestJson))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	response, err := client.Do(request)
	if err != nil {
		return err
	}

	defer response.Body.Close()

	if response.StatusCode != http.StatusOK {
		bodyBytes, _ := io.ReadAll(response.Body)
		return fmt.Errorf("response status code: %s body: %s", response.Status, string(bodyBytes))
	}

	return nil
}

func (c *CatteryClient) Ping() (*messages.PingResponse, error) {

	requestUrl, err := url.JoinPath(c.baseURL, "/agent", "ping", c.agentId)
	if err != nil {
		return nil, fmt.Errorf("failed to join path: %w", err)
	}

	request, err := http.NewRequest("POST", requestUrl, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}
	response, err := c.httpClient.Do(request)
	if err != nil {
		return nil, fmt.Errorf("post error: %w", err)
	}

	defer response.Body.Close()

	if response.StatusCode != http.StatusOK {
		bodyBytes, _ := io.ReadAll(response.Body)
		return nil, fmt.Errorf("response status code: %s body: %s", response.Status, string(bodyBytes))
	}

	pingResponse := &messages.PingResponse{}
	err = json.NewDecoder(response.Body).Decode(pingResponse)
	if err != nil {
		return nil, fmt.Errorf("error decoding ping response: %w", err)
	}

	return pingResponse, nil
}