Make connect timeout a ConnOpener private

diff --git a/src/adaptation/icap/Xaction.cc b/src/adaptation/icap/Xaction.cc
index 74eb3b22b03bb70578e7f076d00ef41dc42ac311..660553603754eba8275a24cf35748956ba506640 100644 (file)
--- a/src/adaptation/icap/Xaction.cc
+++ b/src/adaptation/icap/Xaction.cc
@@ -129,9 +129,8 @@ void Adaptation::Icap::Xaction::openConnection()
     connector = asyncCall(93,3, "Adaptation::Icap::Xaction::noteCommConnected",
                           ConnectDialer(this, &Adaptation::Icap::Xaction::noteCommConnected));
 
-    ConnOpener *cs = new ConnOpener(connection, connector);
+    ConnOpener *cs = new ConnOpener(connection, connector, TheConfig.connect_timeout(service().cfg().bypass));
     cs->setHost(s.cfg().host.termedBuf());
-    cs->connect_timeout = TheConfig.connect_timeout(service().cfg().bypass);
     AsyncJob::AsyncStart(cs);
 }
 

diff --git a/src/comm/ConnOpener.cc b/src/comm/ConnOpener.cc
index 67cae661e4e2533eefac6213a7c3f173987c9379..7229d8a302512566c1d077d758bcd2a5f854e381 100644 (file)
--- a/src/comm/ConnOpener.cc
+++ b/src/comm/ConnOpener.cc
@@ -3,6 +3,7 @@
  */
 
 #include "config.h"
+#include "base/TextException.h"
 #include "comm/ConnOpener.h"
 #include "comm/Connection.h"
 #include "comm.h"
@@ -12,9 +13,9 @@
 
 CBDATA_CLASS_INIT(ConnOpener);
 
-ConnOpener::ConnOpener(Comm::ConnectionPointer &c, AsyncCall::Pointer handler) :
+ConnOpener::ConnOpener(Comm::ConnectionPointer &c, AsyncCall::Pointer &handler, time_t ctimeout) :
         AsyncJob("ConnOpener"),
-        connect_timeout(Config.Timeout.connect),
+        connect_timeout(ctimeout),
         host(NULL),
         solo(c),
         callback(handler),
@@ -37,13 +38,18 @@ bool
 ConnOpener::doneAll() const
 {
     // is the conn to be opened still waiting?
-    if (solo != NULL)
+    if (solo != NULL) {
+        debugs(5, 6, HERE << " ConnOpener::doneAll() ? NO. 'solo' is still set");
         return false;
+    }
 
     // is the callback still to be called?
-    if (callback != NULL)
+    if (callback != NULL) {
+        debugs(5, 6, HERE << " ConnOpener::doneAll() ? NO. callback is still set");
         return false;
+    }
 
+    debugs(5, 6, HERE << " ConnOpener::doneAll() ? YES.");
     return true;
 }
 

diff --git a/src/comm/ConnOpener.h b/src/comm/ConnOpener.h
index ca271b9b84f1aecc50d42687a9e4628d7c6fd399..e287675414e77f4081ed7145a165bf0bcde030e9 100644 (file)
--- a/src/comm/ConnOpener.h
+++ b/src/comm/ConnOpener.h
@@ -22,10 +22,11 @@ public:
     virtual bool doneAll() const;
     virtual void swanSong();
 
+public:
     // ****** ConnOpener API iplementation ******
 
     /** attempt to open a connection. */
-    ConnOpener(Comm::ConnectionPointer &, AsyncCall::Pointer handler);
+    ConnOpener(Comm::ConnectionPointer &, AsyncCall::Pointer &handler, time_t connect_timeout);
     ~ConnOpener();
 
     void setHost(const char *);    ///< set the hostname note for this connection
@@ -63,14 +64,13 @@ private:
     // As soon as comm IO accepts Async calls we can use a ConnOpener::connect call
     static void ConnectRetry(int fd, void *data);
 
-public:
+private:
     /**
      * time at which to abandon the connection.
      * the connection-done callback will be passed COMM_TIMEOUT
      */
     time_t connect_timeout;
 
-private:
     char *host;                         ///< domain name we are trying to connect to.
 
     Comm::ConnectionPointer solo;       ///< single connection currently being opened.

diff --git a/src/dns_internal.cc b/src/dns_internal.cc
index c7263fed18685939235dc58b5331441b481cd793..d62716d55320c3ca2eb2a286490fe4f1330d7e88 100644 (file)
--- a/src/dns_internal.cc
+++ b/src/dns_internal.cc
@@ -749,7 +749,7 @@ idnsInitVC(int ns)
 
     AsyncCall::Pointer call = commCbCall(78,3, "idnsInitVCConnected", CommConnectCbPtrFun(idnsInitVCConnected, vc));
 
-    ConnOpener *cs = new ConnOpener(conn, call);
+    ConnOpener *cs = new ConnOpener(conn, call, Config.Timeout.connect);
     cs->setHost("DNS TCP Socket");
     AsyncJob::AsyncStart(cs);
 }

diff --git a/src/forward.cc b/src/forward.cc
index 9c6981c36e826759df3cb69a550064d1d2da2abc..680a7999544562d8faf94c757f3a42049a476180 100644 (file)
--- a/src/forward.cc
+++ b/src/forward.cc
@@ -813,9 +813,8 @@ FwdState::connectStart()
 #endif
 
     AsyncCall::Pointer call = commCbCall(17,3, "fwdConnectDoneWrapper", CommConnectCbPtrFun(fwdConnectDoneWrapper, this));
