Connection.Tox: Deleted dead code.

1 files changed, 10 insertions, 30 deletions

diff --git a/Connection/Tox.hs b/Connection/Tox.hs
index 0156806e..7b304050 100644
--- a/Connection/Tox.hs
+++ b/Connection/Tox.hs
@@ -85,16 +85,10 @@ launch lbl st f = do
     return $ StatefulTask tid stvar
 
 
-data SessionTasks = SessionTasks
-    { persuing   :: StatefulTask (G.Status ToxProgress)
-    , refreshing :: StatefulTask (G.Status ToxProgress)
-    }
-
 data SessionState = SessionState
     { connPolicy    :: TVar Policy
     , connPingLogic :: PingMachine
-    , sessionTasks  :: TVar SessionTasks
-    -- , transient     :: TVar (DSum Transient Identity)
+    , handshakeTask :: TVar (StatefulTask (G.Status ToxProgress))
     }
 
 newSessionState :: IO SessionState
@@ -103,27 +97,19 @@ newSessionState = do
                              25000 -- 25 ms send ping
                              30000 -- 30 ms timed out
     a <- fork $ return ()
-    b <- fork $ return ()
     atomically $ do
         av <- newTVar G.Dormant
-        bv <- newTVar G.Dormant
-        let tasks = SessionTasks (StatefulTask a av) (StatefulTask b bv)
+        let tasks = StatefulTask a av
         SessionState <$> newTVar G.RefusingToConnect <*> pure pings <*> newTVar tasks
 
 
 sessionStatus :: SessionState -> G.Connection ToxProgress
 sessionStatus st = G.Connection
-    { G.connStatus    = combinedStatus =<< readTVar (sessionTasks st)
+    { G.connStatus    = readTVar . taskState =<< readTVar (handshakeTask st)
     , G.connPolicy    = readTVar (connPolicy st)
     , G.connPingLogic = connPingLogic st
     }
 
-combinedStatus :: SessionTasks -> STM (G.Status ToxProgress)
-combinedStatus tasks = do
-    p <- readTVar (taskState $ persuing tasks)
-    r <- readTVar (taskState $ refreshing tasks)
-    return $ maximum [p,r]
-
 lookupForPolicyChange :: TVar (Map.Map Key SessionState)
                          -> Key -> Policy -> IO (Maybe SessionState)
 lookupForPolicyChange conmap k policy = do
@@ -195,17 +181,12 @@ setToxPolicy params conmap k@(Key me them) policy = do
         hPutStrLn stderr $ "C.mst="++show (fmap (const ()) mst)
         forM_ mst $ \st -> do
             let getPolicy = readTVar $ connPolicy st
-            tasks <- atomically $ readTVar (sessionTasks st)
+            tasks <- atomically $ readTVar (handshakeTask st)
             persuing <- launch ("persue:"++show k)
                                 (G.InProgress $ toEnum 0)
                                $ persueContact  getPolicy get_status persue_methods
-            {-
-            refreshing <- launch ("refresh:"++show k)
-                                (G.InProgress $ toEnum 0)
-                               $ freshenContact getPolicy get_status freshen_methods
-            -}
             atomically $ do
-                writeTVar (sessionTasks st) $ SessionTasks persuing _refreshing
+                writeTVar (handshakeTask st) $ persuing
                 let routing   = dhtRouting params
                     Key _ nid = k
                 registerNodeCallback routing $ NodeInfoCallback
@@ -231,12 +212,11 @@ setToxPolicy params conmap k@(Key me them) policy = do
                     Key _ nid = k
                 unregisterNodeCallback callbackId routing nid
             atomically $ do
-                tasks <- readTVar (sessionTasks st)
-                p <- readTVar $ taskState (persuing tasks)
-                r <- readTVar $ taskState (refreshing tasks)
-                case (p,r) of
-                    (G.Dormant,G.Dormant) -> return ()
-                    _                     -> retry
+                tasks <- readTVar (handshakeTask st)
+                p <- readTVar $ taskState tasks
+                case p of
+                    G.Dormant  -> return ()
+                    _          -> retry
     OpenToConnect -> do -- passively accept connections if they initiate.
         mst <- lookupForPolicyChange conmap k policy
         r <- atomically $ lookupContact k (roster params)