hasbolt 0.1.0.7 → 0.1.0.8

raw patch · 2 files changed

+32/−34 lines, 2 filesdep ~hasboltPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hasbolt

API changes (from Hackage documentation)

Files

• hasbolt.cabal +3/−3
• src/Database/Bolt/Connection/Pipe.hs +29/−31

@@ -1,5 +1,5 @@ name: hasbolt-version: 0.1.0.7+version: 0.1.0.8 cabal-version: >=1.10 build-type: Simple license: BSD3@@ -56,14 +56,14 @@         Database.Bolt.Connection.Pipe         Database.Bolt.Connection         Database.Bolt.Record-    ghc-options: -Wall+    ghc-options: -Wall -O2  test-suite hasbolt-test     type: exitcode-stdio-1.0     main-is: Spec.hs     build-depends:         base >=4.9.0.0 && <4.10,-        hasbolt >=0.1.0.7 && <0.2,+        hasbolt >=0.1.0.8 && <0.2,         hspec >=2.2.4 && <2.3,         QuickCheck >=2.8.2 && <2.9,         hex >=0.1.2 && <0.2,

@@ -7,16 +7,16 @@ import           Database.Bolt.Value.Instances import           Database.Bolt.Value.Type -import           Control.Monad                       (unless, void, when)-import           Control.Monad.IO.Class              (MonadIO (..), liftIO)-import           Data.Binary                         (Binary (..))-import           Data.ByteString                     (ByteString, append)-import qualified Data.ByteString                     as B (concat, length, null,-                                                           splitAt, empty)-import           Data.Maybe                          (fromMaybe)-import           Data.Word                           (Word16, Word32)-import           Network.Simple.TCP                  (closeSock, connectSock,-                                                      recv, send)+import           Control.Monad                      (forM_, unless, void, when)+import           Control.Monad.IO.Class             (MonadIO (..), liftIO)+import           Data.Binary                        (Binary (..))+import           Data.ByteString                    (ByteString)+import qualified Data.ByteString                    as B (concat, empty, length,+                                                          null, splitAt)+import           Data.Maybe                         (fromMaybe)+import           Data.Word                          (Word16, Word32)+import           Network.Simple.TCP                 (Socket, closeSock,+                                                     connectSock, recv, send)  -- |Creates new 'Pipe' instance to use all requests through connect :: MonadIO m => BoltCfg -> m Pipe@@ -46,36 +46,34 @@ flush :: MonadIO m => Pipe -> Request -> m () flush pipe request = do let chunkSize = fromIntegral (mcs pipe)                         let chunks = split chunkSize (pack $ toStructure request)-                        let packet = B.concat $ consSize <$> chunks                         let terminal = encodeStrict (0 :: Word16)-                        send (connectionSocket pipe) (packet `append` terminal)+                        let sock = connectionSocket pipe+                        forM_ chunks $ \chunk -> do+                          let size = fromIntegral (B.length chunk) :: Word16+                          send sock $ encodeStrict size+                          send sock chunk+                        send sock terminal   where split :: Int -> ByteString -> [ByteString]         split size bs | B.null bs = []                       | otherwise = let (chunk, rest) = B.splitAt size bs                                     in chunk : split size rest -        consSize :: ByteString -> ByteString-        consSize bs = let size = fromIntegral (B.length bs) :: Word16-                      in encodeStrict size `append` bs- fetch :: MonadIO m => Pipe -> m Response-fetch pipe = do bs <- fetchHelper+fetch pipe = do bs <- B.concat <$> chunks                 unpack bs >>= fromStructure-  where fetchHelper :: MonadIO m => m ByteString-        fetchHelper = do chunkSize :: Word16 <- recvWord pipe 2-                         case chunkSize of-                           0 -> return B.empty-                           _ -> do chunk <- recvChunk pipe chunkSize-                                   rest  <- fetchHelper-                                   return $ chunk `append` rest+  where sock = connectionSocket pipe +        chunks :: MonadIO m => m [ByteString]+        chunks = do chunk <- recvWord sock 2 >>= recvChunk sock+                    if B.null chunk then return [] else (chunk:) <$> chunks+ -- Helper functions  handshake :: MonadIO m => Pipe -> BoltCfg -> m () handshake pipe bcfg = do let sock = connectionSocket pipe                          send sock (encodeStrict $ magic bcfg)                          send sock (boltVersionProposal bcfg)-                         serverVersion :: Word32 <- recvWord pipe 4+                         serverVersion :: Word32 <- recvWord sock 4                          when (serverVersion /= version bcfg) $                            fail "Unsupported server version"                          flush pipe (createInit bcfg)@@ -87,11 +85,11 @@ boltVersionProposal :: BoltCfg -> ByteString boltVersionProposal bcfg = B.concat $ encodeStrict <$> [version bcfg, 0, 0, 0] -recvWord :: (MonadIO m, Binary a, Integral a) => Pipe -> Int -> m a-recvWord pipe size = do let sock = connectionSocket pipe-                        bs <- liftIO $ recv sock size+recvWord :: (MonadIO m, Binary a, Integral a) => Socket -> Int -> m a+recvWord sock size = do bs <- liftIO $ recv sock size                         return (fromMaybe 0 $ decodeStrict <$> bs) -recvChunk :: MonadIO m => Pipe -> Word16 -> m ByteString-recvChunk pipe size = do let sock = connectionSocket pipe-                         fromMaybe B.empty <$> liftIO (recv sock (fromIntegral size))+recvChunk :: MonadIO m => Socket -> Word16 -> m ByteString+recvChunk _    0    = return B.empty+recvChunk sock size = do let isize = fromIntegral size+                         fromMaybe B.empty <$> liftIO (recv sock isize)