generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-02-23 15:14:40 +01:00
Code Issues Projects Releases Wiki Activity

Problem: tipc_connector_t data members not conforming to naming conventions

Browse Source 
Solution: add underscore prefix to data members
This commit is contained in:
Simon Giesecke 2019-01-31 08:20:15 -05:00
parent 58063a75a2
commit c94ad64876
2 changed files with 64 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/tipc_connecter.cpp
View File

@ -60,30 +60,30 @@ zmq::tipc_connecter_t::tipc_connecter_t (class io_thread_t *io_thread_,
bool delayed_start_) :
own_t (io_thread_, options_),
io_object_t (io_thread_),
addr (addr_),
s (retired_fd),
handle_valid (false),
delayed_start (delayed_start_),
timer_started (false),
session (session_),
current_reconnect_ivl (options.reconnect_ivl)
_addr (addr_),
_s (retired_fd),
_handle_valid (false),
_delayed_start (delayed_start_),
_timer_started (false),
_session (session_),
_current_reconnect_ivl (options.reconnect_ivl)
{
zmq_assert (addr);
zmq_assert (addr->protocol == "tipc");
addr->to_string (endpoint);
socket = session->get_socket ();
zmq_assert (_addr);
zmq_assert (_addr->protocol == "tipc");
_addr->to_string (_endpoint);
_socket = _session->get_socket ();
}
zmq::tipc_connecter_t::~tipc_connecter_t ()
{
zmq_assert (!timer_started);
zmq_assert (!handle_valid);
zmq_assert (s == retired_fd);
zmq_assert (!_timer_started);
zmq_assert (!_handle_valid);
zmq_assert (_s == retired_fd);
}
void zmq::tipc_connecter_t::process_plug ()
{
if (delayed_start)
if (_delayed_start)
add_reconnect_timer ();
else
start_connecting ();
@ -91,17 +91,17 @@ void zmq::tipc_connecter_t::process_plug ()
void zmq::tipc_connecter_t::process_term (int linger_)
{
if (timer_started) {
if (_timer_started) {
cancel_timer (reconnect_timer_id);
timer_started = false;
_timer_started = false;
}
if (handle_valid) {
rm_fd (handle);
handle_valid = false;
if (_handle_valid) {
rm_fd (_handle);
_handle_valid = false;
}
if (s != retired_fd)
if (_s != retired_fd)
close ();
own_t::process_term (linger_);
@ -118,8 +118,8 @@ void zmq::tipc_connecter_t::in_event ()
void zmq::tipc_connecter_t::out_event ()
{
fd_t fd = connect ();
rm_fd (handle);
handle_valid = false;
rm_fd (_handle);
_handle_valid = false;
// Handle the error condition by attempt to reconnect.
if (fd == retired_fd) {
@ -129,22 +129,22 @@ void zmq::tipc_connecter_t::out_event ()
}
// Create the engine object for this connection.
stream_engine_t *engine =
new (std::nothrow) stream_engine_t (fd, options, endpoint);
new (std::nothrow) stream_engine_t (fd, options, _endpoint);
alloc_assert (engine);
// Attach the engine to the corresponding session object.
send_attach (session, engine);
send_attach (_session, engine);
// Shut the connecter down.
terminate ();
socket->event_connected (endpoint, fd);
_socket->event_connected (_endpoint, fd);
}
void zmq::tipc_connecter_t::timer_event (int id_)
{
zmq_assert (id_ == reconnect_timer_id);
timer_started = false;
_timer_started = false;
start_connecting ();
}
@ -155,22 +155,22 @@ void zmq::tipc_connecter_t::start_connecting ()
// Connect may succeed in synchronous manner.
if (rc == 0) {
handle = add_fd (s);
handle_valid = true;
_handle = add_fd (_s);
_handle_valid = true;
out_event ();
}
// Connection establishment may be delayed. Poll for its completion.
else if (rc == -1 && errno == EINPROGRESS) {
handle = add_fd (s);
handle_valid = true;
set_pollout (handle);
socket->event_connect_delayed (endpoint, zmq_errno ());
_handle = add_fd (_s);
_handle_valid = true;
set_pollout (_handle);
_socket->event_connect_delayed (_endpoint, zmq_errno ());
}
// Handle any other error condition by eventual reconnect.
else {
if (s != retired_fd)
if (_s != retired_fd)
close ();
add_reconnect_timer ();
}
@ -181,8 +181,8 @@ void zmq::tipc_connecter_t::add_reconnect_timer ()
if (options.reconnect_ivl != -1) {
int rc_ivl = get_new_reconnect_ivl ();
add_timer (rc_ivl, reconnect_timer_id);
socket->event_connect_retried (endpoint, rc_ivl);
timer_started = true;
_socket->event_connect_retried (_endpoint, rc_ivl);
_timer_started = true;
}
}
@ -190,16 +190,16 @@ int zmq::tipc_connecter_t::get_new_reconnect_ivl ()
{
// The new interval is the current interval + random value.
int this_interval =
current_reconnect_ivl + (generate_random () % options.reconnect_ivl);
_current_reconnect_ivl + (generate_random () % options.reconnect_ivl);
// Only change the current reconnect interval if the maximum reconnect
// interval was set and if it's larger than the reconnect interval.
if (options.reconnect_ivl_max > 0
&& options.reconnect_ivl_max > options.reconnect_ivl) {
// Calculate the next interval
current_reconnect_ivl = current_reconnect_ivl * 2;
if (current_reconnect_ivl >= options.reconnect_ivl_max) {
current_reconnect_ivl = options.reconnect_ivl_max;
_current_reconnect_ivl = _current_reconnect_ivl * 2;
if (_current_reconnect_ivl >= options.reconnect_ivl_max) {
_current_reconnect_ivl = options.reconnect_ivl_max;
}
}
return this_interval;
@ -207,27 +207,27 @@ int zmq::tipc_connecter_t::get_new_reconnect_ivl ()
int zmq::tipc_connecter_t::open ()
{
zmq_assert (s == retired_fd);
zmq_assert (_s == retired_fd);
// Cannot connect to random tipc addresses
if (addr->resolved.tipc_addr->is_random ()) {
if (_addr->resolved.tipc_addr->is_random ()) {
errno = EINVAL;
return -1;
}
// Create the socket.
s = open_socket (AF_TIPC, SOCK_STREAM, 0);
if (s == -1)
_s = open_socket (AF_TIPC, SOCK_STREAM, 0);
if (_s == -1)
return -1;
// Set the non-blocking flag.
unblock_socket (s);
unblock_socket (_s);
// Connect to the remote peer.
#ifdef ZMQ_HAVE_VXWORKS
int rc = ::connect (s, (sockaddr *) addr->resolved.tipc_addr->addr (),
addr->resolved.tipc_addr->addrlen ());
#else
int rc = ::connect (s, addr->resolved.tipc_addr->addr (),
addr->resolved.tipc_addr->addrlen ());
int rc = ::connect (_s, _addr->resolved.tipc_addr->addr (),
_addr->resolved.tipc_addr->addrlen ());
#endif
// Connect was successful immediately.
if (rc == 0)
@ -245,11 +245,11 @@ int zmq::tipc_connecter_t::open ()
void zmq::tipc_connecter_t::close ()
{
zmq_assert (s != retired_fd);
int rc = ::close (s);
zmq_assert (_s != retired_fd);
int rc = ::close (_s);
errno_assert (rc == 0);
socket->event_closed (endpoint, s);
s = retired_fd;
_socket->event_closed (_endpoint, _s);
_s = retired_fd;
}
zmq::fd_t zmq::tipc_connecter_t::connect ()
@ -262,7 +262,7 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
#else
socklen_t len = sizeof (err);
#endif
int rc = getsockopt (s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
if (rc == -1)
err = errno;
if (err != 0) {
@ -275,8 +275,8 @@ zmq::fd_t zmq::tipc_connecter_t::connect ()
return retired_fd;
}
fd_t result = s;
s = retired_fd;
fd_t result = _s;
_s = retired_fd;
return result;
}

20
src/tipc_connecter.hpp
View File

@ -87,35 +87,35 @@ class tipc_connecter_t : public own_t, public io_object_t
fd_t connect ();
// Address to connect to. Owned by session_base_t.
const address_t *addr;
const address_t *_addr;
// Underlying socket.
fd_t s;
fd_t _s;
// Handle corresponding to the listening socket.
handle_t handle;
handle_t _handle;
// If true file descriptor is registered with the poller and 'handle'
// contains valid value.
bool handle_valid;
bool _handle_valid;
// If true, connecter is waiting a while before trying to connect.
const bool delayed_start;
const bool _delayed_start;
// True iff a timer has been started.
bool timer_started;
bool _timer_started;
// Reference to the session we belong to.
zmq::session_base_t *session;
zmq::session_base_t *_session;
// Current reconnect ivl, updated for backoff strategy
int current_reconnect_ivl;
int _current_reconnect_ivl;
// String representation of endpoint to connect to
std::string endpoint;
std::string _endpoint;
// Socket
zmq::socket_base_t *socket;
zmq::socket_base_t *_socket;
// Internal function to return a reconnect backoff delay.
// Will modify the current_reconnect_ivl used for next call