add a store to postprocessing

Signed-off-by: jkoberg <jkoberg@owncloud.com>

services/postprocessing/pkg/service/service.go

@@ -1,10 +1,14 @@
 package service
 
 import (
+	"encoding/json"
+	"fmt"
+
 	"github.com/cs3org/reva/v2/pkg/events"
 	"github.com/owncloud/ocis/v2/ocis-pkg/log"
 	"github.com/owncloud/ocis/v2/services/postprocessing/pkg/config"
 	"github.com/owncloud/ocis/v2/services/postprocessing/pkg/postprocessing"
+	"go-micro.dev/v4/store"
 )
 
 // PostprocessingService is an instance of the service handling postprocessing of files
@@ -13,11 +17,12 @@ type PostprocessingService struct {
 	events <-chan events.Event
 	pub    events.Publisher
 	steps  []events.Postprocessingstep
+	store  store.Store
 	c      config.Postprocessing
 }
 
 // NewPostprocessingService returns a new instance of a postprocessing service
-func NewPostprocessingService(stream events.Stream, logger log.Logger, c config.Postprocessing) (*PostprocessingService, error) {
+func NewPostprocessingService(stream events.Stream, logger log.Logger, sto store.Store, c config.Postprocessing) (*PostprocessingService, error) {
 	evs, err := events.Consume(stream, "postprocessing",
 		events.BytesReceived{},
 		events.StartPostprocessingStep{},
@@ -33,36 +38,51 @@ func NewPostprocessingService(stream events.Stream, logger log.Logger, c config.
 		events: evs,
 		pub:    stream,
 		steps:  getSteps(c),
+		store:  sto,
 		c:      c,
 	}, nil
 }
 
 // Run to fulfil Runner interface
 func (pps *PostprocessingService) Run() error {
-	current := make(map[string]*postprocessing.Postprocessing)
 	for e := range pps.events {
 		var next interface{}
 		switch ev := e.Event.(type) {
 		case events.BytesReceived:
 			pp := postprocessing.New(ev.UploadID, ev.URL, ev.ExecutingUser, ev.Filename, ev.Filesize, ev.ResourceID, pps.steps, pps.c.Delayprocessing)
-			current[ev.UploadID] = pp
+			if err := storePP(pps.store, pp); err != nil {
+				pps.log.Error().Str("uploadID", ev.UploadID).Err(err).Msg("cannot store upload")
+				continue
+			}
+
 			next = pp.Init(ev)
 		case events.PostprocessingStepFinished:
-			pp := current[ev.UploadID]
-			if pp == nil {
+			if ev.UploadID == "" {
 				// no current upload - this was an on demand scan
 				continue
 			}
+			pp, err := getPP(pps.store, ev.UploadID)
+			if err != nil {
+				pps.log.Error().Str("uploadID", ev.UploadID).Err(err).Msg("cannot get upload")
+				continue
+			}
 			next = pp.NextStep(ev)
 		case events.StartPostprocessingStep:
 			if ev.StepToStart != events.PPStepDelay {
 				continue
 			}
-			pp := current[ev.UploadID]
+			pp, err := getPP(pps.store, ev.UploadID)
+			if err != nil {
+				pps.log.Error().Str("uploadID", ev.UploadID).Err(err).Msg("cannot get upload")
+				continue
+			}
 			next = pp.Delay(ev)
 		case events.UploadReady:
 			// the storage provider thinks the upload is done - so no need to keep it any more
-			delete(current, ev.UploadID)
+			if err := pps.store.Delete(ev.UploadID); err != nil {
+				pps.log.Error().Str("uploadID", ev.UploadID).Err(err).Msg("cannot delete upload")
+				continue
+			}
 		}
 
 		if next != nil {
@@ -87,3 +107,29 @@ func getSteps(c config.Postprocessing) []events.Postprocessingstep {
 
 	return steps
 }
+
+func storePP(sto store.Store, pp *postprocessing.Postprocessing) error {
+	b, err := json.Marshal(pp)
+	if err != nil {
+		return err
+	}
+
+	return sto.Write(&store.Record{
+		Key:   pp.ID,
+		Value: b,
+	})
+}
+
+func getPP(sto store.Store, uploadID string) (*postprocessing.Postprocessing, error) {
+	recs, err := sto.Read(uploadID)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(recs) != 1 {
+		return nil, fmt.Errorf("expected only one result for '%s', got %d", uploadID, len(recs))
+	}
+
+	var pp postprocessing.Postprocessing
+	return &pp, json.Unmarshal(recs[0].Value, &pp)
+}