How does hgearman worker work? - haskell

Question

I asked a question how does hgearman-client work? three weeks ago. With some help I wrote a simple client application and I'm working on the worker side now. The worker implementation below compiles well and runs without any exception. The only trouble is that W.runWorker gc (return g) will not be executed. If I understand it correctly, it's the result of Haskell laziness and return t Monad wrapping. But I haven't faintest idea how to get rid of the issue. Could some one help?
import qualified Control.Monad.State as S
import qualified Data.ByteString.Char8 as B
import qualified Network.Gearman.Client as C
import qualified Network.Gearman.Worker as W
import Network.Gearman.Internal (Function, Port)
import Network.Socket (HostName)
main :: IO ()
main = do
c <- connect
case c of
Left e -> error $ B.unpack e
Right gc -> do
(res, _) <- flip S.runStateT gc $ do
g <- (W.registerWorker name func)
let t = W.runWorker gc (return g)
return t >> return ()
return res
where
connect = C.connectGearman (B.pack "i") host port
host = "localhost"::HostName
port = 4730::Port
name = (B.pack "foo")::Function
func _ = B.pack "bar"
Unfortunately an attempt to bind t <- W.runWorker ends in compiler exception. If I change the code in this way:
Right gc -> do
(res, _) <- flip S.runStateT gc $ do
g <- (W.registerWorker name func)
t <- W.runWorker gc (return ())
return t >> return ()
return res
The compilation fails with exception:
Couldn't match expected type `S.StateT
Network.Gearman.Internal.GearmanClient IO a0'
with actual type `IO GHC.Conc.Sync.ThreadId'
In a stmt of a 'do' block: t <- W.runWorker gc (return ())
In the second argument of `($)', namely
`do { g <- (W.registerWorker name func);
t <- W.runWorker gc (return ());
return t >> return () }'
IO GHC.Conc.Sync.ThreadId is the result of runWorker.

Answer 1

A value of type Gearman a for some a is an action, a recipe to do something. You can bind together such recipes to make bigger recipes, until you have constructed the main recipe which is the one that gets run.
Practically speaking, it means if you are running a do-block that looks like this:
do ...
foo
...
then foo will be run. If you have a do-block that looks like this:
do ...
ret <- foo
...
then foo will be run and the result of running foo will be stored in ret. Those two syntaxes are binds. However if you are running a do-block that looks like this:
do ...
let ret = foo
...
then foo will not be run -- instead you are just asking for the variable ret to be shorthand for foo, so foo and ret are afterwards interchangeable.
So now you can see, in:
do g <- W.registerWorker name func
let t = W.runWorker gc (return g)
return t >> return ()
the second line does not actually run a worker, it just lets t be a shorthand for running a worker. Returning an action does not bind it either. You need to bind:
t <- W.runWorker gc (return g)
By the way, I've been looking at the documentation and it looks like registerWorker returns a Gearman (), which means that the result of running the action is (), or "nothing interesting". So g is nothing interesting, you could get rid of it and say
do W.registerWorker name func
t <- W.runWorker gc (return ())
return t >> return ()
Presumably in place of that return () in the second line you would put an action that you wanted to run in the worker. Like:
t <- W.runWorker gc $ do
... the things you want the worker to do ...
return t >> return ()
And finally that last line: return t >> return (), also written
do return t
return ()
is exactly the same thing as return (). return x constructs an action with no side-effects, which is only used for the result. Then when you use >> (or don't bind the result in a do block) you run an action only for its side-effects and discard its result. So the first return does nothing whatsoever.

Answer 2

Finally I implemented a gearman worker in Haskell.
{-# LANGUAGE DeriveDataTypeable #-}
import Control.Exception (Exception, IOException, catch, throwIO)
import qualified Data.ByteString.Char8 as B
import Control.Monad.State
import Data.Typeable (Typeable)
import qualified Network.Gearman.Client as C
import qualified Network.Gearman.Worker as W
import Network.Gearman.Internal (Function, GearmanClient, Port)
import Network.Socket (HostName)
import Control.Concurrent
import qualified Control.Monad.State as S
data ConnectException = ConnectException HostName Port IOException
deriving (Show, Typeable)
instance Exception ConnectException
main :: IO ()
main = do
c <- connect
gc <- either (error . B.unpack) return c
work gc
return ()
where
connect = C.connectGearman (B.pack "worker-id") host port `catch` \e -> throwIO (ConnectException host port e)
host = "localhost"::HostName
port = 4730::Port
work :: GearmanClient -> IO ()
work gc = do
(res, _) <- flip S.runStateT gc $ do
W.registerWorker (B.pack "reverse"::Function) B.reverse
S.get >>= (\env -> forever $ S.liftIO (W.runWorker env (return ()) >> threadDelay (1000*1000)))
return ()
return res