00001
00002
00003
00004
00005
00006
00007
00008 #include "fileDriver.h"
00009 #include "eirods_log.h"
00010 #include "eirods_resource_plugin.h"
00011 #include "eirods_first_class_object.h"
00012 #include "eirods_stacktrace.h"
00013
00014 #include "eirods_resource_constants.h"
00015 #include "eirods_resource_manager.h"
00016 extern eirods::resource_manager resc_mgr;
00017
00018
00019
00020 eirods::error fileCreate( rsComm_t* _comm, eirods::first_class_object& _object ) {
00021
00022
00023 if( _object.physical_path().empty() ) {
00024 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00025 eirods::log( ret_err );
00026 return ret_err;
00027 }
00028
00029
00030
00031 eirods::resource_ptr resc;
00032 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00033 if( !ret_err.ok() ) {
00034 eirods::log( ret_err );
00035 return PASSMSG( "failed to resolve resource", ret_err );
00036 }
00037
00038
00039
00040 ret_err = resc->call( _comm, eirods::RESOURCE_OP_CREATE, _object );
00041
00042
00043
00044 if( !ret_err.ok() ) {
00045 return PASSMSG( "failed to call 'create'", ret_err );
00046 } else {
00047 return CODE( ret_err.code() );
00048 }
00049
00050
00051 }
00052
00053
00054
00055 eirods::error fileOpen( rsComm_t* _comm, eirods::first_class_object& _object ) {
00056
00057
00058 if( _object.physical_path().empty() ) {
00059 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00060 eirods::log( ret_err );
00061 return ret_err;
00062 }
00063
00064
00065
00066 eirods::resource_ptr resc;
00067 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00068 if( !ret_err.ok() ) {
00069 return PASSMSG( "failed to resolve resource", ret_err );
00070 }
00071
00072
00073
00074 ret_err = resc->call( _comm, eirods::RESOURCE_OP_OPEN, _object );
00075
00076
00077
00078 if( !ret_err.ok() ) {
00079 return PASSMSG( "failed to call 'open'", ret_err );
00080
00081 } else {
00082 return CODE( _object.file_descriptor() );
00083
00084 }
00085
00086 }
00087
00088
00089
00090 eirods::error fileRead( rsComm_t* _comm, eirods::first_class_object& _object, void* _buf, int _len ) {
00091
00092
00093 eirods::resource_ptr resc;
00094 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00095 if( !ret_err.ok() ) {
00096 return PASSMSG( "failed to resolve resource", ret_err );
00097 }
00098
00099
00100
00101 ret_err = resc->call< void*, int >( _comm, eirods::RESOURCE_OP_READ, _object, _buf, _len );
00102
00103
00104
00105 if( !ret_err.ok() ) {
00106 return PASSMSG( "failed to call 'read'", ret_err );
00107 } else {
00108 return CODE( ret_err.code() );
00109 }
00110
00111 }
00112
00113
00114
00115 eirods::error fileWrite( rsComm_t* _comm, eirods::first_class_object& _object, void* _buf, int _len ) {
00116
00117
00118 eirods::resource_ptr resc;
00119 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00120 if( !ret_err.ok() ) {
00121 return PASSMSG( "failed to resolve resource", ret_err );
00122 }
00123
00124
00125
00126 ret_err = resc->call< void*, int >( _comm, eirods::RESOURCE_OP_WRITE, _object, _buf, _len );
00127
00128
00129
00130 if( !ret_err.ok() ) {
00131 return PASSMSG( "failed to call 'write'", ret_err );
00132 } else {
00133 std::stringstream msg;
00134 msg << "Write successful.";
00135 return PASSMSG(msg.str(), ret_err);
00136 }
00137
00138 }
00139
00140
00141
00142 eirods::error fileClose( rsComm_t* _comm, eirods::first_class_object& _object ) {
00143
00144
00145 if( _object.physical_path().empty() ) {
00146 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00147 eirods::log( ret_err );
00148 return ret_err;
00149 }
00150
00151
00152
00153 eirods::resource_ptr resc;
00154 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00155 if( !ret_err.ok() ) {
00156 return PASSMSG( "failed to resolve resource", ret_err );
00157 }
00158
00159
00160
00161 ret_err = resc->call( _comm, eirods::RESOURCE_OP_CLOSE, _object );
00162
00163
00164
00165 if( !ret_err.ok() ) {
00166 return PASSMSG( "failed to call 'close'", ret_err );
00167 } else {
00168 return CODE( ret_err.code() );
00169 }
00170
00171 }
00172
00173
00174
00175 eirods::error fileUnlink( rsComm_t* _comm, eirods::first_class_object& _object ) {
00176
00177
00178 if( _object.physical_path().empty() ) {
00179 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00180 eirods::log( ret_err );
00181 return ret_err;
00182 }
00183
00184
00185
00186 eirods::resource_ptr resc;
00187 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00188 if( !ret_err.ok() ) {
00189 return PASSMSG( "failed to resolve resource", ret_err );
00190 }
00191
00192
00193
00194 ret_err = resc->call( _comm, eirods::RESOURCE_OP_UNLINK, _object );
00195
00196
00197
00198 if( !ret_err.ok() ) {
00199 return PASSMSG( "failed to call 'unlink'", ret_err );
00200 } else {
00201 return CODE( ret_err.code() );
00202 }
00203
00204 }
00205
00206
00207
00208 eirods::error fileStat( rsComm_t* _comm, eirods::first_class_object& _object, struct stat* _statbuf ) {
00209
00210
00211 if( _object.physical_path().empty() ) {
00212 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00213 eirods::log( ret_err );
00214 return ret_err;
00215 }
00216
00217
00218
00219 eirods::resource_ptr resc;
00220 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00221 if( !ret_err.ok() ) {
00222 return PASSMSG( "failed to resolve resource", ret_err );
00223 }
00224
00225
00226
00227 ret_err = resc->call< struct stat* >( _comm, eirods::RESOURCE_OP_STAT, _object, _statbuf );
00228
00229
00230
00231 if( !ret_err.ok() ) {
00232 return PASSMSG( "failed to call 'stat'", ret_err );
00233 } else {
00234 return CODE( ret_err.code() );
00235 }
00236
00237 }
00238
00239
00240
00241 eirods::error fileFstat( rsComm_t* _comm, eirods::first_class_object& _object, struct stat* _statbuf ) {
00242
00243
00244 if( _object.physical_path().empty() ) {
00245 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00246 eirods::log( ret_err );
00247 return ret_err;
00248 }
00249
00250
00251
00252 eirods::resource_ptr resc;
00253 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00254 if( !ret_err.ok() ) {
00255 return PASSMSG( "failed to resolve resource", ret_err );
00256 }
00257
00258
00259
00260 ret_err = resc->call< struct stat* >( _comm, eirods::RESOURCE_OP_FSTAT, _object, _statbuf );
00261
00262
00263
00264 if( !ret_err.ok() ) {
00265 return PASSMSG( "failed to call 'fstat'", ret_err );
00266 } else {
00267 return CODE( ret_err.code() );
00268 }
00269
00270 }
00271
00272
00273
00274 eirods::error fileLseek( rsComm_t* _comm, eirods::first_class_object& _object, size_t _offset, int _whence ) {
00275
00276
00277 if( _object.physical_path().empty() ) {
00278 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "file name is empty." );
00279 eirods::log( ret_err );
00280 return ret_err;
00281 }
00282
00283
00284
00285 eirods::resource_ptr resc;
00286 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00287 if( !ret_err.ok() ) {
00288 return PASSMSG( "failed to resolve resource", ret_err );
00289 }
00290
00291
00292
00293 ret_err = resc->call< size_t, int >( _comm, eirods::RESOURCE_OP_LSEEK, _object, _offset, _whence );
00294
00295
00296
00297 if( !ret_err.ok() ) {
00298 return PASSMSG( "failed to call 'lseek'", ret_err );
00299 } else {
00300 return CODE( ret_err.code() );
00301 }
00302
00303 }
00304
00305
00306
00307 eirods::error fileFsync( rsComm_t* _comm, eirods::first_class_object& _object ) {
00308
00309
00310 if( _object.physical_path().empty() ) {
00311 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileFsync - File Name is Empty." );
00312 eirods::log( ret_err );
00313 return ret_err;
00314 }
00315
00316
00317
00318 eirods::resource_ptr resc;
00319 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00320 if( !ret_err.ok() ) {
00321 return PASSMSG( "failed to resolve resource", ret_err );
00322 }
00323
00324
00325
00326 ret_err = resc->call( _comm, eirods::RESOURCE_OP_FSYNC, _object );
00327
00328
00329
00330 if( !ret_err.ok() ) {
00331 return PASSMSG( "failed to call 'fsync'", ret_err );
00332 } else {
00333 return CODE( ret_err.code() );
00334 }
00335
00336 }
00337
00338
00339
00340 eirods::error fileMkdir( rsComm_t* _comm, eirods::first_class_object& _object ) {
00341
00342
00343 if( _object.physical_path().empty() ) {
00344 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileMkdir - File Name is Empty." );
00345 eirods::log( ret_err );
00346 return ret_err;
00347 }
00348
00349
00350
00351 eirods::resource_ptr resc;
00352 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00353 if( !ret_err.ok() ) {
00354 return PASSMSG( "failed to resolve resource", ret_err );
00355 }
00356
00357
00358
00359 ret_err = resc->call( _comm, eirods::RESOURCE_OP_MKDIR, _object );
00360
00361
00362
00363 if( !ret_err.ok() ) {
00364 return PASSMSG( "failed to call 'mkdir'", ret_err );
00365 } else {
00366 return CODE( ret_err.code() );
00367 }
00368
00369 }
00370
00371
00372
00373 eirods::error fileChmod( rsComm_t* _comm, eirods::first_class_object& _object ) {
00374
00375
00376 if( _object.physical_path().empty() ) {
00377 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileChmod - File Name is Empty." );
00378 eirods::log( ret_err );
00379 return ret_err;
00380 }
00381
00382
00383
00384 eirods::resource_ptr resc;
00385 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00386 if( !ret_err.ok() ) {
00387 return PASSMSG( "failed to resolve resource", ret_err );
00388 }
00389
00390
00391
00392 ret_err = resc->call( _comm, eirods::RESOURCE_OP_CHMOD, _object );
00393
00394
00395
00396 if( !ret_err.ok() ) {
00397 return PASSMSG( "failed to call 'chmod'", ret_err );
00398 } else {
00399 return CODE( ret_err.code() );
00400 }
00401
00402 }
00403
00404
00405
00406 eirods::error fileRmdir( rsComm_t* _comm, eirods::first_class_object& _object ) {
00407
00408
00409 if( _object.physical_path().empty() ) {
00410 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileRmdir - File Name is Empty." );
00411 eirods::log( ret_err );
00412 return ret_err;
00413 }
00414
00415
00416
00417 eirods::resource_ptr resc;
00418 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00419 if( !ret_err.ok() ) {
00420 return PASSMSG( "failed to resolve resource", ret_err );
00421 }
00422
00423
00424
00425 ret_err = resc->call( _comm, eirods::RESOURCE_OP_RMDIR, _object );
00426
00427
00428
00429 if( !ret_err.ok() ) {
00430 return PASSMSG( "failed to call 'rmdir'", ret_err );
00431 } else {
00432 return CODE( ret_err.code() );
00433 }
00434
00435 }
00436
00437
00438
00439 eirods::error fileOpendir( rsComm_t* _comm, eirods::first_class_object& _object ) {
00440
00441
00442 if( _object.physical_path().empty() ) {
00443 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileOpendir - File Name is Empty." );
00444 eirods::log( ret_err );
00445 return ret_err;
00446 }
00447
00448
00449
00450 eirods::resource_ptr resc;
00451 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00452 if( !ret_err.ok() ) {
00453 return PASSMSG( "failed to resolve resource", ret_err );
00454 }
00455
00456
00457
00458 ret_err = resc->call( _comm, eirods::RESOURCE_OP_OPENDIR, _object );
00459
00460
00461
00462 if( !ret_err.ok() ) {
00463 return PASSMSG( "failed to call 'opendir'", ret_err );
00464 } else {
00465 return CODE( ret_err.code() );
00466 }
00467
00468 }
00469
00470
00471
00472 eirods::error fileClosedir( rsComm_t* _comm, eirods::first_class_object& _object ) {
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483 eirods::resource_ptr resc;
00484 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00485 if( !ret_err.ok() ) {
00486 return PASSMSG( "failed to resolve resource", ret_err );
00487 }
00488
00489
00490
00491 ret_err = resc->call( _comm, eirods::RESOURCE_OP_CLOSEDIR, _object );
00492
00493
00494
00495 if( !ret_err.ok() ) {
00496 return PASSMSG( "failed to call 'closedir'", ret_err );
00497 } else {
00498 return CODE( ret_err.code() );
00499 }
00500
00501 }
00502
00503
00504
00505 eirods::error fileReaddir( rsComm_t* _comm, eirods::first_class_object& _object, struct rodsDirent** _dirent_ptr ) {
00506
00507
00508 eirods::resource_ptr resc;
00509 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00510 if( !ret_err.ok() ) {
00511 return PASSMSG( "failed to resolve resource", ret_err );
00512 }
00513
00514
00515
00516 ret_err = resc->call< struct rodsDirent** >( _comm, eirods::RESOURCE_OP_READDIR, _object, _dirent_ptr );
00517
00518
00519
00520 if( !ret_err.ok() ) {
00521 return PASSMSG( "failed to call 'readdir'", ret_err );
00522 } else {
00523 return CODE( ret_err.code() );
00524 }
00525
00526 }
00527
00528
00529
00530 eirods::error fileStage( rsComm_t* _comm, eirods::first_class_object& _object ) {
00531
00532
00533 if( _object.physical_path().empty() ) {
00534 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileStage - File Name is Empty." );
00535 eirods::log( ret_err );
00536 return ret_err;
00537 }
00538
00539
00540
00541 eirods::resource_ptr resc;
00542 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00543 if( !ret_err.ok() ) {
00544 return PASSMSG( "failed to resolve resource", ret_err );
00545 }
00546
00547
00548
00549 ret_err = resc->call( _comm, eirods::RESOURCE_OP_STAGE, _object );
00550
00551
00552
00553 if( !ret_err.ok() ) {
00554 return PASSMSG( "failed to call 'stage'", ret_err );
00555 } else {
00556 return CODE( ret_err.code() );
00557 }
00558
00559 }
00560
00561
00562
00563 eirods::error fileRename( rsComm_t* _comm,
00564 eirods::first_class_object& _object,
00565 const std::string& _new_file_name ) {
00566
00567
00568 if( _object.physical_path().empty() || _new_file_name.empty() ) {
00569 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileRename - File Name is Empty." );
00570 eirods::log( ret_err );
00571 return ret_err;
00572 }
00573
00574
00575
00576 eirods::resource_ptr resc;
00577 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00578 if( !ret_err.ok() ) {
00579 return PASSMSG( "failed to resolve resource", ret_err );
00580 }
00581
00582
00583
00584 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_RENAME, _object, _new_file_name.c_str() );
00585
00586
00587
00588 if( !ret_err.ok() ) {
00589 return PASSMSG( "failed to call 'rename'", ret_err );
00590 } else {
00591 return CODE( ret_err.code() );
00592 }
00593
00594 }
00595
00596
00597
00598 eirods::error fileGetFsFreeSpace( rsComm_t* _comm, eirods::first_class_object& _object ) {
00599
00600
00601 if( _object.physical_path().empty() ) {
00602 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileGetFsFreeSpace - File Name is Empty." );
00603 eirods::log( ret_err );
00604 return ret_err;
00605 }
00606
00607
00608
00609 eirods::resource_ptr resc;
00610 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00611 if( !ret_err.ok() ) {
00612 return PASSMSG( "failed to resolve resource", ret_err );
00613 }
00614
00615
00616
00617 ret_err = resc->call( _comm, eirods::RESOURCE_OP_FREESPACE, _object );
00618
00619
00620
00621 if( !ret_err.ok() ) {
00622 return PASSMSG( "failed to call 'stage'", ret_err );
00623 } else {
00624 return CODE( ret_err.code() );
00625 }
00626
00627 }
00628
00629
00630
00631 eirods::error fileTruncate( rsComm_t* _comm, eirods::first_class_object& _object ) {
00632
00633
00634 if( _object.physical_path().empty() ) {
00635 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileTruncate - File Name is Empty." );
00636 eirods::log( ret_err );
00637 return ret_err;
00638 }
00639
00640
00641
00642 eirods::resource_ptr resc;
00643 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00644 if( !ret_err.ok() ) {
00645 return PASSMSG( "failed to resolve resource", ret_err );
00646 }
00647
00648
00649
00650 ret_err = resc->call( _comm, eirods::RESOURCE_OP_TRUNCATE, _object );
00651
00652
00653
00654 if( !ret_err.ok() ) {
00655 return PASSMSG( "failed to call 'truncate'", ret_err );
00656 } else {
00657 return CODE( ret_err.code() );
00658 }
00659
00660 }
00661
00662
00663
00664 eirods::error fileStageToCache( rsComm_t* _comm,
00665 eirods::first_class_object& _object,
00666 const std::string& _cache_file_name ) {
00667
00668
00669 if( _cache_file_name.empty() ) {
00670 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileStageToCache - File Name is Empty." );
00671 eirods::log( ret_err );
00672 return ret_err;
00673 }
00674
00675
00676
00677 eirods::resource_ptr resc;
00678 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00679 if( !ret_err.ok() ) {
00680 return PASSMSG( "failed to resolve resource", ret_err );
00681 }
00682
00683
00684
00685 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_STAGETOCACHE, _object, _cache_file_name.c_str() );
00686
00687
00688
00689 if( !ret_err.ok() ) {
00690 return PASSMSG( "failed to call 'stagetocache'", ret_err );
00691 } else {
00692 return SUCCESS();
00693 }
00694
00695 }
00696
00697
00698
00699 eirods::error fileSyncToArch( rsComm_t* _comm,
00700 eirods::first_class_object& _object,
00701 const std::string& _cache_file_name ) {
00702
00703
00704 if( _cache_file_name.empty() ) {
00705 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileSyncToArch - File Name is Empty." );
00706 eirods::log( ret_err );
00707 return ret_err;
00708 }
00709
00710
00711
00712 eirods::resource_ptr resc;
00713 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00714 if( !ret_err.ok() ) {
00715 return PASSMSG( "failed to resolve resource", ret_err );
00716 }
00717
00718
00719
00720 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_SYNCTOARCH, _object, _cache_file_name.c_str() );
00721
00722
00723
00724 if( !ret_err.ok() ) {
00725 return PASSMSG( "failed to call 'synctoarch'", ret_err );
00726 } else {
00727 return SUCCESS();
00728 }
00729
00730 }
00731
00732
00733 eirods::error fileRegistered(
00734 rsComm_t* _comm,
00735 eirods::first_class_object& _object )
00736 {
00737 eirods::error result = SUCCESS();
00738 eirods::error ret;
00739
00740
00741
00742 if( _object.physical_path().empty() ) {
00743 std::stringstream msg;
00744 msg << __FUNCTION__;
00745 msg << " - File name is empty.";
00746 result = ERROR(-1, msg.str());
00747 } else {
00748
00749
00750
00751 eirods::resource_ptr resc;
00752 ret = _object.resolve( resc_mgr, resc );
00753 if( !ret.ok() ) {
00754 std::stringstream msg;
00755 msg << __FUNCTION__;
00756 msg << " - Failed to resolve resource.";
00757 result = PASSMSG(msg.str(), ret);
00758 } else {
00759
00760
00761
00762 ret = resc->call( _comm, eirods::RESOURCE_OP_REGISTERED, _object );
00763 if( !ret.ok() ) {
00764 std::stringstream msg;
00765 msg << __FUNCTION__;
00766 msg << " - Failed to call registered interface.";
00767 result = PASSMSG(msg.str(), ret);
00768 }
00769 }
00770 }
00771 return result;
00772 }
00773
00774
00775 eirods::error fileUnregistered(
00776 rsComm_t* _comm,
00777 eirods::first_class_object& _object )
00778 {
00779 eirods::error result = SUCCESS();
00780 eirods::error ret;
00781
00782
00783
00784 if( _object.physical_path().empty() ) {
00785 std::stringstream msg;
00786 msg << __FUNCTION__;
00787 msg << " - File name is empty.";
00788 result = ERROR(-1, msg.str());
00789 } else {
00790
00791
00792
00793 eirods::resource_ptr resc;
00794 ret = _object.resolve( resc_mgr, resc );
00795 if( !ret.ok() ) {
00796 std::stringstream msg;
00797 msg << __FUNCTION__;
00798 msg << " - Failed to resolve resource.";
00799 result = PASSMSG(msg.str(), ret);
00800 } else {
00801
00802
00803
00804 ret = resc->call( _comm, eirods::RESOURCE_OP_UNREGISTERED, _object );
00805 if( !ret.ok() ) {
00806 std::stringstream msg;
00807 msg << __FUNCTION__;
00808 msg << " - Failed to call unregistered interface.";
00809 result = PASSMSG(msg.str(), ret);
00810 }
00811 }
00812 }
00813 return result;
00814 }
00815
00816
00817 eirods::error fileModified(
00818 rsComm_t* _comm,
00819 eirods::first_class_object& _object )
00820 {
00821 eirods::error result = SUCCESS();
00822 eirods::error ret;
00823
00824 std::string resc_hier = _object.resc_hier();
00825 if(!resc_hier.empty()) {
00826
00827
00828
00829 eirods::resource_ptr resc;
00830 ret = _object.resolve( resc_mgr, resc );
00831 if( !ret.ok() ) {
00832 std::stringstream msg;
00833 msg << __FUNCTION__;
00834 msg << " - Failed to resolve resource.";
00835 result = PASSMSG(msg.str(), ret);
00836 } else {
00837
00838
00839
00840 ret = resc->call( _comm, eirods::RESOURCE_OP_MODIFIED, _object );
00841 if( !ret.ok() ) {
00842 std::stringstream msg;
00843 msg << __FUNCTION__;
00844 msg << " - Failed to call modified interface.";
00845 result = PASSMSG(msg.str(), ret);
00846 }
00847 }
00848 } else {
00849
00850 }
00851 return result;
00852 }