00001
00002
00003
00004
00005
00006
00007
00008 #include "procStat.h"
00009 #include "objMetaOpr.h"
00010 #include "resource.h"
00011 #include "miscServerFunct.h"
00012 #include "rodsLog.h"
00013 #include "rsGlobalExtern.h"
00014 #include "rcGlobalExtern.h"
00015
00016 int
00017 rsProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp,
00018 genQueryOut_t **procStatOut)
00019 {
00020 int status;
00021 int remoteFlag;
00022 rodsServerHost_t *rodsServerHost;
00023
00024 if (*procStatInp->rodsZone != '\0') {
00025 remoteFlag = getRcatHost (MASTER_RCAT, procStatInp->rodsZone,
00026 &rodsServerHost);
00027 if (remoteFlag < 0) {
00028 rodsLog (LOG_ERROR,
00029 "rsProcStat: getRcatHost() failed. erro=%d", remoteFlag);
00030 return (remoteFlag);
00031 }
00032 if (rodsServerHost->localFlag == REMOTE_HOST) {
00033 status = remoteProcStat (rsComm, procStatInp, procStatOut,
00034 rodsServerHost);
00035 } else {
00036 status = _rsProcStat (rsComm, procStatInp, procStatOut);
00037 }
00038 } else {
00039 status = _rsProcStat (rsComm, procStatInp, procStatOut);
00040 }
00041 return status;
00042 }
00043
00044 int
00045 _rsProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp,
00046 genQueryOut_t **procStatOut)
00047 {
00048 int status;
00049 rodsServerHost_t *rodsServerHost;
00050 int remoteFlag;
00051 rodsHostAddr_t addr;
00052 procStatInp_t myProcStatInp;
00053 char *tmpStr;
00054
00055 if (getValByKey (&procStatInp->condInput, ALL_KW) != NULL) {
00056 status = _rsProcStatAll (rsComm, procStatInp, procStatOut);
00057 return status;
00058 }
00059 if (getValByKey (&procStatInp->condInput, EXEC_LOCALLY_KW) != NULL) {
00060 status = localProcStat (rsComm, procStatInp, procStatOut);
00061 return status;
00062 }
00063
00064 bzero (&addr, sizeof (addr));
00065 bzero (&myProcStatInp, sizeof (myProcStatInp));
00066 if (*procStatInp->addr != '\0') {
00067 rstrcpy (addr.hostAddr, procStatInp->addr, LONG_NAME_LEN);
00068 remoteFlag = resolveHost (&addr, &rodsServerHost);
00069 } else if ((tmpStr = getValByKey (&procStatInp->condInput, RESC_NAME_KW))
00070 != NULL) {
00071 rescGrpInfo_t *rescGrpInfo = NULL;
00072 status = _getRescInfo (rsComm, tmpStr, &rescGrpInfo);
00073 if (status < 0 || NULL == rescGrpInfo ) {
00074 rodsLog (LOG_ERROR,
00075 "_rsProcStat: _getRescInfo of %s error. stat = %d",
00076 tmpStr, status);
00077 return status;
00078 }
00079 rstrcpy (procStatInp->addr, rescGrpInfo->rescInfo->rescLoc, NAME_LEN);
00080 rodsServerHost = (rodsServerHost_t*)rescGrpInfo->rescInfo->rodsServerHost;
00081 if (rodsServerHost == NULL) {
00082 remoteFlag = SYS_INVALID_SERVER_HOST;
00083 } else {
00084 remoteFlag = rodsServerHost->localFlag;
00085 }
00086 } else {
00087
00088 remoteFlag = getRcatHost (MASTER_RCAT, NULL, &rodsServerHost);
00089 }
00090 if (remoteFlag < 0) {
00091 rodsLog (LOG_ERROR,
00092 "_rsProcStat: getRcatHost() failed. erro=%d", remoteFlag);
00093 return (remoteFlag);
00094 } else if (remoteFlag == REMOTE_HOST) {
00095 addKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW, "");
00096 status = remoteProcStat (rsComm, &myProcStatInp, procStatOut,
00097 rodsServerHost);
00098 rmKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW);
00099 } else {
00100 status = localProcStat (rsComm, procStatInp, procStatOut);
00101 }
00102 return status;
00103 }
00104
00105 int
00106 _rsProcStatAll (rsComm_t *rsComm, procStatInp_t *procStatInp,
00107 genQueryOut_t **procStatOut)
00108 {
00109 rodsServerHost_t *tmpRodsServerHost;
00110 procStatInp_t myProcStatInp;
00111 int status;
00112 genQueryOut_t *singleProcStatOut = NULL;
00113 int savedStatus = 0;
00114
00115 bzero (&myProcStatInp, sizeof (myProcStatInp));
00116 tmpRodsServerHost = ServerHostHead;
00117 while (tmpRodsServerHost != NULL) {
00118 if (getHostStatusByRescInfo (tmpRodsServerHost) ==
00119 INT_RESC_STATUS_UP) {
00120 if (tmpRodsServerHost->localFlag == LOCAL_HOST) {
00121 setLocalSrvAddr (myProcStatInp.addr);
00122 status = localProcStat (rsComm, &myProcStatInp,
00123 &singleProcStatOut);
00124 } else {
00125 rstrcpy (myProcStatInp.addr, tmpRodsServerHost->hostName->name,
00126 NAME_LEN);
00127 addKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW, "");
00128 status = remoteProcStat (rsComm, &myProcStatInp,
00129 &singleProcStatOut, tmpRodsServerHost);
00130 rmKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW);
00131 }
00132 if (status < 0) {
00133 savedStatus = status;
00134 }
00135 if (singleProcStatOut != NULL) {
00136 if (*procStatOut == NULL) {
00137 *procStatOut = singleProcStatOut;
00138 } else {
00139 catGenQueryOut (*procStatOut, singleProcStatOut,
00140 MAX_PROC_STAT_CNT);
00141 freeGenQueryOut (&singleProcStatOut);
00142 }
00143 singleProcStatOut = NULL;
00144 }
00145 }
00146 tmpRodsServerHost = tmpRodsServerHost->next;
00147 }
00148 return savedStatus;
00149 }
00150
00151 int
00152 localProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp,
00153 genQueryOut_t **procStatOut)
00154 {
00155 int numProc, status;
00156 procLog_t procLog;
00157 char childPath[MAX_NAME_LEN];
00158 #ifndef USE_BOOST_FS
00159 DIR *dirPtr;
00160 struct dirent *myDirent;
00161 #ifndef windows_platform
00162 struct stat statbuf;
00163 #else
00164 struct irodsntstat statbuf;
00165 #endif
00166 #endif
00167 int count = 0;
00168
00169 numProc = getNumFilesInDir (ProcLogDir) + 2;
00170
00171 bzero (&procLog, sizeof (procLog));
00172
00173 if (*procStatInp->addr != '\0') {
00174 rstrcpy (procLog.serverAddr, procStatInp->addr, NAME_LEN);
00175 } else {
00176 setLocalSrvAddr (procLog.serverAddr);
00177 }
00178 if (numProc <= 0) {
00179
00180 initProcStatOut (procStatOut, 1);
00181 addProcToProcStatOut (&procLog, *procStatOut);
00182 return numProc;
00183 } else {
00184 initProcStatOut (procStatOut, numProc);
00185 }
00186
00187
00188 #ifdef USE_BOOST_FS
00189 path srcDirPath (ProcLogDir);
00190 if (!exists(srcDirPath) || !is_directory(srcDirPath)) {
00191 #else
00192 dirPtr = opendir (ProcLogDir);
00193 if (dirPtr == NULL) {
00194 #endif
00195 status = USER_INPUT_PATH_ERR - errno;
00196 rodsLogError (LOG_ERROR, status,
00197 "localProcStat: opendir local dir error for %s", ProcLogDir);
00198 return status;
00199 }
00200 #ifdef USE_BOOST_FS
00201 directory_iterator end_itr;
00202 for (directory_iterator itr(srcDirPath); itr != end_itr;++itr) {
00203 path p = itr->path();
00204 path cp = p.filename();
00205 if (!isdigit (*cp.c_str())) continue;
00206 snprintf (childPath, MAX_NAME_LEN, "%s",
00207 p.c_str ());
00208 #else
00209 while ((myDirent = readdir (dirPtr)) != NULL) {
00210 if (strcmp (myDirent->d_name, ".") == 0 ||
00211 strcmp (myDirent->d_name, "..") == 0) {
00212 continue;
00213 }
00214 if (!isdigit (*myDirent->d_name)) continue;
00215 snprintf (childPath, MAX_NAME_LEN, "%s/%s", ProcLogDir,
00216 myDirent->d_name);
00217 #endif
00218 #ifdef USE_BOOST_FS
00219 if (!exists (p)) {
00220 #else
00221 #ifndef windows_platform
00222 status = stat (childPath, &statbuf);
00223 #else
00224 status = iRODSNt_stat(childPath, &statbuf);
00225 #endif
00226 if (status != 0) {
00227 #endif
00228 rodsLogError (LOG_ERROR, status,
00229 "localProcStat: stat error for %s", childPath);
00230 continue;
00231 }
00232 #ifdef USE_BOOST_FS
00233 if (is_regular_file(p)) {
00234 #else
00235 if (statbuf.st_mode & S_IFREG) {
00236 #endif
00237 if (count >= numProc) {
00238 rodsLog (LOG_ERROR,
00239 "localProcStat: proc count %d exceeded", numProc);
00240 break;
00241 }
00242 #ifdef USE_BOOST_FS
00243 procLog.pid = atoi (cp.c_str());
00244 #else
00245 procLog.pid = atoi (myDirent->d_name);
00246 #endif
00247 if (readProcLog (procLog.pid, &procLog) < 0) continue;
00248 status = addProcToProcStatOut (&procLog, *procStatOut);
00249 if (status < 0) continue;
00250 count++;
00251 } else {
00252 continue;
00253 }
00254 }
00255 #ifndef USE_BOOST_FS
00256 closedir (dirPtr);
00257 #endif
00258 return 0;
00259 }
00260
00261 int
00262 remoteProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp,
00263 genQueryOut_t **procStatOut, rodsServerHost_t *rodsServerHost)
00264 {
00265 int status;
00266 procLog_t procLog;
00267
00268 if (rodsServerHost == NULL) {
00269 rodsLog (LOG_ERROR,
00270 "remoteProcStat: Invalid rodsServerHost");
00271 return SYS_INVALID_SERVER_HOST;
00272 }
00273
00274 if (procStatInp == NULL || procStatOut == NULL) return USER__NULL_INPUT_ERR;
00275
00276 status = svrToSvrConnect (rsComm, rodsServerHost);
00277
00278 if (status >= 0) {
00279 status = rcProcStat (rodsServerHost->conn, procStatInp, procStatOut);
00280 }
00281 if (status < 0 && *procStatOut == NULL) {
00282
00283 initProcStatOut (procStatOut, 1);
00284 bzero (&procLog, sizeof (procLog));
00285 rstrcpy (procLog.serverAddr, rodsServerHost->hostName->name,
00286 NAME_LEN);
00287 addProcToProcStatOut (&procLog, *procStatOut);
00288 }
00289 return status;
00290 }
00291
00292 int
00293 initProcStatOut (genQueryOut_t **procStatOut, int numProc)
00294 {
00295 genQueryOut_t *myProcStatOut;
00296
00297 if (procStatOut == NULL || numProc <= 0) return USER__NULL_INPUT_ERR;
00298
00299 myProcStatOut = *procStatOut = (genQueryOut_t*)malloc (sizeof (genQueryOut_t));
00300 bzero (myProcStatOut, sizeof (genQueryOut_t));
00301
00302 myProcStatOut->continueInx = -1;
00303
00304 myProcStatOut->attriCnt = 9;
00305
00306 myProcStatOut->sqlResult[0].attriInx = PID_INX;
00307 myProcStatOut->sqlResult[0].len = NAME_LEN;
00308 myProcStatOut->sqlResult[0].value =
00309 (char*)malloc (NAME_LEN * numProc);
00310 bzero (myProcStatOut->sqlResult[0].value, NAME_LEN * numProc);
00311
00312 myProcStatOut->sqlResult[1].attriInx = STARTTIME_INX;
00313 myProcStatOut->sqlResult[1].len = NAME_LEN;
00314 myProcStatOut->sqlResult[1].value =
00315 (char*)malloc (NAME_LEN * numProc);
00316 bzero (myProcStatOut->sqlResult[1].value, NAME_LEN * numProc);
00317
00318 myProcStatOut->sqlResult[2].attriInx = CLIENT_NAME_INX;
00319 myProcStatOut->sqlResult[2].len = NAME_LEN;
00320 myProcStatOut->sqlResult[2].value =
00321 (char*)malloc (NAME_LEN * numProc);
00322 bzero (myProcStatOut->sqlResult[2].value, NAME_LEN * numProc);
00323
00324 myProcStatOut->sqlResult[3].attriInx = CLIENT_ZONE_INX;
00325 myProcStatOut->sqlResult[3].len = NAME_LEN;
00326 myProcStatOut->sqlResult[3].value =
00327 (char*)malloc (NAME_LEN * numProc);
00328 bzero (myProcStatOut->sqlResult[3].value, NAME_LEN * numProc);
00329
00330 myProcStatOut->sqlResult[4].attriInx = PROXY_NAME_INX;
00331 myProcStatOut->sqlResult[4].len = NAME_LEN;
00332 myProcStatOut->sqlResult[4].value =
00333 (char*)malloc (NAME_LEN * numProc);
00334 bzero (myProcStatOut->sqlResult[4].value, NAME_LEN * numProc);
00335
00336 myProcStatOut->sqlResult[5].attriInx = PROXY_ZONE_INX;
00337 myProcStatOut->sqlResult[5].len = NAME_LEN;
00338 myProcStatOut->sqlResult[5].value =
00339 (char*)malloc (NAME_LEN * numProc);
00340 bzero (myProcStatOut->sqlResult[5].value, NAME_LEN * numProc);
00341
00342 myProcStatOut->sqlResult[6].attriInx = REMOTE_ADDR_INX;
00343 myProcStatOut->sqlResult[6].len = NAME_LEN;
00344 myProcStatOut->sqlResult[6].value =
00345 (char*)malloc (NAME_LEN * numProc);
00346 bzero (myProcStatOut->sqlResult[6].value, NAME_LEN * numProc);
00347
00348 myProcStatOut->sqlResult[7].attriInx = SERVER_ADDR_INX;
00349 myProcStatOut->sqlResult[7].len = NAME_LEN;
00350 myProcStatOut->sqlResult[7].value =
00351 (char*)malloc (NAME_LEN * numProc);
00352 bzero (myProcStatOut->sqlResult[7].value, NAME_LEN * numProc);
00353
00354 myProcStatOut->sqlResult[8].attriInx = PROG_NAME_INX;
00355 myProcStatOut->sqlResult[8].len = NAME_LEN;
00356 myProcStatOut->sqlResult[8].value =
00357 (char*)malloc (NAME_LEN * numProc);
00358 bzero (myProcStatOut->sqlResult[8].value, NAME_LEN * numProc);
00359
00360
00361 return 0;
00362 }
00363
00364 int
00365 addProcToProcStatOut (procLog_t *procLog, genQueryOut_t *procStatOut)
00366 {
00367 int rowCnt;
00368
00369 if (procLog == NULL || procStatOut == NULL) return USER__NULL_INPUT_ERR;
00370 rowCnt = procStatOut->rowCnt;
00371
00372 snprintf (&procStatOut->sqlResult[0].value[NAME_LEN * rowCnt],
00373 NAME_LEN, "%d", procLog->pid);
00374 snprintf (&procStatOut->sqlResult[1].value[NAME_LEN * rowCnt],
00375 NAME_LEN, "%u", procLog->startTime);
00376 rstrcpy (&procStatOut->sqlResult[2].value[NAME_LEN * rowCnt],
00377 procLog->clientName, NAME_LEN);
00378 rstrcpy (&procStatOut->sqlResult[3].value[NAME_LEN * rowCnt],
00379 procLog->clientZone, NAME_LEN);
00380 rstrcpy (&procStatOut->sqlResult[4].value[NAME_LEN * rowCnt],
00381 procLog->proxyName, NAME_LEN);
00382 rstrcpy (&procStatOut->sqlResult[5].value[NAME_LEN * rowCnt],
00383 procLog->proxyZone, NAME_LEN);
00384 rstrcpy (&procStatOut->sqlResult[6].value[NAME_LEN * rowCnt],
00385 procLog->remoteAddr, NAME_LEN);
00386 rstrcpy (&procStatOut->sqlResult[7].value[NAME_LEN * rowCnt],
00387 procLog->serverAddr, NAME_LEN);
00388 rstrcpy (&procStatOut->sqlResult[8].value[NAME_LEN * rowCnt],
00389 procLog->progName, NAME_LEN);
00390
00391 procStatOut->rowCnt++;
00392
00393 return 0;
00394 }
00395