process load balancing: broken but in progress

internal/pkg/prinery/doc.go

@@ -0,0 +1 @@
+package prinery

internal/pkg/prinery/prinery.go

@@ -0,0 +1,123 @@
+package prinery
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/thecodingmachine/gotenberg/internal/pkg/print"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/process"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xerror"
+	"github.com/thecodingmachine/gotenberg/internal/pkg/xlog"
+)
+
+type request struct {
+	ctx    context.Context
+	logger xlog.Logger
+	print  print.Print
+	dest   string
+	result chan error
+}
+
+type worker struct {
+	work chan request
+	proc process.Process
+}
+
+func (w *worker) do(done chan *worker) {
+	for {
+		req := <-w.work
+		req.result <- req.print.Print(req.ctx, req.dest, w.proc)
+		done <- w
+	}
+}
+
+type Prinery struct {
+	logger  xlog.Logger
+	manager process.Manager
+	work    chan request
+	pool    chan *worker
+	done    chan *worker
+}
+
+func New(logger xlog.Logger, manager process.Manager, key process.Key) (*Prinery, error) {
+	const op string = "prinery.New"
+	processes := manager.Processes(key)
+	nWorkers := len(processes)
+	if nWorkers == 0 {
+		err := fmt.Errorf("no processes found for key '%s'", string(key))
+		return nil, xerror.New(op, err)
+	}
+	logger.DebugfOp(op, "found '%d' processes for key '%s'", nWorkers, string(key))
+	work := make(chan request, 1)
+	pool := make(chan *worker, nWorkers)
+	done := make(chan *worker, nWorkers)
+	for _, p := range processes {
+		w := &worker{
+			work: work,
+			proc: p,
+		}
+		pool <- w
+		go w.do(done)
+	}
+	return &Prinery{
+		logger:  logger,
+		manager: manager,
+		work:    work,
+		pool:    pool,
+		done:    done,
+	}, nil
+}
+
+func (p *Prinery) PrintRequest(ctx context.Context, logger xlog.Logger, prnt print.Print, dest string) error {
+	const op string = "prinery.Prinery.PrintRequest"
+	req := request{
+		ctx:    ctx,
+		logger: logger,
+		print:  prnt,
+		dest:   dest,
+		result: make(chan error),
+	}
+	p.dispatch(req)
+	err := <-req.result
+	if err != nil {
+		return xerror.New(op, err)
+	}
+	return nil
+}
+
+func (p *Prinery) Start() {
+	for {
+		select {
+		case req := <-p.work:
+			p.dispatch(req)
+		case w := <-p.done:
+			p.completed(w)
+		}
+	}
+}
+
+func (p *Prinery) dispatch(req request) {
+	const op string = "prinery.Prinery.dispatch"
+	select {
+	case w := <-p.pool:
+		w.work <- req
+	case <-req.ctx.Done():
+		req.result <- xerror.New(op, req.ctx.Err())
+	}
+}
+
+func (p *Prinery) completed(w *worker) {
+	const op string = "prinery.Prinerty.completed"
+	go func() {
+		// check process viability.
+		isViable := p.manager.IsViable(w.proc)
+		// check process memory usage.
+		// TODO handle error.
+		memory, _ := p.manager.Memory(w.proc)
+		p.logger.DebugfOp(op, "%s: isViable = %t, memory = %d", w.proc.ID(), isViable, memory)
+		// TODO manage viability and memory usage.
+		// pushing back the worker.
+		p.pool <- w
+	}()
+
+}