ward conflict

Author: FoseFx

libs/common/errors.go

@@ -0,0 +1,29 @@
+package common
+
+import (
+	"common/locale"
+	"context"
+	"google.golang.org/genproto/googleapis/rpc/errdetails"
+	"google.golang.org/grpc/codes"
+	"hwlocale"
+)
+
+// SingleInvalidFieldError builds a NewStatusError
+func SingleInvalidFieldError(ctx context.Context, field, msg string, locale hwlocale.Locale) error {
+	return NewStatusError(ctx,
+		codes.InvalidArgument,
+		msg,
+		locale,
+		&errdetails.BadRequest{
+			FieldViolations: []*errdetails.BadRequest_FieldViolation{
+				{
+					Field:       field,
+					Description: hwlocale.Localize(ctx, locale),
+				},
+			}},
+	)
+}
+
+func UnparsableConsistencyError(ctx context.Context, field string) error {
+	return SingleInvalidFieldError(ctx, field, "consistency not parsable", locale.InvalidFieldError(ctx))
+}

libs/hwutil/parse.go

@@ -131,3 +131,14 @@ type JSONAble interface {
 type MapAble interface {
 	ToMap() map[string]interface{}
 }
+
+func ParseConsistency(consistencyStr *string) (consistency *uint64, success bool) {
+	if consistencyStr == nil {
+		return nil, true
+	}
+	if c, err := strconv.ParseUint(*consistencyStr, 10, 64); err != nil {
+		return nil, false
+	} else {
+		return &c, true
+	}
+}

services/tasks-svc/internal/util/conflict.go

@@ -0,0 +1,26 @@
+package util
+
+import (
+	"fmt"
+	commonpb "gen/libs/common/v1"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/anypb"
+)
+
+// AttributeConflict is a constructor for commonpb.AttributeConflicts
+// I'd love to move this somewhere else, but I also don't want common to depend on gen (and thus hwdb, hwes, ...)
+func AttributeConflict(is, want proto.Message) (*commonpb.AttributeConflict, error) {
+	wantAny, err := anypb.New(want)
+	if err != nil {
+		return nil, fmt.Errorf("AttributeConflict could not marshal want: %w", err)
+	}
+	isAny, err := anypb.New(is)
+	if err != nil {
+		return nil, fmt.Errorf("AttributeConflict could not marshal is: %w", err)
+	}
+
+	return &commonpb.AttributeConflict{
+		Is:   isAny,
+		Want: wantAny,
+	}, nil
+}

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

@@ -1,16 +1,20 @@
 package ward
 
 import (
+	"common"
 	"context"
+	commonpb "gen/libs/common/v1"
 	pb "gen/services/tasks_svc/v1"
 	"github.com/google/uuid"
 	zlog "github.com/rs/zerolog/log"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/wrapperspb"
 	"hwdb"
 	"hwutil"
 	"strconv"
 	"tasks-svc/internal/tracking"
+	"tasks-svc/internal/util"
 	"tasks-svc/repos/ward_repo"
 )
 
@@ -140,16 +144,28 @@ func (ServiceServer) GetRecentWards(ctx context.Context, req *pb.GetRecentWardsR
 }
 
 func (ServiceServer) UpdateWard(ctx context.Context, req *pb.UpdateWardRequest) (*pb.UpdateWardResponse, error) {
-	wardRepo := ward_repo.New(hwdb.GetDB())
-
 	// TODO: Auth
 
 	id, err := uuid.Parse(req.Id)
 	if err != nil {
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
-	consistency, err := wardRepo.UpdateWard(ctx, ward_repo.UpdateWardParams{
+	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()
+	wardRepo := ward_repo.New(tx)
+
+	// Do Update
+	result, err := wardRepo.UpdateWard(ctx, ward_repo.UpdateWardParams{
 		ID:   id,
 		Name: req.Name,
 	})
@@ -158,11 +174,46 @@ func (ServiceServer) UpdateWard(ctx context.Context, req *pb.UpdateWardRequest)
 		return nil, err
 	}
 
+	// conflict detection
+	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 {
+			conflicts["name"], err = util.AttributeConflict(
+				wrapperspb.String(result.OldName),
+				wrapperspb.String(*req.Name),
+			)
+			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.UpdateWardResponse{
+				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
+	}
+
 	tracking.AddWardToRecentActivity(ctx, id.String())
 
 	return &pb.UpdateWardResponse{
-		Conflict:    nil, // TODO
-		Consistency: strconv.FormatUint(uint64(consistency), 10),
+		Conflict:    nil,
+		Consistency: strconv.FormatUint(uint64(result.Consistency), 10),
 	}, nil
 }
 

services/tasks-svc/repos/ward_repo.sql

@@ -55,11 +55,19 @@ SELECT EXISTS (
 ) ward_exists;
 
 -- name: UpdateWard :one
+WITH old_table AS (
+	SELECT name as old_name, consistency as old_consistency
+	FROM wards
+	WHERE wards.id = @id
+)
 UPDATE wards
 SET	name = coalesce(sqlc.narg('name'), name),
 	consistency = consistency + 1
-WHERE id = @id
-RETURNING consistency;
+WHERE wards.id = @id
+RETURNING
+	consistency,
+	(SELECT old_name FROM old_table),
+	(SELECT old_consistency FROM old_table);
 
 
 -- name: DeleteWard :exec

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

@@ -5,6 +5,7 @@ import (
 	pb "gen/services/tasks_svc/v1"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/types/known/wrapperspb"
 	"hwtesting"
 	"hwutil"
 	"strconv"
@@ -377,3 +378,47 @@ func TestGetWardDetails(t *testing.T) {
 	assert.Equal(t, expected, actual)
 
 }
+
+func TestUpdateWardConflict(t *testing.T) {
+	ctx := context.Background()
+	wardClient := wardServiceClient()
+
+	// prepare
+	wardId, initialConsistency := prepareWard(t, ctx, "")
+
+	name1 := "This came first"
+
+	// update 1
+	update1Res, err := wardClient.UpdateWard(ctx, &pb.UpdateWardRequest{
+		Id:          wardId,
+		Name:        &name1,
+		Consistency: &initialConsistency,
+	})
+	assert.NoError(t, err)
+	assert.Nil(t, update1Res.Conflict)
+	assert.NotEqual(t, initialConsistency, update1Res.Consistency)
+
+	name2 := "This came second"
+
+	// racing update 2
+	update2Res, err := wardClient.UpdateWard(ctx, &pb.UpdateWardRequest{
+		Id:          wardId,
+		Name:        &name2,
+		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)
+
+}