fix: Wall sugesstions
authorMax Voit <max.voit+gtdv@with-eyes.net>
Thu, 23 Jul 2015 12:37:08 +0000 (14:37 +0200)
committerMax Voit <max.voit+gtdv@with-eyes.net>
Thu, 23 Jul 2015 12:37:08 +0000 (14:37 +0200)
acid-state-dist.cabal
src/Data/Acid/Centered.hs
src/Data/Acid/Centered/Common.hs
src/Data/Acid/Centered/Master.hs
src/Data/Acid/Centered/Slave.hs
test/Simple.hs
test/SlaveUpdates.hs
test/readme.md

index 4c0a7e4..0635f5e 100644 (file)
@@ -52,10 +52,8 @@ library
                        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:       Data.Acid.Centered.Common
 
   -- LANGUAGE extensions used by modules in this package.
   -- other-extensions:
@@ -82,6 +80,9 @@ library
   -- Base language which the package is written in.
   default-language:    Haskell2010
 
+  -- Switch on debugging by "-Unodebug", off by "-Dnodebug"
+  ghc-options:      -Wall -threaded -cpp -Dnodebug
+
 ----------------------------------------------------------------------
 -- Tests
 test-suite Simple
index e804db8..11b01bd 100644 (file)
@@ -12,7 +12,7 @@
 
 module Data.Acid.Centered
     (
-      PortNumber(..)
+      PortNumber
     , openMasterState
     , openMasterStateFrom
     , MasterState(..)
index a3e1217..a507445 100644 (file)
@@ -20,12 +20,12 @@ module Data.Acid.Centered.Common
     , NodeRevision
     , Revision
     , RequestID
-    , PortNumber(..)
+    , PortNumber
     , SlaveMessage(..)
     , MasterMessage(..)
     ) where
 
-import Data.Acid.Core (Tagged(..), withCoreState)
+import Data.Acid.Core (Tagged, withCoreState)
 import Data.Acid.Local (localCore)
 import Data.Acid.Abstract (downcast)
 import Data.Acid (AcidState, IsAcidic)
@@ -34,8 +34,7 @@ import Data.Acid.CRC (crc16)
 import Control.Monad (liftM, liftM2, liftM3,
                       unless
                      )
