423 lines
14 KiB
Go
423 lines
14 KiB
Go
package graphvent
|
|
|
|
import (
|
|
"github.com/google/uuid"
|
|
"time"
|
|
)
|
|
|
|
type ReqState byte
|
|
const (
|
|
Unlocked = ReqState(0)
|
|
Unlocking = ReqState(1)
|
|
Locked = ReqState(2)
|
|
Locking = ReqState(3)
|
|
AbortingLock = ReqState(4)
|
|
)
|
|
|
|
var ReqStateStrings = map[ReqState]string {
|
|
Unlocked: "Unlocked",
|
|
Unlocking: "Unlocking",
|
|
Locked: "Locked",
|
|
Locking: "Locking",
|
|
AbortingLock: "AbortingLock",
|
|
}
|
|
|
|
type LockableExt struct{
|
|
State ReqState `gv:"lockable_state"`
|
|
ReqID *uuid.UUID `gv:"req_id"`
|
|
Owner *NodeID `gv:"owner" node:"Base"`
|
|
PendingOwner *NodeID `gv:"pending_owner" node:"Base"`
|
|
PendingID uuid.UUID `gv:"pending_id"`
|
|
Requirements map[NodeID]ReqState `gv:"requirements" node:"Lockable:"`
|
|
WaitInfos WaitMap `gv:"wait_infos" node:":Base"`
|
|
}
|
|
|
|
func NewLockableExt(requirements []NodeID) *LockableExt {
|
|
var reqs map[NodeID]ReqState = nil
|
|
if requirements != nil {
|
|
reqs = map[NodeID]ReqState{}
|
|
for _, id := range(requirements) {
|
|
reqs[id] = Unlocked
|
|
}
|
|
}
|
|
return &LockableExt{
|
|
State: Unlocked,
|
|
Owner: nil,
|
|
PendingOwner: nil,
|
|
Requirements: reqs,
|
|
WaitInfos: WaitMap{},
|
|
}
|
|
}
|
|
|
|
func UnlockLockable(ctx *Context, node *Node) (uuid.UUID, error) {
|
|
signal := NewLockSignal("unlock")
|
|
messages := []SendMsg{{node.ID, signal}}
|
|
return signal.ID(), ctx.Send(node, messages)
|
|
}
|
|
|
|
func LockLockable(ctx *Context, node *Node) (uuid.UUID, error) {
|
|
signal := NewLockSignal("lock")
|
|
messages := []SendMsg{{node.ID, signal}}
|
|
return signal.ID(), ctx.Send(node, messages)
|
|
}
|
|
|
|
func (ext *LockableExt) Load(ctx *Context, node *Node) error {
|
|
return nil
|
|
}
|
|
|
|
func (ext *LockableExt) Unload(ctx *Context, node *Node) {
|
|
}
|
|
|
|
func (ext *LockableExt) HandleErrorSignal(ctx *Context, node *Node, source NodeID, signal *ErrorSignal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes Changes = nil
|
|
|
|
info, info_found := node.ProcessResponse(ext.WaitInfos, signal)
|
|
if info_found {
|
|
state, found := ext.Requirements[info.Destination]
|
|
if found == true {
|
|
changes.Add("wait_infos")
|
|
ctx.Log.Logf("lockable", "got mapped response %+v for %+v in state %s while in %s", signal, info, ReqStateStrings[state], ReqStateStrings[ext.State])
|
|
switch ext.State {
|
|
case AbortingLock:
|
|
ext.Requirements[info.Destination] = Unlocked
|
|
all_unlocked := true
|
|
for _, state := range(ext.Requirements) {
|
|
if state != Unlocked {
|
|
all_unlocked = false
|
|
break
|
|
}
|
|
}
|
|
if all_unlocked == true {
|
|
changes.Add("state")
|
|
ext.State = Unlocked
|
|
}
|
|
case Locking:
|
|
changes.Add("state")
|
|
ext.Requirements[info.Destination] = Unlocked
|
|
unlocked := 0
|
|
for _, state := range(ext.Requirements) {
|
|
if state == Unlocked {
|
|
unlocked += 1
|
|
}
|
|
}
|
|
|
|
if unlocked == len(ext.Requirements) {
|
|
ctx.Log.Logf("lockable", "%s unlocked from error %s from %s", node.ID, signal.Error, source)
|
|
ext.State = Unlocked
|
|
} else {
|
|
ext.State = AbortingLock
|
|
for id, state := range(ext.Requirements) {
|
|
if state == Locked {
|
|
ext.Requirements[id] = Unlocking
|
|
lock_signal := NewLockSignal("unlock")
|
|
ext.WaitInfos[lock_signal.Id] = node.QueueTimeout("unlock", id, lock_signal, 100*time.Millisecond)
|
|
messages = append(messages, SendMsg{id, lock_signal})
|
|
ctx.Log.Logf("lockable", "sent abort unlock to %s from %s", id, node.ID)
|
|
}
|
|
}
|
|
}
|
|
|
|
case Unlocking:
|
|
ext.Requirements[info.Destination] = Locked
|
|
all_returned := true
|
|
for _, state := range(ext.Requirements) {
|
|
if state == Unlocking {
|
|
all_returned = false
|
|
break
|
|
}
|
|
}
|
|
if all_returned == true {
|
|
ext.State = Locked
|
|
}
|
|
}
|
|
} else {
|
|
ctx.Log.Logf("lockable", "Got mapped error %s, but %s isn't a requirement", signal, info.Destination)
|
|
}
|
|
}
|
|
|
|
return messages, changes
|
|
}
|
|
|
|
func (ext *LockableExt) HandleLinkSignal(ctx *Context, node *Node, source NodeID, signal *LinkSignal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes = Changes{}
|
|
if ext.State == Unlocked {
|
|
switch signal.Action {
|
|
case "add":
|
|
_, exists := ext.Requirements[signal.NodeID]
|
|
if exists == true {
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "already_requirement")})
|
|
} else {
|
|
if ext.Requirements == nil {
|
|
ext.Requirements = map[NodeID]ReqState{}
|
|
}
|
|
ext.Requirements[signal.NodeID] = Unlocked
|
|
changes.Add("requirements")
|
|
messages = append(messages, SendMsg{source, NewSuccessSignal(signal.ID())})
|
|
}
|
|
case "remove":
|
|
_, exists := ext.Requirements[signal.NodeID]
|
|
if exists == false {
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "can't link: not_requirement")})
|
|
} else {
|
|
delete(ext.Requirements, signal.NodeID)
|
|
changes.Add("requirements")
|
|
messages = append(messages, SendMsg{source, NewSuccessSignal(signal.ID())})
|
|
}
|
|
default:
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "unknown_action")})
|
|
}
|
|
} else {
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "not_unlocked")})
|
|
}
|
|
return messages, changes
|
|
}
|
|
|
|
func (ext *LockableExt) HandleSuccessSignal(ctx *Context, node *Node, source NodeID, signal *SuccessSignal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes = Changes{}
|
|
if source == node.ID {
|
|
return messages, changes
|
|
}
|
|
|
|
info, info_found := node.ProcessResponse(ext.WaitInfos, signal)
|
|
if info_found == true {
|
|
state, found := ext.Requirements[info.Destination]
|
|
if found == false {
|
|
ctx.Log.Logf("lockable", "Got success signal for requirement that is no longer in the map(%s), ignoring...", info.Destination)
|
|
} else {
|
|
ctx.Log.Logf("lockable", "got mapped response %+v for %+v in state %s", signal, info, ReqStateStrings[state])
|
|
switch state {
|
|
case Locking:
|
|
switch ext.State {
|
|
case Locking:
|
|
ext.Requirements[info.Destination] = Locked
|
|
locked := 0
|
|
for _, s := range(ext.Requirements) {
|
|
if s == Locked {
|
|
locked += 1
|
|
}
|
|
}
|
|
if locked == len(ext.Requirements) {
|
|
ctx.Log.Logf("lockable", "WHOLE LOCK: %s - %s - %+v", node.ID, ext.PendingID, ext.PendingOwner)
|
|
ext.State = Locked
|
|
ext.Owner = ext.PendingOwner
|
|
changes.Add("state", "owner", "requirements")
|
|
messages = append(messages, SendMsg{*ext.Owner, NewSuccessSignal(ext.PendingID)})
|
|
} else {
|
|
changes.Add("requirements")
|
|
ctx.Log.Logf("lockable", "PARTIAL LOCK: %s - %d/%d", node.ID, locked, len(ext.Requirements))
|
|
}
|
|
case AbortingLock:
|
|
ext.Requirements[info.Destination] = Unlocking
|
|
|
|
lock_signal := NewLockSignal("unlock")
|
|
ext.WaitInfos[lock_signal.Id] = node.QueueTimeout("unlock", info.Destination, lock_signal, 100*time.Millisecond)
|
|
messages = append(messages, SendMsg{info.Destination, lock_signal})
|
|
|
|
ctx.Log.Logf("lockable", "sending abort_lock to %s for %s", info.Destination, node.ID)
|
|
}
|
|
case AbortingLock:
|
|
ctx.Log.Logf("lockable", "Got success signal in AbortingLock %s", node.ID)
|
|
fallthrough
|
|
case Unlocking:
|
|
ext.Requirements[source] = Unlocked
|
|
|
|
unlocked := 0
|
|
for _, s := range(ext.Requirements) {
|
|
if s == Unlocked {
|
|
unlocked += 1
|
|
}
|
|
}
|
|
|
|
if unlocked == len(ext.Requirements) {
|
|
old_state := ext.State
|
|
ext.State = Unlocked
|
|
ctx.Log.Logf("lockable", "WHOLE UNLOCK: %s - %s - %+v", node.ID, ext.PendingID, ext.PendingOwner)
|
|
if old_state == Unlocking {
|
|
previous_owner := *ext.Owner
|
|
ext.Owner = ext.PendingOwner
|
|
ext.ReqID = nil
|
|
changes.Add("state", "owner", "req_id")
|
|
messages = append(messages, SendMsg{previous_owner, NewSuccessSignal(ext.PendingID)})
|
|
} else if old_state == AbortingLock {
|
|
changes.Add("state", "pending_owner")
|
|
messages = append(messages, SendMsg{*ext.PendingOwner, NewErrorSignal(*ext.ReqID, "not_unlocked")})
|
|
ext.PendingOwner = ext.Owner
|
|
}
|
|
} else {
|
|
changes.Add("state")
|
|
ctx.Log.Logf("lockable", "PARTIAL UNLOCK: %s - %d/%d", node.ID, unlocked, len(ext.Requirements))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return messages, changes
|
|
}
|
|
|
|
// Handle a LockSignal and update the extensions owner/requirement states
|
|
func (ext *LockableExt) HandleLockSignal(ctx *Context, node *Node, source NodeID, signal *LockSignal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes = Changes{}
|
|
|
|
switch signal.State {
|
|
case "lock":
|
|
switch ext.State {
|
|
case Unlocked:
|
|
if len(ext.Requirements) == 0 {
|
|
ext.State = Locked
|
|
new_owner := source
|
|
ext.PendingOwner = &new_owner
|
|
ext.Owner = &new_owner
|
|
changes.Add("state", "pending_owner", "owner")
|
|
messages = append(messages, SendMsg{new_owner, NewSuccessSignal(signal.ID())})
|
|
} else {
|
|
ext.State = Locking
|
|
id := signal.ID()
|
|
ext.ReqID = &id
|
|
new_owner := source
|
|
ext.PendingOwner = &new_owner
|
|
ext.PendingID = signal.ID()
|
|
changes.Add("state", "req_id", "pending_owner", "pending_id")
|
|
for id, state := range(ext.Requirements) {
|
|
if state != Unlocked {
|
|
ctx.Log.Logf("lockable", "REQ_NOT_UNLOCKED_WHEN_LOCKING")
|
|
}
|
|
|
|
lock_signal := NewLockSignal("lock")
|
|
ext.WaitInfos[lock_signal.Id] = node.QueueTimeout("lock", id, lock_signal, 500*time.Millisecond)
|
|
ext.Requirements[id] = Locking
|
|
|
|
messages = append(messages, SendMsg{id, lock_signal})
|
|
}
|
|
}
|
|
default:
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "not_unlocked")})
|
|
ctx.Log.Logf("lockable", "Tried to lock %s while %s", node.ID, ext.State)
|
|
}
|
|
case "unlock":
|
|
if ext.State == Locked {
|
|
if len(ext.Requirements) == 0 {
|
|
ext.State = Unlocked
|
|
new_owner := source
|
|
ext.PendingOwner = nil
|
|
ext.Owner = nil
|
|
changes.Add("state", "pending_owner", "owner")
|
|
messages = append(messages, SendMsg{new_owner, NewSuccessSignal(signal.ID())})
|
|
} else if source == *ext.Owner {
|
|
ext.State = Unlocking
|
|
id := signal.ID()
|
|
ext.ReqID = &id
|
|
ext.PendingOwner = nil
|
|
ext.PendingID = signal.ID()
|
|
changes.Add("state", "pending_owner", "pending_id", "req_id")
|
|
for id, state := range(ext.Requirements) {
|
|
if state != Locked {
|
|
ctx.Log.Logf("lockable", "REQ_NOT_LOCKED_WHEN_UNLOCKING")
|
|
}
|
|
|
|
lock_signal := NewLockSignal("unlock")
|
|
ext.WaitInfos[lock_signal.Id] = node.QueueTimeout("unlock", id, lock_signal, 100*time.Millisecond)
|
|
ext.Requirements[id] = Unlocking
|
|
|
|
messages = append(messages, SendMsg{id, lock_signal})
|
|
}
|
|
}
|
|
} else {
|
|
messages = append(messages, SendMsg{source, NewErrorSignal(signal.ID(), "not_locked")})
|
|
}
|
|
default:
|
|
ctx.Log.Logf("lockable", "LOCK_ERR: unkown state %s", signal.State)
|
|
}
|
|
return messages, changes
|
|
}
|
|
|
|
func (ext *LockableExt) HandleTimeoutSignal(ctx *Context, node *Node, source NodeID, signal *TimeoutSignal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes = Changes{}
|
|
|
|
wait_info, found := node.ProcessResponse(ext.WaitInfos, signal)
|
|
if found == true {
|
|
changes.Add("wait_infos")
|
|
state, found := ext.Requirements[wait_info.Destination]
|
|
if found == true {
|
|
ctx.Log.Logf("lockable", "%s timed out %s while %s was %s", wait_info.Destination, ReqStateStrings[state], node.ID, ReqStateStrings[state])
|
|
switch ext.State {
|
|
case AbortingLock:
|
|
ext.Requirements[wait_info.Destination] = Unlocked
|
|
all_unlocked := true
|
|
for _, state := range(ext.Requirements) {
|
|
if state != Unlocked {
|
|
all_unlocked = false
|
|
break
|
|
}
|
|
}
|
|
if all_unlocked == true {
|
|
changes.Add("state")
|
|
ext.State = Unlocked
|
|
}
|
|
case Locking:
|
|
ext.State = AbortingLock
|
|
ext.Requirements[wait_info.Destination] = Unlocked
|
|
for id, state := range(ext.Requirements) {
|
|
if state == Locked {
|
|
ext.Requirements[id] = Unlocking
|
|
lock_signal := NewLockSignal("unlock")
|
|
ext.WaitInfos[lock_signal.Id] = node.QueueTimeout("unlock", id, lock_signal, 100*time.Millisecond)
|
|
messages = append(messages, SendMsg{id, lock_signal})
|
|
ctx.Log.Logf("lockable", "sent abort unlock to %s from %s", id, node.ID)
|
|
}
|
|
}
|
|
case Unlocking:
|
|
ext.Requirements[wait_info.Destination] = Locked
|
|
all_returned := true
|
|
for _, state := range(ext.Requirements) {
|
|
if state == Unlocking {
|
|
all_returned = false
|
|
break
|
|
}
|
|
}
|
|
if all_returned == true {
|
|
ext.State = Locked
|
|
}
|
|
}
|
|
} else {
|
|
ctx.Log.Logf("lockable", "%s timed out", wait_info.Destination)
|
|
}
|
|
}
|
|
|
|
return messages, changes
|
|
}
|
|
|
|
// LockableExts process status signals by forwarding them to it's owner
|
|
// LockSignal and LinkSignal Direct signals are processed to update the requirement/dependency/lock state
|
|
func (ext *LockableExt) Process(ctx *Context, node *Node, source NodeID, signal Signal) ([]SendMsg, Changes) {
|
|
var messages []SendMsg = nil
|
|
var changes = Changes{}
|
|
|
|
switch sig := signal.(type) {
|
|
case *StatusSignal:
|
|
if ext.Owner != nil {
|
|
if *ext.Owner != node.ID {
|
|
messages = append(messages, SendMsg{*ext.Owner, signal})
|
|
}
|
|
}
|
|
case *LinkSignal:
|
|
messages, changes = ext.HandleLinkSignal(ctx, node, source, sig)
|
|
case *LockSignal:
|
|
messages, changes = ext.HandleLockSignal(ctx, node, source, sig)
|
|
case *ErrorSignal:
|
|
messages, changes = ext.HandleErrorSignal(ctx, node, source, sig)
|
|
case *SuccessSignal:
|
|
messages, changes = ext.HandleSuccessSignal(ctx, node, source, sig)
|
|
case *TimeoutSignal:
|
|
messages, changes = ext.HandleTimeoutSignal(ctx, node, source, sig)
|
|
default:
|
|
}
|
|
|
|
return messages, changes
|
|
}
|
|
|