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)  

rsDataObjPut.cpp
Go to the documentation of this file.
1 
3 /* This is script-generated code (for the most part). */
4 /* See dataObjPut.h for a description of this API call.*/
5 
6 #include "dataObjPut.h"
7 #include "rodsLog.h"
8 #include "dataPut.h"
9 #include "filePut.h"
10 #include "objMetaOpr.hpp"
11 #include "physPath.hpp"
12 #include "specColl.hpp"
13 #include "dataObjOpen.h"
14 #include "dataObjCreate.h"
15 #include "dataObjClose.h"
16 #include "regDataObj.h"
17 #include "dataObjUnlink.h"
18 #include "rsGlobalExtern.hpp"
19 #include "rcGlobalExtern.h"
20 #include "rsApiHandler.hpp"
21 #include "subStructFilePut.h"
22 #include "dataObjRepl.h"
23 #include "getRemoteZoneResc.h"
25 #include "modDataObjMeta.h"
26 #include "rsDataObjPut.hpp"
27 #include "rsDataObjRepl.hpp"
28 #include "rsDataObjCreate.hpp"
29 #include "rsDataObjClose.hpp"
30 #include "rsDataPut.hpp"
31 #include "rsRegDataObj.hpp"
32 #include "rsDataObjUnlink.hpp"
33 #include "rsSubStructFilePut.hpp"
34 #include "rsFilePut.hpp"
35 #include "rsUnregDataObj.hpp"
36 
41 #include "irods_stacktrace.hpp"
42 #include "irods_exception.hpp"
43 #include "irods_serialization.hpp"
45 
46 int
47 rsDataObjPut( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
48  bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut ) {
49  int status;
50  int status2;
51  int remoteFlag;
53  specCollCache_t *specCollCache = NULL;
54 
55  resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
56  &dataObjInp->condInput );
57  remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
58  REMOTE_CREATE );
59 
60  if ( const char* acl_string = getValByKey( &dataObjInp->condInput, ACL_INCLUDED_KW ) ) {
61  try {
62  irods::deserialize_acl( acl_string );
63  }
64  catch ( const irods::exception& e ) {
65  rodsLog( LOG_ERROR, "%s", e.what() );
66  return e.code();
67  }
68  }
69  if ( const char* metadata_string = getValByKey( &dataObjInp->condInput, METADATA_INCLUDED_KW ) ) {
70  try {
71  irods::deserialize_metadata( metadata_string );
72  }
73  catch ( const irods::exception& e ) {
74  rodsLog( LOG_ERROR, "%s", e.what() );
75  return e.code();
76  }
77  }
78 
79  if ( remoteFlag < 0 ) {
80  return remoteFlag;
81  }
82  else if ( remoteFlag == LOCAL_HOST ) {
83  // =-=-=-=-=-=-=-
84  // working on the "home zone", determine if we need to redirect to a different
85  // server in this zone for this operation. if there is a RESC_HIER_STR_KW then
86  // we know that the redirection decision has already been made
87  std::string hier;
88  if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
91  dataObjInp, hier );
92  if ( !ret.ok() ) {
93  std::stringstream msg;
94  msg << __FUNCTION__;
95  msg << " :: failed in irods::irods::resolve_resource_hierarchy for [";
96  msg << dataObjInp->objPath << "]";
97  irods::log( PASSMSG( msg.str(), ret ) );
98  return ret.code();
99  }
100  // =-=-=-=-=-=-=-
101  // we resolved the redirect and have a host, set the hier str for subsequent
102  // api calls, etc.
103  addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
104 
105  } // if keyword
106 
107  status2 = applyRuleForPostProcForWrite( rsComm, dataObjInpBBuf,
108  dataObjInp->objPath );
109  if ( status2 < 0 ) {
110  return ( status2 );
111  }
112 
113  dataObjInp->openFlags = O_RDWR;
114  status = _rsDataObjPut( rsComm, dataObjInp, dataObjInpBBuf,
115  portalOprOut );
116  }
117  else {
118  int l1descInx;
119  status = _rcDataObjPut( rodsServerHost->conn, dataObjInp,
120  dataObjInpBBuf, portalOprOut );
121  if ( status < 0 ||
122  getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL ) {
123  return status;
124  }
125  else {
126  /* have to allocate a local l1descInx to keep track of things
127  * since the file is in remote zone. It sets remoteL1descInx,
128  * oprType = REMOTE_ZONE_OPR and remoteZoneHost so that
129  * rsComplete knows what to do */
130  l1descInx = allocAndSetL1descForZoneOpr(
131  ( *portalOprOut )->l1descInx, dataObjInp, rodsServerHost, NULL );
132  if ( l1descInx < 0 ) {
133  return l1descInx;
134  }
135  ( *portalOprOut )->l1descInx = l1descInx;
136  return status;
137  }
138  }
139 
140  return status;
141 }
142 
143 /* _rsDataObjPut - process put request
144  * The reply to this API can go off the main part of the API's
145  * request/reply protocol and uses the sendAndRecvOffMainMsg call
146  * to handle a sequence of request/reply until a return value of
147  * SYS_HANDLER_NO_ERROR.
148  */
149 
150 int
151 _rsDataObjPut( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
152  bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut ) {
153  int status;
154  int l1descInx;
155  int retval;
156  openedDataObjInp_t dataObjCloseInp;
157  int allFlag;
158  transferStat_t *transStat = NULL;
160 
161  if ( getValByKey( &dataObjInp->condInput, ALL_KW ) != NULL ) {
162  allFlag = 1;
163  }
164  else {
165  allFlag = 0;
166  }
167 
168  if ( getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL ) {
169  /* single buffer put */
170  status = l3DataPutSingleBuf( rsComm, dataObjInp, dataObjInpBBuf );
171  if ( status >= 0 && allFlag == 1 ) {
172  /* update the rest of copies */
173  addKeyVal( &dataObjInp->condInput, UPDATE_REPL_KW, "" );
174  status = rsDataObjRepl( rsComm, dataObjInp, &transStat );
175  if ( transStat != NULL ) {
176  free( transStat );
177  }
178  }
179  if ( status >= 0 ) {
181  rsComm, dataObjInpBBuf, dataObjInp->objPath );
182  if ( status >= 0 ) {
183  status = 0;
184  }
185  }
186  return status;
187  }
188 
189  /* get down here. will do parallel I/O */
190  /* so that mmap will work */
191  dataObjInp->openFlags |= O_RDWR;
192  l1descInx = rsDataObjCreate( rsComm, dataObjInp );
193 
194  if ( l1descInx < 0 ) {
195  return l1descInx;
196  }
197 
198  L1desc[l1descInx].oprType = PUT_OPR;
199  L1desc[l1descInx].dataSize = dataObjInp->dataSize;
200 
201  if ( getStructFileType( L1desc[l1descInx].dataObjInfo->specColl ) >= 0 ) { // JMC - backport 4682
202  *portalOprOut = ( portalOprOut_t * ) malloc( sizeof( portalOprOut_t ) );
203  bzero( *portalOprOut, sizeof( portalOprOut_t ) );
204  ( *portalOprOut )->l1descInx = l1descInx;
205  return l1descInx;
206  }
207 
208 
209  status = preProcParaPut( rsComm, l1descInx, portalOprOut );
210 
211  if ( status < 0 ) {
212  memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
213  dataObjCloseInp.l1descInx = l1descInx;
214  L1desc[l1descInx].oprStatus = status;
215  rsDataObjClose( rsComm, &dataObjCloseInp );
216  return status;
217  }
218 
219  if ( allFlag == 1 ) {
220  /* need to save dataObjInp. get freed in sendAndRecvBranchMsg */
221  memset( &replDataObjInp, 0, sizeof( replDataObjInp ) );
222  rstrcpy( replDataObjInp.objPath, dataObjInp->objPath, MAX_NAME_LEN );
223  addKeyVal( &replDataObjInp.condInput, UPDATE_REPL_KW, "" );
224  addKeyVal( &replDataObjInp.condInput, ALL_KW, "" );
225  }
226  /* return portalOprOut to the client and wait for the rcOprComplete
227  * call. That is when the parallel I/O is done */
228  retval = sendAndRecvBranchMsg( rsComm, rsComm->apiInx, status,
229  ( void * ) * portalOprOut, NULL );
230 
231  if ( retval < 0 ) {
232  memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
233  dataObjCloseInp.l1descInx = l1descInx;
234  L1desc[l1descInx].oprStatus = retval;
235  rsDataObjClose( rsComm, &dataObjCloseInp );
236  if ( allFlag == 1 ) {
237  clearKeyVal( &replDataObjInp.condInput );
238  }
239  }
240  else if ( allFlag == 1 ) {
241  status = rsDataObjRepl( rsComm, &replDataObjInp, &transStat );
242  if ( transStat != NULL ) {
243  free( transStat );
244  }
245  clearKeyVal( &replDataObjInp.condInput );
246  }
247 
248  /* already send the client the status */
250 
251 }
252 
253 /* preProcParaPut - preprocessing for parallel put. Basically it calls
254  * rsDataPut to setup portalOprOut with the resource server.
255  */
256 
257 int
258 preProcParaPut( rsComm_t *rsComm, int l1descInx,
260  int status;
261  dataOprInp_t dataOprInp;
262 
263  initDataOprInp( &dataOprInp, l1descInx, PUT_OPR );
264  /* add RESC_HIER_STR_KW for getNumThreads */
265  if ( L1desc[l1descInx].dataObjInfo != NULL ) {
266  addKeyVal( &dataOprInp.condInput, RESC_HIER_STR_KW,
267  L1desc[l1descInx].dataObjInfo->rescHier );
268  }
269  if ( L1desc[l1descInx].remoteZoneHost != NULL ) {
270  status = remoteDataPut( rsComm, &dataOprInp, portalOprOut,
271  L1desc[l1descInx].remoteZoneHost );
272  }
273  else {
274  status = rsDataPut( rsComm, &dataOprInp, portalOprOut );
275  }
276 
277  if ( status >= 0 ) {
278  ( *portalOprOut )->l1descInx = l1descInx;
279  L1desc[l1descInx].bytesWritten = dataOprInp.dataSize;
280  }
281  clearKeyVal( &dataOprInp.condInput );
282  return status;
283 }
284 
285 int
287  dataObjInp_t* dataObjInp,
288  bytesBuf_t* dataObjInpBBuf ) {
289  int bytesWritten;
290  int l1descInx;
291  int status;
292  openedDataObjInp_t dataObjCloseInp;
293  std::string resc_name;
294 
295  /* don't actually physically open the file */
296  addKeyVal( &dataObjInp->condInput, NO_OPEN_FLAG_KW, "" );
297  l1descInx = rsDataObjCreate( rsComm, dataObjInp );
298  if ( l1descInx <= 2 ) {
299  if ( l1descInx >= 0 ) {
301  "l3DataPutSingleBuf: rsDataObjCreate of %s error, status = %d",
302  dataObjInp->objPath,
303  l1descInx );
305  }
306  else {
307  return l1descInx;
308 
309  }
310  }
311 
312  bytesWritten = _l3DataPutSingleBuf( rsComm, l1descInx, dataObjInp, dataObjInpBBuf );
313 
314  memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
315  dataObjCloseInp.l1descInx = l1descInx;
316  L1desc[l1descInx].oprStatus = bytesWritten;
317  L1desc[l1descInx].oprType = PUT_OPR;
318  status = rsDataObjClose( rsComm, &dataObjCloseInp );
319  if ( status < 0 ) {
321  "l3DataPutSingleBuf: rsDataObjClose of %d error, status = %d",
322  l1descInx, status );
323  }
324 
325  if ( bytesWritten >= 0 ) {
326  return status;
327  }
328 
329  return bytesWritten;
330 }
331 
332 
333 int
334 _l3DataPutSingleBuf( rsComm_t *rsComm, int l1descInx, dataObjInp_t *dataObjInp,
335  bytesBuf_t *dataObjInpBBuf ) {
336  dataObjInfo_t *myDataObjInfo = L1desc[l1descInx].dataObjInfo;
337  if (NEWLY_CREATED_COPY == L1desc[l1descInx].replStatus &&
338  !myDataObjInfo->specColl && !L1desc[l1descInx].remoteZoneHost) {
339  /* the check for remoteZoneHost host is not needed because
340  * the put would have done in the remote zone. But it make
341  * the code easier to read (similar ro copy).
342  */
343  int status = svrRegDataObj( rsComm, myDataObjInfo );
344  if ( status < 0 ) {
346  "%s: rsRegDataObj for %s failed, status = %d",
347  __FUNCTION__, myDataObjInfo->objPath, status );
348  return status;
349  }
350  myDataObjInfo->replNum = status;
351  }
352 
353  int bytesWritten = l3FilePutSingleBuf( rsComm, l1descInx, dataObjInpBBuf );
354  if ( bytesWritten >= 0 ) {
355  /* myDataObjInfo->dataSize = bytesWritten; update size problem */
356  if ( bytesWritten == 0 && myDataObjInfo->dataSize > 0 ) {
357  /* overwrite with 0 len file */
358  L1desc[l1descInx].bytesWritten = 1;
359  }
360  else {
361  L1desc[l1descInx].bytesWritten = bytesWritten;
362  }
363 
364  }
365  else {
366  l3Unlink(rsComm, myDataObjInfo);
367  unregDataObj_t inp{};
368  inp.dataObjInfo = myDataObjInfo;
369  rsUnregDataObj(rsComm, &inp);
370  }
371 
372  L1desc[l1descInx].dataSize = dataObjInp->dataSize;
373  return bytesWritten;
374 }
375 
376 int
377 l3FilePutSingleBuf( rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf ) {
378  dataObjInfo_t *dataObjInfo;
379  fileOpenInp_t filePutInp;
380  int bytesWritten;
381  dataObjInp_t *dataObjInp;
382  int retryCnt = 0;
383  int chkType = 0; // JMC - backport 4774
384 
385  dataObjInfo = L1desc[l1descInx].dataObjInfo;
386  dataObjInp = L1desc[l1descInx].dataObjInp;
387 
388  // =-=-=-=-=-=-=-
389  // extract the host location from the resource hierarchy
390  std::string location;
391  irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
392  if ( !ret.ok() ) {
393  irods::log( PASSMSG( "l3FilePutSingleBuf - failed in get_loc_for_hier_string", ret ) );
394  return -1;
395  }
396 
397  if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
398  subFile_t subFile;
399 
400  memset( &subFile, 0, sizeof( subFile ) );
401  rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
402  rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
403  subFile.specColl = dataObjInfo->specColl;
404  subFile.mode = getFileMode( dataObjInp );
405  subFile.flags = O_WRONLY | dataObjInp->openFlags;
406 
407  if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) {
408  subFile.flags |= FORCE_FLAG;
409  }
410 
411  bytesWritten = rsSubStructFilePut( rsComm, &subFile, dataObjInpBBuf );
412  return bytesWritten;
413 
414 
415  } // struct file type >= 0
416 
417  std::string prev_resc_hier;
418  memset( &filePutInp, 0, sizeof( filePutInp ) );
419  rstrcpy( filePutInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN );
420  rstrcpy( filePutInp.objPath, dataObjInp->objPath, MAX_NAME_LEN );
421  if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) {
422  filePutInp.otherFlags |= FORCE_FLAG;
423  }
424 
425  rstrcpy( filePutInp.addr.hostAddr, location.c_str(), NAME_LEN );
426  rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
427  filePutInp.mode = getFileMode( dataObjInp );
428 
429  filePutInp.flags = O_WRONLY | dataObjInp->openFlags;
430  rstrcpy( filePutInp.in_pdmo, L1desc[l1descInx].in_pdmo, MAX_NAME_LEN );
431  // kv pasthru
432  copyKeyVal(
433  &dataObjInfo->condInput,
434  &filePutInp.condInput );
435 
436  // =-=-=-=-=-=-=-
437  // JMC - backport 4774
438  chkType = getchkPathPerm( rsComm, L1desc[l1descInx].dataObjInp, L1desc[l1descInx].dataObjInfo );
439 
440  if ( chkType == DISALLOW_PATH_REG ) {
441  clearKeyVal( &filePutInp.condInput );
442  return PATH_REG_NOT_ALLOWED;
443  }
444  else if ( chkType == NO_CHK_PATH_PERM ) {
445  // =-=-=-=-=-=-=-
446  filePutInp.otherFlags |= NO_CHK_PERM_FLAG; // JMC - backport 4758
447  }
448 
449  filePutOut_t* put_out = 0;
450  prev_resc_hier = filePutInp.resc_hier_;
451  bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out );
452 
453  // update the dataObjInfo with the potential changes made by the resource - hcj
454  rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN );
455  if ( put_out ) {
456  rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN );
457  free( put_out );
458  }
459 
460  /* file already exists ? */
461  while ( bytesWritten < 0 && retryCnt < 10 &&
462  ( filePutInp.otherFlags & FORCE_FLAG ) == 0 &&
463  getErrno( bytesWritten ) == EEXIST ) {
464 
465  if ( resolveDupFilePath( rsComm, dataObjInfo, dataObjInp ) < 0 ) {
466  break;
467  }
468  rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
469 
470 
471  filePutOut_t* put_out = 0;
472  bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out );
473  // update the dataObjInfo with the potential changes made by the resource - hcj
474  rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN );
475  if ( put_out ) {
476  rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN );
477  free( put_out );
478  }
479  retryCnt ++;
480  } // while
481  clearKeyVal( &filePutInp.condInput );
482  return bytesWritten;
483 
484 } // l3FilePutSingleBuf
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
DataObjInp::objPath
char objPath[(1024+64)]
Definition: dataObjInpOut.h:66
OpenedDataObjInp
Definition: dataObjInpOut.h:104
L1desc
l1desc_t L1desc[1026]
Definition: irods_server_globals.cpp:29
getchkPathPerm
int getchkPathPerm(rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfo)
Definition: physPath.cpp:312
NULL
#define NULL
Definition: rodsDef.h:70
regDataObj.h
rsComm_t
Definition: rcConnect.h:145
transferStat_t
Definition: objInfo.h:291
addKeyVal
int addKeyVal(keyValPair_t *condInput, const char *keyWord, const char *value)
Definition: rcMisc.cpp:789
l1desc::remoteZoneHost
rodsServerHost_t * remoteZoneHost
Definition: objDesc.hpp:59
DataOprInp::condInput
keyValPair_t condInput
Definition: dataObjInpOut.h:134
getRemoteZoneResc.h
subStructFilePut.h
DataObjInp::openFlags
int openFlags
Definition: dataObjInpOut.h:68
NEWLY_CREATED_COPY
#define NEWLY_CREATED_COPY
Definition: objInfo.h:115
rsFilePut.hpp
irods_server_properties.hpp
specColl.hpp
modDataObjMeta.h
portalOprOut
Definition: dataObjInpOut.h:114
filePut.h
rodsServerHost::conn
rcComm_t * conn
Definition: rodsConnect.h:64
rsDataObjCreate.hpp
Subfile
Definition: objInfo.h:316
rsUnregDataObj.hpp
irods_stacktrace.hpp
l1desc::dataSize
rodsLong_t dataSize
Definition: objDesc.hpp:46
Subfile::subFilePath
char subFilePath[(1024+64)]
Definition: objInfo.h:318
DataObjInp::dataSize
rodsLong_t dataSize
Definition: dataObjInpOut.h:70
irods::resolve_resource_hierarchy
error resolve_resource_hierarchy(const std::string &, rsComm_t *, dataObjInp_t *, std::string &, dataObjInfo_t **_data_obj_info=0)
Definition: irods_resource_redirect.cpp:505
OpenedDataObjInp::l1descInx
int l1descInx
Definition: dataObjInpOut.h:105
rsDataObjCreate
int rsDataObjCreate(rsComm_t *rsComm, dataObjInp_t *dataObjInp)
Definition: rsDataObjCreate.cpp:77
irods_exception.hpp
sendAndRecvBranchMsg
int sendAndRecvBranchMsg(rsComm_t *rsComm, int apiInx, int status, void *myOutStruct, bytesBuf_t *myOutBsBBuf)
Definition: rsApiHandler.cpp:626
allocAndSetL1descForZoneOpr
int allocAndSetL1descForZoneOpr(int l3descInx, dataObjInp_t *dataObjInp, rodsServerHost_t *remoteZoneHost, openStat_t *openStat)
Definition: objDesc.cpp:638
l1desc::oprStatus
int oprStatus
Definition: objDesc.hpp:39
NO_CHK_PERM_FLAG
#define NO_CHK_PERM_FLAG
Definition: fileOpen.h:10
PUT_OPR
#define PUT_OPR
Definition: dataObjInpOut.h:167
svrRegDataObj
int svrRegDataObj(rsComm_t *rsComm, dataObjInfo_t *dataObjInfo)
Definition: rsRegDataObj.cpp:120
l1desc::dataObjInfo
dataObjInfo_t * dataObjInfo
Definition: objDesc.hpp:42
DataObjInfo::rescHier
char rescHier[(1024+64)]
Definition: objInfo.h:132
getStructFileType
int getStructFileType(specColl_t *specColl)
Definition: objMetaOpr.cpp:386
LOCAL_HOST
#define LOCAL_HOST
Definition: rodsConnect.h:44
DataObjInfo::condInput
keyValPair_t condInput
Definition: objInfo.h:161
irods_resource_backport.hpp
Subfile::specColl
specColl_t * specColl
Definition: objInfo.h:322
fileOpenInp_t::resc_hier_
char resc_hier_[(1024+64)]
Definition: fileOpen.h:16
l1desc::oprType
int oprType
Definition: objDesc.hpp:37
PASSMSG
#define PASSMSG(message_, prev_error_)
Definition: irods_error.hpp:119
ALL_KW
#define ALL_KW
Definition: rodsKeyWdDef.h:10
l1desc::in_pdmo
char in_pdmo[(1024+64)]
Definition: objDesc.hpp:60
rcGlobalExtern.h
DataObjInfo::filePath
char filePath[(1024+64)]
Definition: objInfo.h:137
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
dataObjCreate.h
irods_resource_redirect.hpp
fileOpenInp_t::fileName
char fileName[(1024+64)]
Definition: fileOpen.h:20
DataObjInfo::specColl
specColl_t * specColl
Definition: objInfo.h:158
PATH_REG_NOT_ALLOWED
@ PATH_REG_NOT_ALLOWED
Definition: rodsErrorTable.h:194
rsFilePut
int rsFilePut(rsComm_t *rsComm, fileOpenInp_t *filePutInp, bytesBuf_t *filePutInpBBuf, filePutOut_t **)
Definition: rsFilePut.cpp:32
resolveLinkedPath
int resolveLinkedPath(rsComm_t *rsComm, char *objPath, specCollCache_t **specCollCache, keyValPair_t *condInput)
Definition: specColl.cpp:711
irods::deserialize_acl
std::vector< std::vector< std::string > > deserialize_acl(const std::string &acl)
Definition: irods_serialization.cpp:332
unregDataObj_t::dataObjInfo
dataObjInfo_t * dataObjInfo
Definition: unregDataObj.h:8
irods_serialization.hpp
rsGlobalExtern.hpp
irods::error::code
long long code() const
Definition: irods_error.cpp:194
fileOpenInp_t::flags
int flags
Definition: fileOpen.h:21
RESC_HIER_STR_KW
#define RESC_HIER_STR_KW
Definition: rodsKeyWdDef.h:225
fileOpenInp_t::addr
rodsHostAddr_t addr
Definition: fileOpen.h:19
irods::deserialize_metadata
std::vector< std::string > deserialize_metadata(const std::string &metadata)
Definition: irods_serialization.cpp:313
DATA_INCLUDED_KW
#define DATA_INCLUDED_KW
Definition: rodsKeyWdDef.h:36
rsDataObjPut
int rsDataObjPut(rsComm_t *rsComm, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut)
Definition: rsDataObjPut.cpp:47
rsComm_t::apiInx
int apiInx
Definition: rcConnect.h:160
fileOpenInp_t::objPath
char objPath[(1024+64)]
Definition: fileOpen.h:17
LOG_DEBUG
#define LOG_DEBUG
Definition: rodsLog.h:23
NO_CHK_PATH_PERM
#define NO_CHK_PATH_PERM
Definition: objInfo.h:246
filePutOut_t
Definition: filePut.h:8
remoteDataPut
int remoteDataPut(rsComm_t *rsComm, dataOprInp_t *dataPutInp, portalOprOut_t **portalOprOut, rodsServerHost_t *rodsServerHost)
Definition: rsDataPut.cpp:67
_rcDataObjPut
int _rcDataObjPut(rcComm_t *conn, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut)
Definition: rcDataObjPut.cpp:244
rsDataObjClose
int rsDataObjClose(rsComm_t *rsComm, openedDataObjInp_t *dataObjCloseInp)
Definition: rsDataObjClose.cpp:56
REMOTE_CREATE
#define REMOTE_CREATE
Definition: getRemoteZoneResc.h:4
ACL_INCLUDED_KW
#define ACL_INCLUDED_KW
Definition: rodsKeyWdDef.h:35
DataObjInp
Definition: dataObjInpOut.h:65
rsDataObjClose.hpp
NO_OPEN_FLAG_KW
#define NO_OPEN_FLAG_KW
Definition: rodsKeyWdDef.h:45
rsDataPut.hpp
l1desc::dataObjInp
dataObjInp_t * dataObjInp
Definition: objDesc.hpp:41
MAX_NAME_LEN
#define MAX_NAME_LEN
Definition: rodsDef.h:61
terminate_irods_processes.e
e
Definition: terminate_irods_processes.py:19
getErrno
int getErrno(int errCode)
Definition: rcMisc.cpp:3261
OPEN_EXISTING_COPY
#define OPEN_EXISTING_COPY
Definition: objInfo.h:116
Subfile::addr
rodsHostAddr_t addr
Definition: objInfo.h:317
fileOpenInp_t::mode
int mode
Definition: fileOpen.h:22
DataObjInfo::replNum
int replNum
Definition: objInfo.h:140
filePutOut_t::file_name
char file_name[(1024+64)]
Definition: filePut.h:9
UPDATE_REPL_KW
#define UPDATE_REPL_KW
Definition: rodsKeyWdDef.h:75
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
_rsDataObjPut
int _rsDataObjPut(rsComm_t *rsComm, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut)
Definition: rsDataObjPut.cpp:151
rodsLog.h
physPath.hpp
irods::log
void log(const error &)
Definition: irods_log.cpp:13
initDataOprInp
int initDataOprInp(dataOprInp_t *dataOprInp, int l1descInx, int oprType)
Definition: objDesc.cpp:453
SYS_NO_HANDLER_REPLY_MSG
@ SYS_NO_HANDLER_REPLY_MSG
Definition: rodsErrorTable.h:879
LOG_NOTICE
#define LOG_NOTICE
Definition: rodsLog.h:33
dataObjClose.h
BytesBuf
Definition: rodsDef.h:197
l3DataPutSingleBuf
int l3DataPutSingleBuf(rsComm_t *rsComm, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf)
Definition: rsDataObjPut.cpp:286
irods::error
Definition: irods_error.hpp:23
dataObjPut.h
dataObjRepl.h
unregDataObj_t
Definition: unregDataObj.h:7
fileOpenInp_t::condInput
keyValPair_t condInput
Definition: fileOpen.h:24
irods_hierarchy_parser.hpp
fileOpenInp_t
Definition: fileOpen.h:14
rodsServerHost
Definition: rodsConnect.h:62
rodsHostAddr_t::hostAddr
char hostAddr[256]
Definition: rodsDef.h:297
l1desc::bytesWritten
rodsLong_t bytesWritten
Definition: objDesc.hpp:45
l3FilePutSingleBuf
int l3FilePutSingleBuf(rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf)
Definition: rsDataObjPut.cpp:377
applyRuleForPostProcForWrite
int applyRuleForPostProcForWrite(rsComm_t *rsComm, bytesBuf_t *dataObjWriteInpBBuf, char *objPath)
Definition: rsDataObjWrite.cpp:26
rsDataObjRepl
int rsDataObjRepl(rsComm_t *rsComm, dataObjInp_t *dataObjInp, transferStat_t **transferStat)
Definition: rsDataObjRepl.cpp:65
DataOprInp
Definition: dataObjInpOut.h:122
getAndConnRemoteZone
int getAndConnRemoteZone(rsComm_t *rsComm, dataObjInp_t *dataObjInp, rodsServerHost_t **rodsServerHost, char *remotZoneOpr)
Definition: rodsConnect.cpp:784
replDataObjInp
int replDataObjInp(dataObjInp_t *srcDataObjInp, dataObjInp_t *destDataObjInp)
Definition: rcMisc.cpp:765
irods::exception
Definition: irods_exception.hpp:15
preProcParaPut
int preProcParaPut(rsComm_t *rsComm, int l1descInx, portalOprOut_t **portalOprOut)
Definition: rsDataObjPut.cpp:258
icatHighLevelRoutines.hpp
getFileMode
int getFileMode(dataObjInp_t *dataObjInp)
Definition: physPath.cpp:48
DISALLOW_PATH_REG
#define DISALLOW_PATH_REG
Definition: objInfo.h:245
dataPut.h
rsSubStructFilePut
int rsSubStructFilePut(rsComm_t *rsComm, subFile_t *subFile, bytesBuf_t *subFilePutOutBBuf)
Definition: rsSubStructFilePut.cpp:13
dataObjOpen.h
DataObjInfo::objPath
char objPath[(1024+64)]
Definition: objInfo.h:130
Subfile::mode
int mode
Definition: objInfo.h:319
rsRegDataObj.hpp
resolveDupFilePath
int resolveDupFilePath(rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, dataObjInp_t *dataObjInp)
Definition: physPath.cpp:279
fileOpenInp_t::in_pdmo
char in_pdmo[(1024+64)]
Definition: fileOpen.h:25
rstrcpy
char * rstrcpy(char *dest, const char *src, int maxLen)
Definition: stringOpr.cpp:51
rsUnregDataObj
int rsUnregDataObj(rsComm_t *rsComm, unregDataObj_t *unregDataObjInp)
Definition: rsUnregDataObj.cpp:17
rsApiHandler.hpp
DataObjInp::condInput
keyValPair_t condInput
Definition: dataObjInpOut.h:74
_l3DataPutSingleBuf
int _l3DataPutSingleBuf(rsComm_t *rsComm, int l1descInx, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf)
Definition: rsDataObjPut.cpp:334
irods::get_loc_for_hier_string
error get_loc_for_hier_string(const std::string &_hier, std::string &_loc)
Definition: irods_resource_backport.cpp:633
FORCE_FLAG
#define FORCE_FLAG
Definition: fileOpen.h:12
SYS_FILE_DESC_OUT_OF_RANGE
@ SYS_FILE_DESC_OUT_OF_RANGE
Definition: rodsErrorTable.h:87
METADATA_INCLUDED_KW
#define METADATA_INCLUDED_KW
Definition: rodsKeyWdDef.h:34
NAME_LEN
#define NAME_LEN
Definition: rodsDef.h:55
fileOpenInp_t::otherFlags
int otherFlags
Definition: fileOpen.h:18
rsSubStructFilePut.hpp
Subfile::flags
int flags
Definition: objInfo.h:320
clearKeyVal
int clearKeyVal(keyValPair_t *condInput)
Definition: rcMisc.cpp:1047
irods::error::ok
bool ok()
Definition: irods_error.cpp:258
rsDataPut
int rsDataPut(rsComm_t *rsComm, dataOprInp_t *dataPutInp, portalOprOut_t **portalOprOut)
Definition: rsDataPut.cpp:19
DataObjInfo
Definition: objInfo.h:129
DataObjInfo::dataSize
rodsLong_t dataSize
Definition: objInfo.h:134
irods::CREATE_OPERATION
const std::string CREATE_OPERATION("CREATE")
DataOprInp::dataSize
rodsLong_t dataSize
Definition: dataObjInpOut.h:133
rsDataObjPut.hpp
rsDataObjRepl.hpp
SpecCollCache
Definition: objInfo.h:102
objMetaOpr.hpp
DataObjInfo::subPath
char subPath[(1024+64)]
Definition: objInfo.h:157
copyKeyVal
int copyKeyVal(const keyValPair_t *srcCondInput, keyValPair_t *destCondInput)
Definition: rcMisc.cpp:751