bed conflicts

Author: FoseFx

services/tasks-svc/internal/bed/bed.go

@@ -3,12 +3,15 @@ package bed
 import (
 	"common"
 	"context"
+	commonpb "gen/libs/common/v1"
 	"github.com/jackc/pgx/v5/pgconn"
 	"google.golang.org/genproto/googleapis/rpc/errdetails"
+	"google.golang.org/protobuf/types/known/wrapperspb"
 	"hwdb"
 	"hwlocale"
 	"hwutil"
 	"strconv"
+	"tasks-svc/internal/util"
 	"tasks-svc/locale"
 	"tasks-svc/repos/bed_repo"
 
@@ -186,7 +189,6 @@ func (ServiceServer) GetBedsByRoom(ctx context.Context, req *pb.GetBedsByRoomReq
 }
 
 func (ServiceServer) UpdateBed(ctx context.Context, req *pb.UpdateBedRequest) (*pb.UpdateBedResponse, error) {
-	bedRepo := bed_repo.New(hwdb.GetDB())
 
 	bedID, err := uuid.Parse(req.Id)
 	if err != nil {
@@ -198,7 +200,21 @@ func (ServiceServer) UpdateBed(ctx context.Context, req *pb.UpdateBedRequest) (*
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
-	consistency, err := bedRepo.UpdateBed(ctx, bed_repo.UpdateBedParams{
+	expConsistency, ok := hwutil.ParseConsistency(req.Consistency)
+	if !ok {
+		return nil, common.UnparsableConsistencyError(ctx, "consistency")
+	}
+
+	// Start TX
+	tx, rollback, err := hwdb.BeginTx(hwdb.GetDB(), ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer rollback()
+	bedRepo := bed_repo.New(tx)
+
+	// do update
+	result, err := bedRepo.UpdateBed(ctx, bed_repo.UpdateBedParams{
 		ID:     bedID,
 		Name:   req.Name,
 		RoomID: roomId,
@@ -208,9 +224,52 @@ func (ServiceServer) UpdateBed(ctx context.Context, req *pb.UpdateBedRequest) (*
 		return nil, err
 	}
 
+	// conflict detection
+	if expConsistency != nil && *expConsistency != uint64(result.OldConsistency) {
+		conflicts := make(map[string]*commonpb.AttributeConflict)
+
+		if req.Name != nil && *req.Name != result.OldName {
+			conflicts["name"], err = util.AttributeConflict(
+				wrapperspb.String(result.OldName),
+				wrapperspb.String(*req.Name),
+			)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if req.RoomId != nil && *req.RoomId != result.OldRoomID.String() {
+			conflicts["room_id"], err = util.AttributeConflict(
+				wrapperspb.String(result.OldRoomID.String()),
+				wrapperspb.String(*req.RoomId),
+			)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if len(conflicts) != 0 {
+			// prevent the update
+			if err := hwdb.Error(ctx, tx.Rollback(ctx)); err != nil {
+				return nil, err
+			}
+
+			// return conflict
+			return &pb.UpdateBedResponse{
+				Conflict:    &commonpb.Conflict{ConflictingAttributes: conflicts},
+				Consistency: strconv.FormatUint(uint64(result.OldConsistency), 10),
+			}, nil
+		}
+	}
+
+	// commit update
+	if err := hwdb.Error(ctx, tx.Commit(ctx)); err != nil {
+		return nil, err
+	}
+
 	return &pb.UpdateBedResponse{
-		Conflict:    nil, // TODO
-		Consistency: strconv.FormatUint(uint64(consistency), 10),
+		Conflict:    nil,
+		Consistency: strconv.FormatUint(uint64(result.Consistency), 10),
 	}, nil
 }
 

services/tasks-svc/internal/ward/ward.go

@@ -178,9 +178,7 @@ func (ServiceServer) UpdateWard(ctx context.Context, req *pb.UpdateWardRequest)
 	if expConsistency != nil && *expConsistency != uint64(result.OldConsistency) {
 		conflicts := make(map[string]*commonpb.AttributeConflict)
 
-		// wards are not event-sourced, we thus don't have information on what has changed since
-		// however, wards (currently) only have one field: Name, thus it must have been changed
-		if req.Name != nil {
+		if req.Name != nil && *req.Name != result.OldName {
 			conflicts["name"], err = util.AttributeConflict(
 				wrapperspb.String(result.OldName),
 				wrapperspb.String(*req.Name),

services/tasks-svc/repos/bed_repo.sql

@@ -27,13 +27,25 @@ WHERE (room_id = sqlc.narg('room_id') OR sqlc.narg('room_id') IS NULL)
 ORDER BY name ASC;
 
 -- name: UpdateBed :one
+WITH old_table AS (
+	SELECT
+		name as old_name,
+		room_id as old_room_id,
+		consistency	as old_consistency
+	FROM beds
+	WHERE beds.id = @id
+)
 UPDATE beds
 SET
 	name = coalesce(sqlc.narg('name'), name),
 	room_id = coalesce(sqlc.narg('room_id'), room_id),
 	consistency = consistency + 1
-WHERE id = @id
-RETURNING consistency;
+WHERE beds.id = @id
+RETURNING
+	consistency,
+	(SELECT old_name FROM old_table),
+	(SELECT old_room_id FROM old_table),
+	(SELECT old_consistency FROM old_table);
 
 -- name: DeleteBed :exec
 DELETE FROM beds WHERE id = $1;

services/tasks-svc/repos/bed_repo/bed_repo.sql.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	pb "gen/services/tasks_svc/v1"
 	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/types/known/wrapperspb"
 	"hwutil"
 	"strconv"
 	"testing"
@@ -177,3 +178,77 @@ func TestGetBeds(t *testing.T) {
 
 	}
 }
+
+func TestUpdateBedConflict(t *testing.T) {
+	ctx := context.Background()
+	bedClient := bedServiceClient()
+
+	// prepare
+	wardId, _ := prepareWard(t, ctx, "")
+	roomId0, _ := prepareRoom(t, ctx, wardId, "0")
+
+	bedId, initialConsistency := prepareBed(t, ctx, roomId0, "")
+
+	name1 := "This came first"
+	roomId1, _ := prepareRoom(t, ctx, wardId, "1")
+
+	// update 1
+	update1Res, err := bedClient.UpdateBed(ctx, &pb.UpdateBedRequest{
+		Id:          bedId,
+		Name:        &name1,
+		RoomId:      &roomId1,
+		Consistency: &initialConsistency,
+	})
+	assert.NoError(t, err)
+	assert.Nil(t, update1Res.Conflict)
+	assert.NotEqual(t, initialConsistency, update1Res.Consistency)
+
+	name2 := "This came second"
+	roomId2, _ := prepareRoom(t, ctx, wardId, "2")
+
+	// racing update 2
+	update2Res, err := bedClient.UpdateBed(ctx, &pb.UpdateBedRequest{
+		Id:          bedId,
+		Name:        &name2,
+		RoomId:      &roomId2,
+		Consistency: &initialConsistency,
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, update1Res.Consistency, update2Res.Consistency)
+	assert.NotNil(t, update2Res.Conflict)
+
+	nameRes := update2Res.Conflict.ConflictingAttributes["name"]
+	assert.NotNil(t, nameRes)
+
+	nameIs := &wrapperspb.StringValue{}
+	assert.NoError(t, nameRes.Is.UnmarshalTo(nameIs))
+	assert.Equal(t, name1, nameIs.Value)
+
+	nameWant := &wrapperspb.StringValue{}
+	assert.NoError(t, nameRes.Want.UnmarshalTo(nameWant))
+	assert.Equal(t, name2, nameWant.Value)
+
+	roomRes := update2Res.Conflict.ConflictingAttributes["room_id"]
+	assert.NotNil(t, roomRes)
+
+	roomIs := &wrapperspb.StringValue{}
+	assert.NoError(t, roomRes.Is.UnmarshalTo(roomIs))
+	assert.Equal(t, roomId1, roomIs.Value)
+
+	roomWant := &wrapperspb.StringValue{}
+	assert.NoError(t, roomRes.Want.UnmarshalTo(roomWant))
+	assert.Equal(t, roomId2, roomWant.Value)
+
+	// racing update 3
+	update3Res, err := bedClient.UpdateBed(ctx, &pb.UpdateBedRequest{
+		Id:          bedId,
+		Name:        &name2,
+		Consistency: &initialConsistency,
+	})
+	assert.NoError(t, err)
+	assert.Equal(t, update1Res.Consistency, update2Res.Consistency)
+	assert.NotNil(t, update2Res.Conflict)
+
+	assert.NotNil(t, update3Res.Conflict.ConflictingAttributes["name"])
+	assert.Nil(t, update3Res.Conflict.ConflictingAttributes["room_id"])
+}