You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sm...@apache.org on 2014/07/07 05:01:08 UTC
[3/5] Adding job manager and data movement API functions -
AIRAVATA-1296
http://git-wip-us.apache.org/repos/asf/airavata/blob/152acbf2/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
index 9a056a0..af7c0e1 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/Airavata.cpp
@@ -10196,18 +10196,1468 @@ uint32_t Airavata_deleteComputeResource_presult::read(::apache::thrift::protocol
return xfer;
}
+uint32_t Airavata_addLocalSubmissionDetails_args::read(::apache::thrift::protocol::TProtocol* 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_computeResourceId = false;
+ bool isset_priorityOrder = false;
+ bool isset_localSubmission = 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_STRING) {
+ xfer += iprot->readString(this->computeResourceId);
+ isset_computeResourceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->priorityOrder);
+ isset_priorityOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->localSubmission.read(iprot);
+ isset_localSubmission = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_computeResourceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_priorityOrder)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_localSubmission)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_addLocalSubmissionDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addLocalSubmissionDetails_args");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->priorityOrder);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("localSubmission", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->localSubmission.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalSubmissionDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addLocalSubmissionDetails_pargs");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->computeResourceId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((*(this->priorityOrder)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("localSubmission", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += (*(this->localSubmission)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalSubmissionDetails_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addLocalSubmissionDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_addLocalSubmissionDetails_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalSubmissionDetails_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_args::read(::apache::thrift::protocol::TProtocol* 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_computeResourceId = false;
+ bool isset_priorityOrder = false;
+ bool isset_sshJobSubmission = 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_STRING) {
+ xfer += iprot->readString(this->computeResourceId);
+ isset_computeResourceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->priorityOrder);
+ isset_priorityOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sshJobSubmission.read(iprot);
+ isset_sshJobSubmission = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_computeResourceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_priorityOrder)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_sshJobSubmission)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addSSHJobSubmissionDetails_args");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->priorityOrder);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("sshJobSubmission", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->sshJobSubmission.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addSSHJobSubmissionDetails_pargs");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->computeResourceId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((*(this->priorityOrder)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("sshJobSubmission", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += (*(this->sshJobSubmission)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_addSSHJobSubmissionDetails_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSSHJobSubmissionDetails_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_args::read(::apache::thrift::protocol::TProtocol* 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_computeResourceId = false;
+ bool isset_priorityOrder = false;
+ bool isset_localDataMovement = 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_STRING) {
+ xfer += iprot->readString(this->computeResourceId);
+ isset_computeResourceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->priorityOrder);
+ isset_priorityOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->localDataMovement.read(iprot);
+ isset_localDataMovement = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_computeResourceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_priorityOrder)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_localDataMovement)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addLocalDataMovementDetails_args");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->priorityOrder);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("localDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->localDataMovement.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addLocalDataMovementDetails_pargs");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->computeResourceId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((*(this->priorityOrder)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("localDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += (*(this->localDataMovement)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_addLocalDataMovementDetails_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addLocalDataMovementDetails_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_args::read(::apache::thrift::protocol::TProtocol* 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_computeResourceId = false;
+ bool isset_priorityOrder = false;
+ bool isset_scpDataMovement = 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_STRING) {
+ xfer += iprot->readString(this->computeResourceId);
+ isset_computeResourceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->priorityOrder);
+ isset_priorityOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->scpDataMovement.read(iprot);
+ isset_scpDataMovement = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_computeResourceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_priorityOrder)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_scpDataMovement)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addSCPDataMovementDetails_args");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->priorityOrder);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("scpDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->scpDataMovement.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addSCPDataMovementDetails_pargs");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->computeResourceId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((*(this->priorityOrder)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("scpDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += (*(this->scpDataMovement)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_addSCPDataMovementDetails_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addSCPDataMovementDetails_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_args::read(::apache::thrift::protocol::TProtocol* 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_computeResourceId = false;
+ bool isset_priorityOrder = false;
+ bool isset_gridFTPDataMovement = 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_STRING) {
+ xfer += iprot->readString(this->computeResourceId);
+ isset_computeResourceId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->priorityOrder);
+ isset_priorityOrder = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->gridFTPDataMovement.read(iprot);
+ isset_gridFTPDataMovement = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_computeResourceId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_priorityOrder)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_gridFTPDataMovement)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addGridFTPDataMovementDetails_args");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->computeResourceId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->priorityOrder);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("gridFTPDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->gridFTPDataMovement.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Airavata_addGridFTPDataMovementDetails_pargs");
+
+ xfer += oprot->writeFieldBegin("computeResourceId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->computeResourceId)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("priorityOrder", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((*(this->priorityOrder)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("gridFTPDataMovement", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += (*(this->gridFTPDataMovement)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_result::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("Airavata_addGridFTPDataMovementDetails_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();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t Airavata_addGridFTPDataMovementDetails_presult::read(::apache::thrift::protocol::TProtocol* 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;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
void AiravataClient::getAPIVersion(std::string& _return)
{
- send_getAPIVersion();
- recv_getAPIVersion(_return);
+ send_getAPIVersion();
+ recv_getAPIVersion(_return);
+}
+
+void AiravataClient::send_getAPIVersion()
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_getAPIVersion_pargs args;
+ 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;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result");
+}
+
+void AiravataClient::createProject(std::string& _return, const ::Project& project)
+{
+ send_createProject(project);
+ recv_createProject(_return);
+}
+
+void AiravataClient::send_createProject(const ::Project& project)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("createProject", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_createProject_pargs args;
+ args.project = &project;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_createProject(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("createProject") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_createProject_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;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createProject failed: unknown result");
+}
+
+void AiravataClient::updateProject(const std::string& projectId, const ::Project& updatedProject)
+{
+ send_updateProject(projectId, updatedProject);
+ recv_updateProject();
}
-void AiravataClient::send_getAPIVersion()
+void AiravataClient::send_updateProject(const std::string& projectId, const ::Project& updatedProject)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getAPIVersion", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("updateProject", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getAPIVersion_pargs args;
+ Airavata_updateProject_pargs args;
+ args.projectId = &projectId;
+ args.updatedProject = &updatedProject;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10215,7 +11665,7 @@ void AiravataClient::send_getAPIVersion()
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getAPIVersion(std::string& _return)
+void AiravataClient::recv_updateProject()
{
int32_t rseqid = 0;
@@ -10235,12 +11685,77 @@ void AiravataClient::recv_getAPIVersion(std::string& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getAPIVersion") != 0) {
+ if (fname.compare("updateProject") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getAPIVersion_presult result;
+ Airavata_updateProject_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.pnfe) {
+ throw result.pnfe;
+ }
+ return;
+}
+
+void AiravataClient::getProject( ::Project& _return, const std::string& projectId)
+{
+ send_getProject(projectId);
+ recv_getProject(_return);
+}
+
+void AiravataClient::send_getProject(const std::string& projectId)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("getProject", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_getProject_pargs args;
+ args.projectId = &projectId;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_getProject( ::Project& _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("getProject") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_getProject_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10259,22 +11774,25 @@ void AiravataClient::recv_getAPIVersion(std::string& _return)
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAPIVersion failed: unknown result");
+ if (result.__isset.pnfe) {
+ throw result.pnfe;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProject failed: unknown result");
}
-void AiravataClient::createProject(std::string& _return, const ::Project& project)
+void AiravataClient::getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName)
{
- send_createProject(project);
- recv_createProject(_return);
+ send_getAllUserProjects(userName);
+ recv_getAllUserProjects(_return);
}
-void AiravataClient::send_createProject(const ::Project& project)
+void AiravataClient::send_getAllUserProjects(const std::string& userName)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("createProject", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getAllUserProjects", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_createProject_pargs args;
- args.project = &project;
+ Airavata_getAllUserProjects_pargs args;
+ args.userName = &userName;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10282,7 +11800,143 @@ void AiravataClient::send_createProject(const ::Project& project)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_createProject(std::string& _return)
+void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _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("getAllUserProjects") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_getAllUserProjects_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;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserProjects failed: unknown result");
+}
+
+void AiravataClient::searchProjectsByProjectName(std::vector< ::Project> & _return, const std::string& userName, const std::string& projectName)
+{
+ send_searchProjectsByProjectName(userName, projectName);
+ recv_searchProjectsByProjectName(_return);
+}
+
+void AiravataClient::send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("searchProjectsByProjectName", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_searchProjectsByProjectName_pargs args;
+ args.userName = &userName;
+ args.projectName = &projectName;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> & _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("searchProjectsByProjectName") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ Airavata_searchProjectsByProjectName_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;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectName failed: unknown result");
+}
+
+void AiravataClient::searchProjectsByProjectDesc(std::vector< ::Project> & _return, const std::string& userName, const std::string& description)
+{
+ send_searchProjectsByProjectDesc(userName, description);
+ recv_searchProjectsByProjectDesc(_return);
+}
+
+void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("searchProjectsByProjectDesc", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ Airavata_searchProjectsByProjectDesc_pargs args;
+ args.userName = &userName;
+ args.description = &description;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> & _return)
{
int32_t rseqid = 0;
@@ -10302,12 +11956,12 @@ void AiravataClient::recv_createProject(std::string& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("createProject") != 0) {
+ if (fname.compare("searchProjectsByProjectDesc") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_createProject_presult result;
+ Airavata_searchProjectsByProjectDesc_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10326,23 +11980,23 @@ void AiravataClient::recv_createProject(std::string& _return)
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createProject failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectDesc failed: unknown result");
}
-void AiravataClient::updateProject(const std::string& projectId, const ::Project& updatedProject)
+void AiravataClient::searchExperimentsByName(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& expName)
{
- send_updateProject(projectId, updatedProject);
- recv_updateProject();
+ send_searchExperimentsByName(userName, expName);
+ recv_searchExperimentsByName(_return);
}
-void AiravataClient::send_updateProject(const std::string& projectId, const ::Project& updatedProject)
+void AiravataClient::send_searchExperimentsByName(const std::string& userName, const std::string& expName)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("updateProject", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("searchExperimentsByName", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_updateProject_pargs args;
- args.projectId = &projectId;
- args.updatedProject = &updatedProject;
+ Airavata_searchExperimentsByName_pargs args;
+ args.userName = &userName;
+ args.expName = &expName;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10350,7 +12004,7 @@ void AiravataClient::send_updateProject(const std::string& projectId, const ::P
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_updateProject()
+void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSummary> & _return)
{
int32_t rseqid = 0;
@@ -10370,16 +12024,21 @@ void AiravataClient::recv_updateProject()
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("updateProject") != 0) {
+ if (fname.compare("searchExperimentsByName") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_updateProject_presult result;
+ Airavata_searchExperimentsByName_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;
}
@@ -10389,25 +12048,23 @@ void AiravataClient::recv_updateProject()
if (result.__isset.ase) {
throw result.ase;
}
- if (result.__isset.pnfe) {
- throw result.pnfe;
- }
- return;
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByName failed: unknown result");
}
-void AiravataClient::getProject( ::Project& _return, const std::string& projectId)
+void AiravataClient::searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& description)
{
- send_getProject(projectId);
- recv_getProject(_return);
+ send_searchExperimentsByDesc(userName, description);
+ recv_searchExperimentsByDesc(_return);
}
-void AiravataClient::send_getProject(const std::string& projectId)
+void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, const std::string& description)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getProject", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("searchExperimentsByDesc", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getProject_pargs args;
- args.projectId = &projectId;
+ Airavata_searchExperimentsByDesc_pargs args;
+ args.userName = &userName;
+ args.description = &description;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10415,7 +12072,7 @@ void AiravataClient::send_getProject(const std::string& projectId)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getProject( ::Project& _return)
+void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return)
{
int32_t rseqid = 0;
@@ -10435,12 +12092,12 @@ void AiravataClient::recv_getProject( ::Project& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getProject") != 0) {
+ if (fname.compare("searchExperimentsByDesc") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getProject_presult result;
+ Airavata_searchExperimentsByDesc_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10459,25 +12116,23 @@ void AiravataClient::recv_getProject( ::Project& _return)
if (result.__isset.ase) {
throw result.ase;
}
- if (result.__isset.pnfe) {
- throw result.pnfe;
- }
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getProject failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByDesc failed: unknown result");
}
-void AiravataClient::getAllUserProjects(std::vector< ::Project> & _return, const std::string& userName)
+void AiravataClient::searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId)
{
- send_getAllUserProjects(userName);
- recv_getAllUserProjects(_return);
+ send_searchExperimentsByApplication(userName, applicationId);
+ recv_searchExperimentsByApplication(_return);
}
-void AiravataClient::send_getAllUserProjects(const std::string& userName)
+void AiravataClient::send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getAllUserProjects", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("searchExperimentsByApplication", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getAllUserProjects_pargs args;
+ Airavata_searchExperimentsByApplication_pargs args;
args.userName = &userName;
+ args.applicationId = &applicationId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10485,7 +12140,7 @@ void AiravataClient::send_getAllUserProjects(const std::string& userName)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
+void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return)
{
int32_t rseqid = 0;
@@ -10505,12 +12160,12 @@ void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getAllUserProjects") != 0) {
+ if (fname.compare("searchExperimentsByApplication") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getAllUserProjects_presult result;
+ Airavata_searchExperimentsByApplication_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10529,23 +12184,22 @@ void AiravataClient::recv_getAllUserProjects(std::vector< ::Project> & _return)
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserProjects failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByApplication failed: unknown result");
}
-void AiravataClient::searchProjectsByProjectName(std::vector< ::Project> & _return, const std::string& userName, const std::string& projectName)
+void AiravataClient::getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId)
{
- send_searchProjectsByProjectName(userName, projectName);
- recv_searchProjectsByProjectName(_return);
+ send_getAllExperimentsInProject(projectId);
+ recv_getAllExperimentsInProject(_return);
}
-void AiravataClient::send_searchProjectsByProjectName(const std::string& userName, const std::string& projectName)
+void AiravataClient::send_getAllExperimentsInProject(const std::string& projectId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("searchProjectsByProjectName", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getAllExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_searchProjectsByProjectName_pargs args;
- args.userName = &userName;
- args.projectName = &projectName;
+ Airavata_getAllExperimentsInProject_pargs args;
+ args.projectId = &projectId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10553,7 +12207,7 @@ void AiravataClient::send_searchProjectsByProjectName(const std::string& userNam
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> & _return)
+void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment> & _return)
{
int32_t rseqid = 0;
@@ -10573,12 +12227,12 @@ void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> &
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("searchProjectsByProjectName") != 0) {
+ if (fname.compare("getAllExperimentsInProject") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_searchProjectsByProjectName_presult result;
+ Airavata_getAllExperimentsInProject_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10597,23 +12251,25 @@ void AiravataClient::recv_searchProjectsByProjectName(std::vector< ::Project> &
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectName failed: unknown result");
+ if (result.__isset.pnfe) {
+ throw result.pnfe;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllExperimentsInProject failed: unknown result");
}
-void AiravataClient::searchProjectsByProjectDesc(std::vector< ::Project> & _return, const std::string& userName, const std::string& description)
+void AiravataClient::getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName)
{
- send_searchProjectsByProjectDesc(userName, description);
- recv_searchProjectsByProjectDesc(_return);
+ send_getAllUserExperiments(userName);
+ recv_getAllUserExperiments(_return);
}
-void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userName, const std::string& description)
+void AiravataClient::send_getAllUserExperiments(const std::string& userName)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("searchProjectsByProjectDesc", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getAllUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_searchProjectsByProjectDesc_pargs args;
+ Airavata_getAllUserExperiments_pargs args;
args.userName = &userName;
- args.description = &description;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10621,7 +12277,7 @@ void AiravataClient::send_searchProjectsByProjectDesc(const std::string& userNam
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> & _return)
+void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _return)
{
int32_t rseqid = 0;
@@ -10641,12 +12297,12 @@ void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> &
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("searchProjectsByProjectDesc") != 0) {
+ if (fname.compare("getAllUserExperiments") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_searchProjectsByProjectDesc_presult result;
+ Airavata_getAllUserExperiments_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10665,23 +12321,22 @@ void AiravataClient::recv_searchProjectsByProjectDesc(std::vector< ::Project> &
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchProjectsByProjectDesc failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserExperiments failed: unknown result");
}
-void AiravataClient::searchExperimentsByName(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& expName)
+void AiravataClient::createExperiment(std::string& _return, const ::Experiment& experiment)
{
- send_searchExperimentsByName(userName, expName);
- recv_searchExperimentsByName(_return);
+ send_createExperiment(experiment);
+ recv_createExperiment(_return);
}
-void AiravataClient::send_searchExperimentsByName(const std::string& userName, const std::string& expName)
+void AiravataClient::send_createExperiment(const ::Experiment& experiment)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("searchExperimentsByName", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_searchExperimentsByName_pargs args;
- args.userName = &userName;
- args.expName = &expName;
+ Airavata_createExperiment_pargs args;
+ args.experiment = &experiment;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10689,7 +12344,7 @@ void AiravataClient::send_searchExperimentsByName(const std::string& userName, c
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_createExperiment(std::string& _return)
{
int32_t rseqid = 0;
@@ -10709,12 +12364,12 @@ void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSumma
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("searchExperimentsByName") != 0) {
+ if (fname.compare("createExperiment") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_searchExperimentsByName_presult result;
+ Airavata_createExperiment_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10733,23 +12388,22 @@ void AiravataClient::recv_searchExperimentsByName(std::vector< ::ExperimentSumma
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByName failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createExperiment failed: unknown result");
}
-void AiravataClient::searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& description)
+void AiravataClient::getExperiment( ::Experiment& _return, const std::string& airavataExperimentId)
{
- send_searchExperimentsByDesc(userName, description);
- recv_searchExperimentsByDesc(_return);
+ send_getExperiment(airavataExperimentId);
+ recv_getExperiment(_return);
}
-void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, const std::string& description)
+void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("searchExperimentsByDesc", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_searchExperimentsByDesc_pargs args;
- args.userName = &userName;
- args.description = &description;
+ Airavata_getExperiment_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10757,7 +12411,7 @@ void AiravataClient::send_searchExperimentsByDesc(const std::string& userName, c
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_getExperiment( ::Experiment& _return)
{
int32_t rseqid = 0;
@@ -10777,12 +12431,12 @@ void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSumma
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("searchExperimentsByDesc") != 0) {
+ if (fname.compare("getExperiment") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_searchExperimentsByDesc_presult result;
+ Airavata_getExperiment_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -10795,29 +12449,32 @@ void AiravataClient::recv_searchExperimentsByDesc(std::vector< ::ExperimentSumma
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;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByDesc failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result");
}
-void AiravataClient::searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return, const std::string& userName, const std::string& applicationId)
+void AiravataClient::updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment)
{
- send_searchExperimentsByApplication(userName, applicationId);
- recv_searchExperimentsByApplication(_return);
+ send_updateExperiment(airavataExperimentId, experiment);
+ recv_updateExperiment();
}
-void AiravataClient::send_searchExperimentsByApplication(const std::string& userName, const std::string& applicationId)
+void AiravataClient::send_updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("searchExperimentsByApplication", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_searchExperimentsByApplication_pargs args;
- args.userName = &userName;
- args.applicationId = &applicationId;
+ Airavata_updateExperiment_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
+ args.experiment = &experiment;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10825,7 +12482,7 @@ void AiravataClient::send_searchExperimentsByApplication(const std::string& user
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::ExperimentSummary> & _return)
+void AiravataClient::recv_updateExperiment()
{
int32_t rseqid = 0;
@@ -10845,46 +12502,45 @@ void AiravataClient::recv_searchExperimentsByApplication(std::vector< ::Experime
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("searchExperimentsByApplication") != 0) {
+ if (fname.compare("updateExperiment") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_searchExperimentsByApplication_presult result;
- result.success = &_return;
+ Airavata_updateExperiment_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;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "searchExperimentsByApplication failed: unknown result");
+ return;
}
-void AiravataClient::getAllExperimentsInProject(std::vector< ::Experiment> & _return, const std::string& projectId)
+void AiravataClient::updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration)
{
- send_getAllExperimentsInProject(projectId);
- recv_getAllExperimentsInProject(_return);
+ send_updateExperimentConfiguration(airavataExperimentId, userConfiguration);
+ recv_updateExperimentConfiguration();
}
-void AiravataClient::send_getAllExperimentsInProject(const std::string& projectId)
+void AiravataClient::send_updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getAllExperimentsInProject", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getAllExperimentsInProject_pargs args;
- args.projectId = &projectId;
+ Airavata_updateExperimentConfiguration_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
+ args.userConfiguration = &userConfiguration;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10892,7 +12548,7 @@ void AiravataClient::send_getAllExperimentsInProject(const std::string& projectI
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment> & _return)
+void AiravataClient::recv_updateExperimentConfiguration()
{
int32_t rseqid = 0;
@@ -10912,49 +12568,33 @@ void AiravataClient::recv_getAllExperimentsInProject(std::vector< ::Experiment>
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getAllExperimentsInProject") != 0) {
+ if (fname.compare("updateExperimentConfiguration") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getAllExperimentsInProject_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;
- }
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllExperimentsInProject failed: unknown result");
+ Airavata_updateExperimentConfiguration_presult result;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ return;
}
-void AiravataClient::getAllUserExperiments(std::vector< ::Experiment> & _return, const std::string& userName)
+void AiravataClient::updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling)
{
- send_getAllUserExperiments(userName);
- recv_getAllUserExperiments(_return);
+ send_updateResourceScheduleing(airavataExperimentId, resourceScheduling);
+ recv_updateResourceScheduleing();
}
-void AiravataClient::send_getAllUserExperiments(const std::string& userName)
+void AiravataClient::send_updateResourceScheduleing(const std::string& airavataExperimentId, const ::ComputationalResourceScheduling& resourceScheduling)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getAllUserExperiments", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("updateResourceScheduleing", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getAllUserExperiments_pargs args;
- args.userName = &userName;
+ Airavata_updateResourceScheduleing_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
+ args.resourceScheduling = &resourceScheduling;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -10962,7 +12602,7 @@ void AiravataClient::send_getAllUserExperiments(const std::string& userName)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _return)
+void AiravataClient::recv_updateResourceScheduleing()
{
int32_t rseqid = 0;
@@ -10982,46 +12622,32 @@ void AiravataClient::recv_getAllUserExperiments(std::vector< ::Experiment> & _re
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getAllUserExperiments") != 0) {
+ if (fname.compare("updateResourceScheduleing") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getAllUserExperiments_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.ace) {
- throw result.ace;
- }
- if (result.__isset.ase) {
- throw result.ase;
- }
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getAllUserExperiments failed: unknown result");
+ return;
}
-void AiravataClient::createExperiment(std::string& _return, const ::Experiment& experiment)
+bool AiravataClient::validateExperiment(const std::string& airavataExperimentId)
{
- send_createExperiment(experiment);
- recv_createExperiment(_return);
+ send_validateExperiment(airavataExperimentId);
+ return recv_validateExperiment();
}
-void AiravataClient::send_createExperiment(const ::Experiment& experiment)
+void AiravataClient::send_validateExperiment(const std::string& airavataExperimentId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("createExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("validateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_createExperiment_pargs args;
- args.experiment = &experiment;
+ Airavata_validateExperiment_pargs args;
+ args.airavataExperimentId = &airavataExperimentId;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -11029,7 +12655,7 @@ void AiravataClient::send_createExperiment(const ::Experiment& experiment)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_createExperiment(std::string& _return)
+bool AiravataClient::recv_validateExperiment()
{
int32_t rseqid = 0;
@@ -11049,46 +12675,50 @@ void AiravataClient::recv_createExperiment(std::string& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("createExperiment") != 0) {
+ if (fname.compare("validateExperiment") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_createExperiment_presult result;
+ bool _return;
+ Airavata_validateExperiment_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;
}
+ if (result.__isset.enf) {
+ throw result.enf;
+ }
if (result.__isset.ace) {
throw result.ace;
}
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "createExperiment failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "validateExperiment failed: unknown result");
}
-void AiravataClient::getExperiment( ::Experiment& _return, const std::string& airavataExperimentId)
+void AiravataClient::launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
{
- send_getExperiment(airavataExperimentId);
- recv_getExperiment(_return);
+ send_launchExperiment(airavataExperimentId, airavataCredStoreToken);
+ recv_launchExperiment();
}
-void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
+void AiravataClient::send_launchExperiment(const std::string& airavataExperimentId, const std::string& airavataCredStoreToken)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("getExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("launchExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_getExperiment_pargs args;
+ Airavata_launchExperiment_pargs args;
args.airavataExperimentId = &airavataExperimentId;
+ args.airavataCredStoreToken = &airavataCredStoreToken;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -11096,7 +12726,7 @@ void AiravataClient::send_getExperiment(const std::string& airavataExperimentId)
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_getExperiment( ::Experiment& _return)
+void AiravataClient::recv_launchExperiment()
{
int32_t rseqid = 0;
@@ -11116,21 +12746,16 @@ void AiravataClient::recv_getExperiment( ::Experiment& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("getExperiment") != 0) {
+ if (fname.compare("launchExperiment") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_getExperiment_presult result;
- result.success = &_return;
+ Airavata_launchExperiment_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;
}
@@ -11143,23 +12768,25 @@ void AiravataClient::recv_getExperiment( ::Experiment& _return)
if (result.__isset.ase) {
throw result.ase;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperiment failed: unknown result");
+ if (result.__isset.lve) {
+ throw result.lve;
+ }
+ return;
}
-void AiravataClient::updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment)
+void AiravataClient::getExperimentStatus( ::ExperimentStatus& _return, const std::string& airavataExperimentId)
{
- send_updateExperiment(airavataExperimentId, experiment);
- recv_updateExperiment();
+ send_getExperimentStatus(airavataExperimentId);
+ recv_getExperimentStatus(_return);
}
-void AiravataClient::send_updateExperiment(const std::string& airavataExperimentId, const ::Experiment& experiment)
+void AiravataClient::send_getExperimentStatus(const std::string& airavataExperimentId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("updateExperiment", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getExperimentStatus", ::apache::thrift::protocol::T_CALL, cseqid);
- Airavata_updateExperiment_pargs args;
+ Airavata_getExperimentStatus_pargs args;
args.airavataExperimentId = &airavataExperimentId;
- args.experiment = &experiment;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -11167,7 +12794,7 @@ void AiravataClient::send_updateExperiment(const std::string& airavataExperiment
oprot_->getTransport()->flush();
}
-void AiravataClient::recv_updateExperiment()
+void AiravataClient::recv_getExperimentStatus( ::ExperimentStatus& _return)
{
int32_t rseqid = 0;
@@ -11187,16 +12814,21 @@ void AiravataClient::recv_updateExperiment()
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("updateExperiment") != 0) {
+ if (fname.compare("getExperimentStatus") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- Airavata_updateExperiment_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;
}
@@ -11209,23 +12841,22 @@ void AiravataClient::recv_updateExperiment()
if (result.__isset.ase) {
throw result.ase;
}
- return;
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getExperimentStatus failed: unknown result");
}
-void AiravataClient::updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration)
+void AiravataClient::getExperimentOutputs(std::vector< ::DataObjectType> & _return, const std::string& airavataExperimentId)
{
- send_updateExperimentConfiguration(airavataExperimentId, userConfiguration);
- recv_updateExperimentConfiguration();
+ send_getExperimentOutputs(airavataExperimentId);
+ recv_getExperimentOutputs(_return);
}
-void AiravataClient::send_updateExperimentConfiguration(const std::string& airavataExperimentId, const ::UserConfigurationData& userConfiguration)
+void AiravataClient::send_getExperimentOutputs(const std::string& airavataExperimentId)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("updateExperimentConfiguration", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("getExperimentOutputs", ::apache::thrift::protocol::T_CALL, cseqid);
- A
<TRUNCATED>