Removed ip polymorphism from PeerAddr type.

1 files changed, 25 insertions, 18 deletions

diff --git a/src/Network/BitTorrent/DHT/ContactInfo.hs b/src/Network/BitTorrent/DHT/ContactInfo.hs
index 3db3d5a8..172306a1 100644
--- a/src/Network/BitTorrent/DHT/ContactInfo.hs
+++ b/src/Network/BitTorrent/DHT/ContactInfo.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE BangPatterns #-}
 module Network.BitTorrent.DHT.ContactInfo
        ( PeerStore
+       , PeerAddr(..)
        , Network.BitTorrent.DHT.ContactInfo.lookup
        , Network.BitTorrent.DHT.ContactInfo.freshPeers
        , Network.BitTorrent.DHT.ContactInfo.insertPeer
@@ -36,17 +37,17 @@ import Network.Address
 -- --  PeerSet
 -- -----------------------------------------------------------------------}
 --
--- type PeerSet a = [(PeerAddr a, NodeInfo a, Timestamp)]
+-- type PeerSet a = [(PeerAddr, NodeInfo a, Timestamp)]
 --
 -- -- compare PSQueue vs Ordered list
 --
--- takeNewest :: PeerSet a -> [PeerAddr a]
+-- takeNewest :: PeerSet a -> [PeerAddr]
 -- takeNewest = undefined
 --
 -- dropOld :: Timestamp -> PeerSet a -> PeerSet a
 -- dropOld = undefined
 --
--- insert :: PeerAddr a -> Timestamp -> PeerSet a -> PeerSet a
+-- insert :: PeerAddr -> Timestamp -> PeerSet a -> PeerSet a
 -- insert = undefined
 --
 -- type Mask = Int
@@ -116,16 +117,19 @@ import Network.Address
 
 -- | Storage used to keep track a set of known peers in client,
 -- tracker or DHT sessions.
-newtype PeerStore ip = PeerStore (HashMap InfoHash (SwarmData ip))
+newtype PeerStore = PeerStore (HashMap InfoHash SwarmData)
 
 type Timestamp = POSIXTime
 
-data SwarmData ip = SwarmData
-    { peers :: !(PSQ (PeerAddr ip) Timestamp)
+data SwarmData = SwarmData
+    { peers :: !(PSQ PeerAddr Timestamp)
     , name :: !(Maybe ByteString)
     }
 
-
+-- | This wrapper will serialize an ip address with a '4' or '6' prefix byte
+-- to indicate whether it is IPv4 or IPv6.
+--
+-- Note: it does not serialize port numbers.
 newtype SerializeAddress a = SerializeAddress { unserializeAddress :: a }
 
 instance Address a => Serialize (SerializeAddress a) where
@@ -145,7 +149,8 @@ instance Address a => Serialize (SerializeAddress a) where
         | otherwise = return $ error "cannot serialize non-IP SerializeAddress"
 
 
-instance (Ord ip, Address ip) => Serialize (SwarmData ip) where
+{- XXX: What happened to the ports?
+instance Serialize SwarmData where
     get = flip SwarmData <$> get
                          <*> ( PSQ.fromList . L.map parseAddr <$> get )
      where
@@ -157,17 +162,17 @@ instance (Ord ip, Address ip) => Serialize (SwarmData ip) where
         put $ L.map (\(addr :-> _) -> (SerializeAddress <$> addr))
                 -- XXX: should we serialize the timestamp?
             $ PSQ.toList peers
+-}
 
-
-knownSwarms :: PeerStore ip -> [ (InfoHash, Int, Maybe ByteString) ]
+knownSwarms :: PeerStore -> [ (InfoHash, Int, Maybe ByteString) ]
 knownSwarms (PeerStore m) = L.map (\(ih,SwarmData q n) -> (ih,PSQ.size q,n)) $ HM.toList m
 
-swarmSingleton :: Ord ip => PeerAddr ip -> SwarmData ip
+swarmSingleton :: PeerAddr -> SwarmData
 swarmSingleton a = SwarmData
     { peers = PSQ.singleton a 0
     , name = Nothing }
 
-swarmInsert :: Ord ip => SwarmData ip -> SwarmData ip -> SwarmData ip
+swarmInsert :: SwarmData -> SwarmData -> SwarmData
 swarmInsert old new = SwarmData
     { peers = L.foldl' (\q (a :-> t) -> PSQ.insertWith (\p _ -> p) a t q) (peers old) (PSQ.toList $ peers new)
     , name = name new <|> name old -- TODO: decodeUtf8' check
@@ -176,12 +181,12 @@ swarmInsert old new = SwarmData
 isSwarmOccupied SwarmData{..} = not $ PSQ.null peers
 
 -- | Empty store.
-instance Default (PeerStore a) where
+instance Default (PeerStore) where
   def = PeerStore HM.empty
   {-# INLINE def #-}
 
 -- | Monoid under union operation.
-instance Ord a => Monoid (PeerStore a) where
+instance Monoid PeerStore where
   mempty  = def
   {-# INLINE mempty #-}
 
@@ -189,20 +194,22 @@ instance Ord a => Monoid (PeerStore a) where
     PeerStore (HM.unionWith swarmInsert a b)
   {-# INLINE mappend #-}
 
+{-
 -- | Can be used to store peers between invocations of the client
 -- software.
-instance (Ord a, Address a) => Serialize (PeerStore a) where
+instance Serialize PeerStore where
   get = PeerStore . HM.fromList <$> get
   put (PeerStore m) = put (L.filter (isSwarmOccupied . snd) $ HM.toList m)
+-}
 
 -- | Returns all peers associated with a given info hash.
-lookup :: Ord a => InfoHash -> PeerStore a -> [PeerAddr a]
+lookup :: InfoHash -> PeerStore -> [PeerAddr]
 lookup ih (PeerStore m) = maybe [] (PSQ.keys . peers) $ HM.lookup ih m
 
 batchSize = 64
 
 -- | Used in 'get_peers' DHT queries.
-freshPeers :: Ord a => InfoHash -> Timestamp -> PeerStore a -> ([PeerAddr a], PeerStore a)
+freshPeers :: InfoHash -> Timestamp -> PeerStore -> ([PeerAddr], PeerStore)
 freshPeers ih tm (PeerStore m) = fromMaybe ([],PeerStore m) $ do
     swarm <- HM.lookup ih m
     let ps0 = take batchSize $ unfoldr (incomp minView) (peers swarm)
@@ -219,7 +226,7 @@ incomp !f !x = do
    pure $! ( (result,x'), x' )
 
 -- | Used in 'announce_peer' DHT queries.
-insertPeer :: Ord a => InfoHash -> Maybe ByteString -> PeerAddr a -> PeerStore a -> PeerStore a
+insertPeer :: InfoHash -> Maybe ByteString -> PeerAddr -> PeerStore -> PeerStore
 insertPeer !ih !name !a !(PeerStore m) = seq a' $ PeerStore (HM.insertWith swarmInsert ih a' m)
  where
     a' = SwarmData { peers = PSQ.singleton a 0