在Haskell中严格使用Binary解码文件的问题

Question

我试图严格读取和解码二进制文件，这似乎在大多数时间都有效。但不幸的是在少数情况下我的计划失败，

“的字节数太少。无法读取字节位置1”

我猜二进制其解码功能认为没有数据可用， 但我知道有与只需重新运行该程序就可以正常工作。

我已经尝试了几种解决方案，但也不是能用来解决我的问题:(

• withBinaryFile：

  decodeFile' path = withBinaryFile path ReadMode doDecode 
      where 
      doDecode h = do c <- LBS.hGetContents h 
          return $! decode c 
  

• 阅读与它严格字节字符串解码整个文件：

  decodeFile' path = decode . LBS.fromChunks . return <$> BS.readFile path 
  

• 增加一些更严格的要求

  decodeFile' path = fmap (decode . LBS.fromChunks . return) $! BS.readFile path 
  

任何想法是怎么回事，如何解决这一问题？

谢谢！

编辑：我想我已经找到了我的问题。这不是严格阅读文件。我有一些主要从文件中读取的进程，但有时需要写入，这会先截断文件并添加新内容。因此，为了编写，我需要首先设置一个文件锁，当使用“Binary.encodeFile”（当我说流程我不是线程，但是运行同一程序的实例时）时，似乎没有这样做。

编辑终于有一段时间来解决我的问题，使用POSIX IO和文件锁定。从那以后我就没有更多的问题了。

为了防止有人对我当前的解决方案感兴趣，或者有人能够指出错误/问题，我会在此处发布我的解决方案。

安全编码文件：

safeEncodeFile path value = do 
    fd <- openFd path WriteOnly (Just 0o600) (defaultFileFlags {trunc = True}) 
    waitToSetLock fd (WriteLock, AbsoluteSeek, 0, 0) 
    let cs = encode value 
    let outFn = LBS.foldrChunks (\c rest -> writeChunk fd c >> rest) (return()) cs 
    outFn 
    closeFd fd 
    where 
    writeChunk fd bs = unsafeUseAsCString bs $ \ptr -> 
         fdWriteBuf fd (castPtr ptr) (fromIntegral $ BS.length bs) 

和解码文件：

safeDecodeFile def path = do 
    e <- doesFileExist path 
    if e 
     then do fd <- openFd path ReadOnly Nothing 
          (defaultFileFlags{nonBlock=True}) 
       waitToSetLock fd (ReadLock, AbsoluteSeek, 0, 0) 
       c <- fdGetContents fd 
       let !v = decode $! c 
       return v 
     else return def 

fdGetContents fd = lazyRead 
    where 
    lazyRead = unsafeInterleaveIO loop 

    loop = do blk <- readBlock fd 
       case blk of 
       Nothing -> return LBS.Empty 
       Just c -> do cs <- lazyRead 
           return (LBS.Chunk c cs) 

readBlock fd = do buf <- mallocBytes 4096 
        readSize <- fdReadBuf fd buf 4096 
        if readSize == 0 
        then do free buf 
          closeFd fd 
          return Nothing 
        else do bs <- unsafePackCStringFinalizer buf 
             (fromIntegral readSize) 
             (free buf) 
          return $ Just bs 

有了合格的进口严格懒字节串为：

import qualified Data.ByteString as BS 
import qualified Data.ByteString.Lazy as LBS 
import qualified Data.ByteString.Lazy.Internal as LBS 

Answer 1

这将是，如果有帮助您可以生成一些运行并显示问题的最小代码片段。现在我不相信这对您的程序跟踪来说不是一个问题，哪些句柄是打开/关闭的，以及读取/写入妨碍彼此。这里是我做的很好的示例测试代码。

import Data.Trie as T 
import qualified Data.ByteString as B 
import qualified Data.ByteString.Lazy as L 
import Data.Binary 
import System.IO 

tmp = "blah" 

main = do 
    let trie = T.fromList [(B.pack [p], p) | p <- [0..]] 
    (file,hdl) <- openTempFile "/tmp" tmp 
    B.hPutStr hdl (B.concat $ L.toChunks $ encode trie) 
    hClose hdl 
    putStrLn file 
    t <- B.readFile file 
    let trie' = decode (L.fromChunks [t]) 
    print (trie' == trie)