为什么hIsEOF不会返回？

Question

I am creating a simple chat server using Haskell's Network library. The server has to do two things:

• Broadcast a message every n ticks to all of the currently connected clients
• Receive any messages from the clients sent to the server.

The server and client are defined as

data Server = Server {
  sSocket :: Socket,
  sPort :: Port,
  sClients :: MVar (Set.Set ClientAddress)
  }

newtype ClientAddress = ClientAddress (Handle, HostName, PortNumber) 
                          deriving (Show)

A server is constructed by running the following function

startServer :: Port -> IO ThreadId -- 
startServer port = withSocketsDo $ do
  socket  <- listenOn $ PortNumber $ fromIntegral port  
  clients <- newMVar Set.empty
  let server = Server socket port clients
  forkIO $ forever $ do
    client@(handle, host, port) <- accept socket
    modifyMVar_ clients (\cs -> return $ Set.insert (ClientAddress client) cs)
    forkIO $ forever $ serve $ ClientAddress client
  forkIO $ forever $ sendServerUpdates 1000000 server

Note that the last two lines fork two different threads: the first for handling client connections and "serving" their messages, and the second for sending server broadcasts to the clients.

Broadcasting to the clients works as follows

sendServerUpdates :: Microsecond -> Server -> IO ()
sendServerUpdates frequency server = do
  withMVar (sClients server) (mapM_ sendServerUpdate)
  threadDelay frequency

sendServerUpdate :: ClientAddress -> IO ()
sendServerUpdate (ClientAddress (handle, host, port)) = do
  putStrLn "Sending update."

---

The issue I have, is that receiving messages from the clients seem to block. I receive messages by checking if the handle has contents

serve :: ClientAddress -> IO ()
serve (ClientAddress (handle, host, port)) = do
  b <- hIsEOF handle
  putStrLn $ show $ b -- <-- It never makes it this far...

Unfortunately, the code never makes it to the second line to call the putStrLn . It seems like hIsEOF encounters some exception, although the documentation doesn't seem to mention it .

Why does my code block on hIsEOF forever?

Answer 1

In hIsEOF 's documentation I found the following:

NOTE: hIsEOF may block, because it has to attempt to read from the stream to determine whether there is any more data to be read.

I wouldn't have expected this. I wonder if hReady or hGetBufNonBlocking are any better? I've never tried the whole non-blocking IO bit in Haskell.