cmd/python-provider/main.go

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math"
	"os"
	"os/exec"
	"strings"
	"time"

	spine "pysolate-spine"
)

const maxNumbers = 100

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run() error {
	wasm, err := os.ReadFile("dist/spine.wasm")
	if err != nil {
		return err
	}
	source, err := os.ReadFile("examples/python_provider.py")
	if err != nil {
		return err
	}
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	runner, err := spine.New(ctx, wasm, spine.Manifest{
		"report_stats": {Call: reportStats},
	})
	if err != nil {
		return err
	}
	defer runner.Close(context.Background())

	out, err := runner.Run(ctx, string(source), map[string]any{
		"numbers": []float64{2, 4, 6, 8},
	})
	if err != nil {
		return err
	}
	fmt.Println(string(out.Value))
	return nil
}

func reportStats(ctx context.Context, args json.RawMessage) (any, error) {
	var input struct {
		Numbers []float64 `json:"numbers"`
	}
	decoder := json.NewDecoder(bytes.NewReader(args))
	decoder.DisallowUnknownFields()
	if err := decoder.Decode(&input); err != nil {
		return nil, fmt.Errorf("report_stats input: %w", err)
	}
	if err := decoder.Decode(new(any)); !errors.Is(err, io.EOF) {
		if err == nil {
			return nil, errors.New("report_stats input: trailing JSON value")
		}
		return nil, fmt.Errorf("report_stats input: %w", err)
	}
	if len(input.Numbers) == 0 || len(input.Numbers) > maxNumbers {
		return nil, fmt.Errorf("report_stats numbers must contain 1 to %d values", maxNumbers)
	}
	for _, number := range input.Numbers {
		if math.IsNaN(number) || math.IsInf(number, 0) {
			return nil, errors.New("report_stats numbers must be finite")
		}
	}

	command := exec.CommandContext(ctx, "python3", "providers/report.py")
	command.Stdin = bytes.NewReader(args)
	var stderr bytes.Buffer
	command.Stderr = &stderr
	output, err := command.Output()
	if err != nil {
		if detail := strings.TrimSpace(stderr.String()); detail != "" {
			return nil, fmt.Errorf("report_stats worker failed: %w: %s", err, detail)
		}
		return nil, fmt.Errorf("report_stats worker failed: %w", err)
	}
	var result struct {
		Count int     `json:"count"`
		Total float64 `json:"total"`
	}
	if err := json.Unmarshal(output, &result); err != nil {
		return nil, fmt.Errorf("report_stats worker returned malformed JSON: %w", err)
	}
	if result.Count != len(input.Numbers) || math.IsNaN(result.Total) || math.IsInf(result.Total, 0) {
		return nil, errors.New("report_stats worker returned invalid result")
	}
	return result, nil
}