http://git-wip-us.apache.org/repos/asf/airavata/blob/edfbbfe0/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp index b5d0ce3..bd093d6 100644 --- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/Airavata.cpp @@ -43574,6 +43574,1091 @@ uint32_t Airavata_getChildDataProducts_presult::read(::apache::thrift::protocol: return xfer; } + +Airavata_shareResourceWithUsers_args::~Airavata_shareResourceWithUsers_args() throw() { +} + + +uint32_t Airavata_shareResourceWithUsers_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_authzToken = false; + bool isset_resourceId = false; + bool isset_resourceType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourceId); + isset_resourceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast390; + xfer += iprot->readI32(ecast390); + this->resourceType = ( ::apache::airavata::model::group::ResourceType::type)ecast390; + isset_resourceType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->userPermissionList.clear(); + uint32_t _size391; + ::apache::thrift::protocol::TType _ktype392; + ::apache::thrift::protocol::TType _vtype393; + xfer += iprot->readMapBegin(_ktype392, _vtype393, _size391); + uint32_t _i395; + for (_i395 = 0; _i395 < _size391; ++_i395) + { + std::string _key396; + xfer += iprot->readString(_key396); + ::apache::airavata::model::group::ResourcePermissionType::type& _val397 = this->userPermissionList[_key396]; + int32_t ecast398; + xfer += iprot->readI32(ecast398); + _val397 = ( ::apache::airavata::model::group::ResourcePermissionType::type)ecast398; + } + xfer += iprot->readMapEnd(); + } + this->__isset.userPermissionList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_shareResourceWithUsers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_shareResourceWithUsers_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->resourceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->resourceType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userPermissionList", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->userPermissionList.size())); + std::map<std::string, ::apache::airavata::model::group::ResourcePermissionType::type> ::const_iterator _iter399; + for (_iter399 = this->userPermissionList.begin(); _iter399 != this->userPermissionList.end(); ++_iter399) + { + xfer += oprot->writeString(_iter399->first); + xfer += oprot->writeI32((int32_t)_iter399->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_shareResourceWithUsers_pargs::~Airavata_shareResourceWithUsers_pargs() throw() { +} + + +uint32_t Airavata_shareResourceWithUsers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_shareResourceWithUsers_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->resourceId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)(*(this->resourceType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userPermissionList", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->userPermissionList)).size())); + std::map<std::string, ::apache::airavata::model::group::ResourcePermissionType::type> ::const_iterator _iter400; + for (_iter400 = (*(this->userPermissionList)).begin(); _iter400 != (*(this->userPermissionList)).end(); ++_iter400) + { + xfer += oprot->writeString(_iter400->first); + xfer += oprot->writeI32((int32_t)_iter400->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_shareResourceWithUsers_result::~Airavata_shareResourceWithUsers_result() throw() { +} + + +uint32_t Airavata_shareResourceWithUsers_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_shareResourceWithUsers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_shareResourceWithUsers_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_shareResourceWithUsers_presult::~Airavata_shareResourceWithUsers_presult() throw() { +} + + +uint32_t Airavata_shareResourceWithUsers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_revokeSharingOfResourceFromUsers_args::~Airavata_revokeSharingOfResourceFromUsers_args() throw() { +} + + +uint32_t Airavata_revokeSharingOfResourceFromUsers_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_authzToken = false; + bool isset_resourceId = false; + bool isset_resourceType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourceId); + isset_resourceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast401; + xfer += iprot->readI32(ecast401); + this->resourceType = ( ::apache::airavata::model::group::ResourceType::type)ecast401; + isset_resourceType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->userPermissionList.clear(); + uint32_t _size402; + ::apache::thrift::protocol::TType _ktype403; + ::apache::thrift::protocol::TType _vtype404; + xfer += iprot->readMapBegin(_ktype403, _vtype404, _size402); + uint32_t _i406; + for (_i406 = 0; _i406 < _size402; ++_i406) + { + std::string _key407; + xfer += iprot->readString(_key407); + ::apache::airavata::model::group::ResourcePermissionType::type& _val408 = this->userPermissionList[_key407]; + int32_t ecast409; + xfer += iprot->readI32(ecast409); + _val408 = ( ::apache::airavata::model::group::ResourcePermissionType::type)ecast409; + } + xfer += iprot->readMapEnd(); + } + this->__isset.userPermissionList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_revokeSharingOfResourceFromUsers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_revokeSharingOfResourceFromUsers_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->resourceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->resourceType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userPermissionList", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->userPermissionList.size())); + std::map<std::string, ::apache::airavata::model::group::ResourcePermissionType::type> ::const_iterator _iter410; + for (_iter410 = this->userPermissionList.begin(); _iter410 != this->userPermissionList.end(); ++_iter410) + { + xfer += oprot->writeString(_iter410->first); + xfer += oprot->writeI32((int32_t)_iter410->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_revokeSharingOfResourceFromUsers_pargs::~Airavata_revokeSharingOfResourceFromUsers_pargs() throw() { +} + + +uint32_t Airavata_revokeSharingOfResourceFromUsers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_revokeSharingOfResourceFromUsers_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->resourceId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)(*(this->resourceType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userPermissionList", ::apache::thrift::protocol::T_MAP, 4); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>((*(this->userPermissionList)).size())); + std::map<std::string, ::apache::airavata::model::group::ResourcePermissionType::type> ::const_iterator _iter411; + for (_iter411 = (*(this->userPermissionList)).begin(); _iter411 != (*(this->userPermissionList)).end(); ++_iter411) + { + xfer += oprot->writeString(_iter411->first); + xfer += oprot->writeI32((int32_t)_iter411->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_revokeSharingOfResourceFromUsers_result::~Airavata_revokeSharingOfResourceFromUsers_result() throw() { +} + + +uint32_t Airavata_revokeSharingOfResourceFromUsers_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_revokeSharingOfResourceFromUsers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_revokeSharingOfResourceFromUsers_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_revokeSharingOfResourceFromUsers_presult::~Airavata_revokeSharingOfResourceFromUsers_presult() throw() { +} + + +uint32_t Airavata_revokeSharingOfResourceFromUsers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +Airavata_getAllAccessibleUsers_args::~Airavata_getAllAccessibleUsers_args() throw() { +} + + +uint32_t Airavata_getAllAccessibleUsers_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_authzToken = false; + bool isset_resourceId = false; + bool isset_resourceType = false; + bool isset_permissionType = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->authzToken.read(iprot); + isset_authzToken = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourceId); + isset_resourceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast412; + xfer += iprot->readI32(ecast412); + this->resourceType = ( ::apache::airavata::model::group::ResourceType::type)ecast412; + isset_resourceType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast413; + xfer += iprot->readI32(ecast413); + this->permissionType = ( ::apache::airavata::model::group::ResourcePermissionType::type)ecast413; + isset_permissionType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_authzToken) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceType) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_permissionType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getAllAccessibleUsers_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllAccessibleUsers_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->resourceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->resourceType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("permissionType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32((int32_t)this->permissionType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllAccessibleUsers_pargs::~Airavata_getAllAccessibleUsers_pargs() throw() { +} + + +uint32_t Airavata_getAllAccessibleUsers_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllAccessibleUsers_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->resourceId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceType", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)(*(this->resourceType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("permissionType", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeI32((int32_t)(*(this->permissionType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllAccessibleUsers_result::~Airavata_getAllAccessibleUsers_result() throw() { +} + + +uint32_t Airavata_getAllAccessibleUsers_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size414; + ::apache::thrift::protocol::TType _etype417; + xfer += iprot->readListBegin(_etype417, _size414); + this->success.resize(_size414); + uint32_t _i418; + for (_i418 = 0; _i418 < _size414; ++_i418) + { + xfer += iprot->readString(this->success[_i418]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Airavata_getAllAccessibleUsers_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getAllAccessibleUsers_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); + std::vector<std::string> ::const_iterator _iter419; + for (_iter419 = this->success.begin(); _iter419 != this->success.end(); ++_iter419) + { + xfer += oprot->writeString((*_iter419)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ire) { + xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->ire.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ace) { + xfer += oprot->writeFieldBegin("ace", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->ace.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ase) { + xfer += oprot->writeFieldBegin("ase", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->ase.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.ae) { + xfer += oprot->writeFieldBegin("ae", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->ae.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllAccessibleUsers_presult::~Airavata_getAllAccessibleUsers_presult() throw() { +} + + +uint32_t Airavata_getAllAccessibleUsers_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size420; + ::apache::thrift::protocol::TType _etype423; + xfer += iprot->readListBegin(_etype423, _size420); + (*(this->success)).resize(_size420); + uint32_t _i424; + for (_i424 = 0; _i424 < _size420; ++_i424) + { + xfer += iprot->readString((*(this->success))[_i424]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ire.read(iprot); + this->__isset.ire = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ace.read(iprot); + this->__isset.ace = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ase.read(iprot); + this->__isset.ase = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->ae.read(iprot); + this->__isset.ae = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + void AiravataClient::getAPIVersion(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken) { send_getAPIVersion(authzToken); @@ -45633,25 +46718,245 @@ void AiravataClient::recv_getExperimentStatistics( ::apache::airavata::model::ex if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatistics failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatistics failed: unknown result"); +} + +void AiravataClient::getExperimentsInProject(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& projectId, const int32_t limit, const int32_t offset) +{ + send_getExperimentsInProject(authzToken, projectId, limit, offset); + recv_getExperimentsInProject(_return); +} + +void AiravataClient::send_getExperimentsInProject(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& projectId, const int32_t limit, const int32_t offset) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getExperimentsInProject_pargs args; + args.authzToken = &authzToken; + args.projectId = &projectId; + args.limit = &limit; + args.offset = &offset; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getExperimentsInProject(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getExperimentsInProject") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getExperimentsInProject_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.pnfe) { + throw result.pnfe; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentsInProject failed: unknown result"); +} + +void AiravataClient::getUserExperiments(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName, const int32_t limit, const int32_t offset) +{ + send_getUserExperiments(authzToken, gatewayId, userName, limit, offset); + recv_getUserExperiments(_return); +} + +void AiravataClient::send_getUserExperiments(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName, const int32_t limit, const int32_t offset) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getUserExperiments_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.userName = &userName; + args.limit = &limit; + args.offset = &offset; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getUserExperiments(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("getUserExperiments") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getUserExperiments_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getUserExperiments failed: unknown result"); +} + +void AiravataClient::createExperiment(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +{ + send_createExperiment(authzToken, gatewayId, experiment); + recv_createExperiment(_return); +} + +void AiravataClient::send_createExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_createExperiment_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.experiment = &experiment; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_createExperiment(std::string& _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("createExperiment") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_createExperiment_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } + if (result.__isset.ae) { + throw result.ae; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createExperiment failed: unknown result"); } -void AiravataClient::getExperimentsInProject(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& projectId, const int32_t limit, const int32_t offset) +bool AiravataClient::deleteExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& experimentId) { - send_getExperimentsInProject(authzToken, projectId, limit, offset); - recv_getExperimentsInProject(_return); + send_deleteExperiment(authzToken, experimentId); + return recv_deleteExperiment(); } -void AiravataClient::send_getExperimentsInProject(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& projectId, const int32_t limit, const int32_t offset) +void AiravataClient::send_deleteExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& experimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("deleteExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getExperimentsInProject_pargs args; + Airavata_deleteExperiment_pargs args; args.authzToken = &authzToken; - args.projectId = &projectId; - args.limit = &limit; - args.offset = &offset; + args.experimentId = &experimentId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45659,7 +46964,7 @@ void AiravataClient::send_getExperimentsInProject(const ::apache::airavata::mod oprot_->getTransport()->flush(); } -void AiravataClient::recv_getExperimentsInProject(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return) +bool AiravataClient::recv_deleteExperiment() { int32_t rseqid = 0; @@ -45679,20 +46984,20 @@ void AiravataClient::recv_getExperimentsInProject(std::vector< ::apache::airavat iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getExperimentsInProject") != 0) { + if (fname.compare("deleteExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getExperimentsInProject_presult result; + bool _return; + Airavata_deleteExperiment_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); if (result.__isset.success) { - // _return pointer has now been filled - return; + return _return; } if (result.__isset.ire) { throw result.ire; @@ -45703,32 +47008,26 @@ void AiravataClient::recv_getExperimentsInProject(std::vector< ::apache::airavat if (result.__isset.ase) { throw result.ase; } - if (result.__isset.pnfe) { - throw result.pnfe; - } if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentsInProject failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteExperiment failed: unknown result"); } -void AiravataClient::getUserExperiments(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName, const int32_t limit, const int32_t offset) +void AiravataClient::getExperiment( ::apache::airavata::model::experiment::ExperimentModel& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_getUserExperiments(authzToken, gatewayId, userName, limit, offset); - recv_getUserExperiments(_return); + send_getExperiment(authzToken, airavataExperimentId); + recv_getExperiment(_return); } -void AiravataClient::send_getUserExperiments(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName, const int32_t limit, const int32_t offset) +void AiravataClient::send_getExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getUserExperiments_pargs args; + Airavata_getExperiment_pargs args; args.authzToken = &authzToken; - args.gatewayId = &gatewayId; - args.userName = &userName; - args.limit = &limit; - args.offset = &offset; + args.airavataExperimentId = &airavataExperimentId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45736,7 +47035,7 @@ void AiravataClient::send_getUserExperiments(const ::apache::airavata::model::s oprot_->getTransport()->flush(); } -void AiravataClient::recv_getUserExperiments(std::vector< ::apache::airavata::model::experiment::ExperimentModel> & _return) +void AiravataClient::recv_getExperiment( ::apache::airavata::model::experiment::ExperimentModel& _return) { int32_t rseqid = 0; @@ -45756,12 +47055,12 @@ void AiravataClient::recv_getUserExperiments(std::vector< ::apache::airavata::mo iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getUserExperiments") != 0) { + if (fname.compare("getExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getUserExperiments_presult result; + Airavata_getExperiment_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -45774,6 +47073,9 @@ void AiravataClient::recv_getUserExperiments(std::vector< ::apache::airavata::mo if (result.__isset.ire) { throw result.ire; } + if (result.__isset.enf) { + throw result.enf; + } if (result.__isset.ace) { throw result.ace; } @@ -45783,24 +47085,23 @@ void AiravataClient::recv_getUserExperiments(std::vector< ::apache::airavata::mo if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getUserExperiments failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result"); } -void AiravataClient::createExperiment(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +void AiravataClient::getDetailedExperimentTree( ::apache::airavata::model::experiment::ExperimentModel& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_createExperiment(authzToken, gatewayId, experiment); - recv_createExperiment(_return); + send_getDetailedExperimentTree(authzToken, airavataExperimentId); + recv_getDetailedExperimentTree(_return); } -void AiravataClient::send_createExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +void AiravataClient::send_getDetailedExperimentTree(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getDetailedExperimentTree", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_createExperiment_pargs args; + Airavata_getDetailedExperimentTree_pargs args; args.authzToken = &authzToken; - args.gatewayId = &gatewayId; - args.experiment = &experiment; + args.airavataExperimentId = &airavataExperimentId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45808,7 +47109,7 @@ void AiravataClient::send_createExperiment(const ::apache::airavata::model::sec oprot_->getTransport()->flush(); } -void AiravataClient::recv_createExperiment(std::string& _return) +void AiravataClient::recv_getDetailedExperimentTree( ::apache::airavata::model::experiment::ExperimentModel& _return) { int32_t rseqid = 0; @@ -45828,12 +47129,12 @@ void AiravataClient::recv_createExperiment(std::string& _return) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("createExperiment") != 0) { + if (fname.compare("getDetailedExperimentTree") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_createExperiment_presult result; + Airavata_getDetailedExperimentTree_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -45846,6 +47147,9 @@ void AiravataClient::recv_createExperiment(std::string& _return) if (result.__isset.ire) { throw result.ire; } + if (result.__isset.enf) { + throw result.enf; + } if (result.__isset.ace) { throw result.ace; } @@ -45855,23 +47159,24 @@ void AiravataClient::recv_createExperiment(std::string& _return) if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createExperiment failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getDetailedExperimentTree failed: unknown result"); } -bool AiravataClient::deleteExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& experimentId) +void AiravataClient::updateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) { - send_deleteExperiment(authzToken, experimentId); - return recv_deleteExperiment(); + send_updateExperiment(authzToken, airavataExperimentId, experiment); + recv_updateExperiment(); } -void AiravataClient::send_deleteExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& experimentId) +void AiravataClient::send_updateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) { int32_t cseqid = 0; - oprot_->writeMessageBegin("deleteExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_deleteExperiment_pargs args; + Airavata_updateExperiment_pargs args; args.authzToken = &authzToken; - args.experimentId = &experimentId; + args.airavataExperimentId = &airavataExperimentId; + args.experiment = &experiment; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45879,7 +47184,7 @@ void AiravataClient::send_deleteExperiment(const ::apache::airavata::model::sec oprot_->getTransport()->flush(); } -bool AiravataClient::recv_deleteExperiment() +void AiravataClient::recv_updateExperiment() { int32_t rseqid = 0; @@ -45899,24 +47204,22 @@ bool AiravataClient::recv_deleteExperiment() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("deleteExperiment") != 0) { + if (fname.compare("updateExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - bool _return; - Airavata_deleteExperiment_presult result; - result.success = &_return; + Airavata_updateExperiment_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - return _return; - } if (result.__isset.ire) { throw result.ire; } + if (result.__isset.enf) { + throw result.enf; + } if (result.__isset.ace) { throw result.ace; } @@ -45926,23 +47229,24 @@ bool AiravataClient::recv_deleteExperiment() if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteExperiment failed: unknown result"); + return; } -void AiravataClient::getExperiment( ::apache::airavata::model::experiment::ExperimentModel& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::updateExperimentConfiguration(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::UserConfigurationDataModel& userConfiguration) { - send_getExperiment(authzToken, airavataExperimentId); - recv_getExperiment(_return); + send_updateExperimentConfiguration(authzToken, airavataExperimentId, userConfiguration); + recv_updateExperimentConfiguration(); } -void AiravataClient::send_getExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_updateExperimentConfiguration(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::UserConfigurationDataModel& userConfiguration) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getExperiment_pargs args; + Airavata_updateExperimentConfiguration_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; + args.userConfiguration = &userConfiguration; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45950,7 +47254,7 @@ void AiravataClient::send_getExperiment(const ::apache::airavata::model::securi oprot_->getTransport()->flush(); } -void AiravataClient::recv_getExperiment( ::apache::airavata::model::experiment::ExperimentModel& _return) +void AiravataClient::recv_updateExperimentConfiguration() { int32_t rseqid = 0; @@ -45970,53 +47274,37 @@ void AiravataClient::recv_getExperiment( ::apache::airavata::model::experiment:: iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getExperiment") != 0) { + if (fname.compare("updateExperimentConfiguration") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getExperiment_presult result; - result.success = &_return; + Airavata_updateExperimentConfiguration_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - return; - } - if (result.__isset.ire) { - throw result.ire; - } - if (result.__isset.enf) { - throw result.enf; - } - if (result.__isset.ace) { - throw result.ace; - } - if (result.__isset.ase) { - throw result.ase; - } if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result"); + return; } -void AiravataClient::getDetailedExperimentTree( ::apache::airavata::model::experiment::ExperimentModel& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::updateResourceScheduleing(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::scheduling::ComputationalResourceSchedulingModel& resourceScheduling) { - send_getDetailedExperimentTree(authzToken, airavataExperimentId); - recv_getDetailedExperimentTree(_return); + send_updateResourceScheduleing(authzToken, airavataExperimentId, resourceScheduling); + recv_updateResourceScheduleing(); } -void AiravataClient::send_getDetailedExperimentTree(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_updateResourceScheduleing(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::scheduling::ComputationalResourceSchedulingModel& resourceScheduling) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getDetailedExperimentTree", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateResourceScheduleing", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getDetailedExperimentTree_pargs args; + Airavata_updateResourceScheduleing_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; + args.resourceScheduling = &resourceScheduling; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46024,7 +47312,7 @@ void AiravataClient::send_getDetailedExperimentTree(const ::apache::airavata::m oprot_->getTransport()->flush(); } -void AiravataClient::recv_getDetailedExperimentTree( ::apache::airavata::model::experiment::ExperimentModel& _return) +void AiravataClient::recv_updateResourceScheduleing() { int32_t rseqid = 0; @@ -46044,54 +47332,36 @@ void AiravataClient::recv_getDetailedExperimentTree( ::apache::airavata::model:: iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getDetailedExperimentTree") != 0) { + if (fname.compare("updateResourceScheduleing") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getDetailedExperimentTree_presult result; - result.success = &_return; + Airavata_updateResourceScheduleing_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - return; - } - if (result.__isset.ire) { - throw result.ire; - } - if (result.__isset.enf) { - throw result.enf; - } - if (result.__isset.ace) { - throw result.ace; - } - if (result.__isset.ase) { - throw result.ase; - } if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getDetailedExperimentTree failed: unknown result"); + return; } -void AiravataClient::updateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +bool AiravataClient::validateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_updateExperiment(authzToken, airavataExperimentId, experiment); - recv_updateExperiment(); + send_validateExperiment(authzToken, airavataExperimentId); + return recv_validateExperiment(); } -void AiravataClient::send_updateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::ExperimentModel& experiment) +void AiravataClient::send_validateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("validateExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_updateExperiment_pargs args; + Airavata_validateExperiment_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; - args.experiment = &experiment; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46099,7 +47369,7 @@ void AiravataClient::send_updateExperiment(const ::apache::airavata::model::sec oprot_->getTransport()->flush(); } -void AiravataClient::recv_updateExperiment() +bool AiravataClient::recv_validateExperiment() { int32_t rseqid = 0; @@ -46119,16 +47389,21 @@ void AiravataClient::recv_updateExperiment() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("updateExperiment") != 0) { + if (fname.compare("validateExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_updateExperiment_presult result; + bool _return; + Airavata_validateExperiment_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.success) { + return _return; + } if (result.__isset.ire) { throw result.ire; } @@ -46144,24 +47419,24 @@ void AiravataClient::recv_updateExperiment() if (result.__isset.ae) { throw result.ae; } - return; + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateExperiment failed: unknown result"); } -void AiravataClient::updateExperimentConfiguration(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::UserConfigurationDataModel& userConfiguration) +void AiravataClient::launchExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) { - send_updateExperimentConfiguration(authzToken, airavataExperimentId, userConfiguration); - recv_updateExperimentConfiguration(); + send_launchExperiment(authzToken, airavataExperimentId, gatewayId); + recv_launchExperiment(); } -void AiravataClient::send_updateExperimentConfiguration(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::experiment::UserConfigurationDataModel& userConfiguration) +void AiravataClient::send_launchExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("launchExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_updateExperimentConfiguration_pargs args; + Airavata_launchExperiment_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; - args.userConfiguration = &userConfiguration; + args.gatewayId = &gatewayId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46169,7 +47444,7 @@ void AiravataClient::send_updateExperimentConfiguration(const ::apache::airavat oprot_->getTransport()->flush(); } -void AiravataClient::recv_updateExperimentConfiguration() +void AiravataClient::recv_launchExperiment() { int32_t rseqid = 0; @@ -46189,37 +47464,48 @@ void AiravataClient::recv_updateExperimentConfiguration() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("updateExperimentConfiguration") != 0) { + if (fname.compare("launchExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_updateExperimentConfiguration_presult result; + Airavata_launchExperiment_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.enf) { + throw result.enf; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } if (result.__isset.ae) { throw result.ae; } return; } -void AiravataClient::updateResourceScheduleing(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::scheduling::ComputationalResourceSchedulingModel& resourceScheduling) +void AiravataClient::getExperimentStatus( ::apache::airavata::model::status::ExperimentStatus& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_updateResourceScheduleing(authzToken, airavataExperimentId, resourceScheduling); - recv_updateResourceScheduleing(); + send_getExperimentStatus(authzToken, airavataExperimentId); + recv_getExperimentStatus(_return); } -void AiravataClient::send_updateResourceScheduleing(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const ::apache::airavata::model::scheduling::ComputationalResourceSchedulingModel& resourceScheduling) +void AiravataClient::send_getExperimentStatus(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("updateResourceScheduleing", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getExperimentStatus", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_updateResourceScheduleing_pargs args; + Airavata_getExperimentStatus_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; - args.resourceScheduling = &resourceScheduling; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46227,7 +47513,7 @@ void AiravataClient::send_updateResourceScheduleing(const ::apache::airavata::m oprot_->getTransport()->flush(); } -void AiravataClient::recv_updateResourceScheduleing() +void AiravataClient::recv_getExperimentStatus( ::apache::airavata::model::status::ExperimentStatus& _return) { int32_t rseqid = 0; @@ -46247,34 +47533,51 @@ void AiravataClient::recv_updateResourceScheduleing() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("updateResourceScheduleing") != 0) { + if (fname.compare("getExperimentStatus") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_updateResourceScheduleing_presult result; + Airavata_getExperimentStatus_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.ire) { + throw result.ire; + } + if (result.__isset.enf) { + throw result.enf; + } + if (result.__isset.ace) { + throw result.ace; + } + if (result.__isset.ase) { + throw result.ase; + } if (result.__isset.ae) { throw result.ae; } - return; + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatus failed: unknown result"); } -bool AiravataClient::validateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::getExperimentOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_validateExperiment(authzToken, airavataExperimentId); - return recv_validateExperiment(); + send_getExperimentOutputs(authzToken, airavataExperimentId); + recv_getExperimentOutputs(_return); } -void AiravataClient::send_validateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_getExperimentOutputs(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("validateExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getExperimentOutputs", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_validateExperiment_pargs args; + Airavata_getExperimentOutputs_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; args.write(oprot_); @@ -46284,7 +47587,7 @@ void AiravataClient::send_validateExperiment(const ::apache::airavata::model::s oprot_->getTransport()->flush(); } -bool AiravataClient::recv_validateExperiment() +void AiravataClient::recv_getExperimentOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return) { int32_t rseqid = 0; @@ -46304,20 +47607,20 @@ bool AiravataClient::recv_validateExperiment() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("validateExperiment") != 0) { + if (fname.compare("getExperimentOutputs") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - bool _return; - Airavata_validateExperiment_presult result; + Airavata_getExperimentOutputs_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); if (result.__isset.success) { - return _return; + // _return pointer has now been filled + return; } if (result.__isset.ire) { throw result.ire; @@ -46334,24 +47637,23 @@ bool AiravataClient::recv_validateExperiment() if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateExperiment failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentOutputs failed: unknown result"); } -void AiravataClient::launchExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) +void AiravataClient::getIntermediateOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_launchExperiment(authzToken, airavataExperimentId, gatewayId); - recv_launchExperiment(); + send_getIntermediateOutputs(authzToken, airavataExperimentId); + recv_getIntermediateOutputs(_return); } -void AiravataClient::send_launchExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) +void AiravataClient::send_getIntermediateOutputs(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("launchExperiment", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getIntermediateOutputs", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_launchExperiment_pargs args; + Airavata_getIntermediateOutputs_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; - args.gatewayId = &gatewayId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46359,7 +47661,7 @@ void AiravataClient::send_launchExperiment(const ::apache::airavata::model::sec oprot_->getTransport()->flush(); } -void AiravataClient::recv_launchExperiment() +void AiravataClient::recv_getIntermediateOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return) { int32_t rseqid = 0; @@ -46379,16 +47681,21 @@ void AiravataClient::recv_launchExperiment() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("launchExperiment") != 0) { + if (fname.compare("getIntermediateOutputs") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_launchExperiment_presult result; + Airavata_getIntermediateOutputs_presult result; + result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); + if (result.__isset.success) { + // _return pointer has now been filled + return; + } if (result.__isset.ire) { throw result.ire; } @@ -46404,21 +47711,21 @@ void AiravataClient::recv_launchExperiment() if (result.__isset.ae) { throw result.ae; } - return; + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getIntermediateOutputs failed: unknown result"); } -void AiravataClient::getExperimentStatus( ::apache::airavata::model::status::ExperimentStatus& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::getJobStatuses(std::map<std::string, ::apache::airavata::model::status::JobStatus> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_getExperimentStatus(authzToken, airavataExperimentId); - recv_getExperimentStatus(_return); + send_getJobStatuses(authzToken, airavataExperimentId); + recv_getJobStatuses(_return); } -void AiravataClient::send_getExperimentStatus(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_getJobStatuses(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getExperimentStatus", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getExperimentStatus_pargs args; + Airavata_getJobStatuses_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; args.write(oprot_); @@ -46428,7 +47735,7 @@ void AiravataClient::send_getExperimentStatus(const ::apache::airavata::model:: oprot_->getTransport()->flush(); } -void AiravataClient::recv_getExperimentStatus( ::apache::airavata::model::status::ExperimentStatus& _return) +void AiravataClient::recv_getJobStatuses(std::map<std::string, ::apache::airavata::model::status::JobStatus> & _return) { int32_t rseqid = 0; @@ -46448,12 +47755,12 @@ void AiravataClient::recv_getExperimentStatus( ::apache::airavata::model::status iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getExperimentStatus") != 0) { + if (fname.compare("getJobStatuses") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getExperimentStatus_presult result; + Airavata_getJobStatuses_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -46478,21 +47785,21 @@ void AiravataClient::recv_getExperimentStatus( ::apache::airavata::model::status if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatus failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getJobStatuses failed: unknown result"); } -void AiravataClient::getExperimentOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::getJobDetails(std::vector< ::apache::airavata::model::job::JobModel> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { - send_getExperimentOutputs(authzToken, airavataExperimentId); - recv_getExperimentOutputs(_return); + send_getJobDetails(authzToken, airavataExperimentId); + recv_getJobDetails(_return); } -void AiravataClient::send_getExperimentOutputs(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_getJobDetails(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getExperimentOutputs", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getJobDetails", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getExperimentOutputs_pargs args; + Airavata_getJobDetails_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; args.write(oprot_); @@ -46502,7 +47809,7 @@ void AiravataClient::send_getExperimentOutputs(const ::apache::airavata::model: oprot_->getTransport()->flush(); } -void AiravataClient::recv_getExperimentOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return) +void AiravataClient::recv_getJobDetails(std::vector< ::apache::airavata::model::job::JobModel> & _return) { int32_t rseqid = 0; @@ -46522,12 +47829,12 @@ void AiravataClient::recv_getExperimentOutputs(std::vector< ::apache::airavata:: iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getExperimentOutputs") != 0) { + if (fname.compare("getJobDetails") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getExperimentOutputs_presult result; + Airavata_getJobDetails_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -46552,23 +47859,24 @@ void AiravataClient::recv_getExperimentOutputs(std::vector< ::apache::airavata:: if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentOutputs failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getJobDetails failed: unknown result"); } -void AiravataClient::getIntermediateOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::cloneExperiment(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& existingExperimentID, const std::string& newExperimentName) { - send_getIntermediateOutputs(authzToken, airavataExperimentId); - recv_getIntermediateOutputs(_return); + send_cloneExperiment(authzToken, existingExperimentID, newExperimentName); + recv_cloneExperiment(_return); } -void AiravataClient::send_getIntermediateOutputs(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_cloneExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& existingExperimentID, const std::string& newExperimentName) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getIntermediateOutputs", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("cloneExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getIntermediateOutputs_pargs args; + Airavata_cloneExperiment_pargs args; args.authzToken = &authzToken; - args.airavataExperimentId = &airavataExperimentId; + args.existingExperimentID = &existingExperimentID; + args.newExperimentName = &newExperimentName; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46576,7 +47884,7 @@ void AiravataClient::send_getIntermediateOutputs(const ::apache::airavata::mode oprot_->getTransport()->flush(); } -void AiravataClient::recv_getIntermediateOutputs(std::vector< ::apache::airavata::model::application::io::OutputDataObjectType> & _return) +void AiravataClient::recv_cloneExperiment(std::string& _return) { int32_t rseqid = 0; @@ -46596,12 +47904,12 @@ void AiravataClient::recv_getIntermediateOutputs(std::vector< ::apache::airavata iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getIntermediateOutputs") != 0) { + if (fname.compare("cloneExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getIntermediateOutputs_presult result; + Airavata_cloneExperiment_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -46626,23 +47934,24 @@ void AiravataClient::recv_getIntermediateOutputs(std::vector< ::apache::airavata if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getIntermediateOutputs failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "cloneExperiment failed: unknown result"); } -void AiravataClient::getJobStatuses(std::map<std::string, ::apache::airavata::model::status::JobStatus> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::terminateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) { - send_getJobStatuses(authzToken, airavataExperimentId); - recv_getJobStatuses(_return); + send_terminateExperiment(authzToken, airavataExperimentId, gatewayId); + recv_terminateExperiment(); } -void AiravataClient::send_getJobStatuses(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId) +void AiravataClient::send_terminateExperiment(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataExperimentId, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getJobStatuses", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("terminateExperiment", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getJobStatuses_pargs args; + Airavata_terminateExperiment_pargs args; args.authzToken = &authzToken; args.airavataExperimentId = &airavataExperimentId; + args.gatewayId = &gatewayId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -46650,7 +47959,7 @@ void AiravataClient::send_getJobStatuses(const ::apache::airavata::model::secur oprot_->getTransport()->flush(); } -void AiravataClient::recv_getJobStatuses(std::map<std::string, ::apache::airavata::model::status::JobStatus> & _return) +void AiravataClient::recv_terminateExperiment() { int32_t rseqid = 0; @@ -46670,21 +47979,16 @@ void AiravataClient::recv_getJobStatuses(std::map<std::string, ::apache::airava iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getJobStatuses") != 0) { + if (fname.compare("terminateExperiment") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getJobStatuses_presult result; - result.success = &_return; + Airavata_terminateExperiment_presult result; result.read(iprot_); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); - if (result.__isset.success) { - // _return pointer has now been filled - return; - } if (result.__isset.ire) { throw result.ire; } @@ -46700,23 +48004,24 @@ void AiravataClient::recv_getJobStatuses(std::map<std::string, ::apache::airava if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException
<TRUNCATED>
