Changeset 21003

Timestamp:

01/13/08 08:13:47 (8 months ago)

Author:

patrick

Message:

While pondering the mysteries of life, it occurred to me that the code in the
class vpr::SocketBasicOpt?, vpr::SocketIpOpt?, vpr::SocketStreamOpt?, and
vpr::SocketDatagramOpt? really did not need to be in base classes. I think that
doing things in that manner dates back to the very early days of VPR (circa
October 2000), and things have changed quite a lot in the I/O architecture
since then. This changes things around so that the methods of
vpr::SocketBasicOpt? and vpr::SocketIpOpt? are now directly part of
vpr::Socket_t<T> instead of being inherited. Similarly, the methods of
vpr::SocketDatagramOpt? are now part of vpr::SocketDatagram_t<T> and those
of vpr::SocketStreamOpt? are now part of vpr::SocketStream_t<T>. The class
vpr::SocketOptionWrapper? has been removed altogether as it really served no
purpose at all. Fundamentally, the way that socket options were being
handled violated the rule that public inheritance dictates an is-a
relationship (is a socket a socket option? No.), but in a borader sense, it
just made things more complicated than necessary.

This change should not have any impact on user-level code as I doubt that
anyone would have been handling socket objects as instances of
vpr::SocketOptionWrapper? or a subclass thereof.

Bumped the version to 2.1.10.

Files:

