int RabbitInBoundConnectionPoint::ListenMessage(void** destBuffer) throw (ConnectException)
{
amqp_rpc_reply_t res;
amqp_envelope_t envelope;
amqp_maybe_release_buffers(_conn);
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
res = amqp_consume_message(_conn, &envelope, &timeout, 0);
if (AMQP_RESPONSE_NORMAL == res.reply_type)
{
int messageLen = (int) envelope.message.body.len;
void* message = malloc(messageLen);
memcpy(message, envelope.message.body.bytes, messageLen);
amqp_basic_ack(_conn, 1, envelope.delivery_tag, false);
GetRabbitError("Ack Error");
amqp_destroy_envelope(&envelope);
*destBuffer = message;
return messageLen;
}
else
{
if(res.library_error != AMQP_STATUS_TIMEOUT)
{
LOG(ERROR) << "Error al leer de Rabbit: " << amqp_error_string2(res.library_error);
throw ConnectException("Error al leer de Rabbit", true);
}
}
return 0;
}
void TCPSocket::connect(const char *name, unsigned short port) {
if (this->_state != CREATED) {
throw SocketStateException("Wrong state for operation");
}
struct sockaddr_in remote_addr;
const int GETHOSTBYNAME_R_BUFSIZE = 4096;
char tmp_buf[GETHOSTBYNAME_R_BUFSIZE];
struct hostent *result;
#if defined( linux ) || defined( __linux )
struct hostent ret;
int h_errnop;
if (gethostbyname_r(name, &ret, tmp_buf, GETHOSTBYNAME_R_BUFSIZE,
&result, &h_errnop) == -1) {
throw DNSException(h_errno);
}
if (result == NULL) {
throw DNSException(h_errno);
}
#endif
#if defined( sun ) || defined( __sun )
struct hostent entry;
int h_errnop;
if ((result = gethostbyname_r(name, &entry, tmp_buf, GETHOSTBYNAME_R_BUFSIZE,
&h_errnop)) == NULL) {
throw DNSException(h_errno);
}
#endif
memset(&remote_addr, 0, sizeof (remote_addr));
remote_addr.sin_addr = *((in_addr *) result->h_addr_list[0]);
remote_addr.sin_family = AF_INET;
remote_addr.sin_port = htons(port);
if (this->_nonblocking == false) {
if (::connect(this->_b->_sock, (struct sockaddr*) & remote_addr, sizeof (remote_addr)) == -1) {
if (errno == EAGAIN)
throw EAGAINException();
else
throw ConnectException(errno);
}
this->_state = CONNECTED;
}
if (this->_nonblocking == true) {
::connect(this->_b->_sock, (struct sockaddr*) & remote_addr, sizeof (remote_addr));
this->_state = CONNECTING;
}
#ifdef DEBUG
fprintf(stderr, "connected to %s port %d\n", name, port);
#endif
}
void LocalServerConnection<BufferType>::Close() {
m_pendingChannels->Break(NotConnectedException());
while(!m_pendingChannels->IsEmpty()) {
PendingChannelEntry* entry = m_pendingChannels->Top();
m_pendingChannels->Pop();
entry->m_result.SetException(ConnectException("Server unavailable."));
}
}
void HttpClient::connect() {
try {
auto ipAddr = System::Ipv4Resolver(m_dispatcher).resolve(m_address);
m_connection = System::TcpConnector(m_dispatcher).connect(ipAddr, m_port);
m_streamBuf.reset(new System::TcpStreambuf(m_connection));
m_connected = true;
} catch (const std::exception& e) {
throw ConnectException(e.what());
}
}
std::auto_ptr<Socket>
Connector::connect(unsigned short port, const char *host)
throw (ConnectException&)
{
// connect to server
bsd::SOCK_Connector connector;
std::auto_ptr<Socket> clientConnectionPtr(new Socket);
bsd::SOCK_Stream peer = clientConnectionPtr->getConnectionHandle();
if (connector.connect(peer, host, port) < 0)
throw ConnectException("could not to connect to server");
return clientConnectionPtr;
}
void TCPSocket::validate_connect() {
if (this->_state == CONNECTING) {
int error;
socklen_t len = sizeof (error);
this->getsockopt(SOL_SOCKET, SO_ERROR, &error, &len);
if (error != 0) {
// can this happen?
if (error == EAGAIN)
throw EAGAINException();
else
throw ConnectException(error);
}
this->_state = CONNECTED;
}
}
//////////////////////////////////////////////////////////////////////
// send datagram to peer
//////////////////////////////////////////////////////////////////////
uint DatagramSocket::send (Datagram * pDatagram )
throw(ConnectException , Error )
{
__BEGIN_TRY
Assert(pDatagram != NULL);
try {
int nSent = SocketAPI::sendto_ex(m_SocketID , pDatagram->getData() , pDatagram->getLength() , 0 , pDatagram->getAddress() , szSOCKADDR_IN);
return (uint)nSent;
} catch (ConnectException & t ) {
cout <<"DatagramSocket::send Exception Check!" << endl;
cout << t.toString() << endl;
throw ConnectException("DatagramSocket의 상위로 던진다");
}
__END_CATCH
}
void ClientImpl::initiateConnection(boost::shared_ptr<PendingConnection> &pc) throw (voltdb::ConnectException, voltdb::LibEventException){
std::stringstream ss;
ss << "ClientImpl::initiateConnection to " << pc->m_hostname << ":" << pc->m_port;
logMessage(ClientLogger::INFO, ss.str());
struct bufferevent * bev = bufferevent_socket_new(m_base, -1, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE);
if (bev == NULL) {
throw ConnectException();
}
FreeBEVOnFailure protector(bev);
bufferevent_setcb(bev, authenticationReadCallback, NULL, authenticationEventCallback, pc.get());
if (bufferevent_socket_connect_hostname(bev, NULL, AF_INET, pc->m_hostname.c_str(), pc->m_port) != 0) {
ss.str("");
ss << "!!!! ClientImpl::initiateConnection to " << pc->m_hostname << ":" << pc->m_port << " failed";
logMessage(ClientLogger::ERROR, ss.str());
throw voltdb::LibEventException();
}
protector.success();
}
void ClientImpl::createConnection(const std::string& hostname, const unsigned short port) throw (voltdb::Exception, voltdb::ConnectException, voltdb::LibEventException) {
std::stringstream ss;
ss << "ClientImpl::createConnection" << " hostname:" << hostname << " port:" << port;
logMessage(ClientLogger::INFO, ss.str());
PendingConnectionSPtr pc(new PendingConnection(hostname, port, m_base, this));
initiateConnection(pc);
if (event_base_dispatch(m_base) == -1) {
throw voltdb::LibEventException();
}
if (pc->m_status) {
if (event_base_dispatch(m_base) == -1) {
throw voltdb::LibEventException();
}
if (pc->m_loginExchangeCompleted) {
return;
}
}
throw ConnectException();
}
void ClientImpl::finalizeAuthentication(PendingConnection* pc, struct bufferevent *bev) throw (voltdb::Exception, voltdb::ConnectException){
logMessage(ClientLogger::DEBUG, "ClientImpl::finalizeAuthentication");
FreeBEVOnFailure protector(bev);
if (pc->m_loginExchangeCompleted) {
logMessage(ClientLogger::DEBUG, "ClientImpl::finalizeAuthentication OK");
if (!m_instanceIdIsSet) {
m_instanceIdIsSet = true;
m_clusterStartTime = pc->m_response.clusterStartTime();
m_leaderAddress = pc->m_response.leaderAddress();
} else {
if (m_clusterStartTime != pc->m_response.clusterStartTime() ||
m_leaderAddress != pc->m_response.leaderAddress()) {
throw ClusterInstanceMismatchException();
}
}
//save event for host id
m_hostIdToEvent[pc->m_response.hostId()] = bev;
bufferevent_setwatermark( bev, EV_READ, 4, HIGH_WATERMARK);
m_bevs.push_back(bev);
m_contexts[bev] =
boost::shared_ptr<CxnContext>(
new CxnContext(pc->m_hostname, pc->m_port));
boost::shared_ptr<CallbackMap> callbackMap(new CallbackMap());
m_callbacks[bev] = callbackMap;
//Add callback for Topology Notification to map for magic volt session id
boost::shared_ptr<TopologyNotificationCallback> topoNotificationCallback(new TopologyNotificationCallback(&m_distributer));
callbackMap->insert(std::pair< int64_t, boost::shared_ptr<ProcedureCallback> >(VOLT_NOTIFICATION_MAGIC_NUMBER, topoNotificationCallback));
bufferevent_setcb(
bev,
voltdb::regularReadCallback,
voltdb::regularWriteCallback,
voltdb::regularEventCallback, this);
{
boost::mutex::scoped_lock lock(m_pendingConnectionLock);
for (std::list<PendingConnectionSPtr>::iterator i = m_pendingConnectionList.begin(); i != m_pendingConnectionList.end(); ++i) {
if (i->get() == pc) {
m_pendingConnectionList.erase(i);
m_pendingConnectionSize.store(m_pendingConnectionList.size(), boost::memory_order_release);
break;
}
}
}
//update topology info and procedures info
if (m_useClientAffinity) {
updateHashinator();
subscribeToTopologyNotifications();
}
std::stringstream ss;
ss << "connectionActive " << m_contexts[bev]->m_name << ":" << m_contexts[bev]->m_port ;
logMessage(ClientLogger::INFO, ss.str());
//Notify client that a connection was active
if (m_listener.get() != NULL) {
try {
m_listener->connectionActive( m_contexts[bev]->m_name, m_bevs.size() );
} catch (const std::exception& e) {
std::cerr << "Status listener threw exception on connection active: " << e.what() << std::endl;
}
}
}
else {
logMessage(ClientLogger::DEBUG, "ClientImpl::finalizeAuthentication Fail");
std::stringstream ss;
ss << "connection failed " << " " << pc->m_hostname << ":" << pc->m_port;
logMessage(ClientLogger::ERROR, ss.str());
throw ConnectException();
}
protector.success();
}
