void
Receiver::handle_read_stream (const ACE_Asynch_Read_Stream::Result &result)
{
ACE_DEBUG ((LM_DEBUG,
"handle_read_stream called\n"));
// Reset pointers.
result.message_block ().rd_ptr ()[result.bytes_transferred ()] =
'\0';
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", result.bytes_to_read
()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block",
result.message_block ().rd_ptr ()));
if ( result.success () && result.bytes_transferred () != 0)
{
// Successful read: write the data to the file asynchronously.
// Note how we reuse the <ACE_Message_Block> for the writing.
// Therefore, we do not delete this buffer because it is handled
// in <handle_write_stream>.
if(this->initiate_write_stream (result.message_block (),
result.bytes_transferred () ) == 0 )
{
if ( duplex != 0 )
{
// Initiate new read from the stream.
this->initiate_read_stream () ;
}
}
}
else
{
result.message_block ().release ();
ACE_DEBUG ((LM_DEBUG, "Receiver completed\n"));
}
{
ACE_GUARD (MyMutex, locker, m_Mtx);
--nIOCount;
}
check_destroy () ;
}
void zmq::socket_base_t::start_reaping (poller_t *poller_)
{
// Plug the socket to the reaper thread.
poller = poller_;
handle = poller->add_fd (mailbox.get_fd (), this);
poller->set_pollin (handle);
// Initialise the termination and check whether it can be deallocated
// immediately.
terminate ();
check_destroy ();
}
void xs::socket_base_t::start_reaping (io_thread_t *io_thread_)
{
// Plug the socket to the reaper thread.
io_thread = io_thread_;
handle = io_thread->add_fd (mailbox_fd (&mailbox), this);
io_thread->set_pollin (handle);
// Initialise the termination and check whether it can be deallocated
// immediately.
terminate ();
check_destroy ();
}
void zmq::socket_base_t::in_event ()
{
// This function is invoked only once the socket is running in the context
// of the reaper thread. Process any commands from other threads/sockets
// that may be available at the moment. Ultimately, the socket will
// be destroyed.
ENTER_MUTEX ();
// If the socket is thread safe we need to unsignal the reaper signaler
if (thread_safe)
reaper_signaler->recv();
process_commands (0, false);
EXIT_MUTEX ();
check_destroy ();
}
int
Receiver::open (void *)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Reactor *TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this, flg_mask_) == -1)
return -1;
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
int Sender::open (void *)
{
ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, locker, this->mutex_, -1);
ACE_Reactor * TPReactor = ACE_Reactor::instance ();
this->reactor (TPReactor);
flg_mask_ = ACE_Event_Handler::NULL_MASK ;
if (TPReactor->register_handler (this,flg_mask_) == -1)
return -1;
if (this->initiate_write () == -1)
return -1;
if (duplex != 0)
initiate_io (ACE_Event_Handler::READ_MASK);
return check_destroy ();
}
void
Receiver::handle_write_stream (const ACE_Asynch_Write_Stream::Result
&result)
{
ACE_DEBUG ((LM_DEBUG, "handle_write_stream called\n"));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write",
result.bytes_to_write ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", result.handle ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transfered",
result.bytes_transferred ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "act", (u_long) result.act ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "success", result.success ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "completion_key", (u_long)
result.completion_key ()));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", result.error ()));
ACE_DEBUG ((LM_DEBUG, "********************\n"));
result.message_block ().release ();
if (result.success ())
{
// This code is not robust enough to deal with short file writes
// (which hardly ever happen) ;-)
//ACE_ASSERT (result.bytes_to_write () == result.bytes_transferred ());
if ( duplex == 0 )
{
initiate_read_stream () ;
}
}
{
ACE_Guard<MyMutex> locker (m_Mtx) ;
nIOCount-- ;
}
check_destroy () ;
}
void
Receiver::open (ACE_HANDLE handle,
ACE_Message_Block &)
{
ACE_DEBUG ((LM_DEBUG,
"%N:%l:Receiver::open called\n"));
this->handle_ = handle;
if (this->ws_.open (*this, this->handle_) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Write_Stream::open"));
else if (this->rs_.open (*this, this->handle_) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"ACE_Asynch_Read_Stream::open"));
else
initiate_read_stream ();
check_destroy ();
}
int
Sender::handle_output (ACE_HANDLE h)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Time_Value tv = ACE_Time_Value::zero;
ACE_Message_Block *mb = 0;
int err=0;
ssize_t res=0;
size_t bytes=0;
int qcount = this->getq (mb , & tv);
if (mb != 0) // qcount >= 0
{
bytes = mb->length ();
res = this->peer ().send (mb->rd_ptr (), bytes);
this->total_w_++;
if (res < 0)
err = errno ;
else
this->total_snd_ += res;
if (loglevel == 0 || res <= 0 || err!= 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG, "**** Sender::handle_output () SessionId=%d****\n", index_));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_write", bytes));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", h));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transferred", res));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", err));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", mb->rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "**** end of message ****************\n"));
}
}
ACE_Message_Block::release (mb);
if (err != 0 || res < 0)
return -1;
int rc = 0;
if (qcount <= 0) // no more message blocks in queue
{
if (duplex != 0 && // full duplex, continue write
(this->total_snd_ - this->total_rcv_ ) < 1024*32 ) // flow control
rc = initiate_write ();
else
rc = terminate_io (ACE_Event_Handler::WRITE_MASK);
if (rc == -1)
return -1;
}
rc = initiate_io (ACE_Event_Handler::READ_MASK);
if (rc == -1)
return -1;
return check_destroy ();
}
int
Sender::handle_input (ACE_HANDLE h)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (BUFSIZ),
-1);
int err = 0;
ssize_t res = this->peer ().recv (mb->rd_ptr (),
BUFSIZ-1);
this->total_r_++;
if (res >= 0)
{
mb->wr_ptr (res);
this->total_rcv_ += res;
}
else
err = errno ;
mb->wr_ptr ()[0] = '\0';
if (loglevel == 0 || res <= 0 || err!= 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG, "**** Sender::handle_input () SessionId=%d****\n", index_));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", BUFSIZ));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", h));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transferred", res));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", err));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", mb->rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "**** end of message ****************\n"));
}
ACE_Message_Block::release (mb);
if (err == EWOULDBLOCK)
{
err=0;
res=0;
return check_destroy ();
}
if (err !=0 || res <= 0)
return -1;
int rc = 0;
if (duplex != 0) // full duplex, continue read
rc = initiate_io (ACE_Event_Handler::READ_MASK);
else
rc = terminate_io (ACE_Event_Handler::READ_MASK);
if (rc != 0)
return -1 ;
rc = initiate_write ();
if (rc != 0)
return -1;
return check_destroy ();
}
int
Receiver::handle_input (ACE_HANDLE h)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
ACE_Message_Block *mb = 0;
ACE_NEW_RETURN (mb,
ACE_Message_Block (BUFSIZ),
-1);
int err = 0;
ssize_t res = this->peer ().recv (mb->rd_ptr (), BUFSIZ-1);
this->total_r_++;
if (res >= 0)
{
mb->wr_ptr (res);
this->total_rcv_ += res;
}
else
err = errno ;
mb->wr_ptr ()[0] = '\0';
if (loglevel == 0 || res <= 0 || err!= 0)
{
LogLocker log_lock;
ACE_DEBUG ((LM_DEBUG, "**** Receiver::handle_input () SessionId=%d****\n", index_));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_to_read", BUFSIZ));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "handle", h));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "bytes_transferred", res));
ACE_DEBUG ((LM_DEBUG, "%s = %d\n", "error", err));
ACE_DEBUG ((LM_DEBUG, "%s = %s\n", "message_block", mb->rd_ptr ()));
ACE_DEBUG ((LM_DEBUG, "**** end of message ****************\n"));
}
if (err == EWOULDBLOCK)
{
err=0;
res=0;
return check_destroy ();
}
if (err !=0 || res <= 0)
{
ACE_Message_Block::release (mb);
return -1;
}
ACE_Time_Value tv = ACE_Time_Value::zero;
int qcount = this->putq (mb, & tv);
if (qcount <= 0) // failed to putq
{
ACE_Message_Block::release (mb);
return -1 ;
}
int rc = 0;
if (duplex == 0) // half-duplex , stop read
rc = this->terminate_io (ACE_Event_Handler::READ_MASK);
else // full duplex
{
if (qcount >= 20 ) // flow control, stop read
rc = this->terminate_io (ACE_Event_Handler::READ_MASK);
else
rc = this->initiate_io (ACE_Event_Handler::READ_MASK);
}
if (rc == -1)
return -1;
//initiate write
if (this->initiate_io (ACE_Event_Handler::WRITE_MASK) != 0)
return -1;
return check_destroy ();
}