int IOProxy::connect_callback( Stream * /*stream*/ )
{
ReliSock *client = new ReliSock;
bool accept_client = false;
int success;
success = server->accept(*client);
if(success) {
if(get_local_ipaddr().compare_address(client->peer_addr())) {
dprintf(D_ALWAYS,"IOProxy: accepting connection from %s\n",client->peer_ip_str());
accept_client = true;
} else {
dprintf(D_ALWAYS,"IOProxy: rejecting connection from %s: invalid ip addr\n",client->peer_ip_str());
}
} else {
dprintf(D_ALWAYS,"IOProxy: Couldn't accept connection: %s\n",strerror(errno));
}
if(accept_client) {
IOProxyHandler *handler = new IOProxyHandler();
if(!handler->init(client,cookie)) {
dprintf(D_ALWAYS,"IOProxy: couldn't register request callback!\n");
client->close();
delete client;
}
} else {
client->close();
delete client;
}
return KEEP_STREAM;
}
// sending command to remote replication daemon; specified command function
// allows to specify which data is to be sent to the remote daemon
void
AbstractReplicatorStateMachine::sendCommand(
int command, char* daemonSinfulString, CommandFunction function )
{
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand %s to %s\n",
utilToString( command ), daemonSinfulString );
Daemon daemon( DT_ANY, daemonSinfulString );
ReliSock socket;
// no retries after 'm_connectionTimeout' seconds of unsuccessful connection
socket.timeout( m_connectionTimeout );
socket.doNotEnforceMinimalCONNECT_TIMEOUT( );
if( ! socket.connect( daemonSinfulString, 0, false ) ) {
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand "
"unable to connect to %s\n",
daemonSinfulString );
socket.close( );
return ;
}
// General actions for any command sending
if( ! daemon.startCommand( command, &socket, m_connectionTimeout ) ) {
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand "
"cannot start command %s to %s\n",
utilToString( command ), daemonSinfulString );
socket.close( );
return ;
}
char const* sinfulString = daemonCore->InfoCommandSinfulString();
if(! socket.put( sinfulString )/* || ! socket.end_of_message( )*/) {
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand "
"unable to code the local sinful string or eom%s\n",
sinfulString );
socket.close( );
return ;
}
else {
dprintf( D_FULLDEBUG, "AbstractReplicatorStateMachine::sendCommand "
"local sinful string coded successfully\n" );
}
// End of General actions for any command sending
// Command-specific actions
if( ! ((*this).*(function))( socket ) ) {
socket.close( );
return ;
}
// End of Command-specific actions
if( ! socket.end_of_message( ) ) {
socket.close( );
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand "
"unable to code the end of message\n" );
return ;
}
socket.close( );
dprintf( D_ALWAYS, "AbstractReplicatorStateMachine::sendCommand "
"%s command sent to %s successfully\n",
utilToString( command ), daemonSinfulString );
}
/* Function : transferFileCommand
* Return value: TRANSFERER_TRUE - upon success,
* TRANSFERER_FALSE - upon failure
* Description : sends a transfer command to the remote replication daemon,
* which creates a uploading 'condor_transferer' process
* Notes : sends to the replication daemon a port number, on which it
* will be listening to the files uploading requests
*/
int
DownloadReplicaTransferer::transferFileCommand( )
{
char* temporaryDaemonSinfulString =
const_cast<char*>( m_daemonSinfulString.Value( ) );
dprintf( D_ALWAYS, "DownloadReplicaTransferer::transferFileCommand "
"to %s started\n", temporaryDaemonSinfulString );
Daemon daemon( DT_ANY, temporaryDaemonSinfulString );
ReliSock temporarySocket;
// no retries after 'm_connectionTimeout' seconds of unsuccessful connection
temporarySocket.timeout( m_connectionTimeout );
temporarySocket.doNotEnforceMinimalCONNECT_TIMEOUT( );
if( ! temporarySocket.connect( temporaryDaemonSinfulString, 0, false ) ) {
dprintf( D_NETWORK, "DownloadReplicaTransferer::transferFileCommand "
"unable to connect to %s, reason: %s\n",
temporaryDaemonSinfulString, strerror( errno ) );
temporarySocket.close( );
return TRANSFERER_FALSE;
}
if( ! daemon.startCommand( REPLICATION_TRANSFER_FILE, &temporarySocket,
m_connectionTimeout ) ) {
dprintf( D_COMMAND, "DownloadReplicaTransferer::transferFileCommand "
"unable to start command to addr %s\n",
temporaryDaemonSinfulString );
temporarySocket.close( );
return TRANSFERER_FALSE;
}
MyString sinfulString;
// find and bind port of the socket, to which the uploading
// 'condor_transferer' process will send the important files
ReliSock listeningSocket;
listeningSocket.timeout( m_maxTransferLifetime / 2);
//listeningSocket.timeout( ACCEPT_TIMEOUT );
//listeningSocket.timeout( m_connectionTimeout );
// this setting is practically unnecessary, since we do not connect to
// remote sockets with 'listeningSocket'
listeningSocket.doNotEnforceMinimalCONNECT_TIMEOUT( );
if( ! listeningSocket.bind( FALSE ) || ! listeningSocket.listen( ) ) {
temporarySocket.close( );
listeningSocket.close( );
return TRANSFERER_FALSE;
}
sinfulString = listeningSocket.get_sinful_public();
// after the socket for the downloading/uploading process is occupied,
// its number is sent to the remote replication daemon
char* temporarySinfulString = const_cast<char*>( sinfulString.Value( ) );
if( ! temporarySocket.code( temporarySinfulString ) ||
! temporarySocket.end_of_message( ) ) {
dprintf( D_NETWORK, "DownloadReplicaTransferer::transferFileCommand "
"unable to code the sinful string %s\n", temporarySinfulString );
temporarySocket.close( );
listeningSocket.close( );
return TRANSFERER_FALSE;
} else {
dprintf( D_ALWAYS, "DownloadReplicaTransferer::transferFileCommand "
"sinful string %s coded successfully\n", temporarySinfulString );
}
temporarySocket.close( );
m_socket = listeningSocket.accept( );
// m_socket->set_timeout_multiplier( 1 );
m_socket->timeout( INT_MAX ); //m_connectionTimeout );
m_socket->doNotEnforceMinimalCONNECT_TIMEOUT( );
listeningSocket.close( );
dprintf( D_ALWAYS, "DownloadReplicaTransferer::transferFileCommand "
"sent transfer command successfully and accepted "
"request on port no. %d\n", m_socket->get_port( ) );
return TRANSFERER_TRUE;
}
void send_command(const ClassAdWrapper & ad, DaemonCommands dc, const std::string &target="")
{
std::string addr;
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, addr))
{
PyErr_SetString(PyExc_ValueError, "Address not available in location ClassAd.");
throw_error_already_set();
}
std::string ad_type_str;
if (!ad.EvaluateAttrString(ATTR_MY_TYPE, ad_type_str))
{
PyErr_SetString(PyExc_ValueError, "Daemon type not available in location ClassAd.");
throw_error_already_set();
}
int ad_type = AdTypeFromString(ad_type_str.c_str());
if (ad_type == NO_AD)
{
printf("ad type %s.\n", ad_type_str.c_str());
PyErr_SetString(PyExc_ValueError, "Unknown ad type.");
throw_error_already_set();
}
daemon_t d_type;
switch (ad_type) {
case MASTER_AD:
d_type = DT_MASTER;
break;
case STARTD_AD:
d_type = DT_STARTD;
break;
case SCHEDD_AD:
d_type = DT_SCHEDD;
break;
case NEGOTIATOR_AD:
d_type = DT_NEGOTIATOR;
break;
case COLLECTOR_AD:
d_type = DT_COLLECTOR;
break;
default:
d_type = DT_NONE;
PyErr_SetString(PyExc_ValueError, "Unknown daemon type.");
throw_error_already_set();
}
ClassAd ad_copy;
ad_copy.CopyFrom(ad);
Daemon d(&ad_copy, d_type, NULL);
bool result;
{
condor::ModuleLock ml;
result = !d.locate();
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Unable to locate daemon.");
throw_error_already_set();
}
ReliSock sock;
{
condor::ModuleLock ml;
result = !sock.connect(d.addr());
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Unable to connect to the remote daemon");
throw_error_already_set();
}
{
condor::ModuleLock ml;
result = !d.startCommand(dc, &sock, 0, NULL);
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Failed to start command.");
throw_error_already_set();
}
if (target.size())
{
std::string target_to_send = target;
if (!sock.code(target_to_send))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send target.");
throw_error_already_set();
}
if (!sock.end_of_message())
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send end-of-message.");
throw_error_already_set();
}
}
sock.close();
}
void send_command(const ClassAdWrapper & ad, DaemonCommands dc, const std::string &target="")
{
std::string addr;
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, addr))
{
PyErr_SetString(PyExc_ValueError, "Address not available in location ClassAd.");
throw_error_already_set();
}
std::string ad_type_str;
if (!ad.EvaluateAttrString(ATTR_MY_TYPE, ad_type_str))
{
PyErr_SetString(PyExc_ValueError, "Daemon type not available in location ClassAd.");
throw_error_already_set();
}
int ad_type = AdTypeFromString(ad_type_str.c_str());
if (ad_type == NO_AD)
{
PyErr_SetString(PyExc_ValueError, "Unknown ad type.");
throw_error_already_set();
}
daemon_t d_type;
switch (ad_type) {
case MASTER_AD: d_type = DT_MASTER; break;
case STARTD_AD: d_type = DT_STARTD; break;
case SCHEDD_AD: d_type = DT_SCHEDD; break;
case NEGOTIATOR_AD: d_type = DT_NEGOTIATOR; break;
case COLLECTOR_AD: d_type = DT_COLLECTOR; break;
default:
PyErr_SetString(PyExc_ValueError, "Unknown daemon type.");
throw_error_already_set();
}
ClassAd ad_copy; ad_copy.CopyFrom(ad);
Daemon d(&ad_copy, d_type, NULL);
if (!d.locate())
{
PyErr_SetString(PyExc_RuntimeError, "Unable to locate daemon.");
throw_error_already_set();
}
ReliSock sock;
if (!sock.connect(d.addr()))
{
PyErr_SetString(PyExc_RuntimeError, "Unable to connect to the remote daemon");
throw_error_already_set();
}
if (!d.startCommand(dc, &sock, 0, NULL))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to start command.");
throw_error_already_set();
}
if (target.size())
{
std::vector<unsigned char> target_cstr; target_cstr.reserve(target.size()+1);
memcpy(&target_cstr[0], target.c_str(), target.size()+1);
if (!sock.code(&target_cstr[0]))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send target.");
throw_error_already_set();
}
if (!sock.end_of_message())
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send end-of-message.");
throw_error_already_set();
}
}
sock.close();
}