-import Control.Concurrent (ThreadId, myThreadId, threadDelay)
-import Data.ByteString.Char8 (ByteString)
+import Control.Concurrent (threadDelay)
 import qualified Data.ByteString.Lazy.Char8 as CSL
 import Data.Serialize (Serialize(..), put, get,
                        putWord8, getWord8,
@@ -44,9 +43,13 @@ import Data.Serialize (Serialize(..), put, get,
 import Data.Typeable (Typeable)
 import Data.SafeCopy (safePut)
 import Data.Word (Word16)
+
+#ifdef nodebug
+#else
 import System.IO (stderr, hPutStrLn)
 import qualified Control.Concurrent.Lock as L
 import System.IO.Unsafe (unsafePerformIO)
+#endif
 
 --------------------------------------------------------------------------------
 
@@ -66,6 +69,10 @@ type RequestID = Int
 type Crc = Word16
 
 
+#ifdef nodebug
+debug :: String -> IO ()
+debug _ = return ()
+#else
 -- | Debugging without interleaving output from different threads
 {-# NOINLINE debugLock #-}
 debugLock :: L.Lock
@@ -73,8 +80,7 @@ debugLock = unsafePerformIO L.new
 
 debug :: String -> IO ()
 debug = L.with debugLock . hPutStrLn stderr
--- to turn off debug use
---debug _ = return ()
+#endif
 
 -- | Messages the Master sends to Slaves.
 data MasterMessage = DoRep Revision (Maybe RequestID) (Tagged CSL.ByteString)
index 71484f9..d02c969 100644 (file)
@@ -30,30 +30,22 @@ import Data.SafeCopy
 import Data.Acid
 import Data.Acid.Core
 import Data.Acid.Abstract
-import Data.Acid.Advanced
 import Data.Acid.Local
 import Data.Acid.Log
-import Data.Serialize (Serialize(..), put, get,
-                       decode, encode,
-                       runPutLazy, runPut
-                      )
+import Data.Serialize (decode, encode, runPutLazy)
 
 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_,
-                      liftM, liftM2)
+import Control.Monad (when, unless, void, forever, forM_, liftM2)
 import Control.Monad.STM (atomically)
 import Control.Concurrent.STM.TVar (readTVar)
 
-import System.ZMQ4 (Context, Socket, Router(..), Receiver, Flag(..),
+import System.ZMQ4 (Context, Socket, Router(..), Receiver,
                     setReceiveHighWM, setSendHighWM, restrict,
-                    context, term, socket, close,
-                    bind, unbind,
+                    context, term, socket, close, bind, unbind,
                     poll, Poll(..), Event(..),
-                    waitRead,
                     sendMulti, receiveMulti)
 import System.FilePath ( (</>) )
 
@@ -67,9 +59,8 @@ import Safe (headDef)
 
 -- auto imports following - need to be cleaned up
 import Control.Concurrent.MVar(MVar, newMVar, newEmptyMVar,
-                               takeMVar, putMVar,
-                               readMVar, isEmptyMVar,
-                               modifyMVar, modifyMVar_, withMVar)
+                               takeMVar, putMVar, isEmptyMVar,
+                               modifyMVar_, withMVar)
 
 --------------------------------------------------------------------------------
 
@@ -115,7 +106,7 @@ masterRequestHandler masterState@MasterState{..} = do
                 -- New Slave joined.
                 NewSlave r -> connectNode masterState ident r
                 -- Slave is done replicating.
-                RepDone r -> return () -- updateNodeStatus masterState ident r
+                RepDone _ -> return () -- updateNodeStatus masterState ident r, TODO
                 -- Slave sends an Udate.
                 ReqUpdate rid event ->
                     queueRepItem masterState (RIUpdate event (Right (rid, ident)))
@@ -195,11 +186,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 encoded = sendToSlave sock (DoSyncRep revision encoded)
 
 -- | 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 encoded = sendToSlave sock (DoRep revision reqId encoded)
 
 sendCheckpoint :: MVar (Socket Router) -> Revision -> NodeIdentity -> IO ()
 sendCheckpoint sock revision = sendToSlave sock (DoCheckpoint revision)
@@ -216,7 +207,7 @@ receiveFrame sock = do
     let ident = head list
     let msg = list !! 1
     case decode msg of
-        Left str -> error $ "Data.Serialize.decode failed on SlaveMessage: " ++ show msg
+        Left str -> error $ "Data.Serialize.decode failed on SlaveMessage: " ++ show str
         Right smsg -> do
             debug $ "Received from [" ++ CS.unpack ident ++ "]: "
                         ++ take 20 (show smsg)
@@ -251,8 +242,8 @@ openMasterStateFrom directory address port initialState = do
         let addr = "tcp://" ++ address ++ ":" ++ show port
         ctx <- context
         sock <- socket ctx Router
-        setReceiveHighWM (restrict (100*1000)) sock
-        setSendHighWM (restrict (100*1000)) sock
+        setReceiveHighWM (restrict (100*1000 :: Int)) sock
+        setSendHighWM (restrict (100*1000 :: Int)) sock
         bind sock addr
         msock <- newMVar sock
         repTid <- newEmptyMVar
@@ -269,8 +260,8 @@ openMasterStateFrom directory address port initialState = do
                                       , zmqAddr = addr
                                       , zmqSocket = msock
                                       }
-        forkIO $ masterRequestHandler masterState
-        forkIO $ masterReplicationHandler masterState
+        void $ forkIO $ masterRequestHandler masterState
+        void $ forkIO $ masterReplicationHandler masterState
         return $ toAcidState masterState
 
 -- | Close the master state.
index 149681f..131c76d 100644 (file)
@@ -25,40 +25,29 @@ module Data.Acid.Centered.Slave
 
 import Data.Typeable
 import Data.SafeCopy
-import Data.Serialize (Serialize(..), put, get,
-                       decode, encode,
-                       runPutLazy, runPut,
-                       runGet, runGetLazy
-                      )
+import Data.Serialize (decode, encode, runPutLazy, runGetLazy)
 
 import Data.Acid
 import Data.Acid.Core
-import Data.Acid.Common
 import Data.Acid.Abstract
 import Data.Acid.Local
 import Data.Acid.Log
 
 import Data.Acid.Centered.Common
 
-import System.ZMQ4 (Context, Socket, Dealer(..), Receiver, Flag(..),
+import System.ZMQ4 (Context, Socket, Dealer(..),
                     setReceiveHighWM, setSendHighWM, restrict,
-                    waitRead,
                     poll, Poll(..), Event(..),
                     context, term, socket, close,
-                    connect, disconnect,
-                    send, receive)
+                    connect, disconnect, send, receive)
 import System.FilePath ( (</>) )
 
-import Control.Concurrent (forkIO, threadDelay, ThreadId, myThreadId, killThread)
+import Control.Concurrent (forkIO, ThreadId, myThreadId, killThread)
 import Control.Concurrent.MVar (MVar, newMVar, newEmptyMVar,
                                 withMVar, modifyMVar, modifyMVar_,
-                                readMVar,
                                 takeMVar, putMVar)
 import Data.IORef (writeIORef)
-import Control.Monad (forever, void,
-                      when, unless,
-                      forM_
-                     )
+import Control.Monad (forever, void, when, unless)
 import Control.Monad.STM (atomically)
 import Control.Concurrent.STM.TVar (readTVar, writeTVar)
 import qualified Control.Concurrent.Event as Event
@@ -68,8 +57,6 @@ import Data.Map (Map)
 import qualified Data.Map as M
 import Data.Maybe (fromMaybe)
 
-import Data.ByteString.Char8 (ByteString)
-import qualified Data.ByteString.Char8 as CS
 import qualified Data.ByteString.Lazy.Char8 as CSL
 
 --------------------------------------------------------------------------------
@@ -124,15 +111,14 @@ enslaveStateFrom directory address port initialState = do
         lastReqId <- newMVar 0
         repChan <- newChan
         syncDone <- Event.new
-        sockLock <- newMVar ()
         reqTid <- newEmptyMVar
         repTid <- newEmptyMVar
         -- remote
         let addr = "tcp://" ++ address ++ ":" ++ show port
         ctx <- context
         sock <- socket ctx Dealer
-        setReceiveHighWM (restrict (100*1000)) sock
-        setSendHighWM (restrict (100*1000)) sock
+        setReceiveHighWM (restrict (100*1000 :: Int)) sock
+        setSendHighWM (restrict (100*1000 :: Int)) sock
         connect sock addr
         msock <- newMVar sock
         sendToMaster msock $ NewSlave lrev
@@ -148,8 +134,8 @@ enslaveStateFrom directory address port initialState = do
                                     , slaveZmqAddr = addr
                                     , slaveZmqSocket = msock
                                     }
