128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
|
|
"fuego/internal/runner"
|
|
)
|
|
|
|
type SecretsFile struct {
|
|
RunnerID int64 `json:"runner_id"`
|
|
RunnerSecret string `json:"runner_secret"`
|
|
ManagerSecret string `json:"manager_secret"`
|
|
}
|
|
|
|
func main() {
|
|
var (
|
|
managerURL = flag.String("manager", getEnv("MANAGER_URL", "http://localhost:8080"), "Manager URL")
|
|
name = flag.String("name", getEnv("RUNNER_NAME", ""), "Runner name")
|
|
hostname = flag.String("hostname", getEnv("RUNNER_HOSTNAME", ""), "Runner hostname")
|
|
ipAddress = flag.String("ip", getEnv("RUNNER_IP", ""), "Runner IP address")
|
|
token = flag.String("token", getEnv("REGISTRATION_TOKEN", ""), "Registration token")
|
|
secretsFile = flag.String("secrets-file", getEnv("SECRETS_FILE", ""), "Path to secrets file for persistent storage")
|
|
)
|
|
flag.Parse()
|
|
|
|
if *name == "" {
|
|
hostname, _ := os.Hostname()
|
|
*name = fmt.Sprintf("runner-%s", hostname)
|
|
}
|
|
if *hostname == "" {
|
|
*hostname, _ = os.Hostname()
|
|
}
|
|
if *ipAddress == "" {
|
|
*ipAddress = "127.0.0.1"
|
|
}
|
|
|
|
client := runner.NewClient(*managerURL, *name, *hostname, *ipAddress)
|
|
|
|
// Try to load secrets from file
|
|
var runnerID int64
|
|
var runnerSecret, managerSecret string
|
|
if *secretsFile != "" {
|
|
if secrets, err := loadSecrets(*secretsFile); err == nil {
|
|
runnerID = secrets.RunnerID
|
|
runnerSecret = secrets.RunnerSecret
|
|
managerSecret = secrets.ManagerSecret
|
|
client.SetSecrets(runnerID, runnerSecret, managerSecret)
|
|
log.Printf("Loaded secrets from %s", *secretsFile)
|
|
}
|
|
}
|
|
|
|
// If no secrets loaded, register with token
|
|
if runnerID == 0 {
|
|
if *token == "" {
|
|
log.Fatalf("Registration token required (use --token or set REGISTRATION_TOKEN env var)")
|
|
}
|
|
|
|
var err error
|
|
runnerID, runnerSecret, managerSecret, err = client.Register(*token)
|
|
if err != nil {
|
|
log.Fatalf("Failed to register runner: %v", err)
|
|
}
|
|
log.Printf("Registered runner with ID: %d", runnerID)
|
|
|
|
// Save secrets to file if specified
|
|
if *secretsFile != "" {
|
|
secrets := SecretsFile{
|
|
RunnerID: runnerID,
|
|
RunnerSecret: runnerSecret,
|
|
ManagerSecret: managerSecret,
|
|
}
|
|
if err := saveSecrets(*secretsFile, secrets); err != nil {
|
|
log.Printf("Warning: Failed to save secrets: %v", err)
|
|
} else {
|
|
log.Printf("Saved secrets to %s", *secretsFile)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start WebSocket connection with reconnection
|
|
go client.ConnectWebSocketWithReconnect()
|
|
|
|
// Start heartbeat loop (for WebSocket ping/pong and HTTP fallback)
|
|
go client.HeartbeatLoop()
|
|
|
|
// ProcessTasks is now handled via WebSocket, but kept for HTTP fallback
|
|
// WebSocket will handle task assignment automatically
|
|
log.Printf("Runner started, connecting to manager via WebSocket...")
|
|
|
|
// Block forever
|
|
select {}
|
|
}
|
|
|
|
func loadSecrets(path string) (*SecretsFile, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var secrets SecretsFile
|
|
if err := json.Unmarshal(data, &secrets); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &secrets, nil
|
|
}
|
|
|
|
func saveSecrets(path string, secrets SecretsFile) error {
|
|
data, err := json.MarshalIndent(secrets, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return os.WriteFile(path, data, 0600)
|
|
}
|
|
|
|
func getEnv(key, defaultValue string) string {
|
|
if value := os.Getenv(key); value != "" {
|
|
return value
|
|
}
|
|
return defaultValue
|
|
}
|
|
|