acid-state 0.12.4 → 0.13.0

raw patch · 4 files changed

+62/−15 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• acid-state.cabal +7/−6
• src/Data/Acid/Abstract.hs +7/−8
• src/Data/Acid/Local.hs +47/−0
• src/Data/Acid/Log.hs +1/−1

@@ -1,5 +1,5 @@ Name:                acid-state-Version:             0.12.4+Version:             0.13.0 Synopsis:            Add ACID guarantees to any serializable Haskell data structure. Description:         Use regular Haskell data structures as your database and get stronger ACID guarantees than most RDBMS offer. Homepage:            http://acid-state.seize.it/@@ -24,12 +24,13 @@   Exposed-Modules:     Data.Acid,                        Data.Acid.Local, Data.Acid.Memory,                        Data.Acid.Memory.Pure, Data.Acid.Remote,-                       Data.Acid.Advanced--  Other-modules:       Data.Acid.Log, Data.Acid.Archive,-                       Data.Acid.CRC, Paths_acid_state,-                       Data.Acid.TemplateHaskell, Data.Acid.Common, FileIO,+                       Data.Acid.Advanced,+                       Data.Acid.Log, Data.Acid.CRC,                        Data.Acid.Abstract, Data.Acid.Core++  Other-modules:       Data.Acid.Archive,+                       Paths_acid_state,+                       Data.Acid.TemplateHaskell, Data.Acid.Common, FileIO    Build-depends:       array,                        base >= 4 && < 5,

@@ -35,15 +35,14 @@ {-| State container offering full ACID (Atomicity, Consistency, Isolation and Durability)     guarantees. -    [@Atomicity@]  State changes are all-or-nothing. This is what you'd expect of any state-                   variable in Haskell and AcidState doesn't change that.-+    [@Atomicity@]   State changes are all-or-nothing. This is what you'd expect+                    of any state variable in Haskell and AcidState doesn't+                    change that.     [@Consistency@] No event or set of events will break your data invariants.--    [@Isolation@] Transactions cannot interfere with each other even when issued in parallel.--    [@Durability@] Successful transaction are guaranteed to survive unexpected system shutdowns-                   (both those caused by hardware and software).+    [@Isolation@]   Transactions cannot interfere with each other even when+                    issued in parallel.+    [@Durability@]  Successful transaction are guaranteed to survive unexpected+                    system shutdowns (both those caused by hardware and software). -} data AcidState st   = AcidState {

@@ -17,7 +17,11 @@     , openLocalStateFrom     , prepareLocalState     , prepareLocalStateFrom+    , scheduleLocalUpdate'+    , scheduleLocalColdUpdate'     , createCheckpointAndClose+    , LocalState(..)+    , Checkpoint(..)     ) where  import Data.Acid.Log as Log@@ -95,6 +99,32 @@          return mvar     where hotMethod = lookupHotMethod (coreMethods (localCore acidState)) event +-- | Same as scheduleLocalUpdate but does not immediately change the localCopy+-- and return the result mvar - returns an IO action to do this instead. Take+-- care to run actions of multiple Updates in the correct order as otherwise+-- Queries will operate on outdated state.+scheduleLocalUpdate' :: UpdateEvent event => LocalState (EventState event) -> event -> MVar (EventResult event) -> IO (IO ())+scheduleLocalUpdate' acidState event mvar+    = do+         let encoded = runPutLazy (safePut event)++         -- It is important that we encode the event now so that we can catch+         -- any exceptions (see nestedStateError in examples/errors/Exceptions.hs)+         evaluate (Lazy.length encoded)++         act <- modifyCoreState (localCore acidState) $ \st ->+           do let !(result, !st') = runState hotMethod st+              -- Schedule the log entry. Very important that it happens when 'localCore' is locked+              -- to ensure that events are logged in the same order that they are executed.+              pushEntry (localEvents acidState) (methodTag event, encoded) $ return ()+              let action = do writeIORef (localCopy acidState) st'+                              putMVar mvar result+              return (st', action)+         -- this is the action to update state for queries and release the+         -- result into the supplied mvar+         return act+    where hotMethod = lookupHotMethod (coreMethods (localCore acidState)) event+ scheduleLocalColdUpdate :: LocalState st -> Tagged ByteString -> IO (MVar ByteString) scheduleLocalColdUpdate acidState event     = do mvar <- newEmptyMVar@@ -106,6 +136,23 @@                                                            putMVar mvar result               return st'          return mvar+    where coldMethod = lookupColdMethod (localCore acidState) event++-- | Same as scheduleLocalColdUpdate but does not immediately change the+-- localCopy and return the result mvar - returns an IO action to do this+-- instead. Take care to run actions of multiple Updates in the correct order as+-- otherwise Queries will operate on outdated state.+scheduleLocalColdUpdate' :: LocalState st -> Tagged ByteString -> MVar ByteString -> IO (IO ())+scheduleLocalColdUpdate' acidState event mvar+    = do act <- modifyCoreState (localCore acidState) $ \st ->+           do let !(result, !st') = runState coldMethod st+              -- Schedule the log entry. Very important that it happens when 'localCore' is locked+              -- to ensure that events are logged in the same order that they are executed.+              pushEntry (localEvents acidState) event $ return ()+              let action = do writeIORef (localCopy acidState) st'+                              putMVar mvar result+              return (st', action)+         return act     where coldMethod = lookupColdMethod (localCore acidState) event  -- | Issue a Query event and wait for its result. Events may be issued in parallel.

@@ -3,7 +3,7 @@ -- extendible array of entries. -- module Data.Acid.Log-    ( FileLog+    ( FileLog(..)     , LogKey(..)     , EntryId     , openFileLog