cleanup: strip trailing whitespaces
authorMax Voit <max.voit+gtdv@with-eyes.net>
Mon, 20 Jul 2015 10:49:00 +0000 (12:49 +0200)
committerMax Voit <max.voit+gtdv@with-eyes.net>
Mon, 20 Jul 2015 10:49:00 +0000 (12:49 +0200)
acid-state-dist.cabal
src/Data/Acid/Centered/Common.hs
src/Data/Acid/Centered/Master.hs
src/Data/Acid/Centered/Slave.hs

index 712ae21..2a9d27b 100644 (file)
@@ -1,10 +1,10 @@
--- Initial acid-state-dist.cabal generated by cabal init.  For further 
+-- Initial acid-state-dist.cabal generated by cabal init.  For further
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 -- The name of the package.
 name:                acid-state-dist
 
--- The package version.  See the Haskell package versioning policy (PVP) 
+-- The package version.  See the Haskell package versioning policy (PVP)
 -- for standards guiding when and how versions should be incremented.
 -- http://www.haskell.org/haskellwiki/Package_versioning_policy
 -- PVP summary:      +-+------- breaking API changes
@@ -16,7 +16,7 @@ version:             0.1.0.0
 synopsis:            Replication backend for acid-state
 
 -- A longer description of the package.
--- description:         
+-- description:
 
 -- The license under which the package is released.
 license:             GPL-3
@@ -27,20 +27,20 @@ license-file:        LICENSE
 -- The package author(s).
 author:              Max Voit
 
--- An email address to which users can send suggestions, bug reports, and 
+-- An email address to which users can send suggestions, bug reports, and
 -- patches.
 maintainer:          max.voit+hdv@with-eyes.net
 
 -- A copyright notice.
--- copyright:           
+-- copyright:
 
 category:            Data
 
 build-type:          Simple
 
--- Extra files to be distributed with the package, such as examples or a 
+-- Extra files to be distributed with the package, such as examples or a
 -- README.
--- extra-source-files:  
+-- extra-source-files:
 
 -- Constraint on the version of Cabal needed to build this package.
 cabal-version:       >=1.10
@@ -51,15 +51,15 @@ library
   exposed-modules:     Data.Acid.Centered,
                        Data.Acid.Centered.Master,
                        Data.Acid.Centered.Slave
-  
+
   other-modules:       Data.Acid.Centered.Common
 
   -- Modules included in this library but not exported.
-  -- other-modules:       
-  
+  -- other-modules:
+
   -- LANGUAGE extensions used by modules in this package.
-  -- other-extensions:    
-  
+  -- other-extensions:
+
   -- Other library packages from which modules are imported.
   build-depends:       base > 4.7 && < 4.9,
                        safecopy,
@@ -74,10 +74,10 @@ library
                        semigroups,
                        safe,
                        mtl
-  
+
   -- Directories containing source files.
   hs-source-dirs:      src
-  
+
   -- Base language which the package is written in.
   default-language:    Haskell2010
-  
+
index 1af46c5..7085e11 100644 (file)
@@ -103,7 +103,7 @@ instance Serialize MasterMessage where
         DoArchive r          -> putWord8 5 >> put r
         MayQuit              -> putWord8 8
         MasterQuit           -> putWord8 9
-    get = do 
+    get = do
         tag <- getWord8
         case tag of
             0 -> liftM3 DoRep get get get
index 87d4118..cb60ca3 100644 (file)
@@ -7,7 +7,7 @@
   Maintainer  :  max.voit+hdv@with-eyes.net
   Portability :  ?
 
-  This module provides a replication backend for acid state, centered around 
+  This module provides a replication backend for acid state, centered around
   the master. Thus in case of partitions no updates may be accepted and the
   system blocks.
 
@@ -30,7 +30,7 @@ import Data.SafeCopy
 -- some not exported by acid-state, export and reinstall: Core, Abstract, Log
 import Data.Acid
 import Data.Acid.Core
