extern CONNECTOR SERVICE_CreateConnectorEx
(const char* service,
TSERV_Type types,
const SConnNetInfo* net_info,
const SSERVICE_Extra* params)
{
char* x_service;
CONNECTOR ccc;
SServiceConnector* xxx;
if (!service || !*service || !(x_service = SERV_ServiceName(service)))
return 0;
ccc = (SConnector*) malloc(sizeof(SConnector));
xxx = (SServiceConnector*) calloc(1, sizeof(*xxx) + strlen(service));
/* initialize connector structures */
ccc->handle = xxx;
ccc->next = 0;
ccc->meta = 0;
ccc->setup = s_Setup;
ccc->destroy = s_Destroy;
xxx->types = types;
xxx->net_info = (net_info
? ConnNetInfo_Clone(net_info)
: ConnNetInfo_Create(service));
if (!ConnNetInfo_SetupStandardArgs(xxx->net_info, x_service)) {
free(x_service);
s_Destroy(ccc);
return 0;
}
strcpy((char*) xxx->service, service);
free(x_service);
/* now get ready for first probe dispatching */
if (types & fSERV_Stateless)
xxx->net_info->stateless = 1/*true*/;
if (types & fSERV_Firewall)
xxx->net_info->firewall = 1/*true*/;
if (!s_OpenDispatcher(xxx)) {
s_Destroy(ccc);
return 0;
}
assert(xxx->iter);
/* finally, store all callback parameters */
if (params)
memcpy(&xxx->params, params, sizeof(xxx->params));
/* done */
return ccc;
}
static int/*bool*/ s_LoadServices(SERV_ITER iter)
{
int/*bool*/ ok = 0/*false*/;
char services[1024];
const char* c;
char* s;
if (!iter->ismask) {
ok = s_LoadSingleService(iter->name, iter);
if (!ok || !iter->reverse_dns)
return ok;
}
if (!(c = ConnNetInfo_GetValue(0, REG_CONN_LOCAL_SERVICES,
services, sizeof(services), 0)) || !*c) {
return ok;
}
s = services;
ok = 0/*false*/;
for (s += strspn(s, " \t"); *s; s += strspn(s, " \t")) {
size_t len = strcspn(s, " \t");
assert(len);
if (s[len])
s[len++] = '\0';
if (!(c = SERV_ServiceName(s)))
break;
if ((iter->reverse_dns
|| (iter->ismask
&& (!*iter->name || UTIL_MatchesMask(c, iter->name))))
&& s_LoadSingleService(c, iter)) {
ok = 1/*succeeded*/;
}
free((void*) c);
s += len;
}
return ok/*whatever*/;
}
EIO_Status CConnTest::ServiceOkay(string* reason)
{
static const char kService[] = "bounce";
SConnNetInfo* net_info = ConnNetInfo_Create(kService, m_DebugPrintout);
if (net_info)
net_info->lb_disable = 1/*no local LB to use even if available*/;
PreCheck(eStatelessService, 0/*main*/,
"Checking whether NCBI services operational");
CConn_ServiceStream svc(kService, fSERV_Stateless, net_info,
0/*extra*/, m_Timeout);
svc.SetCanceledCallback(m_Canceled);
svc << kTest << NcbiEndl;
string temp;
svc >> temp;
bool responded = temp.size() > 0 ? true : false;
EIO_Status status = ConnStatus(NStr::Compare(temp, kTest) != 0, &svc);
if (status == eIO_Interrupt)
temp = kCanceled;
else if (status == eIO_Success)
temp = "OK";
else {
char* str = net_info ? SERV_ServiceName(kService) : 0;
if (str && NStr::CompareNocase(str, kService) == 0) {
free(str);
str = 0;
}
SERV_ITER iter = SERV_OpenSimple(kService);
if (!iter || !SERV_GetNextInfo(iter)) {
// Service not found
SERV_Close(iter);
iter = SERV_OpenSimple(kTest);
if (!iter || !SERV_GetNextInfo(iter)
|| NStr::CompareNocase(SERV_MapperName(iter), "DISPD") != 0) {
// Make sure there will be a mapper error printed
SERV_Close(iter);
temp.clear();
iter = 0;
} else {
// kTest service can be located but not kService
temp = str ? "Substituted service" : "Service";
temp += " cannot be located";
}
} else {
temp = responded ? "Unrecognized" : "No";
temp += " response from ";
temp += str ? "substituted service" : "service";
}
if (!temp.empty()) {
if (str) {
temp += "; please remove [";
string upper(kService);
temp += NStr::ToUpper(upper);
temp += "]CONN_SERVICE_NAME=\"";
temp += str;
temp += "\" from your configuration\n";
} else if (status != eIO_Timeout || m_Timeout > kTimeout)
temp += "; please contact " + HELP_EMAIL + '\n';
}
if (status != eIO_Timeout) {
const char* mapper = SERV_MapperName(iter);
if (!mapper || NStr::CompareNocase(mapper, "DISPD") != 0) {
temp += "Network dispatcher is not enabled as a service"
" locator; please review your configuration to purge any"
" occurrences of [CONN]DISPD_DISABLE off your settings\n";
}
} else
temp += x_TimeoutMsg();
SERV_Close(iter);
if (str)
free(str);
}
PostCheck(eStatelessService, 0/*main*/, status, temp);
ConnNetInfo_Destroy(net_info);
if (reason)
reason->swap(temp);
return status;
}