• juggler/trunk/modules/vapor/ChangeLog (modified) (1 diff)
• juggler/trunk/modules/vapor/VERSION (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/IO/Socket/Makefile.in (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketBasicOpt.h (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketDatagramOpt.cpp (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketDatagramOpt.h (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketDatagram_t.h (modified) (6 diffs)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketIpOpt.h (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketOptions.h (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketStreamOpt.cpp (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketStreamOpt.h (deleted)
• juggler/trunk/modules/vapor/vpr/IO/Socket/SocketStream_t.h (modified) (8 diffs)
• juggler/trunk/modules/vapor/vpr/IO/Socket/Socket_t.h (modified) (4 diffs)

juggler/trunk/modules/vapor/ChangeLog

@@ -1 +1 @@
-DATE       AUTHOR   CHANGE
----------- -------- -----------------------------------------------------------
+2008-01-13 patrick  Folded vpr::SocketBasicOpt and vpr::SocketIpOpt into
+                    vpr::Socket_t<T>. Folded vpr::SocketStreamOpt into
+                    vpr::SocketStream_t<T>. Folded vpr::SocketDatagramOpt into
+                    vpr::SocketDatagram_t<T>. Removed vpr::SocketOptionWrapper.
+                    NEW VERSION: 2.1.10
-2008-01-12 patrick  Extended vpr::SocketStream to support "corked" or no-push
-                    writing.

juggler/trunk/modules/vapor/VERSION

@@ +1 @@
+2.1.10-0 @01/13/2008 14:15:00 UTC@
-2.1.9-0 @01/12/2008 15:20:00 UTC@
-2.1.8-0 @10/30/2007 20:15:00 UTC@

juggler/trunk/modules/vapor/vpr/IO/Socket/Makefile.in

@@ -59 +59 @@
-                SocketAcceptor.cpp              \
-                SocketConnector.cpp             \
-                SocketDatagramOpt.cpp           \
-                SocketException.cpp             \
-                SocketStreamOpt.cpp             \
-                UnknownHostException.cpp
-

juggler/trunk/modules/vapor/vpr/IO/Socket/SocketDatagram_t.h

@@ -41 +41 @@
-
-#include <vpr/IO/Socket/Socket_t.h>
-#include <vpr/IO/Socket/SocketDatagramOpt.h>
-
-#include <boost/smart_ptr.hpp>
@@ -58 +57 @@
- *
- * @see vpr::SocketDatagramImplNSPR, vpr::SocketDatagramImplBSD
+ *
+ * @note vpr::SocketDatagramOpt was folded into this class in version 2.1.10.
+ *       User-level code will most likely not be affected by this difference.
- */
-template<class SocketConfig_>
-class SocketDatagram_t
-   : public Socket_t<SocketConfig_>
-   , public SocketDatagramOpt
-{
-public:
@@ -73 +74 @@
-   SocketDatagram_t()
-      : Socket_t<Config>()
-      , SocketDatagramOpt()
-      , mSocketDgramImpl()
-   {
@@ -96 +96 @@
-                    const vpr::InetAddr& remoteAddr)
-      : Socket_t<Config>()
-      , SocketDatagramOpt()
-   {
-      mSocketDgramImpl =
@@ -111 +110 @@
-   SocketDatagram_t(const SocketDatagram_t& sock)
-      : Socket_t<Config>()
-      , SocketDatagramOpt()
-      , mSocketDgramImpl(sock.mSocketDgramImpl)
-   {
@@ -214 +212 @@
-   }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-// Put in back door for simulator

juggler/trunk/modules/vapor/vpr/IO/Socket/SocketOptions.h

@@ -125 +125 @@
-}
-
-/** \class SocketOptionWrapper SocketOptions.h vpr/IO/Socket/SocketOptions.h
- *
- * Simple interface for setting and querying socket options.
- */
-class VPR_CLASS_API SocketOptionWrapper
-{
-public:
-   virtual ~SocketOptionWrapper()
-   {
-      /* Do nothing. */ ;
-   }
-
-protected:
-   /**
-    * Retrieves the value for the given option as set on the socket.
-    *
-    * @param option The option to be queried.
-    * @param data   A data buffer that will be used to store the value of the
-    *               given option.
-    *
-    * @throws vpr::SocketException if the value for the given option
-    *         could not be retrieved.
-    */
-   virtual void getOption(const vpr::SocketOptions::Types option,
-                          struct vpr::SocketOptions::Data& data) const = 0;
-
-   /**
-    * Sets a value for the given option on the socket using the given data
-    * block.
-    *
-    * @param option The option whose value will be set.
-    * @param data   A data buffer containing the value to be used in setting
-    *               the socket option.
-    *
-    * @throws vpr::SocketException if the value for the given option
-    *         could not be set.
-    */
-   virtual void setOption(const vpr::SocketOptions::Types option,
-                          const struct vpr::SocketOptions::Data& data) = 0;
-};
-
-} // End of vpr namespace
-

juggler/trunk/modules/vapor/vpr/IO/Socket/SocketStream_t.h

@@ -40 +40 @@
-#include <vpr/vprConfig.h>
-
-#include <vpr/IO/Socket/SocketStreamOpt.h>
-#include <vpr/IO/Socket/Socket_t.h> /* base bridge class.. */
-
@@ -58 +57 @@
- *
- * @see vpr::SocketStreamImplNSPR, vpr::SocketStreamImplBSD
+ *
+ * @note vpr::SocketStreamOpt was folded into this class in version 2.1.10.
+ *       User-level code will most likely not be affected by this difference.
- */
-//template<class RealSocketStreamImpl, class RealSocketStreamImplParent, class IO_STATS_STRATEGY = NullIOStatsStrategy>
-//class SocketStream_t : public Socket_t<RealSocketStreamImplParent, IO_STATS_STRATEGY>,
-template<class SocketConfig_>
-, public SocketStreamOpt
+
-{
-public:
@@ -108 +110 @@
-   SocketStream_t(const SocketStream_t& sock)
-      : Socket_t<SocketConfig_>()
-      , SocketStreamOpt()
-      , mSocketStreamImpl(sock.mSocketStreamImpl)
-   {
@@ -207 +208 @@
-   }
-
+   /** @name Socket Options */
+   //@{
+   /**
+    *
+    */
+   size_t getMaxSegmentSize() const
+   {
+      vpr::SocketOptions::Data option;
+
+      this->getOption(vpr::SocketOptions::MaxSegment, option);
+      return option.max_segment;
+   }
+
+   /**
+    *
+    */
+   void setMaxSegmentSize(const vpr::Int32 size)
+   {
+      vpr::SocketOptions::Data option;
+      option.max_segment = size;
+      this->setOption(vpr::SocketOptions::MaxSegment, option);
+   }
+
+   /** @name Nagle Algorithm Control */
+   //@{
+   /**
+    * Gets the current no-delay status for this socket.  If no-delay is true,
+    * then the Nagle algorithm has been disabled.
+    *
+    * @return \c true is returned if the Nabel algorithm is \em not being used
+    *         to delay the transmission of TCP segments. Otherwise, the Nagle
+    *         algorithm is delaying the transmission.
+    */
+   bool getNoDelay() const
+   {
+      vpr::SocketOptions::Data option;
+
+      this->getOption(vpr::SocketOptions::NoDelay, option);
+      return option.no_delay;
+   }
+
+   /**
+    * Sets the current no-delay status for this socket.  If no-delay is true,
+    * then the Nagle algorithm will be disabled.
+    *
+    * @param enableVal The Boolean enable/disable state for no-delay on this
+    *                  socket.
+    */
+   void setNoDelay(const bool enableVal)
+   {
+      vpr::SocketOptions::Data option;
+      option.no_delay = enableVal;
+      this->setOption(vpr::SocketOptions::NoDelay, option);
+   }
+   //@}
+
+   /** @name TCP Corking Interface */
+   //@{
+   /**
+    * Gets the state of the "no push" or "corking" for this socket. While a
+    * TCP socket is in the corked state, write operations are queued for
+    * later transmission when the socket is uncorked (that is, when the
+    * no-push state is disabled).
+    *
+    * @return true is returned if this socket is currently in the no-push
+    *         (corked) state. false is returned otherwise.
+    *
+    * @since 2.1.9
+    */
+   bool getNoPush() const
+   {
+#if defined(HAVE_CORKABLE_TCP)
+      vpr::SocketOptions::Data option;
+
+      this->getOption(vpr::SocketOptions::NoPush, option);
+      return option.no_push;
+#else
+      return mCorked;
+#endif
+   }
+
+   /**
+    * Enables or disables the no-push (or "corked") state.
+    *
+    * @post If this socket was previously in the corked state and the value of
+    *       \p enableVal is false, then all queued buffer writes will be
+    *       performed.
+    *
+    * @param enableVal A boolean value indicating whether this socket should
+    *                  be in the no-push (corked) state.
+    *
+    * @since 2.1.9
+    */
+   void setNoPush(const bool enableVal)
+   {
+// NSPR sockets are not corkable, but the OS may still support TCP corking.
+#if defined(HAVE_CORKABLE_TCP) && VPR_IO_DOMAIN_INCLUDE != VPR_DOMAIN_NSPR
+      vpr::SocketOptions::Data option;
+      option.no_push = enableVal;
+      this->setOption(vpr::SocketOptions::NoPush, option);
+#else
+      if ( enableVal != mCorked )
+      {
+         // Changing from the uncorked state to the corked state.
+         if ( enableVal )
+         {
+            mSocketStreamImpl->cork();
+         }
+         // Changing from the corked state to the uncorked state.
+         else
+         {
+            mSocketStreamImpl->uncork();
+         }
+      }
+#endif
+
+      mCorked = enableVal;
+   }
+
-   /**
-    * Changes the strategy used for determining hwo much memory to allocate
@@ -223 +343 @@
-      mSocketStreamImpl->setCorkAllocStrategy(s);
-   }
+   //@}
+
+   //@}
-
-protected:
@@ -242 +365 @@
-
-   /**
-    * @throw vpr::SocketException
-    *           Thrown if querying the indiccated option on this socket fails.
-    */
-   virtual void getOption(const vpr::SocketOptions::Types option,
-                          struct vpr::SocketOptions::Data& data)
-      const
-   {
-      mSocketStreamImpl->getOption(option, data);
-   }
-
-   /**
-    * @throw vpr::SocketException
-    *           Thrown if setting the indicated option on this socket fails.
-    */
-   virtual void setOption(const vpr::SocketOptions::Types option,
-                          const struct vpr::SocketOptions::Data& data)
-   {
-      mSocketStreamImpl->setOption(option, data);
-   }
-
-   /**
-    * @name TCP Corking Interface Implementation
-    *
@@ -268 +370 @@
-    */
-   //@{
-   /**
-    * Calls through to the cork() method of the internal stream socket
-    * implementation.
-    *
-    * @since 2.1.9
-    *
-    * @see vpr::SocketStreamImplBSD::cork()
-    * @see vpr::SocketStreamImplNSPR::cork()
-    */
-   virtual void cork()
-   {
-      mSocketStreamImpl->cork();
-   }
-
-   /**
-    * Calls through to the uncork() method of the internal stream socket
-    * implementation.
-    *
-    * @since 2.1.9
-    *
-    * @see vpr::SocketStreamImplBSD::uncork()
-    * @see vpr::SocketStreamImplNSPR::uncork()
-    */
-   virtual void uncork()
-   {
-      mSocketStreamImpl->uncork();
-   }
-   //@}
-
-// Put in back door for simulator
-#if VPR_IO_DOMAIN_INCLUDE == VPR_DOMAIN_SIMULATOR
@@ -303 +376 @@
-   /// Platform-specific stream socket implementation
-   boost::shared_ptr<SocketStreamImpl> mSocketStreamImpl;
+
+private:
+   bool mCorked;
-};
-

juggler/trunk/modules/vapor/vpr/IO/Socket/Socket_t.h

@@ -46 +46 @@
-#include <vpr/IO/IOSys.h>
-#include <vpr/IO/Socket/SocketOptions.h>
-#include <vpr/IO/Socket/SocketIpOpt.h>
-
-#include <vpr/Util/Interval.h>
@@ -73 +72 @@
- * @see vpr::SocketStream_t, vpr::SocketDatagram_t, vpr::SocketImplNSPR,
- *      vpr::SocketImplBSD
+ *
+ * @note vpr::SocketBasicOpt and vpr::SocketIpOpt were folded into this class
+ *       in version 2.1.10. User-level code will most likely not be affected
+ *       by this difference.
- */
-//template<class RealSocketImpl, class IO_STATS_STRATEGY = NullIOStatsStrategy>
-template<class SockConfig_>
-, public vpr::SocketIpOpt
+
-{
-public:
@@ -596 +599 @@
-      mSocketImpl->setRemoteAddr(addr);
-   }
+
+   /** @name Socket Options */
+   //@{
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   bool getKeepAlive() const
+   {
+      vpr::SocketOptions::Data option;
+
+      getOption(vpr::SocketOptions::KeepAlive, option);
+
+      return option.keep_alive;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setKeepAlive(const bool enableVal)
+   {
+      vpr::SocketOptions::Data option;
+      option.keep_alive = enableVal;
+      setOption(vpr::SocketOptions::KeepAlive, option);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void getLingerOnClose(bool& enabled, int& lingerSec) const
+   {
+      vpr::SocketOptions::Data opt;
+
+      getOption(vpr::SocketOptions::Linger, opt);
+
+      enabled   = opt.linger.enabled;
+      lingerSec = opt.linger.seconds;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setLingerOnClose(const bool enableVal,
+                         const int lingerSec)
+   {
+      vpr::SocketOptions::Data opt;
+
+      opt.linger.enabled = enableVal;
+      opt.linger.seconds = lingerSec;
+
+      setOption(vpr::SocketOptions::Linger, opt);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   size_t getRecvBufferSize() const
+   {
+      vpr::SocketOptions::Data opt;
+
+      getOption(vpr::SocketOptions::RecvBufferSize, opt);
+
+      return opt.recv_buffer_size;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setRecvBufferSize(const Int32 size)
+   {
+      vpr::SocketOptions::Data opt;
+
+      opt.recv_buffer_size = size;
+
+      setOption(vpr::SocketOptions::RecvBufferSize, opt);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   size_t getSendBufferSize() const
+   {
+      vpr::SocketOptions::Data opt;
+
+      getOption(vpr::SocketOptions::SendBufferSize, opt);
+
+      return opt.send_buffer_size;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setSendBufferSize(const Int32 size)
+   {
+      vpr::SocketOptions::Data opt;
+
+      opt.send_buffer_size = size;
+
+      setOption(vpr::SocketOptions::SendBufferSize, opt);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   bool getReuseAddr() const
+   {
+      vpr::SocketOptions::Data option;
+
+      getOption(vpr::SocketOptions::ReuseAddr, option);
+
+      return option.reuse_addr;
+   }
+
+   /**
+    * Enables reuse of the address that will be bound by the socket.
+    *
+    * @pre The socket has been opened, but bind() has not been called.
+    *
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setReuseAddr(const bool enableVal)
+   {
+      vpr::SocketOptions::Data option;
+      option.reuse_addr = enableVal;
+      setOption(vpr::SocketOptions::ReuseAddr, option);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   vpr::SocketOptions::TypeOfService getTypeOfService() const
+   {
+      vpr::SocketOptions::Data option;
+
+      getOption(vpr::SocketOptions::IpTypeOfService, option);
+      return option.type_of_service;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setTypeOfService(const vpr::SocketOptions::TypeOfService& tos)
+   {
+      vpr::SocketOptions::Data option;
+      option.type_of_service = tos;
+      setOption(vpr::SocketOptions::IpTypeOfService, option);
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   vpr::Int32 getTimeToLive() const
+   {
+      vpr::SocketOptions::Data option;
+
+      getOption(vpr::SocketOptions::IpTimeToLive, option);
+      return option.ip_ttl;
+   }
+
+   /**
+    * @throw vpr::SocketException Thrown if the operation failed.
+    */
+   void setTimeToLive(const vpr::Int32 ttl)
+   {
+      vpr::SocketOptions::Data option;
+      option.ip_ttl = ttl;
+      setOption(vpr::SocketOptions::IpTimeToLive, option);
+   }
+   //@}
-
-protected:
@@ -756 +927 @@
-   }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-   {
-      mSocketImpl->getOption(option, data);
-   }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-   {
-      mSocketImpl->setOption(option, data);