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