Return-Path: X-Original-To: apmail-airavata-commits-archive@www.apache.org Delivered-To: apmail-airavata-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 37C3911ECD for ; Sat, 12 Jul 2014 04:08:22 +0000 (UTC) Received: (qmail 31840 invoked by uid 500); 12 Jul 2014 04:08:22 -0000 Delivered-To: apmail-airavata-commits-archive@airavata.apache.org Received: (qmail 31722 invoked by uid 500); 12 Jul 2014 04:08:22 -0000 Mailing-List: contact commits-help@airavata.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@airavata.apache.org Delivered-To: mailing list commits@airavata.apache.org Received: (qmail 30666 invoked by uid 99); 12 Jul 2014 04:08:20 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 12 Jul 2014 04:08:20 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id F2E048B756E; Sat, 12 Jul 2014 04:08:19 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: smarru@apache.org To: commits@airavata.apache.org Date: Sat, 12 Jul 2014 04:08:37 -0000 Message-Id: In-Reply-To: <59af82c218f44511b467247ab91186a4@git.apache.org> References: <59af82c218f44511b467247ab91186a4@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [19/47] Added c++ client samples for integrattion of airavata with any other application's c++ interface http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.cpp new file mode 100644 index 0000000..d2f6b63 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.cpp @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "applicationCatalogAPI_constants.h" + +namespace airavata { namespace api { namespace appcatalog { + +const applicationCatalogAPIConstants g_applicationCatalogAPI_constants; + +applicationCatalogAPIConstants::applicationCatalogAPIConstants() { + AIRAVATA_API_VERSION = "0.12.0"; + +} + +}}} // namespace + http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.h new file mode 100644 index 0000000..325136d --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_constants.h @@ -0,0 +1,25 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef applicationCatalogAPI_CONSTANTS_H +#define applicationCatalogAPI_CONSTANTS_H + +#include "applicationCatalogAPI_types.h" + +namespace airavata { namespace api { namespace appcatalog { + +class applicationCatalogAPIConstants { + public: + applicationCatalogAPIConstants(); + + std::string AIRAVATA_API_VERSION; +}; + +extern const applicationCatalogAPIConstants g_applicationCatalogAPI_constants; + +}}} // namespace + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.cpp new file mode 100644 index 0000000..d0f5533 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.cpp @@ -0,0 +1,13 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "applicationCatalogAPI_types.h" + +#include + +namespace airavata { namespace api { namespace appcatalog { + +}}} // namespace http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.h new file mode 100644 index 0000000..4a9fc73 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogAPI_types.h @@ -0,0 +1,27 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef applicationCatalogAPI_TYPES_H +#define applicationCatalogAPI_TYPES_H + +#include +#include +#include +#include + +#include +#include "airavataErrors_types.h" +#include "airavataDataModel_types.h" +#include "computeHostModel_types.h" +#include "applicationInterfaceModel_types.h" +#include "applicationDeploymentModel_types.h" + + +namespace airavata { namespace api { namespace appcatalog { + +}}} // namespace + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.cpp new file mode 100644 index 0000000..e3b3394 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.cpp @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "applicationCatalogDataModel_constants.h" + + + +const applicationCatalogDataModelConstants g_applicationCatalogDataModel_constants; + +applicationCatalogDataModelConstants::applicationCatalogDataModelConstants() { + DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS"; + +} + + + http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.h new file mode 100644 index 0000000..d8bf387 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_constants.h @@ -0,0 +1,25 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef applicationCatalogDataModel_CONSTANTS_H +#define applicationCatalogDataModel_CONSTANTS_H + +#include "applicationCatalogDataModel_types.h" + + + +class applicationCatalogDataModelConstants { + public: + applicationCatalogDataModelConstants(); + + std::string DEFAULT_ID; +}; + +extern const applicationCatalogDataModelConstants g_applicationCatalogDataModel_constants; + + + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.cpp new file mode 100644 index 0000000..9cdf168 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.cpp @@ -0,0 +1,1327 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "applicationCatalogDataModel_types.h" + +#include + + + +int _kResourceJobManagerValues[] = { + ResourceJobManager::FORK, + ResourceJobManager::PBS, + ResourceJobManager::UGE, + ResourceJobManager::SLURM +}; +const char* _kResourceJobManagerNames[] = { + "FORK", + "PBS", + "UGE", + "SLURM" +}; +const std::map _ResourceJobManager_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kResourceJobManagerValues, _kResourceJobManagerNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kJobSubmissionProtocolValues[] = { + JobSubmissionProtocol::SSH, + JobSubmissionProtocol::GSISSH, + JobSubmissionProtocol::GRAM, + JobSubmissionProtocol::UNICORE +}; +const char* _kJobSubmissionProtocolNames[] = { + "SSH", + "GSISSH", + "GRAM", + "UNICORE" +}; +const std::map _JobSubmissionProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kJobSubmissionProtocolValues, _kJobSubmissionProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kDataMovementProtocolValues[] = { + DataMovementProtocol::SCP, + DataMovementProtocol::SFTP, + DataMovementProtocol::GridFTP, + DataMovementProtocol::UNICORE_STORAGE_SERVICE +}; +const char* _kDataMovementProtocolNames[] = { + "SCP", + "SFTP", + "GridFTP", + "UNICORE_STORAGE_SERVICE" +}; +const std::map _DataMovementProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kDataMovementProtocolValues, _kDataMovementProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +int _kSecurityProtocolValues[] = { + SecurityProtocol::USERNAME_PASSWORD, + SecurityProtocol::SSH_KEYS, + SecurityProtocol::GSI, + SecurityProtocol::KERBEROS, + SecurityProtocol::OAUTH +}; +const char* _kSecurityProtocolNames[] = { + "USERNAME_PASSWORD", + "SSH_KEYS", + "GSI", + "KERBEROS", + "OAUTH" +}; +const std::map _SecurityProtocol_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kSecurityProtocolValues, _kSecurityProtocolNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); + +const char* SCPDataMovement::ascii_fingerprint = "FEB6B2CD28861B4EED855CACA1FEF2CB"; +const uint8_t SCPDataMovement::binary_fingerprint[16] = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB}; + +uint32_t SCPDataMovement::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_dataMovementDataID = false; + bool isset_securityProtocol = 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->dataMovementDataID); + isset_dataMovementDataID = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast0; + xfer += iprot->readI32(ecast0); + this->securityProtocol = (SecurityProtocol::type)ecast0; + isset_securityProtocol = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->sshPort); + this->__isset.sshPort = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dataMovementDataID) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_securityProtocol) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SCPDataMovement::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("SCPDataMovement"); + + xfer += oprot->writeFieldBegin("dataMovementDataID", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dataMovementDataID); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("securityProtocol", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->securityProtocol); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.sshPort) { + xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->sshPort); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SCPDataMovement &a, SCPDataMovement &b) { + using ::std::swap; + swap(a.dataMovementDataID, b.dataMovementDataID); + swap(a.securityProtocol, b.securityProtocol); + swap(a.sshPort, b.sshPort); + swap(a.__isset, b.__isset); +} + +const char* GridFTPDataMovement::ascii_fingerprint = "790EE8B1D56A3B9B76C41DD063726E75"; +const uint8_t GridFTPDataMovement::binary_fingerprint[16] = {0x79,0x0E,0xE8,0xB1,0xD5,0x6A,0x3B,0x9B,0x76,0xC4,0x1D,0xD0,0x63,0x72,0x6E,0x75}; + +uint32_t GridFTPDataMovement::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_dataMovementDataID = false; + bool isset_securityProtocol = false; + bool isset_gridFTPEndPoint = 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->dataMovementDataID); + isset_dataMovementDataID = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast1; + xfer += iprot->readI32(ecast1); + this->securityProtocol = (SecurityProtocol::type)ecast1; + isset_securityProtocol = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->gridFTPEndPoint.clear(); + uint32_t _size2; + ::apache::thrift::protocol::TType _etype5; + xfer += iprot->readListBegin(_etype5, _size2); + this->gridFTPEndPoint.resize(_size2); + uint32_t _i6; + for (_i6 = 0; _i6 < _size2; ++_i6) + { + xfer += iprot->readString(this->gridFTPEndPoint[_i6]); + } + xfer += iprot->readListEnd(); + } + isset_gridFTPEndPoint = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dataMovementDataID) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_securityProtocol) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_gridFTPEndPoint) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GridFTPDataMovement::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("GridFTPDataMovement"); + + xfer += oprot->writeFieldBegin("dataMovementDataID", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dataMovementDataID); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("securityProtocol", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->securityProtocol); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("gridFTPEndPoint", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->gridFTPEndPoint.size())); + std::vector ::const_iterator _iter7; + for (_iter7 = this->gridFTPEndPoint.begin(); _iter7 != this->gridFTPEndPoint.end(); ++_iter7) + { + xfer += oprot->writeString((*_iter7)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GridFTPDataMovement &a, GridFTPDataMovement &b) { + using ::std::swap; + swap(a.dataMovementDataID, b.dataMovementDataID); + swap(a.securityProtocol, b.securityProtocol); + swap(a.gridFTPEndPoint, b.gridFTPEndPoint); +} + +const char* SSHJobSubmission::ascii_fingerprint = "FEB6B2CD28861B4EED855CACA1FEF2CB"; +const uint8_t SSHJobSubmission::binary_fingerprint[16] = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB}; + +uint32_t SSHJobSubmission::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_jobSubmissionDataID = false; + bool isset_resourceJobManager = 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->jobSubmissionDataID); + isset_jobSubmissionDataID = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast8; + xfer += iprot->readI32(ecast8); + this->resourceJobManager = (ResourceJobManager::type)ecast8; + isset_resourceJobManager = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->sshPort); + this->__isset.sshPort = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_jobSubmissionDataID) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceJobManager) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SSHJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("SSHJobSubmission"); + + xfer += oprot->writeFieldBegin("jobSubmissionDataID", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->jobSubmissionDataID); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->resourceJobManager); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.sshPort) { + xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->sshPort); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SSHJobSubmission &a, SSHJobSubmission &b) { + using ::std::swap; + swap(a.jobSubmissionDataID, b.jobSubmissionDataID); + swap(a.resourceJobManager, b.resourceJobManager); + swap(a.sshPort, b.sshPort); + swap(a.__isset, b.__isset); +} + +const char* GlobusJobSubmission::ascii_fingerprint = "DF4253F78D7B543C16FA461660D38A03"; +const uint8_t GlobusJobSubmission::binary_fingerprint[16] = {0xDF,0x42,0x53,0xF7,0x8D,0x7B,0x54,0x3C,0x16,0xFA,0x46,0x16,0x60,0xD3,0x8A,0x03}; + +uint32_t GlobusJobSubmission::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_jobSubmissionDataID = false; + bool isset_securityProtocol = false; + bool isset_resourceJobManager = 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->jobSubmissionDataID); + isset_jobSubmissionDataID = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast9; + xfer += iprot->readI32(ecast9); + this->securityProtocol = (SecurityProtocol::type)ecast9; + isset_securityProtocol = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast10; + xfer += iprot->readI32(ecast10); + this->resourceJobManager = (ResourceJobManager::type)ecast10; + isset_resourceJobManager = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->globusGateKeeperEndPoint.clear(); + uint32_t _size11; + ::apache::thrift::protocol::TType _etype14; + xfer += iprot->readListBegin(_etype14, _size11); + this->globusGateKeeperEndPoint.resize(_size11); + uint32_t _i15; + for (_i15 = 0; _i15 < _size11; ++_i15) + { + xfer += iprot->readString(this->globusGateKeeperEndPoint[_i15]); + } + xfer += iprot->readListEnd(); + } + this->__isset.globusGateKeeperEndPoint = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_jobSubmissionDataID) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_securityProtocol) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceJobManager) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GlobusJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("GlobusJobSubmission"); + + xfer += oprot->writeFieldBegin("jobSubmissionDataID", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->jobSubmissionDataID); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("securityProtocol", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->securityProtocol); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((int32_t)this->resourceJobManager); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.globusGateKeeperEndPoint) { + xfer += oprot->writeFieldBegin("globusGateKeeperEndPoint", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->globusGateKeeperEndPoint.size())); + std::vector ::const_iterator _iter16; + for (_iter16 = this->globusGateKeeperEndPoint.begin(); _iter16 != this->globusGateKeeperEndPoint.end(); ++_iter16) + { + xfer += oprot->writeString((*_iter16)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GlobusJobSubmission &a, GlobusJobSubmission &b) { + using ::std::swap; + swap(a.jobSubmissionDataID, b.jobSubmissionDataID); + swap(a.securityProtocol, b.securityProtocol); + swap(a.resourceJobManager, b.resourceJobManager); + swap(a.globusGateKeeperEndPoint, b.globusGateKeeperEndPoint); + swap(a.__isset, b.__isset); +} + +const char* GSISSHJobSubmission::ascii_fingerprint = "6969A7F145C4403B2F9081A498E933FD"; +const uint8_t GSISSHJobSubmission::binary_fingerprint[16] = {0x69,0x69,0xA7,0xF1,0x45,0xC4,0x40,0x3B,0x2F,0x90,0x81,0xA4,0x98,0xE9,0x33,0xFD}; + +uint32_t GSISSHJobSubmission::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_jobSubmissionDataID = false; + bool isset_resourceJobManager = 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->jobSubmissionDataID); + isset_jobSubmissionDataID = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + int32_t ecast17; + xfer += iprot->readI32(ecast17); + this->resourceJobManager = (ResourceJobManager::type)ecast17; + isset_resourceJobManager = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->sshPort); + this->__isset.sshPort = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->exports.clear(); + uint32_t _size18; + ::apache::thrift::protocol::TType _etype21; + xfer += iprot->readSetBegin(_etype21, _size18); + uint32_t _i22; + for (_i22 = 0; _i22 < _size18; ++_i22) + { + std::string _elem23; + xfer += iprot->readString(_elem23); + this->exports.insert(_elem23); + } + xfer += iprot->readSetEnd(); + } + this->__isset.exports = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->preJobCommands.clear(); + uint32_t _size24; + ::apache::thrift::protocol::TType _etype27; + xfer += iprot->readListBegin(_etype27, _size24); + this->preJobCommands.resize(_size24); + uint32_t _i28; + for (_i28 = 0; _i28 < _size24; ++_i28) + { + xfer += iprot->readString(this->preJobCommands[_i28]); + } + xfer += iprot->readListEnd(); + } + this->__isset.preJobCommands = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->postJobCommands.clear(); + uint32_t _size29; + ::apache::thrift::protocol::TType _etype32; + xfer += iprot->readListBegin(_etype32, _size29); + this->postJobCommands.resize(_size29); + uint32_t _i33; + for (_i33 = 0; _i33 < _size29; ++_i33) + { + xfer += iprot->readString(this->postJobCommands[_i33]); + } + xfer += iprot->readListEnd(); + } + this->__isset.postJobCommands = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->installedPath); + this->__isset.installedPath = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->monitorMode); + this->__isset.monitorMode = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_jobSubmissionDataID) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceJobManager) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GSISSHJobSubmission::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("GSISSHJobSubmission"); + + xfer += oprot->writeFieldBegin("jobSubmissionDataID", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->jobSubmissionDataID); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceJobManager", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32((int32_t)this->resourceJobManager); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.sshPort) { + xfer += oprot->writeFieldBegin("sshPort", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->sshPort); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.exports) { + xfer += oprot->writeFieldBegin("exports", ::apache::thrift::protocol::T_SET, 4); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->exports.size())); + std::set ::const_iterator _iter34; + for (_iter34 = this->exports.begin(); _iter34 != this->exports.end(); ++_iter34) + { + xfer += oprot->writeString((*_iter34)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.preJobCommands) { + xfer += oprot->writeFieldBegin("preJobCommands", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->preJobCommands.size())); + std::vector ::const_iterator _iter35; + for (_iter35 = this->preJobCommands.begin(); _iter35 != this->preJobCommands.end(); ++_iter35) + { + xfer += oprot->writeString((*_iter35)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.postJobCommands) { + xfer += oprot->writeFieldBegin("postJobCommands", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->postJobCommands.size())); + std::vector ::const_iterator _iter36; + for (_iter36 = this->postJobCommands.begin(); _iter36 != this->postJobCommands.end(); ++_iter36) + { + xfer += oprot->writeString((*_iter36)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.installedPath) { + xfer += oprot->writeFieldBegin("installedPath", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->installedPath); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.monitorMode) { + xfer += oprot->writeFieldBegin("monitorMode", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->monitorMode); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GSISSHJobSubmission &a, GSISSHJobSubmission &b) { + using ::std::swap; + swap(a.jobSubmissionDataID, b.jobSubmissionDataID); + swap(a.resourceJobManager, b.resourceJobManager); + swap(a.sshPort, b.sshPort); + swap(a.exports, b.exports); + swap(a.preJobCommands, b.preJobCommands); + swap(a.postJobCommands, b.postJobCommands); + swap(a.installedPath, b.installedPath); + swap(a.monitorMode, b.monitorMode); + swap(a.__isset, b.__isset); +} + +const char* ComputeResourceDescription::ascii_fingerprint = "BA89EA8A5D740F97C53BA51CA49FEC18"; +const uint8_t ComputeResourceDescription::binary_fingerprint[16] = {0xBA,0x89,0xEA,0x8A,0x5D,0x74,0x0F,0x97,0xC5,0x3B,0xA5,0x1C,0xA4,0x9F,0xEC,0x18}; + +uint32_t ComputeResourceDescription::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_isEmpty = false; + bool isset_resourceId = false; + bool isset_hostName = false; + bool isset_jobSubmissionProtocols = false; + bool isset_dataMovementProtocols = 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_BOOL) { + xfer += iprot->readBool(this->isEmpty); + isset_isEmpty = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourceId); + isset_resourceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostName); + isset_hostName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->hostAliases.clear(); + uint32_t _size37; + ::apache::thrift::protocol::TType _etype40; + xfer += iprot->readSetBegin(_etype40, _size37); + uint32_t _i41; + for (_i41 = 0; _i41 < _size37; ++_i41) + { + std::string _elem42; + xfer += iprot->readString(_elem42); + this->hostAliases.insert(_elem42); + } + xfer += iprot->readSetEnd(); + } + this->__isset.hostAliases = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_SET) { + { + this->ipAddresses.clear(); + uint32_t _size43; + ::apache::thrift::protocol::TType _etype46; + xfer += iprot->readSetBegin(_etype46, _size43); + uint32_t _i47; + for (_i47 = 0; _i47 < _size43; ++_i47) + { + std::string _elem48; + xfer += iprot->readString(_elem48); + this->ipAddresses.insert(_elem48); + } + xfer += iprot->readSetEnd(); + } + this->__isset.ipAddresses = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->resourceDescription); + this->__isset.resourceDescription = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->scratchLocation); + this->__isset.scratchLocation = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->preferredJobSubmissionProtocol); + this->__isset.preferredJobSubmissionProtocol = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 9: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->jobSubmissionProtocols.clear(); + uint32_t _size49; + ::apache::thrift::protocol::TType _ktype50; + ::apache::thrift::protocol::TType _vtype51; + xfer += iprot->readMapBegin(_ktype50, _vtype51, _size49); + uint32_t _i53; + for (_i53 = 0; _i53 < _size49; ++_i53) + { + std::string _key54; + xfer += iprot->readString(_key54); + JobSubmissionProtocol::type& _val55 = this->jobSubmissionProtocols[_key54]; + int32_t ecast56; + xfer += iprot->readI32(ecast56); + _val55 = (JobSubmissionProtocol::type)ecast56; + } + xfer += iprot->readMapEnd(); + } + isset_jobSubmissionProtocols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 10: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->dataMovementProtocols.clear(); + uint32_t _size57; + ::apache::thrift::protocol::TType _ktype58; + ::apache::thrift::protocol::TType _vtype59; + xfer += iprot->readMapBegin(_ktype58, _vtype59, _size57); + uint32_t _i61; + for (_i61 = 0; _i61 < _size57; ++_i61) + { + std::string _key62; + xfer += iprot->readString(_key62); + DataMovementProtocol::type& _val63 = this->dataMovementProtocols[_key62]; + int32_t ecast64; + xfer += iprot->readI32(ecast64); + _val63 = (DataMovementProtocol::type)ecast64; + } + xfer += iprot->readMapEnd(); + } + isset_dataMovementProtocols = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_isEmpty) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_resourceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_hostName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_jobSubmissionProtocols) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dataMovementProtocols) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ComputeResourceDescription::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ComputeResourceDescription"); + + xfer += oprot->writeFieldBegin("isEmpty", ::apache::thrift::protocol::T_BOOL, 1); + xfer += oprot->writeBool(this->isEmpty); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("resourceId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->resourceId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("hostName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->hostName); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.hostAliases) { + xfer += oprot->writeFieldBegin("hostAliases", ::apache::thrift::protocol::T_SET, 4); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->hostAliases.size())); + std::set ::const_iterator _iter65; + for (_iter65 = this->hostAliases.begin(); _iter65 != this->hostAliases.end(); ++_iter65) + { + xfer += oprot->writeString((*_iter65)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ipAddresses) { + xfer += oprot->writeFieldBegin("ipAddresses", ::apache::thrift::protocol::T_SET, 5); + { + xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast(this->ipAddresses.size())); + std::set ::const_iterator _iter66; + for (_iter66 = this->ipAddresses.begin(); _iter66 != this->ipAddresses.end(); ++_iter66) + { + xfer += oprot->writeString((*_iter66)); + } + xfer += oprot->writeSetEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.resourceDescription) { + xfer += oprot->writeFieldBegin("resourceDescription", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->resourceDescription); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.scratchLocation) { + xfer += oprot->writeFieldBegin("scratchLocation", ::apache::thrift::protocol::T_STRING, 7); + xfer += oprot->writeString(this->scratchLocation); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.preferredJobSubmissionProtocol) { + xfer += oprot->writeFieldBegin("preferredJobSubmissionProtocol", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->preferredJobSubmissionProtocol); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("jobSubmissionProtocols", ::apache::thrift::protocol::T_MAP, 9); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast(this->jobSubmissionProtocols.size())); + std::map ::const_iterator _iter67; + for (_iter67 = this->jobSubmissionProtocols.begin(); _iter67 != this->jobSubmissionProtocols.end(); ++_iter67) + { + xfer += oprot->writeString(_iter67->first); + xfer += oprot->writeI32((int32_t)_iter67->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dataMovementProtocols", ::apache::thrift::protocol::T_MAP, 10); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast(this->dataMovementProtocols.size())); + std::map ::const_iterator _iter68; + for (_iter68 = this->dataMovementProtocols.begin(); _iter68 != this->dataMovementProtocols.end(); ++_iter68) + { + xfer += oprot->writeString(_iter68->first); + xfer += oprot->writeI32((int32_t)_iter68->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ComputeResourceDescription &a, ComputeResourceDescription &b) { + using ::std::swap; + swap(a.isEmpty, b.isEmpty); + swap(a.resourceId, b.resourceId); + swap(a.hostName, b.hostName); + swap(a.hostAliases, b.hostAliases); + swap(a.ipAddresses, b.ipAddresses); + swap(a.resourceDescription, b.resourceDescription); + swap(a.scratchLocation, b.scratchLocation); + swap(a.preferredJobSubmissionProtocol, b.preferredJobSubmissionProtocol); + swap(a.jobSubmissionProtocols, b.jobSubmissionProtocols); + swap(a.dataMovementProtocols, b.dataMovementProtocols); + swap(a.__isset, b.__isset); +} + +const char* ApplicationDescriptor::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9"; +const uint8_t ApplicationDescriptor::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9}; + +uint32_t ApplicationDescriptor::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_applicationDescriptorId = 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->applicationDescriptorId); + isset_applicationDescriptorId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->applicationDescriptorData); + this->__isset.applicationDescriptorData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_applicationDescriptorId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ApplicationDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ApplicationDescriptor"); + + xfer += oprot->writeFieldBegin("applicationDescriptorId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->applicationDescriptorId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.applicationDescriptorData) { + xfer += oprot->writeFieldBegin("applicationDescriptorData", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->applicationDescriptorData); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ApplicationDescriptor &a, ApplicationDescriptor &b) { + using ::std::swap; + swap(a.applicationDescriptorId, b.applicationDescriptorId); + swap(a.applicationDescriptorData, b.applicationDescriptorData); + swap(a.__isset, b.__isset); +} + +const char* ApplicationDeployment::ascii_fingerprint = "960C379A1227D22F43E92F77C32827B9"; +const uint8_t ApplicationDeployment::binary_fingerprint[16] = {0x96,0x0C,0x37,0x9A,0x12,0x27,0xD2,0x2F,0x43,0xE9,0x2F,0x77,0xC3,0x28,0x27,0xB9}; + +uint32_t ApplicationDeployment::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_deploymentId = false; + bool isset_computeResourceDescription = false; + bool isset_applicationDescriptor = 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->deploymentId); + isset_deploymentId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->computeResourceDescription.read(iprot); + isset_computeResourceDescription = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->applicationDescriptor.read(iprot); + isset_applicationDescriptor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_deploymentId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_computeResourceDescription) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_applicationDescriptor) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ApplicationDeployment::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ApplicationDeployment"); + + xfer += oprot->writeFieldBegin("deploymentId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->deploymentId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("computeResourceDescription", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->computeResourceDescription.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("applicationDescriptor", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->applicationDescriptor.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ApplicationDeployment &a, ApplicationDeployment &b) { + using ::std::swap; + swap(a.deploymentId, b.deploymentId); + swap(a.computeResourceDescription, b.computeResourceDescription); + swap(a.applicationDescriptor, b.applicationDescriptor); +} + +const char* ApplicationInterface::ascii_fingerprint = "EEF3E81C0A64CA93FD2422A6CF9ABA97"; +const uint8_t ApplicationInterface::binary_fingerprint[16] = {0xEE,0xF3,0xE8,0x1C,0x0A,0x64,0xCA,0x93,0xFD,0x24,0x22,0xA6,0xCF,0x9A,0xBA,0x97}; + +uint32_t ApplicationInterface::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_applicationInterfaceId = 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->applicationInterfaceId); + isset_applicationInterfaceId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->applicationInterfaceData); + this->__isset.applicationInterfaceData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->applicationDeployments.clear(); + uint32_t _size69; + ::apache::thrift::protocol::TType _etype72; + xfer += iprot->readListBegin(_etype72, _size69); + this->applicationDeployments.resize(_size69); + uint32_t _i73; + for (_i73 = 0; _i73 < _size69; ++_i73) + { + xfer += this->applicationDeployments[_i73].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.applicationDeployments = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_applicationInterfaceId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ApplicationInterface::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ApplicationInterface"); + + xfer += oprot->writeFieldBegin("applicationInterfaceId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->applicationInterfaceId); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.applicationInterfaceData) { + xfer += oprot->writeFieldBegin("applicationInterfaceData", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->applicationInterfaceData); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.applicationDeployments) { + xfer += oprot->writeFieldBegin("applicationDeployments", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->applicationDeployments.size())); + std::vector ::const_iterator _iter74; + for (_iter74 = this->applicationDeployments.begin(); _iter74 != this->applicationDeployments.end(); ++_iter74) + { + xfer += (*_iter74).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ApplicationInterface &a, ApplicationInterface &b) { + using ::std::swap; + swap(a.applicationInterfaceId, b.applicationInterfaceId); + swap(a.applicationInterfaceData, b.applicationInterfaceData); + swap(a.applicationDeployments, b.applicationDeployments); + swap(a.__isset, b.__isset); +} + + http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.h new file mode 100644 index 0000000..814bcd3 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationCatalogDataModel_types.h @@ -0,0 +1,713 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef applicationCatalogDataModel_TYPES_H +#define applicationCatalogDataModel_TYPES_H + +#include +#include +#include +#include + +#include + + + + +struct ResourceJobManager { + enum type { + FORK = 0, + PBS = 1, + UGE = 2, + SLURM = 3 + }; +}; + +extern const std::map _ResourceJobManager_VALUES_TO_NAMES; + +struct JobSubmissionProtocol { + enum type { + SSH = 0, + GSISSH = 1, + GRAM = 2, + UNICORE = 3 + }; +}; + +extern const std::map _JobSubmissionProtocol_VALUES_TO_NAMES; + +struct DataMovementProtocol { + enum type { + SCP = 0, + SFTP = 1, + GridFTP = 2, + UNICORE_STORAGE_SERVICE = 3 + }; +}; + +extern const std::map _DataMovementProtocol_VALUES_TO_NAMES; + +struct SecurityProtocol { + enum type { + USERNAME_PASSWORD = 0, + SSH_KEYS = 1, + GSI = 2, + KERBEROS = 3, + OAUTH = 4 + }; +}; + +extern const std::map _SecurityProtocol_VALUES_TO_NAMES; + +typedef struct _SCPDataMovement__isset { + _SCPDataMovement__isset() : sshPort(true) {} + bool sshPort; +} _SCPDataMovement__isset; + +class SCPDataMovement { + public: + + static const char* ascii_fingerprint; // = "FEB6B2CD28861B4EED855CACA1FEF2CB"; + static const uint8_t binary_fingerprint[16]; // = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB}; + + SCPDataMovement() : dataMovementDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), sshPort(22) { + } + + virtual ~SCPDataMovement() throw() {} + + std::string dataMovementDataID; + SecurityProtocol::type securityProtocol; + int32_t sshPort; + + _SCPDataMovement__isset __isset; + + void __set_dataMovementDataID(const std::string& val) { + dataMovementDataID = val; + } + + void __set_securityProtocol(const SecurityProtocol::type val) { + securityProtocol = val; + } + + void __set_sshPort(const int32_t val) { + sshPort = val; + __isset.sshPort = true; + } + + bool operator == (const SCPDataMovement & rhs) const + { + if (!(dataMovementDataID == rhs.dataMovementDataID)) + return false; + if (!(securityProtocol == rhs.securityProtocol)) + return false; + if (__isset.sshPort != rhs.__isset.sshPort) + return false; + else if (__isset.sshPort && !(sshPort == rhs.sshPort)) + return false; + return true; + } + bool operator != (const SCPDataMovement &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SCPDataMovement & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(SCPDataMovement &a, SCPDataMovement &b); + + +class GridFTPDataMovement { + public: + + static const char* ascii_fingerprint; // = "790EE8B1D56A3B9B76C41DD063726E75"; + static const uint8_t binary_fingerprint[16]; // = {0x79,0x0E,0xE8,0xB1,0xD5,0x6A,0x3B,0x9B,0x76,0xC4,0x1D,0xD0,0x63,0x72,0x6E,0x75}; + + GridFTPDataMovement() : dataMovementDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0) { + } + + virtual ~GridFTPDataMovement() throw() {} + + std::string dataMovementDataID; + SecurityProtocol::type securityProtocol; + std::vector gridFTPEndPoint; + + void __set_dataMovementDataID(const std::string& val) { + dataMovementDataID = val; + } + + void __set_securityProtocol(const SecurityProtocol::type val) { + securityProtocol = val; + } + + void __set_gridFTPEndPoint(const std::vector & val) { + gridFTPEndPoint = val; + } + + bool operator == (const GridFTPDataMovement & rhs) const + { + if (!(dataMovementDataID == rhs.dataMovementDataID)) + return false; + if (!(securityProtocol == rhs.securityProtocol)) + return false; + if (!(gridFTPEndPoint == rhs.gridFTPEndPoint)) + return false; + return true; + } + bool operator != (const GridFTPDataMovement &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GridFTPDataMovement & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(GridFTPDataMovement &a, GridFTPDataMovement &b); + +typedef struct _SSHJobSubmission__isset { + _SSHJobSubmission__isset() : sshPort(true) {} + bool sshPort; +} _SSHJobSubmission__isset; + +class SSHJobSubmission { + public: + + static const char* ascii_fingerprint; // = "FEB6B2CD28861B4EED855CACA1FEF2CB"; + static const uint8_t binary_fingerprint[16]; // = {0xFE,0xB6,0xB2,0xCD,0x28,0x86,0x1B,0x4E,0xED,0x85,0x5C,0xAC,0xA1,0xFE,0xF2,0xCB}; + + SSHJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), resourceJobManager((ResourceJobManager::type)0), sshPort(22) { + } + + virtual ~SSHJobSubmission() throw() {} + + std::string jobSubmissionDataID; + ResourceJobManager::type resourceJobManager; + int32_t sshPort; + + _SSHJobSubmission__isset __isset; + + void __set_jobSubmissionDataID(const std::string& val) { + jobSubmissionDataID = val; + } + + void __set_resourceJobManager(const ResourceJobManager::type val) { + resourceJobManager = val; + } + + void __set_sshPort(const int32_t val) { + sshPort = val; + __isset.sshPort = true; + } + + bool operator == (const SSHJobSubmission & rhs) const + { + if (!(jobSubmissionDataID == rhs.jobSubmissionDataID)) + return false; + if (!(resourceJobManager == rhs.resourceJobManager)) + return false; + if (__isset.sshPort != rhs.__isset.sshPort) + return false; + else if (__isset.sshPort && !(sshPort == rhs.sshPort)) + return false; + return true; + } + bool operator != (const SSHJobSubmission &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SSHJobSubmission & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(SSHJobSubmission &a, SSHJobSubmission &b); + +typedef struct _GlobusJobSubmission__isset { + _GlobusJobSubmission__isset() : globusGateKeeperEndPoint(false) {} + bool globusGateKeeperEndPoint; +} _GlobusJobSubmission__isset; + +class GlobusJobSubmission { + public: + + static const char* ascii_fingerprint; // = "DF4253F78D7B543C16FA461660D38A03"; + static const uint8_t binary_fingerprint[16]; // = {0xDF,0x42,0x53,0xF7,0x8D,0x7B,0x54,0x3C,0x16,0xFA,0x46,0x16,0x60,0xD3,0x8A,0x03}; + + GlobusJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), securityProtocol((SecurityProtocol::type)0), resourceJobManager((ResourceJobManager::type)0) { + } + + virtual ~GlobusJobSubmission() throw() {} + + std::string jobSubmissionDataID; + SecurityProtocol::type securityProtocol; + ResourceJobManager::type resourceJobManager; + std::vector globusGateKeeperEndPoint; + + _GlobusJobSubmission__isset __isset; + + void __set_jobSubmissionDataID(const std::string& val) { + jobSubmissionDataID = val; + } + + void __set_securityProtocol(const SecurityProtocol::type val) { + securityProtocol = val; + } + + void __set_resourceJobManager(const ResourceJobManager::type val) { + resourceJobManager = val; + } + + void __set_globusGateKeeperEndPoint(const std::vector & val) { + globusGateKeeperEndPoint = val; + __isset.globusGateKeeperEndPoint = true; + } + + bool operator == (const GlobusJobSubmission & rhs) const + { + if (!(jobSubmissionDataID == rhs.jobSubmissionDataID)) + return false; + if (!(securityProtocol == rhs.securityProtocol)) + return false; + if (!(resourceJobManager == rhs.resourceJobManager)) + return false; + if (__isset.globusGateKeeperEndPoint != rhs.__isset.globusGateKeeperEndPoint) + return false; + else if (__isset.globusGateKeeperEndPoint && !(globusGateKeeperEndPoint == rhs.globusGateKeeperEndPoint)) + return false; + return true; + } + bool operator != (const GlobusJobSubmission &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GlobusJobSubmission & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(GlobusJobSubmission &a, GlobusJobSubmission &b); + +typedef struct _GSISSHJobSubmission__isset { + _GSISSHJobSubmission__isset() : sshPort(true), exports(false), preJobCommands(false), postJobCommands(false), installedPath(false), monitorMode(false) {} + bool sshPort; + bool exports; + bool preJobCommands; + bool postJobCommands; + bool installedPath; + bool monitorMode; +} _GSISSHJobSubmission__isset; + +class GSISSHJobSubmission { + public: + + static const char* ascii_fingerprint; // = "6969A7F145C4403B2F9081A498E933FD"; + static const uint8_t binary_fingerprint[16]; // = {0x69,0x69,0xA7,0xF1,0x45,0xC4,0x40,0x3B,0x2F,0x90,0x81,0xA4,0x98,0xE9,0x33,0xFD}; + + GSISSHJobSubmission() : jobSubmissionDataID("DO_NOT_SET_AT_CLIENTS"), resourceJobManager((ResourceJobManager::type)0), sshPort(22), installedPath(), monitorMode() { + } + + virtual ~GSISSHJobSubmission() throw() {} + + std::string jobSubmissionDataID; + ResourceJobManager::type resourceJobManager; + int32_t sshPort; + std::set exports; + std::vector preJobCommands; + std::vector postJobCommands; + std::string installedPath; + std::string monitorMode; + + _GSISSHJobSubmission__isset __isset; + + void __set_jobSubmissionDataID(const std::string& val) { + jobSubmissionDataID = val; + } + + void __set_resourceJobManager(const ResourceJobManager::type val) { + resourceJobManager = val; + } + + void __set_sshPort(const int32_t val) { + sshPort = val; + __isset.sshPort = true; + } + + void __set_exports(const std::set & val) { + exports = val; + __isset.exports = true; + } + + void __set_preJobCommands(const std::vector & val) { + preJobCommands = val; + __isset.preJobCommands = true; + } + + void __set_postJobCommands(const std::vector & val) { + postJobCommands = val; + __isset.postJobCommands = true; + } + + void __set_installedPath(const std::string& val) { + installedPath = val; + __isset.installedPath = true; + } + + void __set_monitorMode(const std::string& val) { + monitorMode = val; + __isset.monitorMode = true; + } + + bool operator == (const GSISSHJobSubmission & rhs) const + { + if (!(jobSubmissionDataID == rhs.jobSubmissionDataID)) + return false; + if (!(resourceJobManager == rhs.resourceJobManager)) + return false; + if (__isset.sshPort != rhs.__isset.sshPort) + return false; + else if (__isset.sshPort && !(sshPort == rhs.sshPort)) + return false; + if (__isset.exports != rhs.__isset.exports) + return false; + else if (__isset.exports && !(exports == rhs.exports)) + return false; + if (__isset.preJobCommands != rhs.__isset.preJobCommands) + return false; + else if (__isset.preJobCommands && !(preJobCommands == rhs.preJobCommands)) + return false; + if (__isset.postJobCommands != rhs.__isset.postJobCommands) + return false; + else if (__isset.postJobCommands && !(postJobCommands == rhs.postJobCommands)) + return false; + if (__isset.installedPath != rhs.__isset.installedPath) + return false; + else if (__isset.installedPath && !(installedPath == rhs.installedPath)) + return false; + if (__isset.monitorMode != rhs.__isset.monitorMode) + return false; + else if (__isset.monitorMode && !(monitorMode == rhs.monitorMode)) + return false; + return true; + } + bool operator != (const GSISSHJobSubmission &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GSISSHJobSubmission & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(GSISSHJobSubmission &a, GSISSHJobSubmission &b); + +typedef struct _ComputeResourceDescription__isset { + _ComputeResourceDescription__isset() : hostAliases(false), ipAddresses(false), resourceDescription(false), scratchLocation(false), preferredJobSubmissionProtocol(false) {} + bool hostAliases; + bool ipAddresses; + bool resourceDescription; + bool scratchLocation; + bool preferredJobSubmissionProtocol; +} _ComputeResourceDescription__isset; + +class ComputeResourceDescription { + public: + + static const char* ascii_fingerprint; // = "BA89EA8A5D740F97C53BA51CA49FEC18"; + static const uint8_t binary_fingerprint[16]; // = {0xBA,0x89,0xEA,0x8A,0x5D,0x74,0x0F,0x97,0xC5,0x3B,0xA5,0x1C,0xA4,0x9F,0xEC,0x18}; + + ComputeResourceDescription() : isEmpty(false), resourceId("DO_NOT_SET_AT_CLIENTS"), hostName(), resourceDescription(), scratchLocation(), preferredJobSubmissionProtocol() { + } + + virtual ~ComputeResourceDescription() throw() {} + + bool isEmpty; + std::string resourceId; + std::string hostName; + std::set hostAliases; + std::set ipAddresses; + std::string resourceDescription; + std::string scratchLocation; + std::string preferredJobSubmissionProtocol; + std::map jobSubmissionProtocols; + std::map dataMovementProtocols; + + _ComputeResourceDescription__isset __isset; + + void __set_isEmpty(const bool val) { + isEmpty = val; + } + + void __set_resourceId(const std::string& val) { + resourceId = val; + } + + void __set_hostName(const std::string& val) { + hostName = val; + } + + void __set_hostAliases(const std::set & val) { + hostAliases = val; + __isset.hostAliases = true; + } + + void __set_ipAddresses(const std::set & val) { + ipAddresses = val; + __isset.ipAddresses = true; + } + + void __set_resourceDescription(const std::string& val) { + resourceDescription = val; + __isset.resourceDescription = true; + } + + void __set_scratchLocation(const std::string& val) { + scratchLocation = val; + __isset.scratchLocation = true; + } + + void __set_preferredJobSubmissionProtocol(const std::string& val) { + preferredJobSubmissionProtocol = val; + __isset.preferredJobSubmissionProtocol = true; + } + + void __set_jobSubmissionProtocols(const std::map & val) { + jobSubmissionProtocols = val; + } + + void __set_dataMovementProtocols(const std::map & val) { + dataMovementProtocols = val; + } + + bool operator == (const ComputeResourceDescription & rhs) const + { + if (!(isEmpty == rhs.isEmpty)) + return false; + if (!(resourceId == rhs.resourceId)) + return false; + if (!(hostName == rhs.hostName)) + return false; + if (__isset.hostAliases != rhs.__isset.hostAliases) + return false; + else if (__isset.hostAliases && !(hostAliases == rhs.hostAliases)) + return false; + if (__isset.ipAddresses != rhs.__isset.ipAddresses) + return false; + else if (__isset.ipAddresses && !(ipAddresses == rhs.ipAddresses)) + return false; + if (__isset.resourceDescription != rhs.__isset.resourceDescription) + return false; + else if (__isset.resourceDescription && !(resourceDescription == rhs.resourceDescription)) + return false; + if (__isset.scratchLocation != rhs.__isset.scratchLocation) + return false; + else if (__isset.scratchLocation && !(scratchLocation == rhs.scratchLocation)) + return false; + if (__isset.preferredJobSubmissionProtocol != rhs.__isset.preferredJobSubmissionProtocol) + return false; + else if (__isset.preferredJobSubmissionProtocol && !(preferredJobSubmissionProtocol == rhs.preferredJobSubmissionProtocol)) + return false; + if (!(jobSubmissionProtocols == rhs.jobSubmissionProtocols)) + return false; + if (!(dataMovementProtocols == rhs.dataMovementProtocols)) + return false; + return true; + } + bool operator != (const ComputeResourceDescription &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ComputeResourceDescription & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ComputeResourceDescription &a, ComputeResourceDescription &b); + +typedef struct _ApplicationDescriptor__isset { + _ApplicationDescriptor__isset() : applicationDescriptorData(false) {} + bool applicationDescriptorData; +} _ApplicationDescriptor__isset; + +class ApplicationDescriptor { + public: + + static const char* ascii_fingerprint; // = "5B708A954C550ECA9C1A49D3C5CAFAB9"; + static const uint8_t binary_fingerprint[16]; // = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9}; + + ApplicationDescriptor() : applicationDescriptorId("DO_NOT_SET_AT_CLIENTS"), applicationDescriptorData() { + } + + virtual ~ApplicationDescriptor() throw() {} + + std::string applicationDescriptorId; + std::string applicationDescriptorData; + + _ApplicationDescriptor__isset __isset; + + void __set_applicationDescriptorId(const std::string& val) { + applicationDescriptorId = val; + } + + void __set_applicationDescriptorData(const std::string& val) { + applicationDescriptorData = val; + __isset.applicationDescriptorData = true; + } + + bool operator == (const ApplicationDescriptor & rhs) const + { + if (!(applicationDescriptorId == rhs.applicationDescriptorId)) + return false; + if (__isset.applicationDescriptorData != rhs.__isset.applicationDescriptorData) + return false; + else if (__isset.applicationDescriptorData && !(applicationDescriptorData == rhs.applicationDescriptorData)) + return false; + return true; + } + bool operator != (const ApplicationDescriptor &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ApplicationDescriptor & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ApplicationDescriptor &a, ApplicationDescriptor &b); + + +class ApplicationDeployment { + public: + + static const char* ascii_fingerprint; // = "960C379A1227D22F43E92F77C32827B9"; + static const uint8_t binary_fingerprint[16]; // = {0x96,0x0C,0x37,0x9A,0x12,0x27,0xD2,0x2F,0x43,0xE9,0x2F,0x77,0xC3,0x28,0x27,0xB9}; + + ApplicationDeployment() : deploymentId("DO_NOT_SET_AT_CLIENTS") { + } + + virtual ~ApplicationDeployment() throw() {} + + std::string deploymentId; + ComputeResourceDescription computeResourceDescription; + ApplicationDescriptor applicationDescriptor; + + void __set_deploymentId(const std::string& val) { + deploymentId = val; + } + + void __set_computeResourceDescription(const ComputeResourceDescription& val) { + computeResourceDescription = val; + } + + void __set_applicationDescriptor(const ApplicationDescriptor& val) { + applicationDescriptor = val; + } + + bool operator == (const ApplicationDeployment & rhs) const + { + if (!(deploymentId == rhs.deploymentId)) + return false; + if (!(computeResourceDescription == rhs.computeResourceDescription)) + return false; + if (!(applicationDescriptor == rhs.applicationDescriptor)) + return false; + return true; + } + bool operator != (const ApplicationDeployment &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ApplicationDeployment & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ApplicationDeployment &a, ApplicationDeployment &b); + +typedef struct _ApplicationInterface__isset { + _ApplicationInterface__isset() : applicationInterfaceData(false), applicationDeployments(false) {} + bool applicationInterfaceData; + bool applicationDeployments; +} _ApplicationInterface__isset; + +class ApplicationInterface { + public: + + static const char* ascii_fingerprint; // = "EEF3E81C0A64CA93FD2422A6CF9ABA97"; + static const uint8_t binary_fingerprint[16]; // = {0xEE,0xF3,0xE8,0x1C,0x0A,0x64,0xCA,0x93,0xFD,0x24,0x22,0xA6,0xCF,0x9A,0xBA,0x97}; + + ApplicationInterface() : applicationInterfaceId("DO_NOT_SET_AT_CLIENTS"), applicationInterfaceData() { + } + + virtual ~ApplicationInterface() throw() {} + + std::string applicationInterfaceId; + std::string applicationInterfaceData; + std::vector applicationDeployments; + + _ApplicationInterface__isset __isset; + + void __set_applicationInterfaceId(const std::string& val) { + applicationInterfaceId = val; + } + + void __set_applicationInterfaceData(const std::string& val) { + applicationInterfaceData = val; + __isset.applicationInterfaceData = true; + } + + void __set_applicationDeployments(const std::vector & val) { + applicationDeployments = val; + __isset.applicationDeployments = true; + } + + bool operator == (const ApplicationInterface & rhs) const + { + if (!(applicationInterfaceId == rhs.applicationInterfaceId)) + return false; + if (__isset.applicationInterfaceData != rhs.__isset.applicationInterfaceData) + return false; + else if (__isset.applicationInterfaceData && !(applicationInterfaceData == rhs.applicationInterfaceData)) + return false; + if (__isset.applicationDeployments != rhs.__isset.applicationDeployments) + return false; + else if (__isset.applicationDeployments && !(applicationDeployments == rhs.applicationDeployments)) + return false; + return true; + } + bool operator != (const ApplicationInterface &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ApplicationInterface & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ApplicationInterface &a, ApplicationInterface &b); + + + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.cpp new file mode 100644 index 0000000..52c0dac --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.cpp @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "applicationDeploymentModel_constants.h" + +namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace appdeployment { + +const applicationDeploymentModelConstants g_applicationDeploymentModel_constants; + +applicationDeploymentModelConstants::applicationDeploymentModelConstants() { + DEFAULT_ID = "DO_NOT_SET_AT_CLIENTS"; + +} + +}}}}} // namespace + http://git-wip-us.apache.org/repos/asf/airavata/blob/f891b7dc/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.h new file mode 100644 index 0000000..a0ba25e --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/applicationDeploymentModel_constants.h @@ -0,0 +1,25 @@ +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef applicationDeploymentModel_CONSTANTS_H +#define applicationDeploymentModel_CONSTANTS_H + +#include "applicationDeploymentModel_types.h" + +namespace apache { namespace airavata { namespace model { namespace appcatalog { namespace appdeployment { + +class applicationDeploymentModelConstants { + public: + applicationDeploymentModelConstants(); + + std::string DEFAULT_ID; +}; + +extern const applicationDeploymentModelConstants g_applicationDeploymentModel_constants; + +}}}}} // namespace + +#endif