bool http_client::open(const char* addr, int conn_timeout /* = 60 */,
int rw_timeout /* = 60 */, bool unzip /* = true */,
bool use_ssl /* = false */)
{
is_request_ = true;
if (stream_ && !stream_fixed_)
{
delete stream_;
stream_ = NULL;
}
ssl_stream* stream = NEW ssl_stream();
rw_timeout_ = rw_timeout;
unzip_ = unzip;
if (stream->open_ssl(addr, conn_timeout,
rw_timeout, use_ssl) == false)
{
delete stream;
return (false);
}
stream_ = stream;
return (true);
}
void galera::ist::Receiver::interrupt()
{
gu::URI uri(recv_addr_);
try
{
asio::ip::tcp::resolver::iterator i;
try
{
asio::ip::tcp::resolver resolver(io_service_);
asio::ip::tcp::resolver::query
query(unescape_addr(uri.get_host()),
uri.get_port(),
asio::ip::tcp::resolver::query::flags(0));
i = resolver.resolve(query);
}
catch (asio::system_error& e)
{
gu_throw_error(e.code().value())
<< "failed to resolve host '"
<< uri.to_string()
<< "', asio error '" << e.what() << "'";
}
if (use_ssl_ == true)
{
asio::ssl::stream<asio::ip::tcp::socket>
ssl_stream(io_service_, ssl_ctx_);
ssl_stream.lowest_layer().connect(*i);
set_fd_options(ssl_stream.lowest_layer());
ssl_stream.handshake(asio::ssl::stream<asio::ip::tcp::socket>::client);
Proto p(version_,
conf_.get(CONF_KEEP_KEYS, CONF_KEEP_KEYS_DEFAULT));
p.recv_handshake(ssl_stream);
p.send_ctrl(ssl_stream, Ctrl::C_EOF);
p.recv_ctrl(ssl_stream);
}
else
{
asio::ip::tcp::socket socket(io_service_);
socket.connect(*i);
set_fd_options(socket);
Proto p(version_,
conf_.get(CONF_KEEP_KEYS, CONF_KEEP_KEYS_DEFAULT));
p.recv_handshake(socket);
p.send_ctrl(socket, Ctrl::C_EOF);
p.recv_ctrl(socket);
}
}
catch (asio::system_error& e)
{
// ignore
}
}
void galera::ist::Receiver::run()
{
asio::ip::tcp::socket socket(io_service_);
asio::ssl::context ssl_ctx(io_service_, asio::ssl::context::sslv23);
asio::ssl::stream<asio::ip::tcp::socket> ssl_stream(io_service_, ssl_ctx_);
try
{
if (use_ssl_ == true)
{
acceptor_.accept(ssl_stream.lowest_layer());
set_fd_options(ssl_stream.lowest_layer());
ssl_stream.handshake(asio::ssl::stream<asio::ip::tcp::socket>::server);
}
else
{
acceptor_.accept(socket);
set_fd_options(socket);
}
}
catch (asio::system_error& e)
{
gu_throw_error(e.code().value()) << "accept() failed"
<< "', asio error '"
<< e.what() << "'";
}
acceptor_.close();
int ec(0);
try
{
Proto p(version_, conf_.get(CONF_KEEP_KEYS, CONF_KEEP_KEYS_DEFAULT));
if (use_ssl_ == true)
{
p.send_handshake(ssl_stream);
p.recv_handshake_response(ssl_stream);
p.send_ctrl(ssl_stream, Ctrl::C_OK);
}
else
{
p.send_handshake(socket);
p.recv_handshake_response(socket);
p.send_ctrl(socket, Ctrl::C_OK);
}
while (true)
{
TrxHandle* trx;
if (use_ssl_ == true)
{
trx = p.recv_trx(ssl_stream);
}
else
{
trx = p.recv_trx(socket);
}
if (trx != 0)
{
if (trx->global_seqno() != current_seqno_)
{
log_error << "unexpected trx seqno: " << trx->global_seqno()
<< " expected: " << current_seqno_;
ec = EINVAL;
goto err;
}
++current_seqno_;
}
gu::Lock lock(mutex_);
while (ready_ == false || consumers_.empty())
{
lock.wait(cond_);
}
Consumer* cons(consumers_.top());
consumers_.pop();
cons->trx(trx);
cons->cond().signal();
if (trx == 0)
{
log_debug << "eof received, closing socket";
break;
}
}
}
catch (asio::system_error& e)
{
log_error << "got error while reading ist stream: " << e.code();
ec = e.code().value();
}
catch (gu::Exception& e)
{
ec = e.get_errno();
if (ec != EINTR)
{
log_error << "got exception while reading ist stream: " << e.what();
}
}
err:
gu::Lock lock(mutex_);
if (use_ssl_ == true)
{
ssl_stream.lowest_layer().close();
// ssl_stream.shutdown();
}
else
{
socket.close();
}
running_ = false;
if (ec != EINTR && current_seqno_ - 1 < last_seqno_)
{
log_error << "IST didn't contain all write sets, expected last: "
<< last_seqno_ << " last received: " << current_seqno_ - 1;
ec = EPROTO;
}
if (ec != EINTR)
{
error_code_ = ec;
}
while (consumers_.empty() == false)
{
consumers_.top()->cond().signal();
consumers_.pop();
}
}