2009-08-12 09:40:16 +02:00
|
|
|
/*
|
2011-03-02 16:30:40 +01:00
|
|
|
Copyright (c) 2007-2011 iMatix Corporation
|
|
|
|
Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
|
2009-08-12 09:40:16 +02:00
|
|
|
|
|
|
|
This file is part of 0MQ.
|
|
|
|
|
|
|
|
0MQ is free software; you can redistribute it and/or modify it under
|
2010-10-30 15:08:28 +02:00
|
|
|
the terms of the GNU Lesser General Public License as published by
|
2009-08-12 09:40:16 +02:00
|
|
|
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
|
2010-10-30 15:08:28 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2009-08-12 09:40:16 +02:00
|
|
|
|
2010-10-30 15:08:28 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2009-08-12 09:40:16 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "session.hpp"
|
2010-08-11 14:09:56 +02:00
|
|
|
#include "socket_base.hpp"
|
2009-08-30 08:18:31 +02:00
|
|
|
#include "i_engine.hpp"
|
2009-08-12 09:40:16 +02:00
|
|
|
#include "err.hpp"
|
2009-08-27 10:54:28 +02:00
|
|
|
#include "pipe.hpp"
|
2010-10-08 21:42:55 +02:00
|
|
|
#include "likely.hpp"
|
2009-08-12 09:40:16 +02:00
|
|
|
|
2010-08-11 14:09:56 +02:00
|
|
|
zmq::session_t::session_t (class io_thread_t *io_thread_,
|
|
|
|
class socket_base_t *socket_, const options_t &options_) :
|
2010-10-16 10:53:29 +02:00
|
|
|
own_t (io_thread_, options_),
|
|
|
|
io_object_t (io_thread_),
|
2009-08-27 10:54:28 +02:00
|
|
|
in_pipe (NULL),
|
2010-03-20 15:04:30 +01:00
|
|
|
incomplete_in (false),
|
2009-08-27 10:54:28 +02:00
|
|
|
out_pipe (NULL),
|
2009-08-21 14:29:22 +02:00
|
|
|
engine (NULL),
|
2010-08-11 14:09:56 +02:00
|
|
|
socket (socket_),
|
|
|
|
io_thread (io_thread_),
|
2010-10-12 17:55:09 +02:00
|
|
|
pipes_attached (false),
|
2010-10-08 17:23:21 +02:00
|
|
|
delimiter_processed (false),
|
|
|
|
force_terminate (false),
|
2010-10-16 10:53:29 +02:00
|
|
|
has_linger_timer (false),
|
2010-10-08 17:23:21 +02:00
|
|
|
state (active)
|
2010-02-13 13:07:33 +01:00
|
|
|
{
|
2009-08-12 09:40:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
zmq::session_t::~session_t ()
|
|
|
|
{
|
2009-09-02 14:59:53 +02:00
|
|
|
zmq_assert (!in_pipe);
|
|
|
|
zmq_assert (!out_pipe);
|
2010-08-14 08:37:38 +02:00
|
|
|
|
|
|
|
if (engine)
|
|
|
|
engine->terminate ();
|
2009-08-12 09:40:16 +02:00
|
|
|
}
|
|
|
|
|
2010-10-08 17:23:21 +02:00
|
|
|
void zmq::session_t::proceed_with_term ()
|
2010-08-06 17:49:37 +02:00
|
|
|
{
|
2010-10-08 17:23:21 +02:00
|
|
|
if (state == terminating)
|
|
|
|
return;
|
|
|
|
|
|
|
|
zmq_assert (state == pending);
|
|
|
|
state = terminating;
|
|
|
|
|
2010-10-16 10:53:29 +02:00
|
|
|
// If there's still a pending linger timer, remove it.
|
|
|
|
if (has_linger_timer) {
|
|
|
|
cancel_timer (linger_timer_id);
|
|
|
|
has_linger_timer = false;
|
|
|
|
}
|
|
|
|
|
2010-10-08 17:23:21 +02:00
|
|
|
if (in_pipe) {
|
|
|
|
register_term_acks (1);
|
2010-08-11 17:06:49 +02:00
|
|
|
in_pipe->terminate ();
|
2010-10-08 17:23:21 +02:00
|
|
|
}
|
|
|
|
if (out_pipe) {
|
|
|
|
register_term_acks (1);
|
2010-08-11 17:06:49 +02:00
|
|
|
out_pipe->terminate ();
|
2010-10-08 17:23:21 +02:00
|
|
|
}
|
|
|
|
|
2010-10-16 10:53:29 +02:00
|
|
|
// The session has already waited for the linger period. We don't want
|
|
|
|
// the child objects to linger any more thus linger is set to zero.
|
|
|
|
own_t::process_term (0);
|
2010-08-06 17:49:37 +02:00
|
|
|
}
|
|
|
|
|
2011-04-21 22:27:48 +02:00
|
|
|
bool zmq::session_t::read (msg_t *msg_)
|
2009-08-12 09:40:16 +02:00
|
|
|
{
|
2010-09-19 08:39:53 +02:00
|
|
|
if (!in_pipe)
|
2009-08-27 10:54:28 +02:00
|
|
|
return false;
|
|
|
|
|
2010-09-19 08:39:53 +02:00
|
|
|
if (!in_pipe->read (msg_))
|
2010-03-20 15:04:30 +01:00
|
|
|
return false;
|
|
|
|
|
2011-04-21 22:27:48 +02:00
|
|
|
incomplete_in = msg_->flags () & msg_t::more;
|
2010-03-20 15:04:30 +01:00
|
|
|
return true;
|
2009-08-12 09:40:16 +02:00
|
|
|
}
|
|
|
|
|
2011-04-21 22:27:48 +02:00
|
|
|
bool zmq::session_t::write (msg_t *msg_)
|
2009-08-12 09:40:16 +02:00
|
|
|
{
|
2010-01-21 09:58:49 +01:00
|
|
|
if (out_pipe && out_pipe->write (msg_)) {
|
2011-04-21 22:27:48 +02:00
|
|
|
int rc = msg_->init ();
|
|
|
|
errno_assert (rc == 0);
|
2009-09-04 16:02:41 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2009-08-12 09:40:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void zmq::session_t::flush ()
|
|
|
|
{
|
2009-09-16 14:02:43 +02:00
|
|
|
if (out_pipe)
|
|
|
|
out_pipe->flush ();
|
2009-08-27 10:54:28 +02:00
|
|
|
}
|
|
|
|
|
2010-08-11 14:09:56 +02:00
|
|
|
void zmq::session_t::clean_pipes ()
|
2009-08-27 16:24:21 +02:00
|
|
|
{
|
2010-03-20 15:04:30 +01:00
|
|
|
// Get rid of half-processed messages in the out pipe. Flush any
|
|
|
|
// unflushed messages upstream.
|
|
|
|
if (out_pipe) {
|
|
|
|
out_pipe->rollback ();
|
|
|
|
out_pipe->flush ();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove any half-read message from the in pipe.
|
|
|
|
if (in_pipe) {
|
|
|
|
while (incomplete_in) {
|
2011-04-21 22:27:48 +02:00
|
|
|
msg_t msg;
|
|
|
|
int rc = msg.init ();
|
|
|
|
errno_assert (rc == 0);
|
2010-03-20 15:04:30 +01:00
|
|
|
if (!read (&msg)) {
|
|
|
|
zmq_assert (!incomplete_in);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-21 22:27:48 +02:00
|
|
|
rc = msg.close ();
|
|
|
|
errno_assert (rc == 0);
|
2010-03-20 15:04:30 +01:00
|
|
|
}
|
|
|
|
}
|
2009-12-15 17:49:40 +01:00
|
|
|
}
|
|
|
|
|
2009-09-21 14:39:59 +02:00
|
|
|
void zmq::session_t::attach_pipes (class reader_t *inpipe_,
|
2010-02-16 18:30:38 +01:00
|
|
|
class writer_t *outpipe_, const blob_t &peer_identity_)
|
2009-09-02 10:22:23 +02:00
|
|
|
{
|
2010-10-12 17:55:09 +02:00
|
|
|
zmq_assert (!pipes_attached);
|
|
|
|
pipes_attached = true;
|
|
|
|
|
2009-09-21 14:39:59 +02:00
|
|
|
if (inpipe_) {
|
|
|
|
zmq_assert (!in_pipe);
|
|
|
|
in_pipe = inpipe_;
|
2010-08-06 17:49:37 +02:00
|
|
|
in_pipe->set_event_sink (this);
|
2009-09-21 14:39:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (outpipe_) {
|
|
|
|
zmq_assert (!out_pipe);
|
|
|
|
out_pipe = outpipe_;
|
2010-08-06 17:49:37 +02:00
|
|
|
out_pipe->set_event_sink (this);
|
2009-09-21 14:39:59 +02:00
|
|
|
}
|
2010-08-11 14:09:56 +02:00
|
|
|
|
2010-09-20 00:06:05 +02:00
|
|
|
// If we are already terminating, terminate the pipes straight away.
|
2010-10-08 17:23:21 +02:00
|
|
|
if (state == terminating) {
|
2010-09-20 00:06:05 +02:00
|
|
|
if (in_pipe) {
|
|
|
|
in_pipe->terminate ();
|
2010-10-08 17:23:21 +02:00
|
|
|
register_term_acks (1);
|
2010-09-20 00:06:05 +02:00
|
|
|
}
|
|
|
|
if (out_pipe) {
|
|
|
|
out_pipe->terminate ();
|
2010-10-08 17:23:21 +02:00
|
|
|
register_term_acks (1);
|
2010-09-20 00:06:05 +02:00
|
|
|
}
|
|
|
|
}
|
2010-10-08 17:23:21 +02:00
|
|
|
}
|
2010-09-20 00:06:05 +02:00
|
|
|
|
2010-10-08 17:23:21 +02:00
|
|
|
void zmq::session_t::delimited (reader_t *pipe_)
|
|
|
|
{
|
|
|
|
zmq_assert (in_pipe == pipe_);
|
|
|
|
zmq_assert (!delimiter_processed);
|
|
|
|
delimiter_processed = true;
|
|
|
|
|
|
|
|
// If we are in process of being closed, but still waiting for all
|
|
|
|
// pending messeges being sent, we can terminate here.
|
|
|
|
if (state == pending)
|
|
|
|
proceed_with_term ();
|
2009-09-02 10:22:23 +02:00
|
|
|
}
|
2009-09-02 14:59:53 +02:00
|
|
|
|
2010-08-06 17:49:37 +02:00
|
|
|
void zmq::session_t::terminated (reader_t *pipe_)
|
2009-09-02 10:22:23 +02:00
|
|
|
{
|
2010-09-20 00:06:05 +02:00
|
|
|
zmq_assert (in_pipe == pipe_);
|
2009-09-21 14:39:59 +02:00
|
|
|
in_pipe = NULL;
|
2010-10-08 17:23:21 +02:00
|
|
|
if (state == terminating)
|
2010-09-20 00:06:05 +02:00
|
|
|
unregister_term_ack ();
|
2009-09-02 10:22:23 +02:00
|
|
|
}
|
|
|
|
|
2010-08-06 17:49:37 +02:00
|
|
|
void zmq::session_t::terminated (writer_t *pipe_)
|
2009-08-27 10:54:28 +02:00
|
|
|
{
|
2010-09-20 00:06:05 +02:00
|
|
|
zmq_assert (out_pipe == pipe_);
|
2009-09-21 14:39:59 +02:00
|
|
|
out_pipe = NULL;
|
2010-10-08 17:23:21 +02:00
|
|
|
if (state == terminating)
|
2010-09-20 00:06:05 +02:00
|
|
|
unregister_term_ack ();
|
2009-08-12 09:40:16 +02:00
|
|
|
}
|
|
|
|
|
2010-08-06 17:49:37 +02:00
|
|
|
void zmq::session_t::activated (reader_t *pipe_)
|
2009-08-28 16:51:46 +02:00
|
|
|
{
|
2009-09-21 14:39:59 +02:00
|
|
|
zmq_assert (in_pipe == pipe_);
|
2010-09-19 08:39:53 +02:00
|
|
|
|
2010-10-08 21:42:55 +02:00
|
|
|
if (likely (engine != NULL))
|
2010-08-11 14:09:56 +02:00
|
|
|
engine->activate_out ();
|
2010-10-08 21:42:55 +02:00
|
|
|
else
|
|
|
|
in_pipe->check_read ();
|
2009-08-28 16:51:46 +02:00
|
|
|
}
|
|
|
|
|
2010-08-06 17:49:37 +02:00
|
|
|
void zmq::session_t::activated (writer_t *pipe_)
|
2010-03-01 10:13:26 +01:00
|
|
|
{
|
|
|
|
zmq_assert (out_pipe == pipe_);
|
|
|
|
if (engine)
|
2010-08-11 14:09:56 +02:00
|
|
|
engine->activate_in ();
|
2010-03-01 10:13:26 +01:00
|
|
|
}
|
|
|
|
|
2009-08-12 09:40:16 +02:00
|
|
|
void zmq::session_t::process_plug ()
|
|
|
|
{
|
2010-02-13 13:07:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void zmq::session_t::process_attach (i_engine *engine_,
|
2010-02-13 14:07:30 +01:00
|
|
|
const blob_t &peer_identity_)
|
2010-02-13 13:07:33 +01:00
|
|
|
{
|
2010-09-20 00:06:05 +02:00
|
|
|
// If we are already terminating, we destroy the engine straight away.
|
2010-10-18 09:11:36 +02:00
|
|
|
// Note that we don't have to unplug it before deleting as it's not
|
|
|
|
// yet plugged to the session.
|
2010-10-08 17:23:21 +02:00
|
|
|
if (state == terminating) {
|
2011-03-16 13:26:23 +01:00
|
|
|
if (engine_)
|
|
|
|
delete engine_;
|
2010-09-20 00:06:05 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-03-16 13:26:23 +01:00
|
|
|
// If some other object (e.g. init) notifies us that the connection failed
|
|
|
|
// without creating an engine we need to start the reconnection process.
|
|
|
|
if (!engine_) {
|
|
|
|
zmq_assert (!engine);
|
|
|
|
detached ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Trigger the notfication event about the attachment.
|
|
|
|
if (!attached (peer_identity_)) {
|
2010-10-26 16:02:47 +02:00
|
|
|
delete engine_;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-02-14 13:34:48 +01:00
|
|
|
// Check whether the required pipes already exist. If not so, we'll
|
|
|
|
// create them and bind them to the socket object.
|
2010-10-12 17:55:09 +02:00
|
|
|
if (!pipes_attached) {
|
|
|
|
zmq_assert (!in_pipe && !out_pipe);
|
|
|
|
pipes_attached = true;
|
|
|
|
reader_t *socket_reader = NULL;
|
|
|
|
writer_t *socket_writer = NULL;
|
|
|
|
|
|
|
|
// Create the pipes, as required.
|
|
|
|
if (options.requires_in) {
|
2011-03-24 16:47:33 +01:00
|
|
|
create_pipe (socket, this, options.rcvhwm, &socket_reader,
|
|
|
|
&out_pipe);
|
2010-10-12 17:55:09 +02:00
|
|
|
out_pipe->set_event_sink (this);
|
|
|
|
}
|
|
|
|
if (options.requires_out) {
|
2011-03-24 16:47:33 +01:00
|
|
|
create_pipe (this, socket, options.sndhwm, &in_pipe,
|
|
|
|
&socket_writer);
|
2010-10-12 17:55:09 +02:00
|
|
|
in_pipe->set_event_sink (this);
|
|
|
|
}
|
2010-02-14 13:34:48 +01:00
|
|
|
|
2010-10-12 17:55:09 +02:00
|
|
|
// Bind the pipes to the socket object.
|
|
|
|
if (socket_reader || socket_writer)
|
|
|
|
send_bind (socket, socket_reader, socket_writer, peer_identity_);
|
2010-02-14 13:34:48 +01:00
|
|
|
}
|
|
|
|
|
2010-02-13 13:07:33 +01:00
|
|
|
// Plug in the engine.
|
2011-03-16 13:26:23 +01:00
|
|
|
zmq_assert (!engine);
|
2009-08-21 14:29:22 +02:00
|
|
|
engine = engine_;
|
2010-08-11 14:09:56 +02:00
|
|
|
engine->plug (io_thread, this);
|
|
|
|
}
|
|
|
|
|
2010-08-11 17:06:49 +02:00
|
|
|
void zmq::session_t::detach ()
|
|
|
|
{
|
|
|
|
// Engine is dead. Let's forget about it.
|
|
|
|
engine = NULL;
|
|
|
|
|
2010-10-13 10:09:46 +02:00
|
|
|
// Remove any half-done messages from the pipes.
|
|
|
|
clean_pipes ();
|
|
|
|
|
|
|
|
// Send the event to the derived class.
|
2010-08-11 17:06:49 +02:00
|
|
|
detached ();
|
2010-10-13 10:09:46 +02:00
|
|
|
|
|
|
|
// Just in case, there's only a delimiter in the inbound pipe.
|
|
|
|
if (in_pipe)
|
|
|
|
in_pipe->check_read ();
|
2010-08-11 17:06:49 +02:00
|
|
|
}
|
|
|
|
|
2010-10-16 10:53:29 +02:00
|
|
|
void zmq::session_t::process_term (int linger_)
|
2010-08-11 14:09:56 +02:00
|
|
|
{
|
2010-10-08 17:23:21 +02:00
|
|
|
zmq_assert (state == active);
|
|
|
|
state = pending;
|
|
|
|
|
2010-10-16 10:53:29 +02:00
|
|
|
// If linger is set to zero, we can terminate the session straight away
|
|
|
|
// not waiting for the pending messages to be sent.
|
|
|
|
if (linger_ == 0) {
|
|
|
|
proceed_with_term ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there's finite linger value, set up a timer.
|
|
|
|
if (linger_ > 0) {
|
|
|
|
zmq_assert (!has_linger_timer);
|
|
|
|
add_timer (linger_, linger_timer_id);
|
|
|
|
has_linger_timer = true;
|
|
|
|
}
|
|
|
|
|
2010-10-08 17:23:21 +02:00
|
|
|
// If there's no engine and there's only delimiter in the pipe it wouldn't
|
|
|
|
// be ever read. Thus we check for it explicitly.
|
|
|
|
if (in_pipe)
|
|
|
|
in_pipe->check_read ();
|
|
|
|
|
|
|
|
// If there's no in pipe there are no pending messages to send.
|
|
|
|
// We can proceed with the shutdown straight away. Also, if there is
|
|
|
|
// inbound pipe, but the delimiter was already processed, we can
|
|
|
|
// terminate immediately. Alternatively, if the derived session type have
|
|
|
|
// called 'terminate' we'll finish straight away.
|
2010-10-08 21:42:55 +02:00
|
|
|
if (!options.requires_out || delimiter_processed || force_terminate ||
|
|
|
|
(!options.immediate_connect && !in_pipe))
|
2010-10-08 17:23:21 +02:00
|
|
|
proceed_with_term ();
|
2010-08-11 14:09:56 +02:00
|
|
|
}
|
|
|
|
|
2010-10-16 10:53:29 +02:00
|
|
|
void zmq::session_t::timer_event (int id_)
|
|
|
|
{
|
|
|
|
// Linger period expired. We can proceed with termination even though
|
|
|
|
// there are still pending messages to be sent.
|
|
|
|
zmq_assert (id_ == linger_timer_id);
|
|
|
|
has_linger_timer = false;
|
|
|
|
proceed_with_term ();
|
|
|
|
}
|
|
|
|
|
2011-03-16 13:26:23 +01:00
|
|
|
bool zmq::session_t::has_engine ()
|
|
|
|
{
|
|
|
|
return engine != NULL;
|
|
|
|
}
|
|
|
|
|
2010-08-24 11:19:22 +02:00
|
|
|
bool zmq::session_t::register_session (const blob_t &name_, session_t *session_)
|
|
|
|
{
|
|
|
|
return socket->register_session (name_, session_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void zmq::session_t::unregister_session (const blob_t &name_)
|
|
|
|
{
|
|
|
|
socket->unregister_session (name_);
|
|
|
|
}
|
|
|
|
|
2010-10-08 17:23:21 +02:00
|
|
|
void zmq::session_t::terminate ()
|
|
|
|
{
|
|
|
|
force_terminate = true;
|
|
|
|
own_t::terminate ();
|
|
|
|
}
|