-        forkIO $ slaveRequestHandler slaveState
-        forkIO $ slaveReplicationHandler slaveState
+        void $ forkIO $ slaveRequestHandler slaveState
+        void $ forkIO $ slaveReplicationHandler slaveState
         return $ slaveToAcidState slaveState
 
 -- | Replication handler of the Slave.
@@ -164,7 +150,7 @@ slaveRequestHandler slaveState@SlaveState{..} = do
         unless (null $ head re) $ do
             msg <- withMVar slaveZmqSocket receive
             case decode msg of
-                Left str -> error $ "Data.Serialize.decode failed on MasterMessage: " ++ show msg
+                Left str -> error $ "Data.Serialize.decode failed on MasterMessage: " ++ show str
                 Right mmsg -> do
                      debug $ "Received: " ++ show mmsg
                      case mmsg of
@@ -233,7 +219,7 @@ slaveReplicationHandler slaveState@SlaveState{..} = do
 -- | Replicate Sync-Checkpoints directly.
 replicateSyncCp :: (IsAcidic st, Typeable st) =>
         SlaveState st -> Revision -> CSL.ByteString -> IO ()
-replicateSyncCp slaveState@SlaveState{..} rev encoded = do
+replicateSyncCp SlaveState{..} rev encoded = do
     st <- decodeCheckpoint encoded
     let lst = downcast slaveLocalState
     let core = localCore lst