-import Data.Acid.Abstract 
+import Data.Acid.Abstract
 import Data.Acid.Advanced
 import Data.Acid.Local
 import Data.Acid.Log
@@ -44,14 +44,14 @@ import Data.Acid.Centered.Common
 import Control.Concurrent (forkIO, ThreadId, myThreadId, killThread)
 import Control.Concurrent.Chan (Chan, newChan, writeChan, readChan)
 import Control.Monad (when, unless, void,
-                      forever, forM_, 
+                      forever, forM_,
                       liftM, liftM2)
 import Control.Monad.STM (atomically)
 import Control.Concurrent.STM.TVar (readTVar)
 
 import System.ZMQ4 (Context, Socket, Router(..), Receiver, Flag(..),
                     setReceiveHighWM, setSendHighWM, restrict,
-                    context, term, socket, close, 
+                    context, term, socket, close,
                     bind, unbind,
                     poll, Poll(..), Event(..),
                     waitRead,
@@ -73,7 +73,7 @@ import Control.Concurrent.MVar(MVar, newMVar, newEmptyMVar,
 
 --------------------------------------------------------------------------------
 
-data MasterState st 
+data MasterState st
     = MasterState { localState :: AcidState st
                   , nodeStatus :: MVar NodeStatus
                   , masterStateLock :: MVar ()
@@ -98,7 +98,7 @@ data ReplicationItem =
 -- | The request handler on master node. Does
 --      o handle receiving requests from nodes,
 --      o answering as needed (old updates),
---      o bookkeeping on node states. 
+--      o bookkeeping on node states.
 masterRequestHandler :: (IsAcidic st, Typeable st) => MasterState st -> IO ()
 masterRequestHandler masterState@MasterState{..} = do
     mtid <- myThreadId
@@ -135,7 +135,7 @@ removeFromNodeStatus nodeStatus ident =
 
 -- | Update the NodeStatus after a node has replicated an Update.
 updateNodeStatus :: MasterState st -> NodeIdentity -> Int -> IO ()
-updateNodeStatus MasterState{..} ident r = 
+updateNodeStatus MasterState{..} ident r =
     modifyMVar_ nodeStatus $ \ns -> do
         -- todo: there should be a fancy way to do this
         when (M.findWithDefault 0 ident ns /= (r - 1)) $
@@ -151,8 +151,8 @@ updateNodeStatus MasterState{..} ident r =
 --   todo: check HWM
 --   todo: check sync validity
 connectNode :: (IsAcidic st, Typeable st) => MasterState st -> NodeIdentity -> Revision -> IO ()
-connectNode MasterState{..} i revision = 
-    withMVar masterRevision $ \mr -> 
+connectNode MasterState{..} i revision =
+    withMVar masterRevision $ \mr ->
         modifyMVar_ nodeStatus $ \ns -> do
             -- todo: do we need to lock masterState for crc?
             crc <- crcOfState localState
@@ -197,11 +197,11 @@ sendSyncCheckpoint sock (Checkpoint cr encoded) =
 
 -- | Send one (encoded) Update to a Slave.
 sendSyncUpdate :: MVar (Socket Router) -> Revision -> Tagged CSL.ByteString -> NodeIdentity -> IO ()
-sendSyncUpdate sock revision update = sendToSlave sock (DoSyncRep revision update) 
-    
+sendSyncUpdate sock revision update = sendToSlave sock (DoSyncRep revision update)
+
 -- | Send one (encoded) Update to a Slave.
 sendUpdate :: MVar (Socket Router) -> Revision -> Maybe RequestID -> Tagged CSL.ByteString -> NodeIdentity -> IO ()
-sendUpdate sock revision reqId update = sendToSlave sock (DoRep revision reqId update) 
+sendUpdate sock revision reqId update = sendToSlave sock (DoRep revision reqId update)
 
 sendCheckpoint :: MVar (Socket Router) -> Revision -> NodeIdentity -> IO ()
 sendCheckpoint sock revision = sendToSlave sock (DoCheckpoint revision)
@@ -209,8 +209,8 @@ sendCheckpoint sock revision = sendToSlave sock (DoCheckpoint revision)
 sendArchive :: MVar (Socket Router) -> Revision -> NodeIdentity -> IO ()
 sendArchive sock revision = sendToSlave sock (DoArchive revision)
 
--- | Receive one Frame. A Frame consists of three messages: 
---      sender ID, empty message, and actual content 
+-- | Receive one Frame. A Frame consists of three messages:
+--      sender ID, empty message, and actual content
 receiveFrame :: (Receiver t) => Socket t -> IO (NodeIdentity, SlaveMessage)
 receiveFrame sock = do
     list <- receiveMulti sock
@@ -228,7 +228,7 @@ receiveFrame sock = do
 -- | Open the master state.
 openMasterState :: (IsAcidic st, Typeable st) =>
                PortNumber   -- ^ port to bind to
-            -> st           -- ^ initial state 
+            -> st           -- ^ initial state
             -> IO (AcidState st)
 openMasterState port initialState = do
         debug "opening master state"
@@ -288,7 +288,7 @@ closeMasterState MasterState{..} = do
         -- cleanup zmq
         debug "Closing down zmq."
         withMVar zmqSocket $ \sock -> do
-            unbind sock zmqAddr 
+            unbind sock zmqAddr
             close sock
         term zmqContext
         -- cleanup local state
@@ -302,19 +302,19 @@ scheduleMasterUpdate masterState@MasterState{..} event = do
         unlocked <- isEmptyMVar masterStateLock
         if not unlocked then error "State is locked!"
         else do
-            result <- newEmptyMVar 
+            result <- newEmptyMVar
             let callback = do
                     hd <- scheduleUpdate localState event
                     void $ forkIO (putMVar result =<< takeMVar hd)
-            let encoded = runPutLazy (safePut event) 
+            let encoded = runPutLazy (safePut event)
             queueRepItem masterState (RIUpdate (methodTag event, encoded) (Left callback))
             return result
-             
+
 -- | Remove nodes that were not responsive
 removeLaggingNodes :: MasterState st -> IO ()
-removeLaggingNodes MasterState{..} = 
+removeLaggingNodes MasterState{..} =
     -- todo: send the node a quit notice
-    withMVar masterRevision $ \mr -> modifyMVar_ nodeStatus $ return . M.filter (== mr) 
+    withMVar masterRevision $ \mr -> modifyMVar_ nodeStatus $ return . M.filter (== mr)
 
 -- | Queue an RepItem (originating from the Master itself of an Slave via zmq)
 queueRepItem :: MasterState st -> ReplicationItem -> IO ()
@@ -355,20 +355,20 @@ masterReplicationHandler MasterState{..} = do
                     -- local part
                     withMVar masterRevision $ \mr ->
                         debug $ "Replicating Update myself to " ++ show (mr + 1)
-                    case sink of 
-                        Left callback   -> callback 
+                    case sink of
+                        Left callback   -> callback
                         _               -> void $ scheduleColdUpdate localState event
                     -- remote part
                     withMVar nodeStatus $ \ns -> do
                         debug $ "Sending Update to Slaves, there are " ++ show (M.size ns)
                         modifyMVar_ masterRevision $ \mrOld -> do
-                            let mr = mrOld + 1 
+                            let mr = mrOld + 1
                             case sink of
-                                Left _ -> forM_ (M.keys ns) $ sendUpdate zmqSocket mr Nothing event 
+                                Left _ -> forM_ (M.keys ns) $ sendUpdate zmqSocket mr Nothing event
                                 Right (reqID, reqNodeIdent) -> do
-                                    let noReqSlaves = filter (/= reqNodeIdent) $ M.keys ns 
+                                    let noReqSlaves = filter (/= reqNodeIdent) $ M.keys ns
                                     sendUpdate zmqSocket mr (Just reqID) event reqNodeIdent
-                                    forM_ noReqSlaves $ sendUpdate zmqSocket mr Nothing event 
+                                    forM_ noReqSlaves $ sendUpdate zmqSocket mr Nothing event
                             return mr
                     loop
     loop
@@ -399,14 +399,14 @@ createArchiveGlobally acid = do
 
 
 toAcidState :: IsAcidic st => MasterState st -> AcidState st
-toAcidState master 
-  = AcidState { _scheduleUpdate    = scheduleMasterUpdate master 
+toAcidState master
+  = AcidState { _scheduleUpdate    = scheduleMasterUpdate master
               , scheduleColdUpdate = scheduleColdUpdate $ localState master
               , _query             = query $ localState master
               , queryCold          = queryCold $ localState master
               , createCheckpoint   = createMasterCheckpoint master
               , createArchive      = createArchive $ localState master
-              , closeAcidState     = closeMasterState master 
+              , closeAcidState     = closeMasterState master
               , acidSubState       = mkAnyState master
               }
 
index 60afb51..2d8c5bd 100644 (file)
@@ -25,7 +25,7 @@
 --      do Queries locally
 --      deny Updates (for now)
 --      receive messages from master and respond
---      
+--
 --      notify master he's out, close local
 
 module Data.Acid.Centered.Slave
@@ -55,12 +55,12 @@ import System.ZMQ4 (Context, Socket, Dealer(..), Receiver, Flag(..),
                     setReceiveHighWM, setSendHighWM, restrict,
                     waitRead,
                     poll, Poll(..), Event(..),
-                    context, term, socket, close, 
+                    context, term, socket, close,
                     connect, disconnect,
                     send, receive)
 
 import Control.Concurrent (forkIO, threadDelay, ThreadId, myThreadId, killThread)
-import Control.Concurrent.MVar (MVar, newMVar, newEmptyMVar, 
+import Control.Concurrent.MVar (MVar, newMVar, newEmptyMVar,
                                 withMVar, modifyMVar, modifyMVar_,
                                 readMVar,
                                 takeMVar, putMVar)
@@ -84,7 +84,7 @@ import qualified Data.ByteString.Lazy.Char8 as CSL
 
 --------------------------------------------------------------------------------
 
-data SlaveState st 
+data SlaveState st
     = SlaveState { slaveLocalState :: AcidState st
                  , slaveRepChan :: Chan SlaveRepItem
                  , slaveSyncDone :: Event.Event
@@ -149,11 +149,11 @@ enslaveState address port initialState = do
                                     , slaveZmqAddr = addr
                                     , slaveZmqSocket = msock
                                     }
-        forkIO $ slaveRequestHandler slaveState 
-        forkIO $ slaveReplicationHandler slaveState 
-        return $ slaveToAcidState slaveState 
+        forkIO $ slaveRequestHandler slaveState
+        forkIO $ slaveReplicationHandler slaveState
+        return $ slaveToAcidState slaveState
 
--- | Replication handler of the Slave. 
+-- | Replication handler of the Slave.
 slaveRequestHandler :: (IsAcidic st, Typeable st) => SlaveState st -> IO ()
 slaveRequestHandler slaveState@SlaveState{..} = do
     mtid <- myThreadId
@@ -172,15 +172,15 @@ slaveRequestHandler slaveState@SlaveState{..} = do
                         -- We are sent an Update to replicate.
                         DoRep r i d -> queueRepItem slaveState (SRIUpdate r i d)
                         -- We are sent a Checkpoint for synchronization.
-                        DoSyncCheckpoint r d -> replicateSyncCp slaveState r d 
+                        DoSyncCheckpoint r d -> replicateSyncCp slaveState r d
                         -- We are sent an Update to replicate for synchronization.
-                        DoSyncRep r d -> replicateSyncUpdate slaveState r d 
+                        DoSyncRep r d -> replicateSyncUpdate slaveState r d
                         -- Master done sending all synchronization Updates.
                         SyncDone c -> onSyncDone slaveState c
                         -- We are sent a Checkpoint request.
-                        DoCheckpoint r -> queueRepItem slaveState (SRICheckpoint r) 
+                        DoCheckpoint r -> queueRepItem slaveState (SRICheckpoint r)
                         -- We are sent an Archive request.
-                        DoArchive r -> queueRepItem slaveState (SRIArchive r) 
+                        DoArchive r -> queueRepItem slaveState (SRIArchive r)
                         -- We are allowed to Quit.
                         MayQuit -> writeChan slaveRepChan SRIEnd
                         -- We are requested to Quit.
@@ -271,22 +271,22 @@ replicateSyncUpdate slaveState rev event = replicateUpdate slaveState rev Nothin
 replicateUpdate :: SlaveState st -> Revision -> Maybe RequestID -> Tagged CSL.ByteString -> Bool -> IO ()
 replicateUpdate SlaveState{..} rev reqId event syncing = do
         debug $ "Got an Update to replicate " ++ show rev
-        modifyMVar_ slaveRevision $ \nr -> if rev - 1 == nr 
+        modifyMVar_ slaveRevision $ \nr -> if rev - 1 == nr
             then do
-                -- commit / run it locally 
+                -- commit / run it locally
                 case reqId of
-                    Nothing -> 
-                        void $ scheduleColdUpdate slaveLocalState event 
+                    Nothing ->
+                        void $ scheduleColdUpdate slaveLocalState event
                     Just rid -> modifyMVar slaveRequests $ \srs -> do
                         debug $ "This is the Update for Request " ++ show rid
                         callback <- fromMaybe (error $ "Callback not found: " ++ show rid) (M.lookup rid srs)
                         -- todo: we remember it, clean it up later
                         let nsrs = M.delete rid srs
-                        return (nsrs, callback) 
+                        return (nsrs, callback)
                 -- send reply: we're done
                 unless syncing $ sendToMaster slaveZmqSocket $ RepDone rev
                 return rev
-            else do 
+            else do
                 sendToMaster slaveZmqSocket RepError
                 error $ "Replication failed at revision " ++ show rev ++ " -> " ++ show nr
                 return nr
@@ -309,8 +309,8 @@ repArchive SlaveState{..} rev = do
         createArchive slaveLocalState
 
 
--- | Update on slave site. 
---      The steps are:  
+-- | Update on slave site.
+--      The steps are:
 --      - Request Update from Master
 --      - Master issues Update with same RequestID
 --      - repHandler replicates and puts result in MVar
@@ -324,7 +324,7 @@ scheduleSlaveUpdate slaveState@SlaveState{..} event = do
             let encoded = runPutLazy (safePut event)
             sendToMaster slaveZmqSocket $ ReqUpdate reqId (methodTag event, encoded)
             let callback = do
-                    hd <- scheduleUpdate slaveLocalState event 
+                    hd <- scheduleUpdate slaveLocalState event
                     void $ forkIO $ putMVar result =<< takeMVar hd
             return $ M.insert reqId callback srs
         return result
@@ -355,7 +355,7 @@ liberateState SlaveState{..} = do
         -- cleanup zmq
         debug "Closing down zmq."
         withMVar slaveZmqSocket $ \s -> do
-            disconnect s slaveZmqAddr 
+            disconnect s slaveZmqAddr
             close s
         term slaveZmqContext
         -- cleanup local state
@@ -364,13 +364,13 @@ liberateState SlaveState{..} = do
 
 
 slaveToAcidState :: IsAcidic st => SlaveState st -> AcidState st
-slaveToAcidState slaveState 
-  = AcidState { _scheduleUpdate    = scheduleSlaveUpdate slaveState 
+slaveToAcidState slaveState
+  = AcidState { _scheduleUpdate    = scheduleSlaveUpdate slaveState
               , scheduleColdUpdate = undefined
               , _query             = query $ slaveLocalState slaveState
               , queryCold          = queryCold $ slaveLocalState slaveState
               , createCheckpoint   = createCheckpoint $ slaveLocalState slaveState
               , createArchive      = createArchive $ slaveLocalState slaveState
-              , closeAcidState     = liberateState slaveState 
+              , closeAcidState     = liberateState slaveState
               , acidSubState       = mkAnyState slaveState
               }