Changeset 11190 for trunk/FACT++/src/Connection.cc

Timestamp:

06/27/11 13:00:22 (13 years ago)

Author:

tbretz

Message:

Added the possbility to give an IP Address with a port rather than a name which must be resolved; send keep alive packages in 10s intervals

File:

• trunk/FACT++/src/Connection.cc (modified) (8 diffs)

trunk/FACT++/src/Connection.cc

@@ -3 +3 @@
 
 @brief Maintains an ansynchronous TCP/IP client connection
+
+@todo
+   Unify with ConnectionUSB
 
 */
@@ -44 +47 @@
 }
 
+/*
 void Connection::AsyncWait(ba::deadline_timer &timer, int millisec,
                            void (Connection::*handler)(const bs::error_code&))
@@ -59 +63 @@
     timer.async_wait(boost::bind(handler, this, dummy::error));
 }
+*/
 
 void Connection::AsyncConnect(tcp::resolver::iterator iterator)
@@ -66 +71 @@
     // AsyncConnect + Deadline
      async_connect(endpoint,
-                  boost::bind(&Connection::ConnectImp,
-                              this, ba::placeholders::error,
-                              iterator));
+                  boost::bind(&Connection::ConnectIterImp,
+                              this, iterator, ba::placeholders::error));
+
+    // We will get a "Connection timeout anyway"
+    //AsyncWait(fConnectTimeout, 5, &Connection::HandleConnectTimeout);
+}
+
+void Connection::AsyncConnect()
+{
+    // AsyncConnect + Deadline
+     async_connect(fEndpoint,
+                  boost::bind(&Connection::ConnectAddrImp,
+                              this, fEndpoint, ba::placeholders::error));
 
     // We will get a "Connection timeout anyway"
@@ -275 +290 @@
 }
 
-void Connection::ConnectImp(const bs::error_code& error,
-                            tcp::resolver::iterator iterator)
-{
-    tcp::endpoint endpoint = *iterator;
-
+void Connection::ConnectAddrImp(const tcp::endpoint &endpoint, const bs::error_code& error)
+{
     const string host = endpoint.port()==0 ? "" :
         endpoint.address().to_string()+":"+lexical_cast<string>(endpoint.port());
@@ -325 +337 @@
 
     fConnectionStatus = kConnecting;
-
+/*
     // Go on with the next
     if (++iterator != tcp::resolver::iterator())
@@ -332 +344 @@
         return;
     }
-
+*/
     // No more entries to try, if we would not put anything else
     // into the queue anymore it would now return (run() would return)
@@ -343 +355 @@
 }
 
+void Connection::ConnectIterImp(tcp::resolver::iterator iterator, const bs::error_code& error)
+{
+    ConnectAddrImp(*iterator, error);
+/*
+    tcp::endpoint endpoint = *iterator;
+
+    const string host = endpoint.port()==0 ? "" :
+        endpoint.address().to_string()+":"+lexical_cast<string>(endpoint.port());
+
+    // Connection established
+    if (!error)
+    {
+        set_option(socket_base::keep_alive(true));
+
+        const int optval = 10;
+        // First keep alive after 10s
+        setsockopt(native(), SOL_TCP, TCP_KEEPIDLE, &optval, sizeof(optval));
+        // New keep alive after 10s
+        setsockopt(native(), SOL_TCP, TCP_KEEPINTVL, &optval, sizeof(optval));
+
+        Info("Connection established to "+host+"...");
+
+        fConnectionStatus = kConnected;
+
+        ConnectionEstablished();
+        return;
+    }
+
+    // If returning from run will lead to deletion of this
+    // instance, close() is not needed (maybe implicitly called).
+    // If run is called again, close() is needed here. Otherwise:
+    // Software caused connection abort when we try to resolve
+    // the endpoint again.
+    CloseImp(false);
+
+    ostringstream msg;
+    if (!host.empty())
+        msg << "Connecting to " << host << ": " << error.message() << " (" << error << ")";
+
+    if (fErrConnect!=msg.str())
+    {
+        if (error!=ba::error::basic_errors::connection_refused)
+            fMsgConnect = "";
+        fErrConnect = msg.str();
+        Warn(fErrConnect);
+    }
+
+    if (error==ba::error::basic_errors::operation_aborted)
+        return;
+
+    fConnectionStatus = kConnecting;
+*/
+    // Go on with the next
+    if (++iterator != tcp::resolver::iterator())
+    {
+        AsyncConnect(iterator);
+        return;
+    }
+/*
+    // No more entries to try, if we would not put anything else
+    // into the queue anymore it would now return (run() would return)
+
+    // Since we don't want to block the main loop, we wait using an
+    // asnychronous timer
+
+    // FIXME: Should we move this before AsyncConnect() ?
+    AsyncWait(fConnectionTimer, 250, &Connection::HandleConnectionTimer);
+*/
+}
+
 // FIXME: Async connect should get address and port as an argument
 void Connection::StartConnect()
 {
     fConnectionStatus = kConnecting;
+
+    if (fEndpoint!=tcp::endpoint())
+    {
+        ostringstream msg;
+        msg << "Trying to connect to " << fEndpoint << "...";
+        Info(msg);
+
+        AsyncConnect();
+        return;
+    }
 
     tcp::resolver resolver(get_io_service());