rbczmq 1.6.2 → 1.6.4

data/ext/zeromq/src/options.hpp

@@ -0,0 +1,135 @@
+/*
+    Copyright (c) 2009-2011 250bpm s.r.o.
+    Copyright (c) 2007-2009 iMatix Corporation
+    Copyright (c) 2011 VMware, Inc.
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_OPTIONS_HPP_INCLUDED__
+#define __ZMQ_OPTIONS_HPP_INCLUDED__
+
+#include <string>
+#include <vector>
+
+#include "stddef.h"
+#include "stdint.hpp"
+#include "tcp_address.hpp"
+#include "../include/zmq.h"
+
+namespace zmq
+{
+
+    struct options_t
+    {
+        options_t ();
+
+        int setsockopt (int option_, const void *optval_, size_t optvallen_);
+        int getsockopt (int option_, void *optval_, size_t *optvallen_);
+
+        //  High-water marks for message pipes.
+        int sndhwm;
+        int rcvhwm;
+
+        //  I/O thread affinity.
+        uint64_t affinity;
+
+        //  Socket identity
+        unsigned char identity_size;
+        unsigned char identity [256];
+
+        // Last socket endpoint resolved URI
+        std::string last_endpoint;
+
+        //  Maximum tranfer rate [kb/s]. Default 100kb/s.
+        int rate;
+
+        //  Reliability time interval [ms]. Default 10 seconds.
+        int recovery_ivl;
+
+        // Sets the time-to-live field in every multicast packet sent.
+        int multicast_hops;
+
+        // SO_SNDBUF and SO_RCVBUF to be passed to underlying transport sockets.
+        int sndbuf;
+        int rcvbuf;
+
+        //  Socket type.
+        int type;
+
+        //  Linger time, in milliseconds.
+        int linger;
+
+        //  Minimum interval between attempts to reconnect, in milliseconds.
+        //  Default 100ms
+        int reconnect_ivl;
+
+        //  Maximum interval between attempts to reconnect, in milliseconds.
+        //  Default 0 (unused)
+        int reconnect_ivl_max;
+
+        //  Maximum backlog for pending connections.
+        int backlog;
+
+        //  Maximal size of message to handle.
+        int64_t maxmsgsize;
+
+        // The timeout for send/recv operations for this socket.
+        int rcvtimeo;
+        int sndtimeo;
+
+        //  If 1, indicates the use of IPv4 sockets only, it will not be
+        //  possible to communicate with IPv6-only hosts. If 0, the socket can
+        //  connect to and accept connections from both IPv4 and IPv6 hosts.
+        int ipv4only;
+        
+        //  If 1, connecting pipes are not attached immediately, meaning a send()
+        //  on a socket with only connecting pipes would block
+        int delay_attach_on_connect;
+
+        //  If true, session reads all the pending messages from the pipe and
+        //  sends them to the network when socket is closed.
+        bool delay_on_close;
+
+        //  If true, socket reads all the messages from the pipe and delivers
+        //  them to the user when the peer terminates.
+        bool delay_on_disconnect;
+
+        //  If 1, (X)SUB socket should filter the messages. If 0, it should not.
+        bool filter;
+
+        //  If true, the identity message is forwarded to the socket.
+        bool recv_identity;
+
+        //  TCP keep-alive settings.
+        //  Defaults to -1 = do not change socket options
+        int tcp_keepalive;
+        int tcp_keepalive_cnt;
+        int tcp_keepalive_idle;
+        int tcp_keepalive_intvl;
+
+        // TCP accept() filters
+        typedef std::vector <tcp_address_mask_t> tcp_accept_filters_t;
+        tcp_accept_filters_t tcp_accept_filters;
+
+        //  ID of the socket.
+        int socket_id;
+    };
+
+}
+
+#endif

data/ext/zeromq/src/own.cpp

@@ -0,0 +1,206 @@
+/*
+    Copyright (c) 2010-2011 250bpm s.r.o.
+    Copyright (c) 2010-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "own.hpp"
+#include "err.hpp"
+#include "io_thread.hpp"
+
+zmq::own_t::own_t (class ctx_t *parent_, uint32_t tid_) :
+    object_t (parent_, tid_),
+    terminating (false),
+    sent_seqnum (0),
+    processed_seqnum (0),
+    owner (NULL),
+    term_acks (0)
+{
+}
+
+zmq::own_t::own_t (io_thread_t *io_thread_, const options_t &options_) :
+    object_t (io_thread_),
+    options (options_),
+    terminating (false),
+    sent_seqnum (0),
+    processed_seqnum (0),
+    owner (NULL),
+    term_acks (0)
+{
+}
+
+zmq::own_t::~own_t ()
+{
+}
+
+void zmq::own_t::set_owner (own_t *owner_)
+{
+    zmq_assert (!owner);
+    owner = owner_;
+}
+
+void zmq::own_t::inc_seqnum ()
+{
+    //  This function may be called from a different thread!
+    sent_seqnum.add (1);
+}
+
+void zmq::own_t::process_seqnum ()
+{
+    //  Catch up with counter of processed commands.
+    processed_seqnum++;
+
+    //  We may have catched up and still have pending terms acks.
+    check_term_acks ();
+}
+
+void zmq::own_t::launch_child (own_t *object_)
+{
+    //  Specify the owner of the object.
+    object_->set_owner (this);
+
+    //  Plug the object into the I/O thread.
+    send_plug (object_);
+
+    //  Take ownership of the object.
+    send_own (this, object_);
+}
+
+void zmq::own_t::term_child (own_t *object_)
+{
+    process_term_req (object_);
+}
+
+void zmq::own_t::process_term_req (own_t *object_)
+{
+    //  When shutting down we can ignore termination requests from owned
+    //  objects. The termination request was already sent to the object.
+    if (terminating)
+        return;
+
+    //  If I/O object is well and alive let's ask it to terminate.
+    owned_t::iterator it = std::find (owned.begin (), owned.end (), object_);
+
+    //  If not found, we assume that termination request was already sent to
+    //  the object so we can safely ignore the request.
+    if (it == owned.end ())
+        return;
+
+    owned.erase (it);
+    register_term_acks (1);
+
+    //  Note that this object is the root of the (partial shutdown) thus, its
+    //  value of linger is used, rather than the value stored by the children.
+    send_term (object_, options.linger);
+}
+
+void zmq::own_t::process_own (own_t *object_)
+{
+    //  If the object is already being shut down, new owned objects are
+    //  immediately asked to terminate. Note that linger is set to zero.
+    if (terminating) {
+        register_term_acks (1);
+        send_term (object_, 0);
+        return;
+    }
+
+    //  Store the reference to the owned object.
+    owned.insert (object_);
+}
+
+void zmq::own_t::terminate ()
+{
+    //  If termination is already underway, there's no point
+    //  in starting it anew.
+    if (terminating)
+        return;
+
+    //  As for the root of the ownership tree, there's noone to terminate it,
+    //  so it has to terminate itself.
+    if (!owner) {
+        process_term (options.linger);
+        return;
+    }
+
+    //  If I am an owned object, I'll ask my owner to terminate me.
+    send_term_req (owner, this);
+}
+
+bool zmq::own_t::is_terminating ()
+{
+    return terminating;
+}
+
+void zmq::own_t::process_term (int linger_)
+{
+    //  Double termination should never happen.
+    zmq_assert (!terminating);
+
+    //  Send termination request to all owned objects.
+    for (owned_t::iterator it = owned.begin (); it != owned.end (); ++it)
+        send_term (*it, linger_);
+    register_term_acks ((int) owned.size ());
+    owned.clear ();
+
+    //  Start termination process and check whether by chance we cannot
+    //  terminate immediately.
+    terminating = true;
+    check_term_acks ();
+}
+
+void zmq::own_t::register_term_acks (int count_)
+{
+    term_acks += count_;
+}
+
+void zmq::own_t::unregister_term_ack ()
+{
+    zmq_assert (term_acks > 0);
+    term_acks--;
+
+    //  This may be a last ack we are waiting for before termination...
+    check_term_acks (); 
+}
+
+void zmq::own_t::process_term_ack ()
+{
+    unregister_term_ack ();
+}
+
+void zmq::own_t::check_term_acks ()
+{
+    if (terminating && processed_seqnum == sent_seqnum.get () &&
+          term_acks == 0) {
+
+        //  Sanity check. There should be no active children at this point.
+        zmq_assert (owned.empty ());
+
+        //  The root object has nobody to confirm the termination to.
+        //  Other nodes will confirm the termination to the owner.
+        if (owner)
+            send_term_ack (owner);
+
+        //  Deallocate the resources.
+        process_destroy ();
+    }
+}
+
+void zmq::own_t::process_destroy ()
+{
+    delete this;
+}
+

data/ext/zeromq/src/own.hpp

@@ -0,0 +1,145 @@
+/*
+    Copyright (c) 2010-2011 250bpm s.r.o.
+    Copyright (c) 2010-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_OWN_HPP_INCLUDED__
+#define __ZMQ_OWN_HPP_INCLUDED__
+
+#include <set>
+#include <algorithm>
+
+#include "object.hpp"
+#include "options.hpp"
+#include "atomic_counter.hpp"
+#include "stdint.hpp"
+
+namespace zmq
+{
+
+    class ctx_t;
+    class io_thread_t;
+
+    //  Base class for objects forming a part of ownership hierarchy.
+    //  It handles initialisation and destruction of such objects.
+
+    class own_t : public object_t
+    {
+    public:
+
+        //  Note that the owner is unspecified in the constructor.
+        //  It'll be supplied later on when the object is plugged in.
+
+        //  The object is not living within an I/O thread. It has it's own
+        //  thread outside of 0MQ infrastructure.
+        own_t (zmq::ctx_t *parent_, uint32_t tid_);
+
+        //  The object is living within I/O thread.
+        own_t (zmq::io_thread_t *io_thread_, const options_t &options_);
+
+        //  When another owned object wants to send command to this object
+        //  it calls this function to let it know it should not shut down
+        //  before the command is delivered.
+        void inc_seqnum ();
+
+        //  Use following two functions to wait for arbitrary events before
+        //  terminating. Just add number of events to wait for using
+        //  register_tem_acks functions. When event occurs, call
+        //  remove_term_ack. When number of pending acks reaches zero
+        //  object will be deallocated.
+        void register_term_acks (int count_);
+        void unregister_term_ack ();
+
+    protected:
+
+        //  Launch the supplied object and become its owner.
+        void launch_child (own_t *object_);
+
+        //  Terminate owned object
+        void term_child (own_t *object_);
+
+        //  Ask owner object to terminate this object. It may take a while
+        //  while actual termination is started. This function should not be
+        //  called more than once.
+        void terminate ();
+
+        //  Returns true if the object is in process of termination.
+        bool is_terminating ();
+
+        //  Derived object destroys own_t. There's no point in allowing
+        //  others to invoke the destructor. At the same time, it has to be
+        //  virtual so that generic own_t deallocation mechanism destroys
+        //  specific type of the owned object correctly.
+        virtual ~own_t ();
+
+        //  Term handler is protocted rather than private so that it can
+        //  be intercepted by the derived class. This is useful to add custom
+        //  steps to the beginning of the termination process.
+        void process_term (int linger_);
+
+        //  A place to hook in when phyicallal destruction of the object
+        //  is to be delayed.
+        virtual void process_destroy ();
+
+        //  Socket options associated with this object.
+        options_t options;
+
+    private:
+
+        //  Set owner of the object
+        void set_owner (own_t *owner_);
+
+        //  Handlers for incoming commands.
+        void process_own (own_t *object_);
+        void process_term_req (own_t *object_);
+        void process_term_ack ();
+        void process_seqnum ();
+
+        //  Check whether all the peding term acks were delivered.
+        //  If so, deallocate this object.
+        void check_term_acks ();
+
+        //  True if termination was already initiated. If so, we can destroy
+        //  the object if there are no more child objects or pending term acks.
+        bool terminating;
+
+        //  Sequence number of the last command sent to this object.
+        atomic_counter_t sent_seqnum;
+
+        //  Sequence number of the last command processed by this object.
+        uint64_t processed_seqnum;
+
+        //  Socket owning this object. It's responsible for shutting down
+        //  this object.
+        own_t *owner;
+
+        //  List of all objects owned by this socket. We are responsible
+        //  for deallocating them before we quit.
+        typedef std::set <own_t*> owned_t;
+        owned_t owned;
+
+        //  Number of events we have to get before we can destroy the object.
+        int term_acks;
+
+        own_t (const own_t&);
+        const own_t &operator = (const own_t&);
+    };
+
+}
+
+#endif