void zmq::ipc_connecter_t::start_connecting () { // Open the connecting socket. int rc = open (); // Connect may succeed in synchronous manner. if (rc == 0) { 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 any other error condition by eventual reconnect. else { if (s != retired_fd) close (); add_reconnect_timer (); } }
void zmq::ipc_connecter_t::process_plug () { if (delayed_start) add_reconnect_timer (); else start_connecting (); }
void zmq::tcp_connecter_t::out_event () { bool is_interruped = false; fd_t fd = connect(&is_interruped); if (is_interruped) { return; } rm_fd (handle); handle_valid = false; // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { close (); wait = true; add_reconnect_timer(); return; } tune_tcp_socket (fd); tune_tcp_keepalives (fd, options.tcp_keepalive, options.tcp_keepalive_cnt, options.tcp_keepalive_idle, options.tcp_keepalive_intvl); // Create the engine object for this connection. stream_engine_t *engine = new (std::nothrow) stream_engine_t (fd, options); alloc_assert (engine); // Attach the engine to the corresponding session object. send_attach (session, engine); // Shut the connecter down. terminate (); session->monitor_event (ZMQ_EVENT_CONNECTED, endpoint.c_str(), fd); }
void zmq::ipc_connecter_t::out_event () { fd_t fd = connect (); rm_fd (handle); handle_valid = false; // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { close (); add_reconnect_timer(); return; } // Create the engine object for this connection. stream_engine_t *engine = new (std::nothrow) stream_engine_t (fd, options, endpoint); alloc_assert (engine); // Attach the engine to the corresponding session object. send_attach (session, engine); // Shut the connecter down. terminate (); socket->event_connected (endpoint, fd); }
void zmq::tcp_connecter_t::start_connecting () { // Open the connecting socket. int rc = open (); // Connect may succeed in synchronous manner. if (rc == 0) { handle = add_fd (s); handle_valid = true; out_event (); return; } // 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); session->monitor_event (ZMQ_EVENT_CONNECT_DELAYED, endpoint.c_str(), zmq_errno()); return; } // Handle any other error condition by eventual reconnect. close (); wait = true; add_reconnect_timer(); }
void zmq::tcp_connecter_t::process_plug () { if (wait) add_reconnect_timer(); else start_connecting (); }
void zmq::tcp_connecter_t::out_event () { rm_fd (handle); handle_valid = false; const fd_t fd = connect (); // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { close (); add_reconnect_timer (); return; } tune_tcp_socket (fd); tune_tcp_keepalives (fd, options.tcp_keepalive, options.tcp_keepalive_cnt, options.tcp_keepalive_idle, options.tcp_keepalive_intvl); // remember our fd for ZMQ_SRCFD in messages socket->set_fd (fd); // Create the engine object for this connection. stream_engine_t *engine = new (std::nothrow) stream_engine_t (fd, options, endpoint); alloc_assert (engine); // Attach the engine to the corresponding session object. send_attach (session, engine); // Shut the connecter down. terminate (); socket->event_connected (endpoint, fd); }
void zmq::zmq_connecter_t::out_event () { fd_t fd = tcp_connecter.connect (); rm_fd (handle); handle_valid = false; // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { tcp_connecter.close (); wait = true; add_reconnect_timer(); return; } // Choose I/O thread to run connecter in. Given that we are already // running in an I/O thread, there must be at least one available. io_thread_t *io_thread = choose_io_thread (options.affinity); zmq_assert (io_thread); // Create an init object. zmq_init_t *init = new (std::nothrow) zmq_init_t (io_thread, NULL, session, fd, options); alloc_assert (init); launch_sibling (init); // Shut the connecter down. terminate (); }
void zmq::zmq_connecter_t::start_connecting () { // Open the connecting socket. int rc = tcp_connecter.open (); // Connect may succeed in synchronous manner. if (rc == 0) { handle = add_fd (tcp_connecter.get_fd ()); handle_valid = true; out_event (); return; } // Connection establishment may be dealyed. Poll for its completion. else if (rc == -1 && errno == EAGAIN) { handle = add_fd (tcp_connecter.get_fd ()); handle_valid = true; set_pollout (handle); return; } // Handle any other error condition by eventual reconnect. wait = true; add_reconnect_timer(); }
void zmq::tcp_connecter_t::out_event () { if (connect_timer_started) { cancel_timer (connect_timer_id); connect_timer_started = false; } rm_handle (); const fd_t fd = connect (); // Handle the error condition by attempt to reconnect. if (fd == retired_fd || !tune_socket (fd)) { close (); add_reconnect_timer (); return; } // Create the engine object for this connection. stream_engine_t *engine = new (std::nothrow) stream_engine_t (fd, options, endpoint); alloc_assert (engine); // Attach the engine to the corresponding session object. send_attach (session, engine); // Shut the connecter down. terminate (); socket->event_connected (endpoint, (int) fd); }
void zmq::tcp_connecter_t::timer_event (int id_) { zmq_assert (id_ == reconnect_timer_id || id_ == connect_timer_id); if (id_ == connect_timer_id) { connect_timer_started = false; rm_handle (); close (); add_reconnect_timer (); } else if (id_ == reconnect_timer_id) { reconnect_timer_started = false; start_connecting (); } }
void zmq::vmci_connecter_t::start_connecting () { // Open the connecting socket. int rc = open (); // Connect may succeed in synchronous manner. if (rc == 0) { handle = add_fd (s); handle_valid = true; out_event (); } // Handle any other error condition by eventual reconnect. else { if (s != retired_fd) close (); add_reconnect_timer (); } }
void zmq::vmci_connecter_t::out_event () { fd_t fd = connect (); rm_fd (handle); handle_valid = false; // Handle the error condition by attempt to reconnect. if (fd == retired_fd) { close (); add_reconnect_timer(); return; } tune_vmci_buffer_size (this->get_ctx (), fd, options.vmci_buffer_size, options.vmci_buffer_min_size, options.vmci_buffer_max_size); if (options.vmci_connect_timeout > 0) { #if defined ZMQ_HAVE_WINDOWS tune_vmci_connect_timeout (this->get_ctx (), fd, options.vmci_connect_timeout); #else struct timeval timeout = {0, options.vmci_connect_timeout * 1000}; tune_vmci_connect_timeout (this->get_ctx (), fd, timeout); #endif } // Create the engine object for this connection. stream_engine_t *engine = new (std::nothrow) stream_engine_t (fd, options, endpoint); alloc_assert (engine); // Attach the engine to the corresponding session object. send_attach (session, engine); // Shut the connecter down. terminate (); socket->event_connected (endpoint, fd); }