cocos/agent/algorithm/binary/binary.go

// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0
package binary

import (
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"os/exec"
	"sync"

	"github.com/ultravioletrs/cocos/agent/algorithm"
	"github.com/ultravioletrs/cocos/agent/algorithm/logging"
	"github.com/ultravioletrs/cocos/agent/events"
)

var execCommand = exec.Command

var _ algorithm.Algorithm = (*binary)(nil)

type binary struct {
	algoFile string
	stderr   io.Writer
	stdout   io.Writer
	args     []string
	cmd      *exec.Cmd
	mu       sync.Mutex
}

func NewAlgorithm(logger *slog.Logger, eventsSvc events.Service, algoFile string, args []string, cmpID string) algorithm.Algorithm {
	return &binary{
		algoFile: algoFile,
		stderr:   &logging.Stderr{Logger: logger, EventSvc: eventsSvc, CmpID: cmpID},
		stdout:   &logging.Stdout{Logger: logger},
		args:     args,
	}
}

func (b *binary) Run() error {
	b.mu.Lock()
	b.cmd = execCommand(b.algoFile, b.args...)
	b.cmd.Stderr = b.stderr
	b.cmd.Stdout = b.stdout

	if err := b.cmd.Start(); err != nil {
		b.mu.Unlock()
		return fmt.Errorf("error starting algorithm: %v", err)
	}
	b.mu.Unlock()

	if err := b.cmd.Wait(); err != nil {
		return fmt.Errorf("algorithm execution error: %v", err)
	}

	return nil
}

func (b *binary) Stop() error {
	b.mu.Lock()
	defer b.mu.Unlock()

	if b.cmd == nil {
		return nil
	}

	if b.cmd.Process == nil {
		return nil
	}

	if err := b.cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) {
		return fmt.Errorf("error stopping algorithm: %v", err)
	}

	return nil
}