@@ -248,8 +234,8 @@ replicateSyncCp slaveState@SlaveState{..} rev encoded = do
         return rev
     where
         adjustEventLogId l r = do
-            atomically $ writeTVar (logNextEntryId (localEvents l)) rev
-            cutFileLog (localEvents l)
+            atomically $ writeTVar (logNextEntryId (localEvents l)) r
+            void $ cutFileLog (localEvents l)
         createCpFake l e r = do
             mvar <- newEmptyMVar
             pushAction (localEvents l) $
@@ -261,6 +247,7 @@ replicateSyncCp slaveState@SlaveState{..} rev encoded = do
                 Right val -> return val
 
 -- | Replicate Sync-Updates directly.
+replicateSyncUpdate :: SlaveState st -> Revision -> Tagged CSL.ByteString -> IO ()
 replicateSyncUpdate slaveState rev event = replicateUpdate slaveState rev Nothing event True
 
 -- | Replicate an Update as requested by Master.
@@ -286,24 +273,22 @@ replicateUpdate SlaveState{..} rev reqId event syncing = do
                 return rev
             else do
                 sendToMaster slaveZmqSocket RepError
-                error $ "Replication failed at revision " ++ show rev ++ " -> " ++ show nr
+                void $ error $ "Replication failed at revision " ++ show rev ++ " -> " ++ show nr
                 return nr
-            where decodeEvent ev = case runGet safeGet ev of
-                                Left str -> error str
-                                Right val -> val
 
 repCheckpoint :: SlaveState st -> Revision -> IO ()
 repCheckpoint SlaveState{..} rev = do
-    debug "Got Checkpoint request."
-    withMVar slaveRevision $ \nr ->
+    debug $ "Got Checkpoint request at revision: " ++ show rev
+    -- todo: check that we're at the correct revision
+    withMVar slaveRevision $ \_ ->
         -- create checkpoint
         createCheckpoint slaveLocalState
 
 repArchive :: SlaveState st -> Revision -> IO ()
 repArchive SlaveState{..} rev = do
-    debug "Got Archive request."
+    debug $ "Got Archive request at revision: " ++ show rev
     -- todo: at right revision?
-    withMVar slaveRevision $ \nr ->
+    withMVar slaveRevision $ \_ ->
         createArchive slaveLocalState
 
 
@@ -313,7 +298,7 @@ repArchive SlaveState{..} rev = do
 --      - Master issues Update with same RequestID
 --      - repHandler replicates and puts result in MVar
 scheduleSlaveUpdate :: UpdateEvent e => SlaveState (EventState e) -> e -> IO (MVar (EventResult e))
-scheduleSlaveUpdate slaveState@SlaveState{..} event = do
+scheduleSlaveUpdate SlaveState{..} event = do
         debug "Update by Slave."
         result <- newEmptyMVar
         -- slaveLastRequestID is only modified here - and used for locking the state
index 803955e..4aeafe1 100644 (file)
@@ -3,7 +3,7 @@
 import Data.Acid
 import Data.Acid.Centered
 
-import Control.Monad (void, when)
+import Control.Monad (when)
 import Control.Concurrent (threadDelay)
 import System.Exit (exitSuccess, exitFailure)
 import System.Directory (doesDirectoryExist, removeDirectoryRecursive)
index 56969cf..da3b3d8 100644 (file)
@@ -3,7 +3,7 @@
 import Data.Acid
 import Data.Acid.Centered
 
-import Control.Monad (void, when)
+import Control.Monad (when)
 import Control.Concurrent (threadDelay)
 import System.Exit (exitSuccess, exitFailure)
 import System.Directory (doesDirectoryExist, removeDirectoryRecursive)
index ef19506..6c6d81d 100644 (file)
@@ -11,10 +11,6 @@ Can Slaves request Updates successfully?
 Do they also get the transaction result (not only updated state)?
 Do Master and other Slaves get the update?
 
-# CRCSuccess
-
-Is a changed state from Master replicated by Slaves and CRC check successful?
-
 # CRCFail
 
 For diverged state the CRC check must fail (unless Checkpoints were replicated).