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