128 lines
3.2 KiB
Go
128 lines
3.2 KiB
Go
package processor
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"screenmark/screenmark/.gen/haystack/haystack/model"
|
|
"screenmark/screenmark/agents"
|
|
"screenmark/screenmark/models"
|
|
"screenmark/screenmark/notifications"
|
|
"sync"
|
|
|
|
"github.com/charmbracelet/log"
|
|
)
|
|
|
|
const STACK_PROCESS_AT_A_TIME = 10
|
|
|
|
// TODO:
|
|
// This processor contains a lot of shared stuff.
|
|
// If we ever want to do more generic stuff with "in-progress" and stuff
|
|
// we can extract that into a common thing
|
|
//
|
|
// However, this will require a pretty big DB shuffle.
|
|
|
|
type StackProcessor struct {
|
|
stackModel models.StackModel
|
|
logger *log.Logger
|
|
|
|
stackAgent agents.CreateListAgent
|
|
|
|
Processor *Processor[model.Stacks]
|
|
|
|
notifier *notifications.Notifier[notifications.Notification]
|
|
}
|
|
|
|
func (p *StackProcessor) setStackToProcess(ctx context.Context, stack model.Stacks) {
|
|
err := p.stackModel.UpdateProcess(ctx, stack.ID, model.Progress_InProgress)
|
|
if err != nil {
|
|
// TODO: what can we actually do here for the errors?
|
|
// We can't stop the work for the others
|
|
|
|
p.logger.Error("failed to update stack", "err", err)
|
|
|
|
// TODO: we can use context here to actually pass some information through
|
|
return
|
|
}
|
|
}
|
|
|
|
func (p *StackProcessor) extractInfo(ctx context.Context, stack model.Stacks) {
|
|
err := p.stackAgent.CreateList(p.logger, stack.UserID, stack.Name, stack.Description)
|
|
if err != nil {
|
|
// Again, wtf do we do?
|
|
// Although i think the agent actually returns an error when it's finished
|
|
p.logger.Error("failed to process image", "err", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (p *StackProcessor) processImage(stack model.Stacks) {
|
|
p.logger.Info("Processing image", "ID", stack.ID)
|
|
|
|
ctx := context.Background()
|
|
|
|
p.setStackToProcess(ctx, stack)
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
// Future proofing!
|
|
wg.Add(1)
|
|
|
|
stackNotification := notifications.GetStackNotification(notifications.StackNotification{
|
|
Type: notifications.STACK_TYPE,
|
|
Status: string(model.Progress_InProgress),
|
|
StackID: stack.ID,
|
|
Name: stack.Name,
|
|
})
|
|
|
|
err := p.notifier.SendAndCreate(stack.UserID.String(), stackNotification)
|
|
if err != nil {
|
|
p.logger.Error("sending in progress notification", "err", err)
|
|
return
|
|
}
|
|
|
|
go func() {
|
|
p.extractInfo(ctx, stack)
|
|
wg.Done()
|
|
}()
|
|
|
|
wg.Wait()
|
|
|
|
// TODO: there is some repeated code here. The ergonomicts of the notifications,
|
|
// isn't the best.
|
|
stackNotification = notifications.GetStackNotification(notifications.StackNotification{
|
|
Type: notifications.STACK_TYPE,
|
|
Status: string(model.Progress_Complete),
|
|
StackID: stack.ID,
|
|
Name: stack.Name,
|
|
})
|
|
|
|
err = p.notifier.SendAndCreate(stack.UserID.String(), stackNotification)
|
|
if err != nil {
|
|
p.logger.Error("sending done notification", "err", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
func NewStackProcessor(
|
|
logger *log.Logger,
|
|
stackModel models.StackModel,
|
|
notifier *notifications.Notifier[notifications.Notification],
|
|
) (StackProcessor, error) {
|
|
if notifier == nil {
|
|
return StackProcessor{}, fmt.Errorf("notifier is nil")
|
|
}
|
|
|
|
stackAgent := agents.NewCreateListAgent(logger, stackModel)
|
|
|
|
imageProcessor := StackProcessor{
|
|
logger: logger,
|
|
stackModel: stackModel,
|
|
stackAgent: stackAgent,
|
|
notifier: notifier,
|
|
}
|
|
|
|
imageProcessor.Processor = NewProcessor(int(IMAGE_PROCESS_AT_A_TIME), imageProcessor.processImage)
|
|
|
|
return imageProcessor, nil
|
|
}
|