-    ConnOpener *cs = new ConnOpener(paths[0], call);
+    ConnOpener *cs = new ConnOpener(paths[0], call, ctimeout);
     cs->setHost(host);
-    cs->connect_timeout = ctimeout;
     AsyncJob::AsyncStart(cs);
 }
 

diff --git a/src/ftp.cc b/src/ftp.cc
index 51559b2c023d2a373da33d4fe317ba4ed9951831..bc6d563d99a265c5956c5d16e63986209bf597ea 100644 (file)
--- a/src/ftp.cc
+++ b/src/ftp.cc
@@ -2418,7 +2418,7 @@ ftpReadEPSV(FtpStateData* ftpState)
     conn->fd = fd;
 
     AsyncCall::Pointer call = commCbCall(9,3, "FtpStateData::ftpPasvCallback", CommConnectCbPtrFun(FtpStateData::ftpPasvCallback, ftpState));
-    ConnOpener *cs = new ConnOpener(conn, call);
+    ConnOpener *cs = new ConnOpener(conn, call, Config.Timeout.connect);
     cs->setHost(ftpState->data.host);
     AsyncJob::AsyncStart(cs);
 }
@@ -2702,9 +2702,8 @@ ftpReadPasv(FtpStateData * ftpState)
     conn->fd = ftpState->data.fd;
 
     AsyncCall::Pointer call = commCbCall(9,3, "FtpStateData::ftpPasvCallback", CommConnectCbPtrFun(FtpStateData::ftpPasvCallback, ftpState));
-    ConnOpener *cs = new ConnOpener(conn, call);
+    ConnOpener *cs = new ConnOpener(conn, call, Config.Timeout.connect);
     cs->setHost(ftpState->data.host);
-    cs->connect_timeout = Config.Timeout.connect;
     AsyncJob::AsyncStart(cs);
 }
 

diff --git a/src/ident/Ident.cc b/src/ident/Ident.cc
index 15ed8e3cb15c830fb252afbb0652617bbd012b2b..bb20ef52d60c4c612590ab5221a1cd0f33ca983e 100644 (file)
--- a/src/ident/Ident.cc
+++ b/src/ident/Ident.cc
@@ -250,9 +250,7 @@ Ident::Start(Comm::ConnectionPointer &conn, IDCB * callback, void *data)
     hash_join(ident_hash, &state->hash);
 
     AsyncCall::Pointer call = commCbCall(30,3, "Ident::ConnectDone", CommConnectCbPtrFun(Ident::ConnectDone, state));
-    ConnOpener *cs = new ConnOpener(state->conn, call);
-    cs->connect_timeout = Ident::TheConfig.timeout;
-    AsyncJob::AsyncStart(cs);
+    AsyncJob::AsyncStart(new ConnOpener(state->conn, call, Ident::TheConfig.timeout));
 }
 
 void

diff --git a/src/neighbors.cc b/src/neighbors.cc
index 805d0524d72496d94a23a0faf1507271e1ebfc31..28f104f8d4d5cc5c734df9695982ec771a6f5d6d 100644 (file)
--- a/src/neighbors.cc
+++ b/src/neighbors.cc
@@ -1369,8 +1369,7 @@ peerProbeConnect(peer * p)
         p->testing_now++;
 
         AsyncCall::Pointer call = commCbCall(15,3, "peerProbeConnectDone", CommConnectCbPtrFun(peerProbeConnectDone, p));
-        ConnOpener *cs = new ConnOpener(conn, call);
-        cs->connect_timeout = ctimeout;
+        ConnOpener *cs = new ConnOpener(conn, call, ctimeout);
         cs->setHost(p->host);
         AsyncJob::AsyncStart(cs);
     }

diff --git a/src/tunnel.cc b/src/tunnel.cc
index 163f24e25a4134d2e89df2ce92447f4cae44bbeb..79a8dc3124eb0d998a5e4914374f0775307a6abe 100644 (file)
--- a/src/tunnel.cc
+++ b/src/tunnel.cc
@@ -547,9 +547,8 @@ tunnelConnectDone(Comm::ConnectionPointer &conn, comm_err_t status, int xerrno,
         if (status != COMM_TIMEOUT && tunnelState->paths.size() > 0) {
             /* Try another IP of this destination host */
             AsyncCall::Pointer call = commCbCall(26,3, "tunnelConnectDone", CommConnectCbPtrFun(tunnelConnectDone, tunnelState));
-            ConnOpener *cs = new ConnOpener(tunnelState->paths[0], call);
+            ConnOpener *cs = new ConnOpener(tunnelState->paths[0], call, Config.Timeout.connect);
             cs->setHost(tunnelState->url);
-            cs->connect_timeout = Config.Timeout.connect;
             AsyncJob::AsyncStart(cs);
         } else {
             err = errorCon(ERR_CONNECT_FAIL, HTTP_SERVICE_UNAVAILABLE, request);
@@ -701,9 +700,8 @@ tunnelPeerSelectComplete(Comm::Paths *peer_paths, void *data)
     }
 
     AsyncCall::Pointer call = commCbCall(26,3, "tunnelConnectDone", CommConnectCbPtrFun(tunnelConnectDone, tunnelState));
-    ConnOpener *cs = new ConnOpener(tunnelState->paths[0], call);
+    ConnOpener *cs = new ConnOpener(tunnelState->paths[0], call, Config.Timeout.connect);
     cs->setHost(tunnelState->url);
-    cs->connect_timeout = Config.Timeout.connect;
     AsyncJob::AsyncStart(cs);
 }