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