From 6850031e80f0d0ae3cb49bcbb601a0a3c16ccea2 Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Sat, 23 Mar 2024 02:51:46 -0600 Subject: [PATCH] Removed log lines, and fixed lock fail logic --- lockable.go | 100 ++++++++++++++++++++++++++++------------------- lockable_test.go | 8 +++- 2 files changed, 66 insertions(+), 42 deletions(-) diff --git a/lockable.go b/lockable.go index 5522ab5..a040eaf 100644 --- a/lockable.go +++ b/lockable.go @@ -111,7 +111,7 @@ func (ext *LockableExt) HandleLinkSignal(ctx *Context, node *Node, source NodeID messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "unknown_action")}) } default: - messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "not_unlocked")}) + messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "not_unlocked: %s", ext.State)}) } return messages, changes @@ -135,7 +135,6 @@ func (ext *LockableExt) HandleUnlockSignal(ctx *Context, node *Node, source Node ext.PendingOwner = nil - ctx.Log.Logf("lockable", "%s transition to Unlocked", node.ID) ext.State = Unlocked messages = append(messages, SendMsg{source, NewSuccessSignal(signal.Id)}) @@ -147,7 +146,6 @@ func (ext *LockableExt) HandleUnlockSignal(ctx *Context, node *Node, source Node ext.ReqID = new(uuid.UUID) *ext.ReqID = signal.Id - ctx.Log.Logf("lockable", "%s transition to Unlocking", node.ID) ext.State = Unlocking for id := range(ext.Requirements) { unlock_signal := NewUnlockSignal() @@ -183,7 +181,6 @@ func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID ext.PendingOwner = new(NodeID) *ext.PendingOwner = source - ctx.Log.Logf("lockable", "%s transition to Locked", node.ID) ext.State = Locked messages = append(messages, SendMsg{source, NewSuccessSignal(signal.Id)}) } else { @@ -195,7 +192,6 @@ func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID ext.ReqID = new(uuid.UUID) *ext.ReqID = signal.Id - ctx.Log.Logf("lockable", "%s transition to Locking", node.ID) ext.State = Locking for id := range(ext.Requirements) { lock_signal := NewLockSignal() @@ -207,7 +203,7 @@ func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID } } default: - messages = append(messages, SendMsg{source, NewErrorSignal(signal.Id, "not_unlocked")}) + messages = append(messages, SendMsg{source, NewErrorSignal(signal.Id, "not_unlocked: %s", ext.State)}) } return messages, changes @@ -225,11 +221,8 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI switch ext.State { case Locking: - changes = append(changes, "state", "pending_owner", "requirements", "req_id") - messages = append(messages, SendMsg{*ext.PendingOwner, NewErrorSignal(*ext.ReqID, signal.Error)}) + changes = append(changes, "state", "requirements") - ext.ReqID = nil - ext.PendingOwner = nil ext.Requirements[id] = Unlocked unlocked := 0 @@ -250,15 +243,19 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI if unlocked == len(ext.Requirements) { changes = append(changes, "owner", "state") - ctx.Log.Logf("lockable", "%s transition to Unlocked", node.ID) ext.State = Unlocked ext.Owner = nil } else { - ctx.Log.Logf("lockable", "%s transition to Unlocking", node.ID) - ext.State = Unlocking + changes = append(changes, "state") + ext.State = AbortingLock } case Unlocking: + unlock_signal := NewUnlockSignal() + ext.Waiting[unlock_signal.Id] = id + messages = append(messages, SendMsg{id, unlock_signal}) + + case AbortingLock: req_state := ext.Requirements[id] // Mark failed lock as Unlocked, or retry unlock switch req_state { @@ -275,7 +272,6 @@ func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeI if unlocked == len(ext.Requirements) { changes = append(changes, "owner", "state") - ctx.Log.Logf("lockable", "%s transition to Unlocked", node.ID) ext.State = Unlocked ext.Owner = nil } @@ -301,30 +297,19 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod delete(ext.Waiting, signal.ReqID) changes = append(changes, "waiting") - req_state := ext.Requirements[id] - switch req_state { + switch ext.State { case Locking: ext.Requirements[id] = Locked - case Unlocking: - ext.Requirements[id] = Unlocked - } - - locked := 0 - unlocked := 0 - for _, req_state := range(ext.Requirements) { - switch req_state { - case Locked: - locked += 1 - case Unlocked: - unlocked += 1 + locked := 0 + for _, req_state := range(ext.Requirements) { + switch req_state { + case Locked: + locked += 1 + } } - } - switch ext.State { - case Locking: if locked == len(ext.Requirements) { changes = append(changes, "state", "owner", "req_id") - ctx.Log.Logf("lockable", "%s transition to Locked", node.ID) ext.State = Locked ext.Owner = new(NodeID) @@ -333,19 +318,54 @@ func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source Nod messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(*ext.ReqID)}) ext.ReqID = nil } - case Unlocking: - if unlocked == len(ext.Requirements) { - changes = append(changes, "state", "owner", "req_id") - ctx.Log.Logf("lockable", "%s transition to Unlocked", node.ID) - ext.State = Unlocked + case AbortingLock: + req_state := ext.Requirements[id] + switch req_state { + case Locking: + ext.Requirements[id] = Unlocking + unlock_signal := NewUnlockSignal() + ext.Waiting[unlock_signal.Id] = id + messages = append(messages, SendMsg{id, unlock_signal}) + case Unlocking: + ext.Requirements[id] = Unlocked + + unlocked := 0 + for _, req_state := range(ext.Requirements) { + switch req_state { + case Unlocked: + unlocked += 1 + } + } - if ext.Owner != nil { - messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(*ext.ReqID)}) + if unlocked == len(ext.Requirements) { + changes = append(changes, "state", "pending_owner", "req_id") + messages = append(messages, SendMsg{*ext.PendingOwner, NewErrorSignal(*ext.ReqID, "not_unlocked: %s", ext.State)}) + ext.State = Unlocked ext.ReqID = nil - ext.Owner = nil + ext.PendingOwner = nil } } + + + case Unlocking: + ext.Requirements[id] = Unlocked + unlocked := 0 + for _, req_state := range(ext.Requirements) { + switch req_state { + case Unlocked: + unlocked += 1 + } + } + + if unlocked == len(ext.Requirements) { + changes = append(changes, "state", "owner", "req_id") + + messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(*ext.ReqID)}) + ext.State = Unlocked + ext.ReqID = nil + ext.Owner = nil + } } } diff --git a/lockable_test.go b/lockable_test.go index ae4d789..8f7728c 100644 --- a/lockable_test.go +++ b/lockable_test.go @@ -79,7 +79,7 @@ func Test1000Lock(t *testing.T) { } func TestLock(t *testing.T) { - ctx := logTestContext(t, []string{"test", "lockable", "signal"}) + ctx := logTestContext(t, []string{"test", "lockable"}) NewLockable := func(reqs []NodeID)(*Node, *ListenerExt) { listener := NewListenerExt(1000) @@ -102,24 +102,28 @@ func TestLock(t *testing.T) { ctx.Log.Logf("test", "l4: %s", l4.ID) ctx.Log.Logf("test", "l5: %s", l5.ID) + ctx.Log.Logf("test", "locking l0") id_1, err := LockLockable(ctx, l0) fatalErr(t, err) response, _, err := WaitForResponse(l0_listener.Chan, time.Millisecond*10, id_1) fatalErr(t, err) ctx.Log.Logf("test", "l0 lock: %+v", response) + ctx.Log.Logf("test", "locking l1") id_2, err := LockLockable(ctx, l1) fatalErr(t, err) - response, _, err = WaitForResponse(l1_listener.Chan, time.Millisecond*10, id_2) + response, _, err = WaitForResponse(l1_listener.Chan, time.Millisecond*1000, id_2) fatalErr(t, err) ctx.Log.Logf("test", "l1 lock: %+v", response) + ctx.Log.Logf("test", "unlocking l0") id_3, err := UnlockLockable(ctx, l0) fatalErr(t, err) response, _, err = WaitForResponse(l0_listener.Chan, time.Millisecond*10, id_3) fatalErr(t, err) ctx.Log.Logf("test", "l0 unlock: %+v", response) + ctx.Log.Logf("test", "locking l1") id_4, err := LockLockable(ctx, l1) fatalErr(t, err) response, _, err = WaitForResponse(l1_listener.Chan, time.Millisecond*10, id_4)