[Haskell-beginners] how to read file with locking

[Jimmy Wylie]

  On 10/9/10 5:49 PM, Joey Hess wrote:
> The function below always returns "", rather than the file's contents.
> _Real World Haskell_ touches on how laziness can make this problimatic,
> without really giving a solution, other than throwing in a putStr to
> force evaluation, which can't be done here. How can I make  hGetContents
> strict, to ensure the file contents are really read before it gets closed?
>
> readFile' file = do
>          f<- openFile file ReadMode
> 	-- locking will go here
>          s<- hGetContents f
>          hClose f
>          return s
>
Haskell won't actually read the file unless you need the contents of the 
file.  In order to ensure that the file contents are read before it gets 
close, you need to actually perform an operation that will force 
evaluation of the file. Haskell will read the file then to perform 
whatever operation you specify.
     for example
          sendFile file = do
               f<- openFile file ReadMode
               s <- hGetContents f
               sendToNetwork s --made up function
               hClose f

In your example, you're getting "" because the handle is closed, so 
Haskell doesn't have anything to read.
You say you can't use putStr in this scenario, but if you're reading the 
file you must be doing something with the contents. Wait to close the 
handle until after that operation takes place.

> Also, I noticed that opening a file and locking it involves a
> very verbose seeming dance. (It's 2 lines of code in most other languages.)
> Does this indicate that few people bother with file locking in Haskell
> and so it still has these rough edges, or that there's a better way to do
> it that I have not found yet?
>
> openLocked file = do
>          handle<- openFile file ReadMode
>          lockfd<- handleToFd handle -- closes handle
>          waitToSetLock lockfd (ReadLock, AbsoluteSeek, 0, 0)
>          handle'<- fdToHandle lockfd
>          return handle'
>
You should go to haskell.org/hoogle, and search openFile, or check out 
the Haskell98 report, but I'm under the impression that ghc locks the 
file for you when you open the file.:
 From haskell98 report:


        21.2.3 File locking

Implementations should enforce as far as possible, at least locally to 
the Haskell process, multiple-reader single-writer locking on files. 
That is, /there may either be many handles on the same file which manage 
input, or just one handle on the file which manages output/. If any open 
or semi-closed handle is managing a file for output, no new handle can 
be allocated for that file. If any open or semi-closed handle is 
managing a file for input, new handles can only be allocated if they do 
not manage output. Whether two files are the same is 
implementation-dependent, but they should normally be the same if they 
have the same absolute path name and neither has been renamed, for example.


        21.3.1 Opening Files

...

/Error reporting/: the openFile computation may fail with 
isAlreadyInUseError if the file is already open and cannot be reopened; 
isDoesNotExistError if the file does not exist; orisPermissionError if 
the user does not have permission to open the file



Hope this helps,
Jimmy Wylie


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/beginners/attachments/20101009/d3bd5364/attachment.html