CNetRequestImpl::CNetRequestImpl(const char* method, const String& strUrl)
{
pszErrFunction = NULL;
hInet = NULL, hConnection = NULL, hRequest = NULL;
memset(&uri, 0, sizeof(uri) );
m_pInstance = this;
CAtlStringW strUrlW(strUrl.c_str());
do
{
if ( !isLocalHost(strUrl.c_str()) && !SetupInternetConnection(strUrlW) )
{
pszErrFunction = L"SetupInternetConnection";
break;
}
hInet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, NULL );
if ( !hInet )
{
pszErrFunction = L"InternetOpen";
break;
}
DWORD dwUrlLength = 1024;
CAtlStringW strCanonicalUrlW;
if ( !InternetCanonicalizeUrl( strUrlW, strCanonicalUrlW.GetBuffer(dwUrlLength), &dwUrlLength, 0) )
{
pszErrFunction = _T("InternetCanonicalizeUrl");
break;
}
strCanonicalUrlW.ReleaseBuffer();
alloc_url_components( &uri, strCanonicalUrlW );
if( !InternetCrackUrl( strCanonicalUrlW, strCanonicalUrlW.GetLength(), 0, &uri ) )
{
pszErrFunction = L"InternetCrackUrl";
break;
}
hConnection = InternetConnect( hInet, uri.lpszHostName, uri.nPort, _T("anonymous"), NULL,
INTERNET_SERVICE_HTTP, 0, 0 );
if ( !hConnection )
{
pszErrFunction = L"InternetConnect";
break;
}
strReqUrlW = uri.lpszUrlPath;
strReqUrlW += uri.lpszExtraInfo;
hRequest = HttpOpenRequest( hConnection, CAtlStringW(method), strReqUrlW, NULL, NULL, NULL,
INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_NO_CACHE_WRITE, NULL );
if ( !hRequest )
{
pszErrFunction = L"HttpOpenRequest";
break;
}
}while(0);
}
UtlBoolean OsSocket::isSameHost(const char* host1, const char* host2)
{
UtlBoolean same;
UtlBoolean isSubDomain = FALSE;
//osPrintf("OsSocket::isSameHost host1: %s host2: %s\n", host1, host2);
if (!isIp4Address(host1) && !isIp4Address(host2))
{
if( (strstr(host1, host2) == host1 || // && need to compare w/ local domain name
strstr(host2, host1) == host2 ))
{
// && need to compare w/ local domain name
isSubDomain = TRUE;
}
}
if(strcmp(host1, host2) == 0 ||
(isLocalHost(host1) && isLocalHost(host2)) ||
isSubDomain )
{
same = TRUE;
}
else
{
// Avoid using gethostbyname if possible
UtlString host1Addr;
UtlString host2Addr;
getHostIpByName(host1, &host1Addr);
getHostIpByName(host2, &host2Addr);
if(host1Addr.compareTo(host2Addr) == 0)
{
same = TRUE;
}
else
{
same = FALSE;
}
host1Addr.remove(0);
host2Addr.remove(0);
}
return(same);
}
static UrlVector localhost_only(const UrlVector& input)
{
UrlVector result;
result.reserve(input.size());
for (const auto& url: input)
{
if (isLocalHost(url.host()))
result.push_back(url);
}
return result;
}
bool XboxServer::PostMessage(const String& message,
const String& host /* = "localhost" */) {
if (isLocalHost(host)) {
Lock l(s_dispatchMutex);
if (!s_dispatcher) {
return false;
}
XboxTransport *job = new XboxTransport(message.toCppString());
job->incRefCount(); // paired with worker's decRefCount()
assert(s_dispatcher);
s_dispatcher->enqueue(job);
return true;
} else { // remote
string url = "http://";
url += host.data();
url += "/xbox_post_message";
std::vector<std::string> headers;
std::string hostStr(host.data());
LibEventHttpClientPtr http =
LibEventHttpClient::Get(hostStr, RuntimeOption::XboxServerPort);
if (http->send(url, headers, 0, false, message.data(), message.size())) {
int code = http->getCode();
if (code > 0) {
int len = 0;
char *response = http->recv(len);
String sresponse(response, len, AttachString);
if (code == 200 &&
same(
unserialize_from_string(
sresponse,
VariableUnserializer::Type::Internal
),
true
)
) {
return true;
}
}
}
}
return false;
}
long SecureSocketImpl::verifyPeerCertificateImpl(const std::string& hostName)
{
Context::VerificationMode mode = _pContext->verificationMode();
if (mode == Context::VERIFY_NONE || !_pContext->extendedCertificateVerificationEnabled() ||
(isLocalHost(hostName) && mode != Context::VERIFY_STRICT))
{
return X509_V_OK;
}
X509* pCert = SSL_get_peer_certificate(_pSSL);
if (pCert)
{
X509Certificate cert(pCert);
return cert.verify(hostName) ? X509_V_OK : X509_V_ERR_APPLICATION_VERIFICATION;
}
else return X509_V_OK;
}
bool XboxServer::SendMessage(const String& message,
Array& ret,
int timeout_ms,
const String& host /* = "localhost" */) {
if (isLocalHost(host)) {
XboxTransport *job;
{
Lock l(s_dispatchMutex);
if (!s_dispatcher) {
return false;
}
job = new XboxTransport(message);
job->incRefCount(); // paired with worker's decRefCount()
job->incRefCount(); // paired with decRefCount() at below
assert(s_dispatcher);
s_dispatcher->enqueue(job);
}
if (timeout_ms <= 0) {
timeout_ms = RuntimeOption::XboxDefaultLocalTimeoutMilliSeconds;
}
int code = 0;
String response = job->getResults(code, timeout_ms);
job->decRefCount(); // i'm done with this job
if (code > 0) {
ret.set(s_code, code);
if (code == 200) {
ret.set(s_response, unserialize_from_string(response));
} else {
ret.set(s_error, response);
}
return true;
}
} else { // remote
string url = "http://";
url += host.data();
url += '/';
url += RuntimeOption::XboxProcessMessageFunc;
int timeoutSeconds = timeout_ms / 1000;
if (timeoutSeconds <= 0) {
timeoutSeconds = RuntimeOption::XboxDefaultRemoteTimeoutSeconds;
}
string hostStr(host.data());
std::vector<std::string> headers;
LibEventHttpClientPtr http =
LibEventHttpClient::Get(hostStr, RuntimeOption::XboxServerPort);
if (http->send(url, headers, timeoutSeconds, false,
message.data(), message.size())) {
int code = http->getCode();
if (code > 0) {
int len = 0;
char *response = http->recv(len);
String sresponse(response, len, AttachString);
ret.set(s_code, code);
if (code == 200) {
ret.set(s_response, unserialize_from_string(sresponse));
} else {
ret.set(s_error, sresponse);
}
return true;
}
// code wasn't correctly set by http client, treat it as not found
ret.set(s_code, 404);
ret.set(s_error, "http client failed");
}
}
return false;
}
bool AbstractNetworkManager::configAdd(jccl::ConfigElementPtr element)
{
if (recognizeClusterMachineConfig(element))
{
// -If local machine element
// -Add machine specific ConfigElements to the pending list.
// -Start Listening thread
// -Else
// -Add Node to AbstractNetworkManager
if (isLocalHost( element->getProperty<std::string>( "host_name" ) ))
{
// XXX: Hack to ensure that we don't start listening for connections until
// we have fully configured all other nodes.
ElementPred pred(getClusterNodeElementType());
jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();
unsigned int num_pending_nodes =
std::count_if(cfg_mgr->getPendingBegin(), cfg_mgr->getPendingEnd(), pred);
if (num_pending_nodes > 1)
{
vprDEBUG( gadgetDBG_NET_MGR, vprDBG_CONFIG_LVL ) << clrSetBOLD(clrRED)
<< clrOutBOLD( clrMAGENTA,"[AbstractNetworkManager]" )
<< " Some nodes not configured yet: " << num_pending_nodes
<< clrRESET << std::endl << vprDEBUG_FLUSH;
return false;
}
// NOTE: Add all machine dependent ConfigElementPtr's here
vprASSERT( element->getNum("display_system") == 1
&& "A Cluster System element must have exactly 1 display_system element" );
std::vector<jccl::ConfigElementPtr> cluster_node_elements =
element->getChildElements();
for (std::vector<jccl::ConfigElementPtr>::iterator i = cluster_node_elements.begin();
i != cluster_node_elements.end();
++i)
{
jccl::ConfigManager::instance()->addConfigElement(*i, jccl::ConfigManager::PendingElement::ADD);
vprDEBUG( gadgetDBG_NET_MGR, vprDBG_CONFIG_LVL ) << clrSetBOLD(clrCYAN)
<< clrOutBOLD( clrMAGENTA,"[AbstractNetworkManager]" )
<< " Adding Machine specific ConfigElement: "
<< (*i)->getName() << clrRESET << std::endl << vprDEBUG_FLUSH;
}
const int listen_port = element->getProperty<int>( "listen_port" );
startListening( listen_port, false );
}
else
{
vprDEBUG( gadgetDBG_NET_MGR, vprDBG_CONFIG_LVL )
<< clrOutBOLD( clrMAGENTA, "[AbstractNetworkManager]" )
<< " Adding Node: " << element->getName()
<< " to the Cluster Network\n" << vprDEBUG_FLUSH;
std::string name = element->getName();
std::string host_name = element->getProperty<std::string>( "host_name" );
vpr::Uint16 listen_port = element->getProperty<int>( "listen_port" );
addNode(name, host_name, listen_port);
}
return true;
}
return false;
}
Future<MessageSocketPtr> TransportSocketCache::socket(const ServiceInfo& servInfo, const std::string& url)
{
const std::string& machineId = servInfo.machineId();
ConnectionAttemptPtr couple = boost::make_shared<ConnectionAttempt>();
couple->relatedUrls = servInfo.endpoints();
bool local = machineId == os::getMachineId();
UrlVector connectionCandidates;
// If the connection is local, we're mainly interested in localhost endpoint
if (local)
connectionCandidates = localhost_only(servInfo.endpoints());
// If the connection isn't local or if the service doesn't expose local endpoints,
// try and connect to whatever is available.
if (connectionCandidates.size() == 0)
connectionCandidates = servInfo.endpoints();
couple->endpoint = MessageSocketPtr();
couple->state = State_Pending;
{
// If we already have a pending connection to one of the urls, we return the future in question
boost::mutex::scoped_lock lock(_socketMutex);
if (_dying)
return makeFutureError<MessageSocketPtr>("TransportSocketCache is closed.");
ConnectionMap::iterator machineIt = _connections.find(machineId);
if (machineIt != _connections.end())
{
// Check if any connection to the machine matches one of our urls
UrlVector& vurls = couple->relatedUrls;
for (std::map<Url, ConnectionAttemptPtr>::iterator b = machineIt->second.begin(), e = machineIt->second.end();
b != e;
b++)
{
UrlVector::iterator uIt = std::find(vurls.begin(), vurls.end(), b->first);
// We found a matching machineId and URL : return the connected endpoint.
if (uIt != vurls.end())
{
qiLogDebug() << "Found pending promise.";
return b->second->promise.future();
}
}
}
// Otherwise, we keep track of all those URLs and assign them the same promise in our map.
// They will all track the same connection.
couple->attemptCount = connectionCandidates.size();
std::map<Url, ConnectionAttemptPtr>& urlMap = _connections[machineId];
for (const auto& url: connectionCandidates)
{
if (!url.isValid())
continue; // Do not try to connect to an invalid url!
if (!local && isLocalHost(url.host()))
continue; // Do not try to connect on localhost when it is a remote!
urlMap[url] = couple;
MessageSocketPtr socket = makeMessageSocket(url.protocol());
_allPendingConnections.push_back(socket);
Future<void> sockFuture = socket->connect(url);
qiLogDebug() << "Inserted [" << machineId << "][" << url.str() << "]";
sockFuture.connect(&TransportSocketCache::onSocketParallelConnectionAttempt, this, _1, socket, url, servInfo);
}
}
return couple->promise.future();
}
int
getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescName, char *srcRescName)
{
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
rescGrpInfo_t *rescGrpInfo;
if (inpNumThr == NO_THREADING)
return 0;
if (dataSize < 0)
return 0;
if (dataSize <= MIN_SZ_FOR_PARA_TRAN) {
if (inpNumThr > 0) {
inpNumThr = 1;
} else {
return 0;
}
}
if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) {
/* client specify no para opr */
return (1);
}
#ifndef PARA_OPR
return (1);
#endif
memset (&doinp, 0, sizeof (doinp));
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
initReiWithDataObjInp (&rei, rsComm, &doinp);
if (destRescName != NULL) {
rescGrpInfo = NULL;
status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numDestThr = rei.status;
if (numDestThr == 0) {
return 0;
} else if (numDestThr == 1 && srcRescName == NULL &&
isLocalHost (rescGrpInfo->rescInfo->rescLoc)) {
/* one thread and resouce on local host */
return 0;
}
}
}
}
if (srcRescName != NULL) {
if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0)
return numDestThr;
rescGrpInfo = NULL;
status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numSrcThr = rei.status;
if (numSrcThr == 0) return 0;
}
}
}
/* At this point, number of threads for both source and destination
have been set based on acSetNumThreads policy point, and neither
of them are set to 0 (to turn off threading). If both numDestThr
and numSrcThr are set, choose the smallest one. The reasoning is
that acSetNumThreads is used by a site to limit the default
maximum parallel threads, so we should honor the most restrictive
setting. */
if (numDestThr > 0 && numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else if (numDestThr < numSrcThr) {
return numDestThr;
} else {
return numSrcThr;
}
}
if (numDestThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numDestThr;
}
}
if (numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
rei.rgi = NULL;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
return 0;
} else {
if (rei.status > 0)
return rei.status;
else
return 0;
}
}
int
getNumThreads( rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescHier, char *srcRescHier, int oprType ) {
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
if ( inpNumThr == NO_THREADING ) {
return 0;
}
if ( dataSize < 0 ) {
return 0;
}
if ( dataSize <= MIN_SZ_FOR_PARA_TRAN ) {
if ( inpNumThr > 0 ) {
inpNumThr = 1;
}
else {
return 0;
}
}
if ( getValByKey( condInput, NO_PARA_OP_KW ) != NULL ) {
/* client specify no para opr */
return 1;
}
memset( &doinp, 0, sizeof( doinp ) );
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
doinp.oprType = oprType;
initReiWithDataObjInp( &rei, rsComm, &doinp );
if (destRescHier && strlen(destRescHier)) {
// get resource (hierarchy) location
std::string location;
irods::error ret = irods::get_loc_for_hier_string( destRescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) );
return -1;
}
irods::hierarchy_parser parser;
parser.set_string( destRescHier );
std::string last_resc;
parser.last_resc( last_resc );
irods::error err = irods::is_resc_live( last_resc.c_str() );
if ( err.ok() ) {
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
}
else {
numDestThr = rei.status;
if ( numDestThr == 0 ) {
return 0;
}
else if ( numDestThr == 1 && srcRescHier == NULL &&
isLocalHost( location.c_str() ) ) {
/* one thread and resource on local host */
return 0;
}
}
}
}
if (destRescHier && strlen(destRescHier) && srcRescHier && strlen(srcRescHier)) {
if ( numDestThr > 0 && strcmp( destRescHier, srcRescHier ) == 0 ) {
return numDestThr;
}
// get resource (hierarchy) location
std::string location;
irods::error ret = irods::get_loc_for_hier_string( destRescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) );
return -1;
}
irods::hierarchy_parser parser;
parser.set_string( srcRescHier );
std::string last_resc;
parser.last_resc( last_resc );
irods::error err = irods::is_resc_live( last_resc.c_str() );
if ( err.ok() ) {
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
}
else {
numSrcThr = rei.status;
if ( numSrcThr == 0 ) {
return 0;
}
}
}
}
if ( numDestThr > 0 ) {
if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) {
return 1;
}
else {
return numDestThr;
}
}
if ( numSrcThr > 0 ) {
if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) {
return 1;
}
else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
return 0;
}
else {
if ( rei.status > 0 ) {
return rei.status;
}
else {
return 0;
}
}
}
int
getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescName, char *srcRescName)
{
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
rescGrpInfo_t *rescGrpInfo;
if (inpNumThr == NO_THREADING)
return 0;
if (dataSize < 0)
return 0;
if (dataSize <= MIN_SZ_FOR_PARA_TRAN) {
if (inpNumThr > 0) {
inpNumThr = 1;
} else {
return 0;
}
}
if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) {
/* client specify no para opr */
return (1);
}
#ifndef PARA_OPR
return (1);
#endif
memset (&doinp, 0, sizeof (doinp));
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
initReiWithDataObjInp (&rei, rsComm, &doinp);
if (destRescName != NULL) {
rescGrpInfo = NULL;
status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numDestThr = rei.status;
if (numDestThr == 0) {
return 0;
} else if (numDestThr == 1 && srcRescName == NULL &&
isLocalHost (rescGrpInfo->rescInfo->rescLoc)) {
/* one thread and resouce on local host */
return 0;
}
}
}
}
if (srcRescName != NULL) {
if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0)
return numDestThr;
rescGrpInfo = NULL;
status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numSrcThr = rei.status;
if (numSrcThr == 0) return 0;
}
}
}
if (numDestThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numDestThr;
}
}
if (numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
rei.rgi = NULL;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
return 0;
} else {
if (rei.status > 0)
return rei.status;
else
return 0;
}
}