Synnefo » snf-ganeti

-- This function calls the later defined updateLocksWaiting', as they are

  let (waiting', (_, newNotify)) = updateLocksWaiting' prio owner req waiting

-- structure, the result of the operation, and a list of owner whose requests

-- have been fulfilled. The result is, as for lock allocation, the set of owners

-- the request is blocked on. Again, the type is chosen to be suitable for use

-- in atomicModifyIORef.

updateLocks' :: (Lock a, Ord b, Ord c)

             => b

             -> [L.LockRequest a]

             -> LockWaiting a b c

             -> (LockWaiting a b c, (Result (S.Set b), S.Set b))

updateLocks' owner reqs state =

-- updateLocks', and so is the output.

updateLocksWaiting' :: (Lock a, Ord b, Ord c)

                    => c

                    -> b

                    -> [L.LockRequest a]

                    -> LockWaiting a b c

                    -> (LockWaiting a b c, (Result (S.Set b), S.Set b))

updateLocksWaiting' prio owner reqs state =

  let (state', (result, notify)) = updateLocks' owner reqs state

-- | Update the locks on an onwer according to the given request, if possible.

-- Additionally (if the request succeeds) fulfill any pending requests that

-- became possible through this request. Return the new state of the waiting

-- structure, the result of the operation, and a list of owners to be notified.

-- The result is, as for lock allocation, the set of owners the request is

-- blocked on. Again, the type is chosen to be suitable for use in

-- atomicModifyIORef.

updateLocks :: (Lock a, Ord b, Ord c)

            => b

            -> [L.LockRequest a]

            -> LockWaiting a b c

            -> (LockWaiting a b c, (Result (S.Set b), S.Set b))

updateLocks owner req state =

  second (second $ S.delete owner) $ updateLocks' owner req state

-- | Update locks as soon as possible. If the request cannot be fulfilled

-- immediately add the request to the waiting queue. The first argument is

-- the priority at which the owner is waiting, the remaining are as for

-- updateLocks, and so is the output.

updateLocksWaiting :: (Lock a, Ord b, Ord c)

                   => c

                   -> b

                   -> [L.LockRequest a]

                   -> LockWaiting a b c

                   -> (LockWaiting a b c, (Result (S.Set b), S.Set b))

updateLocksWaiting prio owner req state =

  second (second $ S.delete owner) $ updateLocksWaiting' prio owner req state