Tracker: refactor into http, udp and types modules

[functorrent.git] / src / FuncTorrent / Tracker.hs

diff --git a/src/FuncTorrent/Tracker.hs b/src/FuncTorrent/Tracker.hs
index 11cecd50cb6fd68af3da5d4c440027cc5014ac59..64a2ce9d3e8c96a5a29c5176bd770be0ba05bb52 100644 (file)
--- a/src/FuncTorrent/Tracker.hs
+++ b/src/FuncTorrent/Tracker.hs
@@ -2,137 +2,28 @@
 module FuncTorrent.Tracker
     (TState(..),
      initialTrackerState,
-     trackerLoop,
+     trackerLoop
     ) where
 
-import Prelude hiding (lookup, splitAt)
+import Control.Concurrent.MVar (newEmptyMVar, newMVar)
+import Data.List (isPrefixOf)
 
-import Control.Concurrent (threadDelay)
-import Control.Concurrent.MVar (MVar, newEmptyMVar, newMVar, readMVar, putMVar, takeMVar)
-import Control.Monad.State
-import Data.ByteString (ByteString)
-import Data.ByteString.Char8 as BC (pack, unpack, splitAt)
-import Data.Char (chr)
-import Data.List (intercalate)
-import Data.Map as M (lookup)
-import Network (PortNumber)
-import Network.HTTP.Base (urlEncode)
-import qualified Data.ByteString.Base16 as B16 (encode)
-
-import FuncTorrent.Bencode (BVal(..), decode)
-import FuncTorrent.Metainfo (Info(..), Metainfo(..))
-import FuncTorrent.Network (sendGetRequest)
-import FuncTorrent.Peer (Peer(..))
-import FuncTorrent.Utils (splitN)
-
--- | Tracker response
-data TrackerResponse = TrackerResponse {
-  interval :: Integer
-  , peers :: [Peer]
-  , complete :: Maybe Integer
-  , incomplete :: Maybe Integer
-  } deriving (Show, Eq)
-
-data TrackerEventState = Started
-                       | Stopped
-                       | Completed
-                       deriving (Show, Eq)
-
-data TState = TState {
-    uploaded :: MVar Integer
-  , downloaded :: MVar Integer
-  , left :: Integer
-  , currentState :: TrackerEventState
-  , connectedPeers :: MVar [Peer]
-  }
+import FuncTorrent.Tracker.Http(trackerLoop)
+import FuncTorrent.Tracker.Types(TState(..), TrackerEventState(..), TrackerProtocol(..))
 
 initialTrackerState :: Integer -> IO TState
 initialTrackerState sz = do
   ps <- newEmptyMVar
   up <- newMVar 0
   down <- newMVar 0
-  return $ TState { currentState = Started
+  return $ TState { currentState = None
                   , connectedPeers = ps
                   , uploaded = up
                   , downloaded = down
                   , left = sz }
 
--- | Deserialize tracker response
-mkTrackerResponse :: BVal -> Either ByteString TrackerResponse
-mkTrackerResponse resp =
-    case lookup "failure reason" body of
-      Just (Bstr err) -> Left err
-      Just _ -> Left "Unknown failure"
-      Nothing ->
-          let (Just (Bint i)) = lookup "interval" body
-              (Just (Bstr peersBS)) = lookup "peers" body
-              pl = map makePeer (splitN 6 peersBS)
-          in Right TrackerResponse {
-                   interval = i
-                 , peers = pl
-                 , complete = Nothing
-                 , incomplete = Nothing
-                 }
-    where
-      (Bdict body) = resp
-
-      toInt :: String -> Integer
-      toInt = read
-
-      toPort :: ByteString -> Integer
-      toPort = read . ("0x" ++) . unpack . B16.encode
-
-      toIP :: ByteString -> String
-      toIP = Data.List.intercalate "." .
-             map (show . toInt . ("0x" ++) . unpack) .
-                 splitN 2 . B16.encode
-
-      makePeer :: ByteString -> Peer
-      makePeer peer = Peer "" (toIP ip') (toPort port')
-          where (ip', port') = splitAt 4 peer
-
---- | URL encode hash as per RFC1738
---- TODO: Add tests
---- REVIEW: Why is this not written in terms of `Network.HTTP.Base.urlEncode` or
---- equivalent library function?
-urlEncodeHash :: ByteString -> String
-urlEncodeHash bs = concatMap (encode' . unpack) (splitN 2 bs)
-  where encode' b@[c1, c2] = let c =  chr (read ("0x" ++ b))
-                            in escape c c1 c2
-        encode' _ = ""
-        escape i c1 c2 | i `elem` nonSpecialChars = [i]
-                       | otherwise = "%" ++ [c1] ++ [c2]
-
-        nonSpecialChars = ['A'..'Z'] ++ ['a'..'z'] ++ ['0'..'9'] ++ "-_.~"
-
--- | Make arguments that should be posted to tracker.
--- This is a separate pure function for testability.
-mkArgs :: PortNumber -> String -> Integer -> Integer -> Metainfo -> [(String, ByteString)]
-mkArgs port peer_id up down m =
-  let fileSize = lengthInBytes $ info m
-      bytesLeft = fileSize - down
-  in
-    [("info_hash", pack . urlEncodeHash . B16.encode . infoHash $ m),
-     ("peer_id", pack . urlEncode $ peer_id),
-     ("port", pack $ show port),
-     ("uploaded", pack $ show up),
-     ("downloaded", pack $ show down),
-     ("left", pack $ show bytesLeft),
-     ("compact", "1"),
-     ("event", "started")]
-
-trackerLoop :: PortNumber -> String -> Metainfo -> TState -> IO ByteString
-trackerLoop port peerId m st = do
-  up <- liftIO $ readMVar $ uploaded st
-  down <- liftIO $ readMVar $ downloaded st
-  resp <- liftIO $ sendGetRequest (head . announceList $ m) $ mkArgs port peerId up down m
-  case decode resp of
-    Left e -> return $ pack (show e)
-    Right trackerInfo ->
-      case mkTrackerResponse trackerInfo of
-        Left e -> return e
-        Right tresp -> do
-          _ <- threadDelay $ fromIntegral (interval tresp)
-          _ <- putMVar (connectedPeers st) (peers tresp)
-          trackerLoop port peerId m st
+getTrackerType :: String -> TrackerProtocol
+getTrackerType url | isPrefixOf "http://" url = Http
+                   | isPrefixOf "udp://" url  = Udp
+                   | otherwise                = UnknownProtocol