http://git-wip-us.apache.org/repos/asf/airavata/blob/171ee0c2/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 bd093d6..97f056b 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 @@ -44659,19 +44659,1839 @@ uint32_t Airavata_getAllAccessibleUsers_presult::read(::apache::thrift::protocol return xfer; } + +Airavata_createGroup_args::~Airavata_createGroup_args() throw() { +} + + +uint32_t Airavata_createGroup_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_groupModel = 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_STRUCT) { + xfer += this->groupModel.read(iprot); + isset_groupModel = 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_groupModel) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_createGroup_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_createGroup_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupModel", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->groupModel.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_createGroup_pargs::~Airavata_createGroup_pargs() throw() { +} + + +uint32_t Airavata_createGroup_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_createGroup_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupModel", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->groupModel)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_createGroup_result::~Airavata_createGroup_result() throw() { +} + + +uint32_t Airavata_createGroup_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_createGroup_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_createGroup_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_createGroup_presult::~Airavata_createGroup_presult() throw() { +} + + +uint32_t Airavata_createGroup_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_updateGroup_args::~Airavata_updateGroup_args() throw() { +} + + +uint32_t Airavata_updateGroup_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_groupModel = 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_STRUCT) { + xfer += this->groupModel.read(iprot); + isset_groupModel = 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_groupModel) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_updateGroup_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_updateGroup_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupModel", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->groupModel.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_updateGroup_pargs::~Airavata_updateGroup_pargs() throw() { +} + + +uint32_t Airavata_updateGroup_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_updateGroup_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupModel", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += (*(this->groupModel)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_updateGroup_result::~Airavata_updateGroup_result() throw() { +} + + +uint32_t Airavata_updateGroup_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_updateGroup_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_updateGroup_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_updateGroup_presult::~Airavata_updateGroup_presult() throw() { +} + + +uint32_t Airavata_updateGroup_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_deleteGroup_args::~Airavata_deleteGroup_args() throw() { +} + + +uint32_t Airavata_deleteGroup_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_groupId = false; + bool isset_ownerId = false; + bool isset_gatewayId = 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->groupId); + isset_groupId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->ownerId); + isset_ownerId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = 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_groupId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_ownerId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_deleteGroup_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_deleteGroup_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->groupId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->ownerId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_deleteGroup_pargs::~Airavata_deleteGroup_pargs() throw() { +} + + +uint32_t Airavata_deleteGroup_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_deleteGroup_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->groupId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ownerId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->ownerId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_deleteGroup_result::~Airavata_deleteGroup_result() throw() { +} + + +uint32_t Airavata_deleteGroup_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_deleteGroup_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_deleteGroup_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_deleteGroup_presult::~Airavata_deleteGroup_presult() throw() { +} + + +uint32_t Airavata_deleteGroup_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_getGroup_args::~Airavata_getGroup_args() throw() { +} + + +uint32_t Airavata_getGroup_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_groupId = 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->groupId); + isset_groupId = 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_groupId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getGroup_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getGroup_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->groupId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getGroup_pargs::~Airavata_getGroup_pargs() throw() { +} + + +uint32_t Airavata_getGroup_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getGroup_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("groupId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->groupId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getGroup_result::~Airavata_getGroup_result() throw() { +} + + +uint32_t Airavata_getGroup_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_STRUCT) { + xfer += this->success.read(iprot); + 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_getGroup_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getGroup_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0); + xfer += this->success.write(oprot); + 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_getGroup_presult::~Airavata_getGroup_presult() throw() { +} + + +uint32_t Airavata_getGroup_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_STRUCT) { + xfer += (*(this->success)).read(iprot); + 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_getAllGroupsUserBelongs_args::~Airavata_getAllGroupsUserBelongs_args() throw() { +} + + +uint32_t Airavata_getAllGroupsUserBelongs_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_userName = false; + bool isset_gatewayId = 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->userName); + isset_userName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->gatewayId); + isset_gatewayId = 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_userName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gatewayId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t Airavata_getAllGroupsUserBelongs_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllGroupsUserBelongs_args"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->authzToken.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->userName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->gatewayId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllGroupsUserBelongs_pargs::~Airavata_getAllGroupsUserBelongs_pargs() throw() { +} + + +uint32_t Airavata_getAllGroupsUserBelongs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Airavata_getAllGroupsUserBelongs_pargs"); + + xfer += oprot->writeFieldBegin("authzToken", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->authzToken)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("userName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->userName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gatewayId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->gatewayId))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +Airavata_getAllGroupsUserBelongs_result::~Airavata_getAllGroupsUserBelongs_result() throw() { +} + + +uint32_t Airavata_getAllGroupsUserBelongs_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 _size425; + ::apache::thrift::protocol::TType _etype428; + xfer += iprot->readListBegin(_etype428, _size425); + this->success.resize(_size425); + uint32_t _i429; + for (_i429 = 0; _i429 < _size425; ++_i429) + { + xfer += this->success[_i429].read(iprot); + } + 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_getAllGroupsUserBelongs_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("Airavata_getAllGroupsUserBelongs_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); + std::vector< ::apache::airavata::model::group::GroupModel> ::const_iterator _iter430; + for (_iter430 = this->success.begin(); _iter430 != this->success.end(); ++_iter430) + { + xfer += (*_iter430).write(oprot); + } + 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_getAllGroupsUserBelongs_presult::~Airavata_getAllGroupsUserBelongs_presult() throw() { +} + + +uint32_t Airavata_getAllGroupsUserBelongs_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 _size431; + ::apache::thrift::protocol::TType _etype434; + xfer += iprot->readListBegin(_etype434, _size431); + (*(this->success)).resize(_size431); + uint32_t _i435; + for (_i435 = 0; _i435 < _size431; ++_i435) + { + xfer += (*(this->success))[_i435].read(iprot); + } + 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); - recv_getAPIVersion(_return); + send_getAPIVersion(authzToken); + recv_getAPIVersion(_return); +} + +void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::security::AuthzToken& authzToken) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getAPIVersion_pargs args; + args.authzToken = &authzToken; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getAPIVersion(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("getAPIVersion") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getAPIVersion_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, "getAPIVersion failed: unknown result"); +} + +bool AiravataClient::isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +{ + send_isUserExists(authzToken, gatewayId, userName); + return recv_isUserExists(); +} + +void AiravataClient::send_isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("isUserExists", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_isUserExists_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.userName = &userName; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_isUserExists() +{ + + 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("isUserExists") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + Airavata_isUserExists_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; + } + 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, "isUserExists failed: unknown result"); +} + +void AiravataClient::addGateway(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +{ + send_addGateway(authzToken, gateway); + recv_addGateway(_return); +} + +void AiravataClient::send_addGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("addGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_addGateway_pargs args; + args.authzToken = &authzToken; + args.gateway = &gateway; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_addGateway(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("addGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_addGateway_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, "addGateway failed: unknown result"); +} + +void AiravataClient::getAllUsersInGateway(std::vector<std::string> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + send_getAllUsersInGateway(authzToken, gatewayId); + recv_getAllUsersInGateway(_return); +} + +void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getAllUsersInGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getAllUsersInGateway_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getAllUsersInGateway(std::vector<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("getAllUsersInGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getAllUsersInGateway_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, "getAllUsersInGateway failed: unknown result"); +} + +void AiravataClient::updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) +{ + send_updateGateway(authzToken, gatewayId, updatedGateway); + recv_updateGateway(); } -void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::security::AuthzToken& authzToken) +void AiravataClient::send_updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("updateGateway", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getAPIVersion_pargs args; + Airavata_updateGateway_pargs args; args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.updatedGateway = &updatedGateway; args.write(oprot_); oprot_->writeMessageEnd(); @@ -44679,7 +46499,7 @@ void AiravataClient::send_getAPIVersion(const ::apache::airavata::model::securi oprot_->getTransport()->flush(); } -void AiravataClient::recv_getAPIVersion(std::string& _return) +void AiravataClient::recv_updateGateway() { int32_t rseqid = 0; @@ -44699,12 +46519,78 @@ void AiravataClient::recv_getAPIVersion(std::string& _return) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getAPIVersion") != 0) { + if (fname.compare("updateGateway") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getAPIVersion_presult result; + Airavata_updateGateway_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + 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; + } + return; +} + +void AiravataClient::getGateway( ::apache::airavata::model::workspace::Gateway& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + send_getGateway(authzToken, gatewayId); + recv_getGateway(_return); +} + +void AiravataClient::send_getGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getGateway", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getGateway_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getGateway( ::apache::airavata::model::workspace::Gateway& _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("getGateway") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getGateway_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -44726,24 +46612,23 @@ void AiravataClient::recv_getAPIVersion(std::string& _return) if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getGateway failed: unknown result"); } -bool AiravataClient::isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +bool AiravataClient::deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { - send_isUserExists(authzToken, gatewayId, userName); - return recv_isUserExists(); + send_deleteGateway(authzToken, gatewayId); + return recv_deleteGateway(); } -void AiravataClient::send_isUserExists(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) +void AiravataClient::send_deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("isUserExists", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("deleteGateway", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_isUserExists_pargs args; + Airavata_deleteGateway_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; - args.userName = &userName; args.write(oprot_); oprot_->writeMessageEnd(); @@ -44751,7 +46636,7 @@ void AiravataClient::send_isUserExists(const ::apache::airavata::model::securit oprot_->getTransport()->flush(); } -bool AiravataClient::recv_isUserExists() +bool AiravataClient::recv_deleteGateway() { int32_t rseqid = 0; @@ -44771,13 +46656,13 @@ bool AiravataClient::recv_isUserExists() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("isUserExists") != 0) { + if (fname.compare("deleteGateway") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } bool _return; - Airavata_isUserExists_presult result; + Airavata_deleteGateway_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -44798,23 +46683,22 @@ bool AiravataClient::recv_isUserExists() if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isUserExists failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteGateway failed: unknown result"); } -void AiravataClient::addGateway(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +void AiravataClient::getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken) { - send_addGateway(authzToken, gateway); - recv_addGateway(_return); + send_getAllGateways(authzToken); + recv_getAllGateways(_return); } -void AiravataClient::send_addGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Gateway& gateway) +void AiravataClient::send_getAllGateways(const ::apache::airavata::model::security::AuthzToken& authzToken) { int32_t cseqid = 0; - oprot_->writeMessageBegin("addGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getAllGateways", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_addGateway_pargs args; + Airavata_getAllGateways_pargs args; args.authzToken = &authzToken; - args.gateway = &gateway; args.write(oprot_); oprot_->writeMessageEnd(); @@ -44822,7 +46706,7 @@ void AiravataClient::send_addGateway(const ::apache::airavata::model::security: oprot_->getTransport()->flush(); } -void AiravataClient::recv_addGateway(std::string& _return) +void AiravataClient::recv_getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) { int32_t rseqid = 0; @@ -44842,12 +46726,369 @@ void AiravataClient::recv_addGateway(std::string& _return) iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("addGateway") != 0) { + if (fname.compare("getAllGateways") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_addGateway_presult result; + Airavata_getAllGateways_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, "getAllGateways failed: unknown result"); +} + +bool AiravataClient::isGatewayExist(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + send_isGatewayExist(authzToken, gatewayId); + return recv_isGatewayExist(); +} + +void AiravataClient::send_isGatewayExist(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("isGatewayExist", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_isGatewayExist_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_isGatewayExist() +{ + + 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("isGatewayExist") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + Airavata_isGatewayExist_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; + } + 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, "isGatewayExist failed: unknown result"); +} + +void AiravataClient::createNotification(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + send_createNotification(authzToken, notification); + recv_createNotification(_return); +} + +void AiravataClient::send_createNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("createNotification", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_createNotification_pargs args; + args.authzToken = &authzToken; + args.notification = ¬ification; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_createNotification(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("createNotification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_createNotification_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, "createNotification failed: unknown result"); +} + +bool AiravataClient::updateNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + send_updateNotification(authzToken, notification); + return recv_updateNotification(); +} + +void AiravataClient::send_updateNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const ::apache::airavata::model::workspace::Notification& notification) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("updateNotification", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_updateNotification_pargs args; + args.authzToken = &authzToken; + args.notification = ¬ification; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_updateNotification() +{ + + 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("updateNotification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + Airavata_updateNotification_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; + } + 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, "updateNotification failed: unknown result"); +} + +bool AiravataClient::deleteNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& notificationId) +{ + send_deleteNotification(authzToken, gatewayId, notificationId); + return recv_deleteNotification(); +} + +void AiravataClient::send_deleteNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& notificationId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("deleteNotification", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_deleteNotification_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.notificationId = ¬ificationId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool AiravataClient::recv_deleteNotification() +{ + + 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("deleteNotification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + Airavata_deleteNotification_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; + } + 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, "deleteNotification failed: unknown result"); +} + +void AiravataClient::getNotification( ::apache::airavata::model::workspace::Notification& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& notificationId) +{ + send_getNotification(authzToken, gatewayId, notificationId); + recv_getNotification(_return); +} + +void AiravataClient::send_getNotification(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& notificationId) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("getNotification", ::apache::thrift::protocol::T_CALL, cseqid); + + Airavata_getNotification_pargs args; + args.authzToken = &authzToken; + args.gatewayId = &gatewayId; + args.notificationId = ¬ificationId; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void AiravataClient::recv_getNotification( ::apache::airavata::model::workspace::Notification& _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("getNotification") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + Airavata_getNotification_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -44869,21 +47110,21 @@ void AiravataClient::recv_addGateway(std::string& _return) if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "addGateway failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getNotification failed: unknown result"); } -void AiravataClient::getAllUsersInGateway(std::vector<std::string> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::getAllNotifications(std::vector< ::apache::airavata::model::workspace::Notification> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { - send_getAllUsersInGateway(authzToken, gatewayId); - recv_getAllUsersInGateway(_return); + send_getAllNotifications(authzToken, gatewayId); + recv_getAllNotifications(_return); } -void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::send_getAllNotifications(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getAllUsersInGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getAllNotifications", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getAllUsersInGateway_pargs args; + Airavata_getAllNotifications_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; args.write(oprot_); @@ -44893,7 +47134,7 @@ void AiravataClient::send_getAllUsersInGateway(const ::apache::airavata::model: oprot_->getTransport()->flush(); } -void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _return) +void AiravataClient::recv_getAllNotifications(std::vector< ::apache::airavata::model::workspace::Notification> & _return) { int32_t rseqid = 0; @@ -44913,12 +47154,12 @@ void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _retur iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getAllUsersInGateway") != 0) { + if (fname.compare("getAllNotifications") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getAllUsersInGateway_presult result; + Airavata_getAllNotifications_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -44940,90 +47181,24 @@ void AiravataClient::recv_getAllUsersInGateway(std::vector<std::string> & _retur if (result.__isset.ae) { throw result.ae; } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUsersInGateway failed: unknown result"); -} - -void AiravataClient::updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) -{ - send_updateGateway(authzToken, gatewayId, updatedGateway); - recv_updateGateway(); -} - -void AiravataClient::send_updateGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const ::apache::airavata::model::workspace::Gateway& updatedGateway) -{ - int32_t cseqid = 0; - oprot_->writeMessageBegin("updateGateway", ::apache::thrift::protocol::T_CALL, cseqid); - - Airavata_updateGateway_pargs args; - args.authzToken = &authzToken; - args.gatewayId = &gatewayId; - args.updatedGateway = &updatedGateway; - args.write(oprot_); - - oprot_->writeMessageEnd(); - oprot_->getTransport()->writeEnd(); - oprot_->getTransport()->flush(); -} - -void AiravataClient::recv_updateGateway() -{ - - 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("updateGateway") != 0) { - iprot_->skip(::apache::thrift::protocol::T_STRUCT); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - } - Airavata_updateGateway_presult result; - result.read(iprot_); - iprot_->readMessageEnd(); - iprot_->getTransport()->readEnd(); - - 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; - } - return; + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllNotifications failed: unknown result"); } -void AiravataClient::getGateway( ::apache::airavata::model::workspace::Gateway& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::generateAndRegisterSSHKeys(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) { - send_getGateway(authzToken, gatewayId); - recv_getGateway(_return); + send_generateAndRegisterSSHKeys(authzToken, gatewayId, userName); + recv_generateAndRegisterSSHKeys(_return); } -void AiravataClient::send_getGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::send_generateAndRegisterSSHKeys(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& userName) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("generateAndRegisterSSHKeys", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getGateway_pargs args; + Airavata_generateAndRegisterSSHKeys_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; + args.userName = &userName; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45031,7 +47206,7 @@ void AiravataClient::send_getGateway(const ::apache::airavata::model::security: oprot_->getTransport()->flush(); } -void AiravataClient::recv_getGateway( ::apache::airavata::model::workspace::Gateway& _return) +void AiravataClient::recv_generateAndRegisterSSHKeys(std::string& _return) { int32_t rseqid = 0; @@ -45051,12 +47226,12 @@ void AiravataClient::recv_getGateway( ::apache::airavata::model::workspace::Gate iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getGateway") != 0) { + if (fname.compare("generateAndRegisterSSHKeys") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getGateway_presult result; + Airavata_generateAndRegisterSSHKeys_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -45075,26 +47250,27 @@ void AiravataClient::recv_getGateway( ::apache::airavata::model::workspace::Gate if (result.__isset.ase) { throw result.ase; } - if (result.__isset.ae) { - throw result.ae; - } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getGateway failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "generateAndRegisterSSHKeys failed: unknown result"); } -bool AiravataClient::deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::registerPwdCredential(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& portalUserName, const std::string& loginUserName, const std::string& password, const std::string& description) { - send_deleteGateway(authzToken, gatewayId); - return recv_deleteGateway(); + send_registerPwdCredential(authzToken, gatewayId, portalUserName, loginUserName, password, description); + recv_registerPwdCredential(_return); } -void AiravataClient::send_deleteGateway(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::send_registerPwdCredential(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId, const std::string& portalUserName, const std::string& loginUserName, const std::string& password, const std::string& description) { int32_t cseqid = 0; - oprot_->writeMessageBegin("deleteGateway", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("registerPwdCredential", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_deleteGateway_pargs args; + Airavata_registerPwdCredential_pargs args; args.authzToken = &authzToken; args.gatewayId = &gatewayId; + args.portalUserName = &portalUserName; + args.loginUserName = &loginUserName; + args.password = &password; + args.description = &description; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45102,7 +47278,7 @@ void AiravataClient::send_deleteGateway(const ::apache::airavata::model::securi oprot_->getTransport()->flush(); } -bool AiravataClient::recv_deleteGateway() +void AiravataClient::recv_registerPwdCredential(std::string& _return) { int32_t rseqid = 0; @@ -45122,20 +47298,20 @@ bool AiravataClient::recv_deleteGateway() iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("deleteGateway") != 0) { + if (fname.compare("registerPwdCredential") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - bool _return; - Airavata_deleteGateway_presult result; + Airavata_registerPwdCredential_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; @@ -45146,25 +47322,24 @@ bool AiravataClient::recv_deleteGateway() if (result.__isset.ase) { throw result.ase; } - if (result.__isset.ae) { - throw result.ae; - } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "deleteGateway failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "registerPwdCredential failed: unknown result"); } -void AiravataClient::getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken) +void AiravataClient::getSSHPubKey(std::string& _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataCredStoreToken, const std::string& gatewayId) { - send_getAllGateways(authzToken); - recv_getAllGateways(_return); + send_getSSHPubKey(authzToken, airavataCredStoreToken, gatewayId); + recv_getSSHPubKey(_return); } -void AiravataClient::send_getAllGateways(const ::apache::airavata::model::security::AuthzToken& authzToken) +void AiravataClient::send_getSSHPubKey(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& airavataCredStoreToken, const std::string& gatewayId) { int32_t cseqid = 0; - oprot_->writeMessageBegin("getAllGateways", ::apache::thrift::protocol::T_CALL, cseqid); + oprot_->writeMessageBegin("getSSHPubKey", ::apache::thrift::protocol::T_CALL, cseqid); - Airavata_getAllGateways_pargs args; + Airavata_getSSHPubKey_pargs args; args.authzToken = &authzToken; + args.airavataCredStoreToken = &airavataCredStoreToken; + args.gatewayId = &gatewayId; args.write(oprot_); oprot_->writeMessageEnd(); @@ -45172,7 +47347,7 @@ void AiravataClient::send_getAllGateways(const ::apache::airavata::model::secur oprot_->getTransport()->flush(); } -void AiravataClient::recv_getAllGateways(std::vector< ::apache::airavata::model::workspace::Gateway> & _return) +void AiravataClient::recv_getSSHPubKey(std::string& _return) { int32_t rseqid = 0; @@ -45192,12 +47367,12 @@ void AiravataClient::recv_getAllGateways(std::vector< ::apache::airavata::model: iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - if (fname.compare("getAllGateways") != 0) { + if (fname.compare("getSSHPubKey") != 0) { iprot_->skip(::apache::thrift::protocol::T_STRUCT); iprot_->readMessageEnd(); iprot_->getTransport()->readEnd(); } - Airavata_getAllGateways_presult result; + Airavata_getSSHPubKey_presult result; result.success = &_return; result.read(iprot_); iprot_->readMessageEnd(); @@ -45216,24 +47391,21 @@ void AiravataClient::recv_getAllGateways(std::vector< ::apache::airavata::model: if (result.__isset.ase) { throw result.ase; } - if (result.__isset.ae) { - throw result.ae; - } - throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllGateways failed: unknown result"); + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSSHPubKey failed: unknown result"); } -bool AiravataClient::isGatewayExist(const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) +void AiravataClient::getAllGatewaySSHPubKeys(std::map<std::string, std::string> & _return, const ::apache::airavata::model::security::AuthzToken& authzToken, const std::string& gatewayId) { - send_isGatewayExist(authzToken, gatewayId); - return recv_isGatewayExist(); + send_getAllGatewaySSHPubKeys(authzToken, gatewayId);
<TRUNCATED>
