Release 4.68.0

api/endpoints/memoisation.go

@@ -22,10 +22,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"strings"
 
 	"github.com/pixlise/core/v4/api/dbCollections"
 	apiRouter "github.com/pixlise/core/v4/api/router"
 	"github.com/pixlise/core/v4/api/ws/wsHelpers"
+	"github.com/pixlise/core/v4/core/client"
 	"github.com/pixlise/core/v4/core/errorwithstatus"
 	"github.com/pixlise/core/v4/core/utils"
 	protos "github.com/pixlise/core/v4/generated-protos"
@@ -123,6 +125,8 @@ func PutMemoise(params apiRouter.ApiHandlerGenericParams) error {
 		return err
 	}
 
+	isClientSavedMap := strings.HasPrefix(key, client.ClientMapKeyPrefix)
+
 	// Ensure key is either empty or the same as the key in the query param
 	if len(reqItem.Key) > 0 && key != reqItem.Key {
 		return errorwithstatus.MakeBadRequestError(errors.New("Memoisation item key doesn't match query parameter"))
@@ -147,6 +151,12 @@ func PutMemoise(params apiRouter.ApiHandlerGenericParams) error {
 		ExprId:              reqItem.ExprId,
 		DataSize:            uint32(len(reqItem.Data)),
 		LastReadTimeUnixSec: timestamp, // Right now this is the last time it was accessed. To be updated in future get calls
+		MemoWriterUserId:    params.UserInfo.UserID,
+	}
+
+	// If we're a client-library side saved map, we don't want this item wiped out by garbage collection!
+	if isClientSavedMap {
+		item.NoGC = true
 	}
 
 	result, err := coll.UpdateByID(ctx, reqItem.Key, bson.D{{Key: "$set", Value: item}}, opt)
@@ -163,5 +173,10 @@ func PutMemoise(params apiRouter.ApiHandlerGenericParams) error {
 	ts := fmt.Sprintf(`{"timestamp": %v}`, timestamp)
 	params.Writer.Write([]byte(ts))
 
+	// If user just saved a client-side created map, notify that it changed as they may be viewing it in a PIXLISE UI instance
+	if isClientSavedMap {
+		params.Svcs.Notifier.SysNotifyMapChanged(key)
+	}
+
 	return nil
 }

api/memoisation/garbageCollection.go

@@ -25,13 +25,13 @@ func collectGarbage(mongoDB *mongo.Database, oldestAllowedSec uint32, ts timesta
 
 	ctx := context.TODO()
 	opts := options.Delete()
-	filter := bson.M{"lastreadtimeunixsec": bson.M{"$lt": oldestAllowedUnixSec}}
+	filter := bson.M{"lastreadtimeunixsec": bson.M{"$lt": oldestAllowedUnixSec}, "nogc": false}
 	coll := mongoDB.Collection(dbCollections.MemoisedItemsName)
 
 	delResult, err := coll.DeleteMany(ctx, filter, opts)
 	if err != nil {
 		log.Errorf("Memoisation GC delete error: %v", err)
+	} else {
+		log.Infof("Memoisation GC deleted %v items", delResult.DeletedCount)
 	}
-
-	log.Infof("Memoisation GC deleted %v items", delResult.DeletedCount)
 }

api/memoisation/garbageCollection_test.go

@@ -20,7 +20,7 @@ func Example_CollectGarbage() {
 
 	// Insert an item that's too old, and one that's newly accessed
 	ts := &timestamper.MockTimeNowStamper{
-		QueuedTimeStamps: []int64{1234567890, 1234567890, 1234567890, 1234567890},
+		QueuedTimeStamps: []int64{1234567890, 1234567890, 1234567890},
 	}
 
 	now := uint32(ts.GetTimeNowSec())
@@ -50,12 +50,32 @@ func Example_CollectGarbage() {
 	_, err = coll.UpdateByID(ctx, item.Key, bson.D{{Key: "$set", Value: item}}, opt)
 	fmt.Printf("Insert 2: %v\n", err)
 
+	item = &protos.MemoisedItem{
+		Key:                 "key789",
+		MemoTimeUnixSec:     now - maxAge - 60,
+		Data:                []byte{10, 20, 30},
+		ScanId:              "scan222",
+		DataSize:            uint32(5),
+		LastReadTimeUnixSec: now - 5,
+		NoGC:                true,
+	}
+	_, err = coll.UpdateByID(ctx, item.Key, bson.D{{Key: "$set", Value: item}}, opt)
+	fmt.Printf("Insert 3: %v\n", err)
+
 	log := &logger.StdOutLogger{}
+	// Should delete one based on time
+	collectGarbage(db, maxAge, ts, log)
+
+	// Should delete the other based on time, no GC should stay
+	maxAge = 1
 	collectGarbage(db, maxAge, ts, log)
 
 	// Output:
 	// Insert 1: <nil>
 	// Insert 2: <nil>
+	// Insert 3: <nil>
+	// INFO: Memoisation GC starting...
+	// INFO: Memoisation GC deleted 1 items
 	// INFO: Memoisation GC starting...
 	// INFO: Memoisation GC deleted 1 items
 }

api/notificationSender/interfaceImplementation.go

@@ -77,6 +77,28 @@ func (n *NotificationSender) SysNotifyScanChanged(scanId string) {
 	n.sendSysNotification(wsSysNotify)
 }
 
+func (n *NotificationSender) SysNotifyROIChanged(roiId string) {
+	wsSysNotify := &protos.NotificationUpd{
+		Notification: &protos.Notification{
+			NotificationType: protos.NotificationType_NT_SYS_DATA_CHANGED,
+			RoiId:            roiId,
+		},
+	}
+
+	n.sendSysNotification(wsSysNotify)
+}
+
+func (n *NotificationSender) SysNotifyMapChanged(mapId string) {
+	wsSysNotify := &protos.NotificationUpd{
+		Notification: &protos.Notification{
+			NotificationType: protos.NotificationType_NT_SYS_DATA_CHANGED,
+			MapId:            mapId,
+		},
+	}
+
+	n.sendSysNotification(wsSysNotify)
+}
+
 func (n *NotificationSender) NotifyNewScanImage(scanName string, scanId string, imageName string) {
 	notifMsg := &protos.NotificationUpd{
 		Notification: &protos.Notification{

api/services/notifierInterface.go

@@ -13,6 +13,12 @@ type INotifier interface {
 	// NOTE: This does NOT send emails, it's of system-level interest only so UI can update caches as required
 	SysNotifyScanChanged(scanId string)
 
+	// When an ROI has changed
+	SysNotifyROIChanged(roiId string)
+
+	// When a map (created by client library saveMapData function) has changed
+	SysNotifyMapChanged(mapId string)
+
 	// When an image is added to a scan
 	NotifyNewScanImage(scanName string, scanId string, imageName string)
 

api/ws/handlers/image-beam-location.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pixlise/core/v4/api/dbCollections"
 	"github.com/pixlise/core/v4/api/ws/wsHelpers"
 	"github.com/pixlise/core/v4/core/errorwithstatus"
+	"github.com/pixlise/core/v4/core/utils"
 	protos "github.com/pixlise/core/v4/generated-protos"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -236,3 +237,119 @@ func HandleImageBeamLocationVersionsReq(req *protos.ImageBeamLocationVersionsReq
 		BeamVersionPerScan: vers,
 	}, nil
 }
+
+func HandleImageBeamLocationUploadReq(req *protos.ImageBeamLocationUploadReq, hctx wsHelpers.HandlerContext) (*protos.ImageBeamLocationUploadResp, error) {
+	ctx := context.TODO()
+
+	if err := wsHelpers.CheckStringField(&req.ImageName, "ImageName", 1, 255); err != nil {
+		return nil, err
+	}
+
+	if req.Location == nil {
+		return nil, fmt.Errorf("Request missing location")
+	}
+
+	// For now, we only allow uploading version 0 so we don't clash with FM versioning
+	if req.Location.BeamVersion != 0 {
+		return nil, fmt.Errorf("Currently only version 0 supported for image beam location upload")
+	}
+
+	// Check that it's a valid image name
+	coll := hctx.Svcs.MongoDB.Collection(dbCollections.ImagesName)
+	imgResult := coll.FindOne(ctx, bson.M{"_id": req.ImageName})
+	if imgResult.Err() != nil {
+		if imgResult.Err() == mongo.ErrNoDocuments {
+			return nil, errorwithstatus.MakeNotFoundError(req.ImageName)
+		}
+		return nil, imgResult.Err()
+	}
+
+	img := protos.ScanImage{}
+	err := imgResult.Decode(&img)
+	if err != nil {
+		return nil, err
+	}
+
+	// NOTE: Once beam location saving works, we will update the "associated scans" list for the image!!
+
+	// Check that the scan ID is valid too
+	coll = hctx.Svcs.MongoDB.Collection(dbCollections.ScansName)
+	scanResult := coll.FindOne(ctx, bson.M{"_id": req.Location.ScanId})
+
+	if scanResult.Err() != nil {
+		if scanResult.Err() == mongo.ErrNoDocuments {
+			return nil, errorwithstatus.MakeNotFoundError(req.Location.ScanId)
+		}
+		return nil, scanResult.Err()
+	}
+
+	// Now load beam locations if any already stored.
+	coll = hctx.Svcs.MongoDB.Collection(dbCollections.ImageBeamLocationsName)
+
+	// Read what's there now
+	var dbLocs *protos.ImageLocations
+
+	imgBeamResult := coll.FindOne(ctx, bson.M{"_id": req.ImageName})
+	if imgBeamResult.Err() != nil {
+		if imgBeamResult.Err() != mongo.ErrNoDocuments {
+			return nil, imgBeamResult.Err()
+		}
+
+		// Doesn't exist yet, that's OK - we're new, just start with a blank structure
+		dbLocs = &protos.ImageLocations{
+			ImageName:       req.ImageName,
+			LocationPerScan: []*protos.ImageLocationsForScan{},
+		}
+	} else {
+		err := imgBeamResult.Decode(&dbLocs)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Add ours to the list. If there's an existing one, overwrite it
+	added := false
+	for _, locPerScan := range dbLocs.LocationPerScan {
+		if locPerScan.ScanId == req.Location.ScanId && locPerScan.BeamVersion == req.Location.BeamVersion {
+			// Overwriting this one
+			locPerScan.Instrument = req.Location.Instrument
+			locPerScan.Locations = req.Location.Locations
+			added = true
+			break
+		}
+	}
+
+	if !added {
+		// We need to add one
+		dbLocs.LocationPerScan = append(dbLocs.LocationPerScan, req.Location)
+	}
+
+	// Now we put it back
+	opt := options.Update().SetUpsert(true)
+
+	beamResult, err := coll.UpdateByID(ctx, req.ImageName, bson.D{{Key: "$set", Value: dbLocs}}, opt)
+	if err != nil {
+		return nil, err
+	}
+
+	if beamResult.MatchedCount == 0 && beamResult.ModifiedCount == 0 {
+		hctx.Svcs.Log.Errorf("ImageBeamLocationUploadReq got unexpected image beam location upsert result: %+v", beamResult)
+	}
+
+	// Update the associated scans of the image itself
+	if !utils.ItemInSlice(req.Location.ScanId, img.AssociatedScanIds) {
+		// Add it here
+		img.AssociatedScanIds = append(img.AssociatedScanIds, req.Location.ScanId)
+
+		coll := hctx.Svcs.MongoDB.Collection(dbCollections.ImagesName)
+		imgUpdResult, err := coll.UpdateByID(ctx, req.ImageName, bson.D{{Key: "$set", Value: dbLocs}}, opt)
+		if err != nil {
+			return nil, err
+		}
+		if imgUpdResult.MatchedCount == 0 && imgUpdResult.ModifiedCount == 0 {
+			hctx.Svcs.Log.Errorf("ImageBeamLocationUploadReq got unexpected image upsert result: %+v", imgUpdResult)
+		}
+	}
+
+	return &protos.ImageBeamLocationUploadResp{}, nil
+}

api/ws/handlers/ownership-access.go

@@ -52,10 +52,18 @@ func HandleObjectEditAccessReq(req *protos.ObjectEditAccessReq, hctx wsHelpers.H
 
 	ctx := context.TODO()
 
+	viewOnlyAccess := false
+
 	// Determine if we have edit access to the object
 	owner, err := wsHelpers.CheckObjectAccess(true, req.ObjectId, req.ObjectType, hctx)
 	if err != nil {
-		return nil, err
+		owner, err = wsHelpers.CheckObjectAccess(false, req.ObjectId, req.ObjectType, hctx)
+		if err != nil {
+			return nil, err
+		}
+
+		// If we have view access, we can't add editors, but we can add viewers
+		viewOnlyAccess = true
 	}
 
 	viewerUsers := map[string]bool{}
@@ -74,7 +82,7 @@ func HandleObjectEditAccessReq(req *protos.ObjectEditAccessReq, hctx wsHelpers.H
 	}
 
 	// Add new ones
-	if req.AddEditors != nil {
+	if req.AddEditors != nil && !viewOnlyAccess {
 		readToMap(req.AddEditors.UserIds, &editorUsers)
 		readToMap(req.AddEditors.GroupIds, &editorGroups)
 	}
@@ -84,12 +92,12 @@ func HandleObjectEditAccessReq(req *protos.ObjectEditAccessReq, hctx wsHelpers.H
 	}
 
 	// Delete ones that need to be deleted
-	if req.DeleteEditors != nil {
+	if req.DeleteEditors != nil && !viewOnlyAccess {
 		deleteFromMap(req.DeleteEditors.UserIds, &editorUsers)
 		deleteFromMap(req.DeleteEditors.GroupIds, &editorGroups)
 	}
 
-	if req.DeleteViewers != nil {
+	if req.DeleteViewers != nil && !viewOnlyAccess {
 		deleteFromMap(req.DeleteViewers.UserIds, &viewerUsers)
 		deleteFromMap(req.DeleteViewers.GroupIds, &viewerGroups)
 	}