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 fileRmdir( 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, "fileRmdir - 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_RMDIR, _object );
00393
00394
00395
00396 if( !ret_err.ok() ) {
00397 return PASSMSG( "failed to call 'rmdir'", ret_err );
00398 } else {
00399 return CODE( ret_err.code() );
00400 }
00401
00402 }
00403
00404
00405
00406 eirods::error fileOpendir( 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, "fileOpendir - 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_OPENDIR, _object );
00426
00427
00428
00429 if( !ret_err.ok() ) {
00430 return PASSMSG( "failed to call 'opendir'", ret_err );
00431 } else {
00432 return CODE( ret_err.code() );
00433 }
00434
00435 }
00436
00437
00438
00439 eirods::error fileClosedir( rsComm_t* _comm, eirods::first_class_object& _object ) {
00440
00441
00442
00443
00444
00445
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_CLOSEDIR, _object );
00459
00460
00461
00462 if( !ret_err.ok() ) {
00463 return PASSMSG( "failed to call 'closedir'", ret_err );
00464 } else {
00465 return CODE( ret_err.code() );
00466 }
00467
00468 }
00469
00470
00471
00472 eirods::error fileReaddir( rsComm_t* _comm, eirods::first_class_object& _object, struct rodsDirent** _dirent_ptr ) {
00473
00474
00475 eirods::resource_ptr resc;
00476 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00477 if( !ret_err.ok() ) {
00478 return PASSMSG( "failed to resolve resource", ret_err );
00479 }
00480
00481
00482
00483 ret_err = resc->call< struct rodsDirent** >( _comm, eirods::RESOURCE_OP_READDIR, _object, _dirent_ptr );
00484
00485
00486
00487 if( !ret_err.ok() ) {
00488 return PASSMSG( "failed to call 'readdir'", ret_err );
00489 } else {
00490 return CODE( ret_err.code() );
00491 }
00492
00493 }
00494
00495
00496
00497 eirods::error fileRename( rsComm_t* _comm,
00498 eirods::first_class_object& _object,
00499 const std::string& _new_file_name ) {
00500
00501
00502 if( _object.physical_path().empty() || _new_file_name.empty() ) {
00503 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileRename - File Name is Empty." );
00504 eirods::log( ret_err );
00505 return ret_err;
00506 }
00507
00508
00509
00510 eirods::resource_ptr resc;
00511 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00512 if( !ret_err.ok() ) {
00513 return PASSMSG( "failed to resolve resource", ret_err );
00514 }
00515
00516
00517
00518 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_RENAME, _object, _new_file_name.c_str() );
00519
00520
00521
00522 if( !ret_err.ok() ) {
00523 return PASSMSG( "failed to call 'rename'", ret_err );
00524 } else {
00525 return CODE( ret_err.code() );
00526 }
00527
00528 }
00529
00530
00531
00532 eirods::error fileGetFsFreeSpace( rsComm_t* _comm, eirods::first_class_object& _object ) {
00533
00534
00535 if( _object.physical_path().empty() ) {
00536 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileGetFsFreeSpace - File Name is Empty." );
00537 eirods::log( ret_err );
00538 return ret_err;
00539 }
00540
00541
00542
00543 eirods::resource_ptr resc;
00544 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00545 if( !ret_err.ok() ) {
00546 return PASSMSG( "failed to resolve resource", ret_err );
00547 }
00548
00549
00550
00551 ret_err = resc->call( _comm, eirods::RESOURCE_OP_FREESPACE, _object );
00552
00553
00554
00555 if( !ret_err.ok() ) {
00556 return PASSMSG( "failed to call 'stage'", ret_err );
00557 } else {
00558 return CODE( ret_err.code() );
00559 }
00560
00561 }
00562
00563
00564
00565 eirods::error fileStageToCache( rsComm_t* _comm,
00566 eirods::first_class_object& _object,
00567 const std::string& _cache_file_name ) {
00568
00569
00570 if( _cache_file_name.empty() ) {
00571 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileStageToCache - File Name is Empty." );
00572 eirods::log( ret_err );
00573 return ret_err;
00574 }
00575
00576
00577
00578 eirods::resource_ptr resc;
00579 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00580 if( !ret_err.ok() ) {
00581 return PASSMSG( "failed to resolve resource", ret_err );
00582 }
00583
00584
00585
00586 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_STAGETOCACHE, _object, _cache_file_name.c_str() );
00587
00588
00589
00590 if( !ret_err.ok() ) {
00591 return PASSMSG( "failed to call 'stagetocache'", ret_err );
00592 } else {
00593 return SUCCESS();
00594 }
00595
00596 }
00597
00598
00599
00600 eirods::error fileSyncToArch( rsComm_t* _comm,
00601 eirods::first_class_object& _object,
00602 const std::string& _cache_file_name ) {
00603
00604
00605 if( _cache_file_name.empty() ) {
00606 eirods::error ret_err = ERROR( SYS_INVALID_INPUT_PARAM, "fileSyncToArch - File Name is Empty." );
00607 eirods::log( ret_err );
00608 return ret_err;
00609 }
00610
00611
00612
00613 eirods::resource_ptr resc;
00614 eirods::error ret_err = _object.resolve( resc_mgr, resc );
00615 if( !ret_err.ok() ) {
00616 return PASSMSG( "failed to resolve resource", ret_err );
00617 }
00618
00619
00620
00621 ret_err = resc->call< const char* >( _comm, eirods::RESOURCE_OP_SYNCTOARCH, _object, _cache_file_name.c_str() );
00622
00623
00624
00625 if( !ret_err.ok() ) {
00626 return PASSMSG( "failed to call 'synctoarch'", ret_err );
00627 } else {
00628 return SUCCESS();
00629 }
00630
00631 }
00632
00633
00634 eirods::error fileRegistered(
00635 rsComm_t* _comm,
00636 eirods::first_class_object& _object )
00637 {
00638 eirods::error result = SUCCESS();
00639 eirods::error ret;
00640
00641
00642
00643 if( _object.physical_path().empty() ) {
00644 std::stringstream msg;
00645 msg << __FUNCTION__;
00646 msg << " - File name is empty.";
00647 result = ERROR(-1, msg.str());
00648 } else {
00649
00650
00651
00652 eirods::resource_ptr resc;
00653 ret = _object.resolve( resc_mgr, resc );
00654 if( !ret.ok() ) {
00655 std::stringstream msg;
00656 msg << __FUNCTION__;
00657 msg << " - Failed to resolve resource.";
00658 result = PASSMSG(msg.str(), ret);
00659 } else {
00660
00661
00662
00663 ret = resc->call( _comm, eirods::RESOURCE_OP_REGISTERED, _object );
00664 if( !ret.ok() ) {
00665 std::stringstream msg;
00666 msg << __FUNCTION__;
00667 msg << " - Failed to call registered interface.";
00668 result = PASSMSG(msg.str(), ret);
00669 }
00670 }
00671 }
00672 return result;
00673 }
00674
00675
00676 eirods::error fileUnregistered(
00677 rsComm_t* _comm,
00678 eirods::first_class_object& _object )
00679 {
00680 eirods::error result = SUCCESS();
00681 eirods::error ret;
00682
00683
00684
00685 if( _object.physical_path().empty() ) {
00686 std::stringstream msg;
00687 msg << __FUNCTION__;
00688 msg << " - File name is empty.";
00689 result = ERROR(-1, msg.str());
00690 } else {
00691
00692
00693
00694 eirods::resource_ptr resc;
00695 ret = _object.resolve( resc_mgr, resc );
00696 if( !ret.ok() ) {
00697 std::stringstream msg;
00698 msg << __FUNCTION__;
00699 msg << " - Failed to resolve resource.";
00700 result = PASSMSG(msg.str(), ret);
00701 } else {
00702
00703
00704
00705 ret = resc->call( _comm, eirods::RESOURCE_OP_UNREGISTERED, _object );
00706 if( !ret.ok() ) {
00707 std::stringstream msg;
00708 msg << __FUNCTION__;
00709 msg << " - Failed to call unregistered interface.";
00710 result = PASSMSG(msg.str(), ret);
00711 }
00712 }
00713 }
00714 return result;
00715 }
00716
00717
00718 eirods::error fileModified(
00719 rsComm_t* _comm,
00720 eirods::first_class_object& _object )
00721 {
00722 eirods::error result = SUCCESS();
00723 eirods::error ret;
00724
00725 std::string resc_hier = _object.resc_hier();
00726 if(!resc_hier.empty()) {
00727
00728
00729
00730 eirods::resource_ptr resc;
00731 ret = _object.resolve( resc_mgr, resc );
00732 if( !ret.ok() ) {
00733 std::stringstream msg;
00734 msg << __FUNCTION__;
00735 msg << " - Failed to resolve resource.";
00736 result = PASSMSG(msg.str(), ret);
00737 } else {
00738
00739
00740
00741 ret = resc->call( _comm, eirods::RESOURCE_OP_MODIFIED, _object );
00742 if( !ret.ok() ) {
00743 std::stringstream msg;
00744 msg << __FUNCTION__;
00745 msg << " - Failed to call modified interface.";
00746 result = PASSMSG(msg.str(), ret);
00747 }
00748 }
00749 } else {
00750
00751 }
00752 return result;
00753 }