chore: reva bump -2.48.0 (#3230)

vendor/github.com/opencloud-eu/reva/v2/pkg/storage/cache/kv.go

@@ -27,15 +27,15 @@ func NewNatsKeyValue(c Config, log *zerolog.Logger) (jetstream.KeyValue, error)
 	}
 	opts := []nats.Option{
 		nats.DisconnectErrHandler(func(nc *nats.Conn, err error) {
-			log.Error().Err(err).Msg("Disconnected from NATS. Trying to reconnect...")
+			log.Error().Err(err).Str("database", c.Database).Msg("Disconnected from NATS. Trying to reconnect...")
 		}),
 		nats.ReconnectHandler(func(nc *nats.Conn) {
-			log.Error().Msgf("Successfully reconnected to NATS at: %s", nc.ConnectedUrl())
+			log.Error().Str("database", c.Database).Msgf("Successfully reconnected to NATS at: %s", nc.ConnectedUrl())
 		}),
 		nats.ClosedHandler(func(nc *nats.Conn) {
 			// Alright, it's time to give up. Send ourselves a SIGTERM to trigger a graceful
 			// shutdown of the service.
-			log.Error().Msg("NATS connection closed permanently. Shutting down...")
+			log.Error().Str("database", c.Database).Msg("NATS connection closed permanently. Shutting down...")
 
 			pid := os.Getpid()
 			process, err := os.FindProcess(pid)

vendor/github.com/opencloud-eu/reva/v2/pkg/storage/pkg/decomposedfs/metadata/hybrid_backend.go

@@ -500,9 +500,21 @@ func (b HybridBackend) Lock(n MetadataNode) (UnlockFunc, error) {
 	mlock, err := lockedfile.OpenFile(metaLockPath, os.O_RDWR|os.O_CREATE, 0600)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
-			// create the parent directory
-			err = os.MkdirAll(filepath.Dir(metaLockPath), 0700)
-			if err != nil {
+			// The lock file's parent directories don't exist yet (or anymore).
+			// We may only create the space's metadata directories, never the
+			// space's base directory itself: locking a node (i.e. the space
+			// root) whose space has been removed (or has not been created yet)
+			// must not resurrect the spaca.
+			base := b.metadataPathFunc(n)
+			if base == "" {
+				return nil, err
+			}
+			// base is the space's metadata directory (e.g. <spaceRoot>/.oc-nodes),
+			// so its parent is the space's base directory.
+			if _, statErr := os.Stat(filepath.Dir(base)); statErr != nil {
+				return nil, statErr
+			}
+			if err = os.MkdirAll(filepath.Dir(metaLockPath), 0700); err != nil {
 				return nil, err
 			}
 			mlock, err = lockedfile.OpenFile(metaLockPath, os.O_RDWR|os.O_CREATE, 0600)

vendor/github.com/opencloud-eu/reva/v2/pkg/storage/pkg/decomposedfs/tree/propagator/async.go

@@ -282,8 +282,10 @@ func (p AsyncPropagator) propagate(ctx context.Context, spaceID, nodeID string,
 
 	attrs := node.Attributes{}
 
+	// lock parent before reading treesize or tree time
+	// we deliberately allow reading disabled spaces so that the metadata is always consistent (see https://github.com/opencloud-eu/reva/issues/747)
 	_, subspan = tracer.Start(ctx, "node.LockAndReadNode")
-	n, unlock, err := node.LockAndReadNode(ctx, p.lookup, spaceID, nodeID, "", false, nil, false)
+	n, unlock, err := node.LockAndReadNode(ctx, p.lookup, spaceID, nodeID, "", true, nil, false)
 	subspan.End()
 	if err != nil {
 		if n != nil && !n.Exists {

vendor/github.com/opencloud-eu/reva/v2/pkg/storage/pkg/decomposedfs/tree/propagator/sync.go

@@ -92,7 +92,8 @@ func (p SyncPropagator) propagateItem(ctx context.Context, n *node.Node, sTime t
 	attrs := node.Attributes{}
 
 	// lock parent before reading treesize or tree time
-	n, unlock, err := node.LockAndReadNode(ctx, p.lookup, n.SpaceID, n.ParentID, "", false, n.SpaceRoot, false)
+	// we deliberately allow reading disabled spaces so that the metadata is always consistent (see https://github.com/opencloud-eu/reva/issues/747)
+	n, unlock, err := node.LockAndReadNode(ctx, p.lookup, n.SpaceID, n.ParentID, "", true, n.SpaceRoot, false)
 	if err != nil {
 		return nil, true, err
 	}

vendor/github.com/opencloud-eu/reva/v2/pkg/utils/grpc.go

@@ -252,6 +252,12 @@ func IsSpaceRoot(ri *storageprovider.ResourceInfo) bool {
 	return f.GetOpaqueId() == s.GetOpaqueId() && f.GetSpaceId() == s.GetSpaceId()
 }
 
+// IsProcessing checks if the given resource info is still being processed
+// (e.g. postprocessing after an upload has not finished yet).
+func IsProcessing(ri *storageprovider.ResourceInfo) bool {
+	return ReadPlainFromOpaque(ri.GetOpaque(), "status") == "processing"
+}
+
 func checkStatusCode(reason, message string, code rpc.Code) error {
 	if code == rpc.Code_CODE_OK {
 		return nil