Move layout info to Torrent module

1 files changed, 269 insertions, 1 deletions

diff --git a/src/Data/Torrent.hs b/src/Data/Torrent.hs
index 5efff598..701da9dd 100644
--- a/src/Data/Torrent.hs
+++ b/src/Data/Torrent.hs
@@ -23,7 +23,11 @@
 {-# LANGUAGE MultiParamTypeClasses      #-}
 {-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving         #-}
 {-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE DeriveFoldable             #-}
+{-# LANGUAGE DeriveTraversable          #-}
 {-# LANGUAGE TemplateHaskell            #-}
 {-# OPTIONS -fno-warn-orphans           #-}
 module Data.Torrent
@@ -51,6 +55,37 @@ module Data.Torrent
        , parseURN
        , renderURN
 
+         -- * File layout
+         -- ** FileInfo
+       , FileOffset
+       , FileSize
+       , FileInfo (..)
+       , fileLength
+       , filePath
+       , fileMD5Sum
+
+         -- ** Layout info
+       , LayoutInfo (..)
+       , joinFilePath
+       , singleFile
+       , multiFile
+       , rootDirName
+       , isSingleFile
+       , isMultiFile
+       , suggestedName
+       , contentLength
+       , fileCount
+       , blockCount
+
+         -- ** Flat layout info
+       , FileLayout
+       , flatLayout
+       , accumPositions
+       , fileOffset
+
+         -- ** Internal
+       , sizeInBase
+
          -- * Info dictionary
        , InfoDict (..)
        , infoDictionary
@@ -109,6 +144,7 @@ import qualified Data.ByteString.Lazy  as BL
 import           Data.Char
 import           Data.Convertible
 import           Data.Default
+import           Data.Foldable as F
 import           Data.Hashable   as Hashable
 import qualified Data.List as L
 import           Data.Map as M
@@ -128,8 +164,8 @@ import Text.ParserCombinators.ReadP as P
 import Text.PrettyPrint as PP
 import Text.PrettyPrint.Class
 import System.FilePath
+import System.Posix.Types
 
-import Data.Torrent.Layout
 import Data.Torrent.Piece
 import Network.BitTorrent.Core.NodeInfo
 
@@ -259,6 +295,238 @@ shortHex :: InfoHash -> Text
 shortHex = T.take 7 . longHex
 
 {-----------------------------------------------------------------------
+--  File info
+-----------------------------------------------------------------------}
+
+-- | Size of a file in bytes.
+type FileSize = FileOffset
+
+deriving instance BEncode  FileOffset
+
+-- | Contain metainfo about one single file.
+data FileInfo a = FileInfo {
+      fiLength      :: {-# UNPACK #-} !FileSize
+      -- ^ Length of the file in bytes.
+
+      -- TODO unpacked MD5 sum
+    , fiMD5Sum      :: !(Maybe ByteString)
+      -- ^ 32 character long MD5 sum of the file.  Used by third-party
+      -- tools, not by bittorrent protocol itself.
+
+    , fiName        :: !a
+      -- ^ One or more string elements that together represent the
+      -- path and filename. Each element in the list corresponds to
+      -- either a directory name or (in the case of the last element)
+      -- the filename.  For example, the file:
+      --
+      --   > "dir1/dir2/file.ext"
+      --
+      --   would consist of three string elements:
+      --
+      --   > ["dir1", "dir2", "file.ext"]
+      --
+    } deriving (Show, Read, Eq, Typeable
+               , Functor, Foldable
+               )
+
+makeLensesFor
+  [ ("fiLength", "fileLength")
+  , ("fiMD5Sum", "fileMD5Sum")
+  , ("fiName"  , "filePath"  )
+  ]
+  ''FileInfo
+
+instance NFData a => NFData (FileInfo a) where
+  rnf FileInfo {..} = rnf fiName
+  {-# INLINE rnf #-}
+
+instance BEncode (FileInfo [ByteString]) where
+  toBEncode FileInfo {..} = toDict $
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "path"   .=! fiName
+    .: endDict
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict $ do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "path"
+  {-# INLINE fromBEncode #-}
+
+type Put a = a -> BDict -> BDict
+
+putFileInfoSingle :: Data.Torrent.Put (FileInfo ByteString)
+putFileInfoSingle FileInfo {..} cont =
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "name"   .=! fiName
+    .: cont
+
+getFileInfoSingle :: BE.Get (FileInfo ByteString)
+getFileInfoSingle = do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "name"
+
+instance BEncode (FileInfo ByteString) where
+  toBEncode = toDict . (`putFileInfoSingle` endDict)
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict getFileInfoSingle
+  {-# INLINE fromBEncode #-}
+
+instance Pretty (FileInfo BS.ByteString) where
+  pretty FileInfo {..} =
+       "Path: " <> text (T.unpack (T.decodeUtf8 fiName))
+    $$ "Size: " <> text (show fiLength)
+    $$ maybe PP.empty ppMD5 fiMD5Sum
+   where
+    ppMD5 md5 = "MD5 : " <> text (show (Base16.encode md5))
+
+-- | Join file path.
+joinFilePath :: FileInfo [ByteString] -> FileInfo ByteString
+joinFilePath = fmap (BS.intercalate "/")
+
+{-----------------------------------------------------------------------
+--  Layout info
+-----------------------------------------------------------------------}
+
+-- | Original (found in torrent file) layout info is either:
+--
+--     * Single file with its /name/.
+--
+--     * Multiple files with its relative file /paths/.
+--
+data LayoutInfo
+  = SingleFile
+    { -- | Single file info.
+      liFile     :: !(FileInfo ByteString)
+    }
+  | MultiFile
+    { -- | List of the all files that torrent contains.
+      liFiles    :: ![FileInfo [ByteString]]
+
+      -- | The /suggested/ name of the root directory in which to
+      -- store all the files.
+    , liDirName  :: !ByteString
+    } deriving (Show, Read, Eq, Typeable)
+
+makeLensesFor
+  [ ("liFile"   , "singleFile" )
+  , ("liFiles"  , "multiFile"  )
+  , ("liDirName", "rootDirName")
+  ]
+  ''LayoutInfo
+
+instance NFData LayoutInfo where
+  rnf SingleFile {..} = ()
+  rnf MultiFile  {..} = rnf liFiles
+
+-- | Empty multifile layout.
+instance Default LayoutInfo where
+  def = MultiFile [] ""
+
+getLayoutInfo :: BE.Get LayoutInfo
+getLayoutInfo = single <|> multi
+  where
+    single = SingleFile <$>  getFileInfoSingle
+    multi  = MultiFile  <$>! "files" <*>! "name"
+
+putLayoutInfo :: Data.Torrent.Put LayoutInfo
+putLayoutInfo SingleFile {..} = putFileInfoSingle liFile
+putLayoutInfo MultiFile  {..} = \ cont ->
+     "files" .=! liFiles
+  .: "name"  .=! liDirName
+  .: cont
+
+instance BEncode LayoutInfo where
+  toBEncode   = toDict . (`putLayoutInfo` endDict)
+  fromBEncode = fromDict getLayoutInfo
+
+instance Pretty LayoutInfo where
+  pretty SingleFile {..} = pretty liFile
+  pretty MultiFile  {..} = vcat $ L.map (pretty . joinFilePath) liFiles
+
+-- | Test if this is single file torrent.
+isSingleFile :: LayoutInfo -> Bool
+isSingleFile SingleFile {} = True
+isSingleFile _             = False
+{-# INLINE isSingleFile #-}
+
+-- | Test if this is multifile torrent.
+isMultiFile :: LayoutInfo -> Bool
+isMultiFile MultiFile {} = True
+isMultiFile _            = False
+{-# INLINE isMultiFile #-}
+
+-- | Get name of the torrent based on the root path piece.
+suggestedName :: LayoutInfo -> ByteString
+suggestedName (SingleFile FileInfo {..}) = fiName
+suggestedName  MultiFile           {..}  = liDirName
+{-# INLINE suggestedName #-}
+
+-- | Find sum of sizes of the all torrent files.
+contentLength :: LayoutInfo -> FileSize
+contentLength SingleFile { liFile  = FileInfo {..} } = fiLength
+contentLength MultiFile  { liFiles = tfs           } = L.sum (L.map fiLength tfs)
+
+-- | Get number of all files in torrent.
+fileCount :: LayoutInfo -> Int
+fileCount SingleFile {..} = 1
+fileCount MultiFile  {..} = L.length liFiles
+
+-- | Find number of blocks of the specified size. If torrent size is
+-- not a multiple of block size then the count is rounded up.
+blockCount :: Int -> LayoutInfo -> Int
+blockCount blkSize ci = contentLength ci `sizeInBase` blkSize
+
+------------------------------------------------------------------------
+
+-- | File layout specifies the order and the size of each file in the
+--   storage. Note that order of files is highly important since we
+--   coalesce all the files in the given order to get the linear block
+--   address space.
+--
+type FileLayout a = [(FilePath, a)]
+
+-- | Extract files layout from torrent info with the given root path.
+flatLayout
+  :: FilePath            -- ^ Root path for the all torrent files.
+  -> LayoutInfo          -- ^ Torrent content information.
+  -> FileLayout FileSize -- ^ The all file paths prefixed with the given root.
+flatLayout prefixPath SingleFile { liFile = FileInfo {..} }
+    = [(prefixPath </> BC.unpack fiName, fiLength)]
+flatLayout prefixPath MultiFile  {..}     = L.map mkPath liFiles
+  where   -- TODO use utf8 encoding in name
+    mkPath FileInfo {..} = (path, fiLength)
+      where
+        path = prefixPath </> BC.unpack liDirName
+           </> joinPath (L.map BC.unpack fiName)
+
+-- | Calculate offset of each file based on its length, incrementally.
+accumPositions :: FileLayout FileSize -> FileLayout (FileOffset, FileSize)
+accumPositions = go 0
+  where
+    go !_ [] = []
+    go !offset ((n, s) : xs) = (n, (offset, s)) : go (offset + s) xs
+
+-- | Gives global offset of a content file for a given full path.
+fileOffset :: FilePath -> FileLayout FileOffset -> Maybe FileOffset
+fileOffset = L.lookup
+{-# INLINE fileOffset #-}
+
+------------------------------------------------------------------------
+
+-- | Divide and round up.
+sizeInBase :: Integral a => a -> Int -> Int
+sizeInBase n b = fromIntegral (n `div` fromIntegral b) + align
+  where
+    align = if n `mod` fromIntegral b == 0 then 0 else 1
+{-# SPECIALIZE sizeInBase :: Int -> Int -> Int #-}
+{-# SPECIALIZE sizeInBase :: Integer -> Int -> Int #-}
+
+{-----------------------------------------------------------------------
 --  Info dictionary
 -----------------------------------------------------------------------}