irods  4.2.8
About: iRODS (the integrated Rule Oriented Data System) is a distributed data-management system for creating data grids, digital libraries, persistent archives, and real-time data systems.
  Fossies Dox: irods-4.2.8.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

rsProcStat.cpp
Go to the documentation of this file.
1 
3 /* rsProcStat.c - server routine that handles the the ProcStat
4  * API
5  */
6 
7 /* script generated code */
8 #include "rcMisc.h"
9 #include "procStat.h"
10 #include "objMetaOpr.hpp"
11 #include "resource.hpp"
12 #include "miscServerFunct.hpp"
13 #include "rodsLog.h"
14 #include "rsGlobalExtern.hpp"
15 #include "rcGlobalExtern.h"
16 #include "procLog.h"
17 #include "rsProcStat.hpp"
18 
19 // =-=-=-=-=-=-=-
21 
22 #include <boost/filesystem/operations.hpp>
23 #include <boost/filesystem/convenience.hpp>
24 using namespace boost::filesystem;
25 
26 
27 
28 
29 int
30 rsProcStat( rsComm_t * rsComm, procStatInp_t * procStatInp,
31  genQueryOut_t **procStatOut ) {
32  int status;
33  int remoteFlag;
35 
36  if ( *procStatInp->rodsZone != '\0' ) {
37  remoteFlag = getRcatHost( MASTER_RCAT, procStatInp->rodsZone,
38  &rodsServerHost );
39  if ( remoteFlag < 0 ) {
41  "rsProcStat: getRcatHost() failed. erro=%d", remoteFlag );
42  return remoteFlag;
43  }
45  status = remoteProcStat( rsComm, procStatInp, procStatOut,
47  }
48  else {
49  status = _rsProcStat( rsComm, procStatInp, procStatOut );
50  }
51  }
52  else {
53  status = _rsProcStat( rsComm, procStatInp, procStatOut );
54  }
55  return status;
56 }
57 
58 int
59 _rsProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
60  genQueryOut_t **procStatOut ) {
61  int status = -1;
63  int remoteFlag = -1;
64  rodsHostAddr_t addr;
65  procStatInp_t myProcStatInp;
66  char *tmpStr = NULL;
67 
68  if ( getValByKey( &procStatInp->condInput, ALL_KW ) != NULL ) {
69  status = _rsProcStatAll( rsComm, procStatOut );
70  return status;
71  }
72  if ( getValByKey( &procStatInp->condInput, EXEC_LOCALLY_KW ) != NULL ) {
73  status = localProcStat( procStatInp, procStatOut );
74  return status;
75  }
76 
77  bzero( &addr, sizeof( addr ) );
78  bzero( &myProcStatInp, sizeof( myProcStatInp ) );
79  if ( *procStatInp->addr != '\0' ) { /* given input addr */
80  rstrcpy( addr.hostAddr, procStatInp->addr, LONG_NAME_LEN );
81  remoteFlag = resolveHost( &addr, &rodsServerHost );
82  }
83  else if ( ( tmpStr = getValByKey( &procStatInp->condInput, RESC_NAME_KW ) ) != NULL ) {
84  std::string resc_name( tmpStr );
85  irods::error ret = SUCCESS();
86 
87  rodsLong_t resc_id = 0;
88  ret = resc_mgr.hier_to_leaf_id(resc_name,resc_id);
89  if(!ret.ok()) {
90  irods::log(PASS(ret));
91  return ret.code();
92  }
93 
94  // Get resource location
95  std::string resc_loc;
96  ret = irods::get_resource_property< std::string >( resc_id, irods::RESOURCE_LOCATION, resc_loc );
97  if ( !ret.ok() ) {
98  irods::log PASSMSG( "_rsProcStat - failed in get_resource_property", ret );
99  return ret.code();
100  }
101  snprintf( procStatInp->addr, NAME_LEN, "%s", resc_loc.c_str() );
102 
103  // Get resource host
104  std::string resc_host;
105  ret = irods::get_resource_property< rodsServerHost_t* >( resc_id, irods::RESOURCE_HOST, rodsServerHost );
106  if ( !ret.ok() ) {
107  irods::log PASSMSG( "_rsProcStat - failed in get_resource_property", ret );
108  return ret.code();
109  }
110 
111  if ( !rodsServerHost ) {
112  remoteFlag = SYS_INVALID_SERVER_HOST;
113  }
114  else {
115  remoteFlag = rodsServerHost->localFlag;
116  }
117  }
118  else {
119  /* do the IES server */
120  remoteFlag = getRcatHost( MASTER_RCAT, NULL, &rodsServerHost );
121  }
122  if ( remoteFlag < 0 ) {
124  "_rsProcStat: getRcatHost() failed. erro=%d", remoteFlag );
125  return remoteFlag;
126  }
127  else if ( remoteFlag == REMOTE_HOST ) {
128  addKeyVal( &myProcStatInp.condInput, EXEC_LOCALLY_KW, "" );
129  status = remoteProcStat( rsComm, &myProcStatInp, procStatOut,
130  rodsServerHost );
131  rmKeyVal( &myProcStatInp.condInput, EXEC_LOCALLY_KW );
132  }
133  else {
134  status = localProcStat( procStatInp, procStatOut );
135  }
136  return status;
137 }
138 
139 int
141  genQueryOut_t **procStatOut ) {
142  rodsServerHost_t *tmpRodsServerHost;
143  procStatInp_t myProcStatInp;
144  int status;
145  genQueryOut_t *singleProcStatOut = NULL;
146  int savedStatus = 0;
147 
148  bzero( &myProcStatInp, sizeof( myProcStatInp ) );
149  tmpRodsServerHost = ServerHostHead;
150  while ( tmpRodsServerHost != NULL ) {
151  irods::error err = irods::get_host_status_by_host_info( tmpRodsServerHost );
152  if ( err.ok() && err.code() == INT_RESC_STATUS_UP ) {
153  if ( tmpRodsServerHost->localFlag == LOCAL_HOST ) {
154  setLocalSrvAddr( myProcStatInp.addr );
155  status = localProcStat( &myProcStatInp, &singleProcStatOut );
156  }
157  else {
158  rstrcpy( myProcStatInp.addr, tmpRodsServerHost->hostName->name, NAME_LEN );
159  addKeyVal( &myProcStatInp.condInput, EXEC_LOCALLY_KW, "" );
160  status = remoteProcStat( rsComm, &myProcStatInp, &singleProcStatOut, tmpRodsServerHost );
161  rmKeyVal( &myProcStatInp.condInput, EXEC_LOCALLY_KW );
162  }
163 
164  if ( status < 0 ) {
165  savedStatus = status;
166  }
167 
168  if ( singleProcStatOut != NULL ) {
169  if ( *procStatOut == NULL ) {
170  *procStatOut = singleProcStatOut;
171  }
172  else {
173  catGenQueryOut( *procStatOut, singleProcStatOut, MAX_PROC_STAT_CNT );
174  freeGenQueryOut( &singleProcStatOut );
175  }
176  singleProcStatOut = NULL;
177  }
178 
179  } // if up
180 
181  tmpRodsServerHost = tmpRodsServerHost->next;
182  } // while
183  return savedStatus;
184 }
185 
186 int
188  genQueryOut_t **procStatOut ) {
189  int numProc, status = 0;
190  procLog_t procLog;
191  char childPath[MAX_NAME_LEN];
192  int count = 0;
193 
194  numProc = getNumFilesInDir( ProcLogDir ) + 2; /* add 2 to give some room */
195 
196  bzero( &procLog, sizeof( procLog ) );
197  /* init serverAddr */
198  if ( *procStatInp->addr != '\0' ) { /* given input addr */
199  rstrcpy( procLog.serverAddr, procStatInp->addr, NAME_LEN );
200  }
201  else {
202  setLocalSrvAddr( procLog.serverAddr );
203  }
204  if ( numProc <= 0 ) {
205  /* add an empty entry with only serverAddr */
206  initProcStatOut( procStatOut, 1 );
207  addProcToProcStatOut( &procLog, *procStatOut );
208  return numProc;
209  }
210  else {
211  initProcStatOut( procStatOut, numProc );
212  }
213 
214  /* loop through the directory */
215  path srcDirPath( ProcLogDir );
216  if ( !exists( srcDirPath ) || !is_directory( srcDirPath ) ) {
217  status = USER_INPUT_PATH_ERR - errno;
219  "localProcStat: opendir local dir error for %s", ProcLogDir );
220  return status;
221  }
222  directory_iterator end_itr; // default construction yields past-the-end
223  for ( directory_iterator itr( srcDirPath ); itr != end_itr; ++itr ) {
224  path p = itr->path();
225  path cp = p.filename();
226  if ( !isdigit( *cp.c_str() ) ) {
227  continue; /* not a pid */
228  }
229  snprintf( childPath, MAX_NAME_LEN, "%s",
230  p.c_str() );
231  if ( !exists( p ) ) {
233  "localProcStat: stat error for %s", childPath );
234  continue;
235  }
236  if ( is_regular_file( p ) ) {
237  if ( count >= numProc ) {
239  "localProcStat: proc count %d exceeded", numProc );
240  break;
241  }
242  procLog.pid = atoi( cp.c_str() );
243  if ( readProcLog( procLog.pid, &procLog ) < 0 ) {
244  continue;
245  }
246  status = addProcToProcStatOut( &procLog, *procStatOut );
247  if ( status < 0 ) {
248  continue;
249  }
250  count++;
251  }
252  else {
253  continue;
254  }
255  }
256  return 0;
257 }
258 
259 int
260 remoteProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
261  genQueryOut_t **procStatOut, rodsServerHost_t *rodsServerHost ) {
262  int status;
263  procLog_t procLog;
264 
265  if ( rodsServerHost == NULL ) {
267  "remoteProcStat: Invalid rodsServerHost" );
269  }
270 
271  if ( procStatInp == NULL || procStatOut == NULL ) {
272  return USER__NULL_INPUT_ERR;
273  }
274 
276 
277  if ( status >= 0 ) {
278  status = rcProcStat( rodsServerHost->conn, procStatInp, procStatOut );
279  }
280  if ( status < 0 && *procStatOut == NULL ) {
281  /* add an empty entry */
282  initProcStatOut( procStatOut, 1 );
283  bzero( &procLog, sizeof( procLog ) );
285  NAME_LEN );
286  addProcToProcStatOut( &procLog, *procStatOut );
287  }
288  return status;
289 }
290 
291 int
292 initProcStatOut( genQueryOut_t **procStatOut, int numProc ) {
293  genQueryOut_t *myProcStatOut;
294 
295  if ( procStatOut == NULL || numProc <= 0 ) {
296  return USER__NULL_INPUT_ERR;
297  }
298 
299  myProcStatOut = *procStatOut = ( genQueryOut_t* )malloc( sizeof( genQueryOut_t ) );
300  bzero( myProcStatOut, sizeof( genQueryOut_t ) );
301 
302  myProcStatOut->continueInx = -1;
303 
304  myProcStatOut->attriCnt = 9;
305 
306  myProcStatOut->sqlResult[0].attriInx = PID_INX;
307  myProcStatOut->sqlResult[0].len = NAME_LEN;
308  myProcStatOut->sqlResult[0].value =
309  ( char* )malloc( NAME_LEN * numProc );
310  bzero( myProcStatOut->sqlResult[0].value, NAME_LEN * numProc );
311 
312  myProcStatOut->sqlResult[1].attriInx = STARTTIME_INX;
313  myProcStatOut->sqlResult[1].len = NAME_LEN;
314  myProcStatOut->sqlResult[1].value =
315  ( char* )malloc( NAME_LEN * numProc );
316  bzero( myProcStatOut->sqlResult[1].value, NAME_LEN * numProc );
317 
318  myProcStatOut->sqlResult[2].attriInx = CLIENT_NAME_INX;
319  myProcStatOut->sqlResult[2].len = NAME_LEN;
320  myProcStatOut->sqlResult[2].value =
321  ( char* )malloc( NAME_LEN * numProc );
322  bzero( myProcStatOut->sqlResult[2].value, NAME_LEN * numProc );
323 
324  myProcStatOut->sqlResult[3].attriInx = CLIENT_ZONE_INX;
325  myProcStatOut->sqlResult[3].len = NAME_LEN;
326  myProcStatOut->sqlResult[3].value =
327  ( char* )malloc( NAME_LEN * numProc );
328  bzero( myProcStatOut->sqlResult[3].value, NAME_LEN * numProc );
329 
330  myProcStatOut->sqlResult[4].attriInx = PROXY_NAME_INX;
331  myProcStatOut->sqlResult[4].len = NAME_LEN;
332  myProcStatOut->sqlResult[4].value =
333  ( char* )malloc( NAME_LEN * numProc );
334  bzero( myProcStatOut->sqlResult[4].value, NAME_LEN * numProc );
335 
336  myProcStatOut->sqlResult[5].attriInx = PROXY_ZONE_INX;
337  myProcStatOut->sqlResult[5].len = NAME_LEN;
338  myProcStatOut->sqlResult[5].value =
339  ( char* )malloc( NAME_LEN * numProc );
340  bzero( myProcStatOut->sqlResult[5].value, NAME_LEN * numProc );
341 
342  myProcStatOut->sqlResult[6].attriInx = REMOTE_ADDR_INX;
343  myProcStatOut->sqlResult[6].len = NAME_LEN;
344  myProcStatOut->sqlResult[6].value =
345  ( char* )malloc( NAME_LEN * numProc );
346  bzero( myProcStatOut->sqlResult[6].value, NAME_LEN * numProc );
347 
348  myProcStatOut->sqlResult[7].attriInx = SERVER_ADDR_INX;
349  myProcStatOut->sqlResult[7].len = NAME_LEN;
350  myProcStatOut->sqlResult[7].value =
351  ( char* )malloc( NAME_LEN * numProc );
352  bzero( myProcStatOut->sqlResult[7].value, NAME_LEN * numProc );
353 
354  myProcStatOut->sqlResult[8].attriInx = PROG_NAME_INX;
355  myProcStatOut->sqlResult[8].len = NAME_LEN;
356  myProcStatOut->sqlResult[8].value =
357  ( char* )malloc( NAME_LEN * numProc );
358  bzero( myProcStatOut->sqlResult[8].value, NAME_LEN * numProc );
359 
360 
361  return 0;
362 }
363 
364 int
365 addProcToProcStatOut( procLog_t *procLog, genQueryOut_t *procStatOut ) {
366  int rowCnt;
367 
368  if ( procLog == NULL || procStatOut == NULL ) {
369  return USER__NULL_INPUT_ERR;
370  }
371  rowCnt = procStatOut->rowCnt;
372 
373  snprintf( &procStatOut->sqlResult[0].value[NAME_LEN * rowCnt],
374  NAME_LEN, "%d", procLog->pid );
375  snprintf( &procStatOut->sqlResult[1].value[NAME_LEN * rowCnt],
376  NAME_LEN, "%u", procLog->startTime );
377  rstrcpy( &procStatOut->sqlResult[2].value[NAME_LEN * rowCnt],
378  procLog->clientName, NAME_LEN );
379  rstrcpy( &procStatOut->sqlResult[3].value[NAME_LEN * rowCnt],
380  procLog->clientZone, NAME_LEN );
381  rstrcpy( &procStatOut->sqlResult[4].value[NAME_LEN * rowCnt],
382  procLog->proxyName, NAME_LEN );
383  rstrcpy( &procStatOut->sqlResult[5].value[NAME_LEN * rowCnt],
384  procLog->proxyZone, NAME_LEN );
385  rstrcpy( &procStatOut->sqlResult[6].value[NAME_LEN * rowCnt],
386  procLog->remoteAddr, NAME_LEN );
387  rstrcpy( &procStatOut->sqlResult[7].value[NAME_LEN * rowCnt],
388  procLog->serverAddr, NAME_LEN );
389  rstrcpy( &procStatOut->sqlResult[8].value[NAME_LEN * rowCnt],
390  procLog->progName, NAME_LEN );
391 
392  procStatOut->rowCnt++;
393 
394  return 0;
395 }
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
getValByKey
char * getValByKey(const keyValPair_t *condInput, const char *keyWord)
Definition: rcMisc.cpp:675
RESC_NAME_KW
#define RESC_NAME_KW
Definition: rodsKeyWdDef.h:19
procStat.h
NULL
#define NULL
Definition: rodsDef.h:70
irods::RESOURCE_LOCATION
const std::string RESOURCE_LOCATION("resource_property_location")
rsComm_t
Definition: rcConnect.h:145
addKeyVal
int addKeyVal(keyValPair_t *condInput, const char *keyWord, const char *value)
Definition: rcMisc.cpp:789
rodsServerHost::localFlag
int localFlag
Definition: rodsConnect.h:68
procLog_t::proxyName
char proxyName[64]
Definition: rodsDef.h:366
procLog_t::clientZone
char clientZone[64]
Definition: rodsDef.h:365
CLIENT_ZONE_INX
#define CLIENT_ZONE_INX
Definition: procStat.h:12
rodsServerHost::conn
rcComm_t * conn
Definition: rodsConnect.h:64
SqlResult::attriInx
int attriInx
Definition: rodsGenQuery.h:62
MAX_PROC_STAT_CNT
#define MAX_PROC_STAT_CNT
Definition: procStat.h:27
PASS
#define PASS(prev_error_)
Definition: irods_error.hpp:118
resc_mgr
irods::resource_manager resc_mgr
Definition: irods_resource_manager.cpp:31
procLog_t::remoteAddr
char remoteAddr[64]
Definition: rodsDef.h:368
procLog_t::pid
int pid
Definition: rodsDef.h:362
localProcStat
int localProcStat(procStatInp_t *procStatInp, genQueryOut_t **procStatOut)
Definition: rsProcStat.cpp:187
REMOTE_HOST
#define REMOTE_HOST
Definition: rodsConnect.h:45
setLocalSrvAddr
int setLocalSrvAddr(char *outLocalAddr)
Definition: miscServerFunct.cpp:2437
irods::experimental::administration::client::v1::exists
auto exists(rcComm_t &conn, const user &user) -> bool
Definition: user_administration.cpp:359
rcMisc.h
ServerHostHead
rodsServerHost_t * ServerHostHead
Definition: irods_server_globals.cpp:21
pid_age.p
p
Definition: pid_age.py:13
LONG_NAME_LEN
#define LONG_NAME_LEN
Definition: rodsDef.h:57
LOCAL_HOST
#define LOCAL_HOST
Definition: rodsConnect.h:44
PROXY_NAME_INX
#define PROXY_NAME_INX
Definition: procStat.h:13
PROXY_ZONE_INX
#define PROXY_ZONE_INX
Definition: procStat.h:14
irods_resource_backport.hpp
rodsServerHost::next
struct rodsServerHost * next
Definition: rodsConnect.h:71
PASSMSG
#define PASSMSG(message_, prev_error_)
Definition: irods_error.hpp:119
ALL_KW
#define ALL_KW
Definition: rodsKeyWdDef.h:10
rcGlobalExtern.h
rsProcStat
int rsProcStat(rsComm_t *rsComm, procStatInp_t *procStatInp, genQueryOut_t **procStatOut)
Definition: rsProcStat.cpp:30
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
GenQueryOut::sqlResult
sqlResult_t sqlResult[50]
Definition: rodsGenQuery.h:72
CLIENT_NAME_INX
#define CLIENT_NAME_INX
Definition: procStat.h:11
INT_RESC_STATUS_UP
#define INT_RESC_STATUS_UP
Definition: rodsDef.h:281
SUCCESS
#define SUCCESS()
Definition: irods_error.hpp:121
rsGlobalExtern.hpp
EXEC_LOCALLY_KW
#define EXEC_LOCALLY_KW
Definition: rodsKeyWdDef.h:12
procStatInp_t::addr
char addr[256]
Definition: procStat.h:20
irods::error::code
long long code() const
Definition: irods_error.cpp:194
_rsProcStatAll
int _rsProcStatAll(rsComm_t *rsComm, genQueryOut_t **procStatOut)
Definition: rsProcStat.cpp:140
procLog_t::proxyZone
char proxyZone[64]
Definition: rodsDef.h:367
rsProcStat.hpp
GenQueryOut::continueInx
int continueInx
Definition: rodsGenQuery.h:70
procLog_t::clientName
char clientName[64]
Definition: rodsDef.h:364
rcProcStat
int rcProcStat(rcComm_t *conn, procStatInp_t *procStatInp, genQueryOut_t **procStatOut)
Definition: rcProcStat.cpp:57
PID_INX
#define PID_INX
Definition: procStat.h:9
hostName::name
char * name
Definition: rodsConnect.h:38
REMOTE_ADDR_INX
#define REMOTE_ADDR_INX
Definition: procStat.h:15
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
SYS_INVALID_SERVER_HOST
@ SYS_INVALID_SERVER_HOST
Definition: rodsErrorTable.h:89
rmKeyVal
int rmKeyVal(keyValPair_t *condInput, const char *keyWord)
Definition: rcMisc.cpp:710
GenQueryOut
Definition: rodsGenQuery.h:67
svrToSvrConnect
int svrToSvrConnect(rsComm_t *rsComm, rodsServerHost_t *rodsServerHost)
Definition: miscServerFunct.cpp:106
readProcLog
int readProcLog(int pid, procLog_t *procLog)
Definition: procLog.cpp:109
catGenQueryOut
int catGenQueryOut(genQueryOut_t *targGenQueryOut, genQueryOut_t *genQueryOut, int maxRowCnt)
Definition: rcMisc.cpp:1172
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
GenQueryOut::attriCnt
int attriCnt
Definition: rodsGenQuery.h:69
rodsLog.h
GenQueryOut::rowCnt
int rowCnt
Definition: rodsGenQuery.h:68
irods::log
void log(const error &)
Definition: irods_log.cpp:13
addProcToProcStatOut
int addProcToProcStatOut(procLog_t *procLog, genQueryOut_t *procStatOut)
Definition: rsProcStat.cpp:365
procLog_t::startTime
unsigned int startTime
Definition: rodsDef.h:363
getNumFilesInDir
int getNumFilesInDir(const char *mydir)
Definition: miscUtil.cpp:2183
getRcatHost
int getRcatHost(int rcatType, const char *rcatZoneHint, rodsServerHost_t **rodsServerHost)
Definition: rodsConnect.cpp:88
irods::error
Definition: irods_error.hpp:23
miscServerFunct.hpp
irods.log
Definition: log.py:1
procLog_t::progName
char progName[64]
Definition: rodsDef.h:370
SqlResult::value
char * value
Definition: rodsGenQuery.h:64
irods::get_host_status_by_host_info
error get_host_status_by_host_info(rodsServerHost_t *)
Definition: irods_resource_backport.cpp:469
MASTER_RCAT
#define MASTER_RCAT
Definition: rodsDef.h:85
irods::resource_manager::hier_to_leaf_id
error hier_to_leaf_id(const std::string &, rodsLong_t &)
Definition: irods_resource_manager.cpp:1082
remoteProcStat
int remoteProcStat(rsComm_t *rsComm, procStatInp_t *procStatInp, genQueryOut_t **procStatOut, rodsServerHost_t *rodsServerHost)
Definition: rsProcStat.cpp:260
ProcLogDir
char ProcLogDir[(1024+64)]
Definition: irods_server_globals.cpp:18
rodsServerHost
Definition: rodsConnect.h:62
procLog.h
rodsHostAddr_t::hostAddr
char hostAddr[256]
Definition: rodsDef.h:297
PROG_NAME_INX
#define PROG_NAME_INX
Definition: procStat.h:16
rodsLogError
void rodsLogError(int level, int errCode, char *formatStr,...)
Definition: rodsLog.cpp:422
procLog_t::serverAddr
char serverAddr[64]
Definition: rodsDef.h:369
resource.hpp
procLog_t
Definition: rodsDef.h:361
SqlResult::len
int len
Definition: rodsGenQuery.h:63
_rsProcStat
int _rsProcStat(rsComm_t *rsComm, procStatInp_t *procStatInp, genQueryOut_t **procStatOut)
Definition: rsProcStat.cpp:59
SERVER_ADDR_INX
#define SERVER_ADDR_INX
Definition: procStat.h:17
rodsServerHost::hostName
hostName_t * hostName
Definition: rodsConnect.h:63
procStatInp_t::rodsZone
char rodsZone[64]
Definition: procStat.h:21
rstrcpy
char * rstrcpy(char *dest, const char *src, int maxLen)
Definition: stringOpr.cpp:51
freeGenQueryOut
int freeGenQueryOut(genQueryOut_t **genQueryOut)
Definition: rcMisc.cpp:1133
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
irods::error::ok
bool ok()
Definition: irods_error.cpp:258
USER_INPUT_PATH_ERR
@ USER_INPUT_PATH_ERR
Definition: rodsErrorTable.h:248
irods::RESOURCE_HOST
const std::string RESOURCE_HOST("resource_property_host")
procStatInp_t::condInput
keyValPair_t condInput
Definition: procStat.h:22
STARTTIME_INX
#define STARTTIME_INX
Definition: procStat.h:10
rodsLong_t
long long rodsLong_t
Definition: rodsType.h:32
objMetaOpr.hpp
resolveHost
int resolveHost(rodsHostAddr_t *addr, rodsServerHost_t **rodsServerHost)
Definition: rodsConnect.cpp:375
rodsHostAddr_t
Definition: rodsDef.h:296
USER__NULL_INPUT_ERR
@ USER__NULL_INPUT_ERR
Definition: rodsErrorTable.h:247
procStatInp_t
Definition: procStat.h:19
initProcStatOut
int initProcStatOut(genQueryOut_t **procStatOut, int numProc)
Definition: rsProcStat.cpp:292