From 5bdc06bf0f48559de42da87d9b797e2e4277d70a Mon Sep 17 00:00:00 2001 From: Noah Metz Date: Mon, 3 Jul 2023 16:37:54 -0600 Subject: [PATCH] Added UnlinkLockables and UnlinkThreads --- gql.go | 14 ++++-- lockable.go | 139 +++++++++++++++++++++++++--------------------------- thread.go | 90 +++++++++++++++++----------------- 3 files changed, 123 insertions(+), 120 deletions(-) diff --git a/gql.go b/gql.go index fb63df4..eff2fe1 100644 --- a/gql.go +++ b/gql.go @@ -560,9 +560,17 @@ func NewGQLThread(ctx * GraphContext, listen string, requirements []Lockable) (* http_done: &sync.WaitGroup{}, } - err = LinkLockables(ctx, thread, requirements) - if err != nil { - return nil, err + if len(requirements) > 0 { + req_nodes := make([]GraphNode, len(requirements)) + for i, req := range(requirements) { + req_nodes[i] = req + } + err = UpdateStates(ctx, req_nodes, func(nodes NodeMap) error { + return LinkLockables(ctx, thread, requirements, nodes) + }) + if err != nil { + return nil, err + } } return thread, nil } diff --git a/lockable.go b/lockable.go index 28f03db..38f6357 100644 --- a/lockable.go +++ b/lockable.go @@ -195,36 +195,30 @@ func (state * BaseLockableState) RemoveRequirement(requirement Lockable) { state.requirements = state.requirements[0:(req_len-1)] } +// Requires lockable and requirement's states to be locked for write func UnlinkLockables(ctx * GraphContext, lockable Lockable, requirement Lockable) error { - // Check if requirement is a requirement of lockable - err := UpdateStates(ctx, []GraphNode{lockable}, func(nodes NodeMap) error{ - state := lockable.State().(LockableState) - var found GraphNode = nil - for _, req := range(state.Requirements()) { - if requirement.ID() == req.ID() { - found = req - break - } - } - - if found == nil { - return fmt.Errorf("UNLINK_LOCKABLES_ERR: %s is not a requirement of %s", requirement.ID(), lockable.ID()) + state := lockable.State().(LockableState) + var found GraphNode = nil + for _, req := range(state.Requirements()) { + if requirement.ID() == req.ID() { + found = req + break } + } - err := UpdateMoreStates(ctx, []GraphNode{found}, nodes, func(nodes NodeMap) error { - req_state := found.State().(LockableState) - req_state.RemoveDependency(lockable) - state.RemoveRequirement(requirement) - return nil - }) + if found == nil { + return fmt.Errorf("UNLINK_LOCKABLES_ERR: %s is not a requirement of %s", requirement.ID(), lockable.ID()) + } - return err - }) + req_state := found.State().(LockableState) + req_state.RemoveDependency(lockable) + state.RemoveRequirement(requirement) - return err + return nil } -func LinkLockables(ctx * GraphContext, lockable Lockable, requirements []Lockable) error { +// Requires lockable and requirements to be locked for write, nodes passed because requirement check recursively locks +func LinkLockables(ctx * GraphContext, lockable Lockable, requirements []Lockable, nodes NodeMap) error { if lockable == nil { return fmt.Errorf("LOCKABLE_LINK_ERR: Will not link Lockables to nil as requirements") } @@ -250,59 +244,48 @@ func LinkLockables(ctx * GraphContext, lockable Lockable, requirements []Lockabl found[requirement.ID()] = true } - gnodes := make([]GraphNode, len(requirements) + 1) - gnodes[0] = lockable - for i, node := range(requirements) { - gnodes[i+1] = node - } - - err := UpdateStates(ctx, gnodes, func(nodes NodeMap) error { - // Check that all the requirements can be added - lockable_state := lockable.State().(LockableState) - // If the lockable is already locked, need to lock this resource as well before we can add it - for _, requirement := range(requirements) { - requirement_state := requirement.State().(LockableState) - for _, req := range(requirements) { - if req.ID() == requirement.ID() { - continue - } - if checkIfRequirement(ctx, req.ID(), requirement_state, requirement.ID(), nodes) == true { - return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependenyc of %s so cannot add the same dependency", req.ID(), requirement.ID()) - } - } - if checkIfRequirement(ctx, lockable.ID(), requirement_state, requirement.ID(), nodes) == true { - return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependency of %s so cannot link as requirement", requirement.ID(), lockable.ID()) - } - - if checkIfRequirement(ctx, requirement.ID(), lockable_state, lockable.ID(), nodes) == true { - return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependency of %s so cannot link as dependency again", lockable.ID(), requirement.ID()) + // Check that all the requirements can be added + lockable_state := lockable.State().(LockableState) + // If the lockable is already locked, need to lock this resource as well before we can add it + for _, requirement := range(requirements) { + requirement_state := requirement.State().(LockableState) + for _, req := range(requirements) { + if req.ID() == requirement.ID() { + continue } - if lockable_state.Owner() == nil { - // If the new owner isn't locked, we can add the requirement - } else if requirement_state.Owner() == nil { - // if the new requirement isn't already locked but the owner is, the requirement needs to be locked first - return fmt.Errorf("LOCKABLE_LINK_ERR: %s is locked, %s must be locked to add", lockable.ID(), requirement.ID()) - } else { - // If the new requirement is already locked and the owner is already locked, their owners need to match - if requirement_state.Owner().ID() != lockable_state.Owner().ID() { - return fmt.Errorf("LOCKABLE_LINK_ERR: %s is not locked by the same owner as %s, can't link as requirement", requirement.ID(), lockable.ID()) - } + if checkIfRequirement(ctx, req.ID(), requirement_state, requirement.ID(), nodes) == true { + return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependenyc of %s so cannot add the same dependency", req.ID(), requirement.ID()) } } - // Update the states of the requirements - for _, requirement := range(requirements) { - requirement_state := requirement.State().(LockableState) - requirement_state.AddDependency(lockable) - lockable_state.AddRequirement(requirement) - ctx.Log.Logf("lockable", "LOCKABLE_LINK: linked %s to %s as a requirement", requirement.ID(), lockable.ID()) + if checkIfRequirement(ctx, lockable.ID(), requirement_state, requirement.ID(), nodes) == true { + return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependency of %s so cannot link as requirement", requirement.ID(), lockable.ID()) } - // Return no error - return nil - }) - + if checkIfRequirement(ctx, requirement.ID(), lockable_state, lockable.ID(), nodes) == true { + return fmt.Errorf("LOCKABLE_LINK_ERR: %s is a dependency of %s so cannot link as dependency again", lockable.ID(), requirement.ID()) + } + if lockable_state.Owner() == nil { + // If the new owner isn't locked, we can add the requirement + } else if requirement_state.Owner() == nil { + // if the new requirement isn't already locked but the owner is, the requirement needs to be locked first + return fmt.Errorf("LOCKABLE_LINK_ERR: %s is locked, %s must be locked to add", lockable.ID(), requirement.ID()) + } else { + // If the new requirement is already locked and the owner is already locked, their owners need to match + if requirement_state.Owner().ID() != lockable_state.Owner().ID() { + return fmt.Errorf("LOCKABLE_LINK_ERR: %s is not locked by the same owner as %s, can't link as requirement", requirement.ID(), lockable.ID()) + } + } + } + // Update the states of the requirements + for _, requirement := range(requirements) { + requirement_state := requirement.State().(LockableState) + requirement_state.AddDependency(lockable) + lockable_state.AddRequirement(requirement) + ctx.Log.Logf("lockable", "LOCKABLE_LINK: linked %s to %s as a requirement", requirement.ID(), lockable.ID()) + } - return err + // Return no error + return nil } func NewBaseLockableState(name string, _type string) BaseLockableState { @@ -711,10 +694,20 @@ func NewSimpleLockable(ctx * GraphContext, name string, requirements []Lockable) if err != nil { return nil, err } + lockable_ptr := &lockable - err = LinkLockables(ctx, lockable_ptr, requirements) - if err != nil { - return nil, err + + if len(requirements) > 0 { + req_nodes := make([]GraphNode, len(requirements)) + for i, req := range(requirements) { + req_nodes[i] = req + } + err = UpdateStates(ctx, req_nodes, func(nodes NodeMap) error { + return LinkLockables(ctx, lockable_ptr, requirements, nodes) + }) + if err != nil { + return nil, err + } } return lockable_ptr, nil diff --git a/thread.go b/thread.go index 80caeb0..4ba8071 100644 --- a/thread.go +++ b/thread.go @@ -261,30 +261,26 @@ func (state * BaseThreadState) ChildInfo(child NodeID) ThreadInfo { return state.child_info[child] } +// Requires thread and childs state to be locked for write func UnlinkThreads(ctx * GraphContext, thread Thread, child Thread) error { - err := UpdateStates(ctx, []GraphNode{thread}, func(nodes NodeMap) error{ - state := thread.State().(ThreadState) - var found GraphNode = nil - for _, c := range(state.Children()) { - if child.ID() == c.ID() { - found = c - break - } + state := thread.State().(ThreadState) + var found GraphNode = nil + for _, c := range(state.Children()) { + if child.ID() == c.ID() { + found = c + break } + } - if found == nil { - return fmt.Errorf("UNLINK_THREADS_ERR: %s is not a child of %s", child.ID(), thread.ID()) - } + if found == nil { + return fmt.Errorf("UNLINK_THREADS_ERR: %s is not a child of %s", child.ID(), thread.ID()) + } - err := UpdateMoreStates(ctx, []GraphNode{found}, nodes, func(nodes NodeMap) error { - child_state := found.State().(ThreadState) - child_state.SetParent(nil) - state.RemoveChild(child) - return nil - }) - return err - }) - return err + child_state := child.State().(ThreadState) + child_state.SetParent(nil) + state.RemoveChild(child) + + return nil } func (state * BaseThreadState) RemoveChild(child Thread) { @@ -348,6 +344,7 @@ func checkIfChild(ctx * GraphContext, thread_id NodeID, cur_state ThreadState, c return false } +// Requires thread and childs state to be locked for write func LinkThreads(ctx * GraphContext, thread Thread, child Thread, info ThreadInfo) error { if ctx == nil || thread == nil || child == nil { return fmt.Errorf("invalid input") @@ -357,31 +354,26 @@ func LinkThreads(ctx * GraphContext, thread Thread, child Thread, info ThreadInf return fmt.Errorf("Will not link %s as a child of itself", thread.ID()) } + thread_state := thread.State().(ThreadState) + child_state := child.State().(ThreadState) - err := UpdateStates(ctx, []GraphNode{thread, child}, func(nodes NodeMap) error { - thread_state := thread.State().(ThreadState) - child_state := child.State().(ThreadState) - - if child_state.Parent() != nil { - return fmt.Errorf("EVENT_LINK_ERR: %s already has a parent, cannot link as child", child.ID()) - } - - if checkIfChild(ctx, thread.ID(), child_state, child.ID()) == true { - return fmt.Errorf("EVENT_LINK_ERR: %s is a child of %s so cannot add as parent", thread.ID(), child.ID()) - } + if child_state.Parent() != nil { + return fmt.Errorf("EVENT_LINK_ERR: %s already has a parent, cannot link as child", child.ID()) + } - if checkIfChild(ctx, child.ID(), thread_state, thread.ID()) == true { - return fmt.Errorf("EVENT_LINK_ERR: %s is already a parent of %s so will not add again", thread.ID(), child.ID()) - } + if checkIfChild(ctx, thread.ID(), child_state, child.ID()) == true { + return fmt.Errorf("EVENT_LINK_ERR: %s is a child of %s so cannot add as parent", thread.ID(), child.ID()) + } - err := thread_state.AddChild(child, info) - if err != nil { - return fmt.Errorf("EVENT_LINK_ERR: error adding %s as child to %s: %e", child.ID(), thread.ID(), err) - } - child_state.SetParent(thread) + if checkIfChild(ctx, child.ID(), thread_state, thread.ID()) == true { + return fmt.Errorf("EVENT_LINK_ERR: %s is already a parent of %s so will not add again", thread.ID(), child.ID()) + } - return nil - }) + err := thread_state.AddChild(child, info) + if err != nil { + return fmt.Errorf("EVENT_LINK_ERR: error adding %s as child to %s: %e", child.ID(), thread.ID(), err) + } + child_state.SetParent(thread) if err != nil { return err @@ -701,9 +693,19 @@ func NewSimpleThread(ctx * GraphContext, name string, requirements []Lockable, a thread_ptr := &thread - err = LinkLockables(ctx, thread_ptr, requirements) - if err != nil { - return nil, err + + if len(requirements) > 0 { + req_nodes := make([]GraphNode, len(requirements)) + for i, req := range(requirements) { + req_nodes[i] = req + } + err = UpdateStates(ctx, req_nodes, func(nodes NodeMap) error { + return LinkLockables(ctx, thread_ptr, requirements, nodes) + }) + if err != nil { + return nil, err + } } + return thread_ptr, nil }