adding initial messaging framework changes
Project: http://git-wip-us.apache.org/repos/asf/airavata/repo Commit: http://git-wip-us.apache.org/repos/asf/airavata/commit/1fe3d1d8 Tree: http://git-wip-us.apache.org/repos/asf/airavata/tree/1fe3d1d8 Diff: http://git-wip-us.apache.org/repos/asf/airavata/diff/1fe3d1d8 Branch: refs/heads/master Commit: 1fe3d1d8e86feb3ade9c55bc8ee13931c5454910 Parents: f29d7e6 Author: Chathuri Wimalasena <[email protected]> Authored: Fri Aug 8 15:32:57 2014 -0400 Committer: Chathuri Wimalasena <[email protected]> Committed: Fri Aug 8 15:32:57 2014 -0400 ---------------------------------------------------------------------- .../lib/airavata/airavataDataModel_types.h | 1 + .../lib/airavata/messagingEvents_constants.cpp | 34 + .../lib/airavata/messagingEvents_constants.h | 41 + .../lib/airavata/messagingEvents_types.cpp | 833 ++++++++++++++ .../lib/airavata/messagingEvents_types.h | 488 ++++++++ .../Airavata/Model/Messaging/Event/Types.php | 990 +++++++++++++++++ .../event/ExperimentStatusChangeEvent.java | 504 +++++++++ .../model/messaging/event/JobIdentity.java | 684 ++++++++++++ .../model/messaging/event/JobMonitor.java | 1043 ++++++++++++++++++ .../messaging/event/JobStatusChangeEvent.java | 610 ++++++++++ .../model/messaging/event/TaskIdentity.java | 588 ++++++++++ .../messaging/event/TaskStatusChangeEvent.java | 509 +++++++++ .../model/messaging/event/WorkflowIdentity.java | 492 +++++++++ .../event/WorkflowNodeStatusChangeEvent.java | 509 +++++++++ .../airavataDataModel.thrift | 1 + .../messagingEvents.thrift | 83 ++ modules/messaging/core/pom.xml | 62 ++ .../airavata/messaging/core/Metadata.java | 25 + .../airavata/messaging/core/Publisher.java | 13 + modules/messaging/pom.xml | 41 + pom.xml | 1 + 21 files changed, 7552 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h index 51dff2f..dfaad45 100644 --- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h @@ -32,6 +32,7 @@ #include <thrift/cxxfunctional.h> #include "workspaceModel_types.h" #include "airavataErrors_types.h" +#include "messagingEvents_types.h" namespace apache { namespace airavata { namespace model { http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp new file mode 100644 index 0000000..a02179a --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp @@ -0,0 +1,34 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "messagingEvents_constants.h" + +namespace apache { namespace airavata { namespace model { namespace messaging { namespace event { + +const messagingEventsConstants g_messagingEvents_constants; + +messagingEventsConstants::messagingEventsConstants() { +} + +}}}}} // namespace + http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h new file mode 100644 index 0000000..c91fd31 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h @@ -0,0 +1,41 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef messagingEvents_CONSTANTS_H +#define messagingEvents_CONSTANTS_H + +#include "messagingEvents_types.h" + +namespace apache { namespace airavata { namespace model { namespace messaging { namespace event { + +class messagingEventsConstants { + public: + messagingEventsConstants(); + +}; + +extern const messagingEventsConstants g_messagingEvents_constants; + +}}}}} // namespace + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp new file mode 100644 index 0000000..0c14c72 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp @@ -0,0 +1,833 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "messagingEvents_types.h" + +#include <algorithm> + +namespace apache { namespace airavata { namespace model { namespace messaging { namespace event { + +const char* ExperimentStatusChangeEvent::ascii_fingerprint = "19B5240589E680301A7E32DF3971EFBE"; +const uint8_t ExperimentStatusChangeEvent::binary_fingerprint[16] = {0x19,0xB5,0x24,0x05,0x89,0xE6,0x80,0x30,0x1A,0x7E,0x32,0xDF,0x39,0x71,0xEF,0xBE}; + +uint32_t ExperimentStatusChangeEvent::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_state = false; + bool isset_experimentId = 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_I32) { + int32_t ecast0; + xfer += iprot->readI32(ecast0); + this->state = ( ::apache::airavata::model::workspace::experiment::ExperimentState::type)ecast0; + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->experimentId); + isset_experimentId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_experimentId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t ExperimentStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ExperimentStatusChangeEvent"); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->experimentId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.experimentId, b.experimentId); +} + +const char* WorkflowIdentity::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972"; +const uint8_t WorkflowIdentity::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72}; + +uint32_t WorkflowIdentity::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_workflowNodeId = false; + bool isset_experimentId = 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->workflowNodeId); + isset_workflowNodeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->experimentId); + isset_experimentId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_workflowNodeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_experimentId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WorkflowIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("WorkflowIdentity"); + + xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->workflowNodeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->experimentId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WorkflowIdentity &a, WorkflowIdentity &b) { + using ::std::swap; + swap(a.workflowNodeId, b.workflowNodeId); + swap(a.experimentId, b.experimentId); +} + +const char* WorkflowNodeStatusChangeEvent::ascii_fingerprint = "E9096211D03C8F19468314A49FB23CF0"; +const uint8_t WorkflowNodeStatusChangeEvent::binary_fingerprint[16] = {0xE9,0x09,0x62,0x11,0xD0,0x3C,0x8F,0x19,0x46,0x83,0x14,0xA4,0x9F,0xB2,0x3C,0xF0}; + +uint32_t WorkflowNodeStatusChangeEvent::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_state = false; + bool isset_workflowNodeIdentity = 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_I32) { + int32_t ecast1; + xfer += iprot->readI32(ecast1); + this->state = ( ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type)ecast1; + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->workflowNodeIdentity.read(iprot); + isset_workflowNodeIdentity = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_workflowNodeIdentity) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t WorkflowNodeStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("WorkflowNodeStatusChangeEvent"); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("workflowNodeIdentity", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->workflowNodeIdentity.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.workflowNodeIdentity, b.workflowNodeIdentity); +} + +const char* TaskIdentity::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; +const uint8_t TaskIdentity::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; + +uint32_t TaskIdentity::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_taskId = false; + bool isset_workflowNodeId = false; + bool isset_experimentId = 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->taskId); + isset_taskId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workflowNodeId); + isset_workflowNodeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->experimentId); + isset_experimentId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_taskId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_workflowNodeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_experimentId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TaskIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("TaskIdentity"); + + xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->taskId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->workflowNodeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->experimentId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TaskIdentity &a, TaskIdentity &b) { + using ::std::swap; + swap(a.taskId, b.taskId); + swap(a.workflowNodeId, b.workflowNodeId); + swap(a.experimentId, b.experimentId); +} + +const char* TaskStatusChangeEvent::ascii_fingerprint = "9686679C94D43D75F2B35A0BED2E4003"; +const uint8_t TaskStatusChangeEvent::binary_fingerprint[16] = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03}; + +uint32_t TaskStatusChangeEvent::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_state = false; + bool isset_taskIdentity = 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_I32) { + int32_t ecast2; + xfer += iprot->readI32(ecast2); + this->state = ( ::apache::airavata::model::workspace::experiment::TaskState::type)ecast2; + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->taskIdentity.read(iprot); + isset_taskIdentity = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_taskIdentity) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TaskStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("TaskStatusChangeEvent"); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("taskIdentity", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->taskIdentity.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.taskIdentity, b.taskIdentity); +} + +const char* JobIdentity::ascii_fingerprint = "C93D890311F28844166CF6E571EB3AC2"; +const uint8_t JobIdentity::binary_fingerprint[16] = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2}; + +uint32_t JobIdentity::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_jobId = false; + bool isset_taskId = false; + bool isset_workflowNodeId = false; + bool isset_experimentId = 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->jobId); + isset_jobId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->taskId); + isset_taskId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->workflowNodeId); + isset_workflowNodeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->experimentId); + isset_experimentId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_jobId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_taskId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_workflowNodeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_experimentId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t JobIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("JobIdentity"); + + xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->jobId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->taskId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->workflowNodeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->experimentId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(JobIdentity &a, JobIdentity &b) { + using ::std::swap; + swap(a.jobId, b.jobId); + swap(a.taskId, b.taskId); + swap(a.workflowNodeId, b.workflowNodeId); + swap(a.experimentId, b.experimentId); +} + +const char* JobMonitor::ascii_fingerprint = "D0036787E2FC651CBEB945D6D6CBBEB8"; +const uint8_t JobMonitor::binary_fingerprint[16] = {0xD0,0x03,0x67,0x87,0xE2,0xFC,0x65,0x1C,0xBE,0xB9,0x45,0xD6,0xD6,0xCB,0xBE,0xB8}; + +uint32_t JobMonitor::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 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->username); + this->__isset.username = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->jobStartedTime); + this->__isset.jobStartedTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->lastMonitoredTime); + this->__isset.lastMonitoredTime = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->hostId); + this->__isset.hostId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_MAP) { + { + this->parameters.clear(); + uint32_t _size3; + ::apache::thrift::protocol::TType _ktype4; + ::apache::thrift::protocol::TType _vtype5; + xfer += iprot->readMapBegin(_ktype4, _vtype5, _size3); + uint32_t _i7; + for (_i7 = 0; _i7 < _size3; ++_i7) + { + std::string _key8; + xfer += iprot->readString(_key8); + std::string& _val9 = this->parameters[_key8]; + xfer += iprot->readString(_val9); + } + xfer += iprot->readMapEnd(); + } + this->__isset.parameters = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->jobName); + this->__isset.jobName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->failedCount); + this->__isset.failedCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t JobMonitor::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("JobMonitor"); + + if (this->__isset.username) { + xfer += oprot->writeFieldBegin("username", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->username); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.jobStartedTime) { + xfer += oprot->writeFieldBegin("jobStartedTime", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->jobStartedTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.lastMonitoredTime) { + xfer += oprot->writeFieldBegin("lastMonitoredTime", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->lastMonitoredTime); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.hostId) { + xfer += oprot->writeFieldBegin("hostId", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->hostId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.parameters) { + xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5); + { + xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size())); + std::map<std::string, std::string> ::const_iterator _iter10; + for (_iter10 = this->parameters.begin(); _iter10 != this->parameters.end(); ++_iter10) + { + xfer += oprot->writeString(_iter10->first); + xfer += oprot->writeString(_iter10->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.jobName) { + xfer += oprot->writeFieldBegin("jobName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->jobName); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.failedCount) { + xfer += oprot->writeFieldBegin("failedCount", ::apache::thrift::protocol::T_I32, 7); + xfer += oprot->writeI32(this->failedCount); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(JobMonitor &a, JobMonitor &b) { + using ::std::swap; + swap(a.username, b.username); + swap(a.jobStartedTime, b.jobStartedTime); + swap(a.lastMonitoredTime, b.lastMonitoredTime); + swap(a.hostId, b.hostId); + swap(a.parameters, b.parameters); + swap(a.jobName, b.jobName); + swap(a.failedCount, b.failedCount); + swap(a.__isset, b.__isset); +} + +const char* JobStatusChangeEvent::ascii_fingerprint = "A4467EF21DF0026B864BF2B95C34A774"; +const uint8_t JobStatusChangeEvent::binary_fingerprint[16] = {0xA4,0x46,0x7E,0xF2,0x1D,0xF0,0x02,0x6B,0x86,0x4B,0xF2,0xB9,0x5C,0x34,0xA7,0x74}; + +uint32_t JobStatusChangeEvent::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_state = false; + bool isset_jobIdentity = false; + bool isset_jobMonitor = 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_I32) { + int32_t ecast11; + xfer += iprot->readI32(ecast11); + this->state = ( ::apache::airavata::model::workspace::experiment::JobState::type)ecast11; + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->jobIdentity.read(iprot); + isset_jobIdentity = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->jobMonitor.read(iprot); + isset_jobMonitor = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_jobIdentity) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_jobMonitor) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t JobStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("JobStatusChangeEvent"); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1); + xfer += oprot->writeI32((int32_t)this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("jobIdentity", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->jobIdentity.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("jobMonitor", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->jobMonitor.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.jobIdentity, b.jobIdentity); + swap(a.jobMonitor, b.jobMonitor); +} + +}}}}} // namespace http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h new file mode 100644 index 0000000..baeb37f --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h @@ -0,0 +1,488 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#ifndef messagingEvents_TYPES_H +#define messagingEvents_TYPES_H + +#include <thrift/Thrift.h> +#include <thrift/TApplicationException.h> +#include <thrift/protocol/TProtocol.h> +#include <thrift/transport/TTransport.h> + +#include <thrift/cxxfunctional.h> +#include "experimentModel_types.h" + + +namespace apache { namespace airavata { namespace model { namespace messaging { namespace event { + + +class ExperimentStatusChangeEvent { + public: + + static const char* ascii_fingerprint; // = "19B5240589E680301A7E32DF3971EFBE"; + static const uint8_t binary_fingerprint[16]; // = {0x19,0xB5,0x24,0x05,0x89,0xE6,0x80,0x30,0x1A,0x7E,0x32,0xDF,0x39,0x71,0xEF,0xBE}; + + ExperimentStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::ExperimentState::type)0), experimentId() { + } + + virtual ~ExperimentStatusChangeEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::ExperimentState::type state; + std::string experimentId; + + void __set_state(const ::apache::airavata::model::workspace::experiment::ExperimentState::type val) { + state = val; + } + + void __set_experimentId(const std::string& val) { + experimentId = val; + } + + bool operator == (const ExperimentStatusChangeEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(experimentId == rhs.experimentId)) + return false; + return true; + } + bool operator != (const ExperimentStatusChangeEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ExperimentStatusChangeEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b); + + +class WorkflowIdentity { + public: + + static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972"; + static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72}; + + WorkflowIdentity() : workflowNodeId(), experimentId() { + } + + virtual ~WorkflowIdentity() throw() {} + + std::string workflowNodeId; + std::string experimentId; + + void __set_workflowNodeId(const std::string& val) { + workflowNodeId = val; + } + + void __set_experimentId(const std::string& val) { + experimentId = val; + } + + bool operator == (const WorkflowIdentity & rhs) const + { + if (!(workflowNodeId == rhs.workflowNodeId)) + return false; + if (!(experimentId == rhs.experimentId)) + return false; + return true; + } + bool operator != (const WorkflowIdentity &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WorkflowIdentity & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(WorkflowIdentity &a, WorkflowIdentity &b); + + +class WorkflowNodeStatusChangeEvent { + public: + + static const char* ascii_fingerprint; // = "E9096211D03C8F19468314A49FB23CF0"; + static const uint8_t binary_fingerprint[16]; // = {0xE9,0x09,0x62,0x11,0xD0,0x3C,0x8F,0x19,0x46,0x83,0x14,0xA4,0x9F,0xB2,0x3C,0xF0}; + + WorkflowNodeStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type)0) { + } + + virtual ~WorkflowNodeStatusChangeEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type state; + WorkflowIdentity workflowNodeIdentity; + + void __set_state(const ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type val) { + state = val; + } + + void __set_workflowNodeIdentity(const WorkflowIdentity& val) { + workflowNodeIdentity = val; + } + + bool operator == (const WorkflowNodeStatusChangeEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(workflowNodeIdentity == rhs.workflowNodeIdentity)) + return false; + return true; + } + bool operator != (const WorkflowNodeStatusChangeEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const WorkflowNodeStatusChangeEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b); + + +class TaskIdentity { + public: + + static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271"; + static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; + + TaskIdentity() : taskId(), workflowNodeId(), experimentId() { + } + + virtual ~TaskIdentity() throw() {} + + std::string taskId; + std::string workflowNodeId; + std::string experimentId; + + void __set_taskId(const std::string& val) { + taskId = val; + } + + void __set_workflowNodeId(const std::string& val) { + workflowNodeId = val; + } + + void __set_experimentId(const std::string& val) { + experimentId = val; + } + + bool operator == (const TaskIdentity & rhs) const + { + if (!(taskId == rhs.taskId)) + return false; + if (!(workflowNodeId == rhs.workflowNodeId)) + return false; + if (!(experimentId == rhs.experimentId)) + return false; + return true; + } + bool operator != (const TaskIdentity &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TaskIdentity & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TaskIdentity &a, TaskIdentity &b); + + +class TaskStatusChangeEvent { + public: + + static const char* ascii_fingerprint; // = "9686679C94D43D75F2B35A0BED2E4003"; + static const uint8_t binary_fingerprint[16]; // = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03}; + + TaskStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::TaskState::type)0) { + } + + virtual ~TaskStatusChangeEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::TaskState::type state; + TaskIdentity taskIdentity; + + void __set_state(const ::apache::airavata::model::workspace::experiment::TaskState::type val) { + state = val; + } + + void __set_taskIdentity(const TaskIdentity& val) { + taskIdentity = val; + } + + bool operator == (const TaskStatusChangeEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(taskIdentity == rhs.taskIdentity)) + return false; + return true; + } + bool operator != (const TaskStatusChangeEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TaskStatusChangeEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b); + + +class JobIdentity { + public: + + static const char* ascii_fingerprint; // = "C93D890311F28844166CF6E571EB3AC2"; + static const uint8_t binary_fingerprint[16]; // = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2}; + + JobIdentity() : jobId(), taskId(), workflowNodeId(), experimentId() { + } + + virtual ~JobIdentity() throw() {} + + std::string jobId; + std::string taskId; + std::string workflowNodeId; + std::string experimentId; + + void __set_jobId(const std::string& val) { + jobId = val; + } + + void __set_taskId(const std::string& val) { + taskId = val; + } + + void __set_workflowNodeId(const std::string& val) { + workflowNodeId = val; + } + + void __set_experimentId(const std::string& val) { + experimentId = val; + } + + bool operator == (const JobIdentity & rhs) const + { + if (!(jobId == rhs.jobId)) + return false; + if (!(taskId == rhs.taskId)) + return false; + if (!(workflowNodeId == rhs.workflowNodeId)) + return false; + if (!(experimentId == rhs.experimentId)) + return false; + return true; + } + bool operator != (const JobIdentity &rhs) const { + return !(*this == rhs); + } + + bool operator < (const JobIdentity & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(JobIdentity &a, JobIdentity &b); + +typedef struct _JobMonitor__isset { + _JobMonitor__isset() : username(false), jobStartedTime(false), lastMonitoredTime(false), hostId(false), parameters(false), jobName(false), failedCount(true) {} + bool username; + bool jobStartedTime; + bool lastMonitoredTime; + bool hostId; + bool parameters; + bool jobName; + bool failedCount; +} _JobMonitor__isset; + +class JobMonitor { + public: + + static const char* ascii_fingerprint; // = "D0036787E2FC651CBEB945D6D6CBBEB8"; + static const uint8_t binary_fingerprint[16]; // = {0xD0,0x03,0x67,0x87,0xE2,0xFC,0x65,0x1C,0xBE,0xB9,0x45,0xD6,0xD6,0xCB,0xBE,0xB8}; + + JobMonitor() : username(), jobStartedTime(0), lastMonitoredTime(0), hostId(), jobName(), failedCount(0) { + } + + virtual ~JobMonitor() throw() {} + + std::string username; + int64_t jobStartedTime; + int64_t lastMonitoredTime; + std::string hostId; + std::map<std::string, std::string> parameters; + std::string jobName; + int32_t failedCount; + + _JobMonitor__isset __isset; + + void __set_username(const std::string& val) { + username = val; + __isset.username = true; + } + + void __set_jobStartedTime(const int64_t val) { + jobStartedTime = val; + __isset.jobStartedTime = true; + } + + void __set_lastMonitoredTime(const int64_t val) { + lastMonitoredTime = val; + __isset.lastMonitoredTime = true; + } + + void __set_hostId(const std::string& val) { + hostId = val; + __isset.hostId = true; + } + + void __set_parameters(const std::map<std::string, std::string> & val) { + parameters = val; + __isset.parameters = true; + } + + void __set_jobName(const std::string& val) { + jobName = val; + __isset.jobName = true; + } + + void __set_failedCount(const int32_t val) { + failedCount = val; + __isset.failedCount = true; + } + + bool operator == (const JobMonitor & rhs) const + { + if (__isset.username != rhs.__isset.username) + return false; + else if (__isset.username && !(username == rhs.username)) + return false; + if (__isset.jobStartedTime != rhs.__isset.jobStartedTime) + return false; + else if (__isset.jobStartedTime && !(jobStartedTime == rhs.jobStartedTime)) + return false; + if (__isset.lastMonitoredTime != rhs.__isset.lastMonitoredTime) + return false; + else if (__isset.lastMonitoredTime && !(lastMonitoredTime == rhs.lastMonitoredTime)) + return false; + if (__isset.hostId != rhs.__isset.hostId) + return false; + else if (__isset.hostId && !(hostId == rhs.hostId)) + return false; + if (__isset.parameters != rhs.__isset.parameters) + return false; + else if (__isset.parameters && !(parameters == rhs.parameters)) + return false; + if (__isset.jobName != rhs.__isset.jobName) + return false; + else if (__isset.jobName && !(jobName == rhs.jobName)) + return false; + if (__isset.failedCount != rhs.__isset.failedCount) + return false; + else if (__isset.failedCount && !(failedCount == rhs.failedCount)) + return false; + return true; + } + bool operator != (const JobMonitor &rhs) const { + return !(*this == rhs); + } + + bool operator < (const JobMonitor & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(JobMonitor &a, JobMonitor &b); + + +class JobStatusChangeEvent { + public: + + static const char* ascii_fingerprint; // = "A4467EF21DF0026B864BF2B95C34A774"; + static const uint8_t binary_fingerprint[16]; // = {0xA4,0x46,0x7E,0xF2,0x1D,0xF0,0x02,0x6B,0x86,0x4B,0xF2,0xB9,0x5C,0x34,0xA7,0x74}; + + JobStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::JobState::type)0) { + } + + virtual ~JobStatusChangeEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::JobState::type state; + JobIdentity jobIdentity; + JobMonitor jobMonitor; + + void __set_state(const ::apache::airavata::model::workspace::experiment::JobState::type val) { + state = val; + } + + void __set_jobIdentity(const JobIdentity& val) { + jobIdentity = val; + } + + void __set_jobMonitor(const JobMonitor& val) { + jobMonitor = val; + } + + bool operator == (const JobStatusChangeEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(jobIdentity == rhs.jobIdentity)) + return false; + if (!(jobMonitor == rhs.jobMonitor)) + return false; + return true; + } + bool operator != (const JobStatusChangeEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const JobStatusChangeEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b); + +}}}}} // namespace + +#endif http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php new file mode 100644 index 0000000..569f523 --- /dev/null +++ b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php @@ -0,0 +1,990 @@ +<?php +namespace Airavata\Model\Messaging\Event; + +/** + * Autogenerated by Thrift Compiler (0.9.1) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +use Thrift\Base\TBase; +use Thrift\Type\TType; +use Thrift\Type\TMessageType; +use Thrift\Exception\TException; +use Thrift\Exception\TProtocolException; +use Thrift\Protocol\TProtocol; +use Thrift\Protocol\TBinaryProtocolAccelerated; +use Thrift\Exception\TApplicationException; + + +class ExperimentStatusChangeEvent { + static $_TSPEC; + + public $state = null; + public $experimentId = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'state', + 'type' => TType::I32, + ), + 2 => array( + 'var' => 'experimentId', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['experimentId'])) { + $this->experimentId = $vals['experimentId']; + } + } + } + + public function getName() { + return 'ExperimentStatusChangeEvent'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->state); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->experimentId); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ExperimentStatusChangeEvent'); + if ($this->state !== null) { + $xfer += $output->writeFieldBegin('state', TType::I32, 1); + $xfer += $output->writeI32($this->state); + $xfer += $output->writeFieldEnd(); + } + if ($this->experimentId !== null) { + $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 2); + $xfer += $output->writeString($this->experimentId); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WorkflowIdentity { + static $_TSPEC; + + public $workflowNodeId = null; + public $experimentId = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'workflowNodeId', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'experimentId', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['workflowNodeId'])) { + $this->workflowNodeId = $vals['workflowNodeId']; + } + if (isset($vals['experimentId'])) { + $this->experimentId = $vals['experimentId']; + } + } + } + + public function getName() { + return 'WorkflowIdentity'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->workflowNodeId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->experimentId); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WorkflowIdentity'); + if ($this->workflowNodeId !== null) { + $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 1); + $xfer += $output->writeString($this->workflowNodeId); + $xfer += $output->writeFieldEnd(); + } + if ($this->experimentId !== null) { + $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 2); + $xfer += $output->writeString($this->experimentId); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class WorkflowNodeStatusChangeEvent { + static $_TSPEC; + + public $state = null; + public $workflowNodeIdentity = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'state', + 'type' => TType::I32, + ), + 2 => array( + 'var' => 'workflowNodeIdentity', + 'type' => TType::STRUCT, + 'class' => '\Airavata\Model\Messaging\Event\WorkflowIdentity', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['workflowNodeIdentity'])) { + $this->workflowNodeIdentity = $vals['workflowNodeIdentity']; + } + } + } + + public function getName() { + return 'WorkflowNodeStatusChangeEvent'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->state); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->workflowNodeIdentity = new \Airavata\Model\Messaging\Event\WorkflowIdentity(); + $xfer += $this->workflowNodeIdentity->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('WorkflowNodeStatusChangeEvent'); + if ($this->state !== null) { + $xfer += $output->writeFieldBegin('state', TType::I32, 1); + $xfer += $output->writeI32($this->state); + $xfer += $output->writeFieldEnd(); + } + if ($this->workflowNodeIdentity !== null) { + if (!is_object($this->workflowNodeIdentity)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('workflowNodeIdentity', TType::STRUCT, 2); + $xfer += $this->workflowNodeIdentity->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class TaskIdentity { + static $_TSPEC; + + public $taskId = null; + public $workflowNodeId = null; + public $experimentId = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'taskId', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'workflowNodeId', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'experimentId', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['taskId'])) { + $this->taskId = $vals['taskId']; + } + if (isset($vals['workflowNodeId'])) { + $this->workflowNodeId = $vals['workflowNodeId']; + } + if (isset($vals['experimentId'])) { + $this->experimentId = $vals['experimentId']; + } + } + } + + public function getName() { + return 'TaskIdentity'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->taskId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->workflowNodeId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->experimentId); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('TaskIdentity'); + if ($this->taskId !== null) { + $xfer += $output->writeFieldBegin('taskId', TType::STRING, 1); + $xfer += $output->writeString($this->taskId); + $xfer += $output->writeFieldEnd(); + } + if ($this->workflowNodeId !== null) { + $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 2); + $xfer += $output->writeString($this->workflowNodeId); + $xfer += $output->writeFieldEnd(); + } + if ($this->experimentId !== null) { + $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 3); + $xfer += $output->writeString($this->experimentId); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class TaskStatusChangeEvent { + static $_TSPEC; + + public $state = null; + public $taskIdentity = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'state', + 'type' => TType::I32, + ), + 2 => array( + 'var' => 'taskIdentity', + 'type' => TType::STRUCT, + 'class' => '\Airavata\Model\Messaging\Event\TaskIdentity', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['taskIdentity'])) { + $this->taskIdentity = $vals['taskIdentity']; + } + } + } + + public function getName() { + return 'TaskStatusChangeEvent'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->state); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentity(); + $xfer += $this->taskIdentity->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('TaskStatusChangeEvent'); + if ($this->state !== null) { + $xfer += $output->writeFieldBegin('state', TType::I32, 1); + $xfer += $output->writeI32($this->state); + $xfer += $output->writeFieldEnd(); + } + if ($this->taskIdentity !== null) { + if (!is_object($this->taskIdentity)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('taskIdentity', TType::STRUCT, 2); + $xfer += $this->taskIdentity->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class JobIdentity { + static $_TSPEC; + + public $jobId = null; + public $taskId = null; + public $workflowNodeId = null; + public $experimentId = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'jobId', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'taskId', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'workflowNodeId', + 'type' => TType::STRING, + ), + 4 => array( + 'var' => 'experimentId', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['jobId'])) { + $this->jobId = $vals['jobId']; + } + if (isset($vals['taskId'])) { + $this->taskId = $vals['taskId']; + } + if (isset($vals['workflowNodeId'])) { + $this->workflowNodeId = $vals['workflowNodeId']; + } + if (isset($vals['experimentId'])) { + $this->experimentId = $vals['experimentId']; + } + } + } + + public function getName() { + return 'JobIdentity'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->jobId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->taskId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->workflowNodeId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->experimentId); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('JobIdentity'); + if ($this->jobId !== null) { + $xfer += $output->writeFieldBegin('jobId', TType::STRING, 1); + $xfer += $output->writeString($this->jobId); + $xfer += $output->writeFieldEnd(); + } + if ($this->taskId !== null) { + $xfer += $output->writeFieldBegin('taskId', TType::STRING, 2); + $xfer += $output->writeString($this->taskId); + $xfer += $output->writeFieldEnd(); + } + if ($this->workflowNodeId !== null) { + $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 3); + $xfer += $output->writeString($this->workflowNodeId); + $xfer += $output->writeFieldEnd(); + } + if ($this->experimentId !== null) { + $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 4); + $xfer += $output->writeString($this->experimentId); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class JobMonitor { + static $_TSPEC; + + public $username = null; + public $jobStartedTime = null; + public $lastMonitoredTime = null; + public $hostId = null; + public $parameters = null; + public $jobName = null; + public $failedCount = 0; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'username', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'jobStartedTime', + 'type' => TType::I64, + ), + 3 => array( + 'var' => 'lastMonitoredTime', + 'type' => TType::I64, + ), + 4 => array( + 'var' => 'hostId', + 'type' => TType::STRING, + ), + 5 => array( + 'var' => 'parameters', + 'type' => TType::MAP, + 'ktype' => TType::STRING, + 'vtype' => TType::STRING, + 'key' => array( + 'type' => TType::STRING, + ), + 'val' => array( + 'type' => TType::STRING, + ), + ), + 6 => array( + 'var' => 'jobName', + 'type' => TType::STRING, + ), + 7 => array( + 'var' => 'failedCount', + 'type' => TType::I32, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['username'])) { + $this->username = $vals['username']; + } + if (isset($vals['jobStartedTime'])) { + $this->jobStartedTime = $vals['jobStartedTime']; + } + if (isset($vals['lastMonitoredTime'])) { + $this->lastMonitoredTime = $vals['lastMonitoredTime']; + } + if (isset($vals['hostId'])) { + $this->hostId = $vals['hostId']; + } + if (isset($vals['parameters'])) { + $this->parameters = $vals['parameters']; + } + if (isset($vals['jobName'])) { + $this->jobName = $vals['jobName']; + } + if (isset($vals['failedCount'])) { + $this->failedCount = $vals['failedCount']; + } + } + } + + public function getName() { + return 'JobMonitor'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->username); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->jobStartedTime); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::I64) { + $xfer += $input->readI64($this->lastMonitoredTime); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->hostId); + } else { + $xfer += $input->skip($ftype); + } + break; + case 5: + if ($ftype == TType::MAP) { + $this->parameters = array(); + $_size0 = 0; + $_ktype1 = 0; + $_vtype2 = 0; + $xfer += $input->readMapBegin($_ktype1, $_vtype2, $_size0); + for ($_i4 = 0; $_i4 < $_size0; ++$_i4) + { + $key5 = ''; + $val6 = ''; + $xfer += $input->readString($key5); + $xfer += $input->readString($val6); + $this->parameters[$key5] = $val6; + } + $xfer += $input->readMapEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 6: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->jobName); + } else { + $xfer += $input->skip($ftype); + } + break; + case 7: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->failedCount); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('JobMonitor'); + if ($this->username !== null) { + $xfer += $output->writeFieldBegin('username', TType::STRING, 1); + $xfer += $output->writeString($this->username); + $xfer += $output->writeFieldEnd(); + } + if ($this->jobStartedTime !== null) { + $xfer += $output->writeFieldBegin('jobStartedTime', TType::I64, 2); + $xfer += $output->writeI64($this->jobStartedTime); + $xfer += $output->writeFieldEnd(); + } + if ($this->lastMonitoredTime !== null) { + $xfer += $output->writeFieldBegin('lastMonitoredTime', TType::I64, 3); + $xfer += $output->writeI64($this->lastMonitoredTime); + $xfer += $output->writeFieldEnd(); + } + if ($this->hostId !== null) { + $xfer += $output->writeFieldBegin('hostId', TType::STRING, 4); + $xfer += $output->writeString($this->hostId); + $xfer += $output->writeFieldEnd(); + } + if ($this->parameters !== null) { + if (!is_array($this->parameters)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('parameters', TType::MAP, 5); + { + $output->writeMapBegin(TType::STRING, TType::STRING, count($this->parameters)); + { + foreach ($this->parameters as $kiter7 => $viter8) + { + $xfer += $output->writeString($kiter7); + $xfer += $output->writeString($viter8); + } + } + $output->writeMapEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->jobName !== null) { + $xfer += $output->writeFieldBegin('jobName', TType::STRING, 6); + $xfer += $output->writeString($this->jobName); + $xfer += $output->writeFieldEnd(); + } + if ($this->failedCount !== null) { + $xfer += $output->writeFieldBegin('failedCount', TType::I32, 7); + $xfer += $output->writeI32($this->failedCount); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class JobStatusChangeEvent { + static $_TSPEC; + + public $state = null; + public $jobIdentity = null; + public $jobMonitor = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'state', + 'type' => TType::I32, + ), + 2 => array( + 'var' => 'jobIdentity', + 'type' => TType::STRUCT, + 'class' => '\Airavata\Model\Messaging\Event\JobIdentity', + ), + 3 => array( + 'var' => 'jobMonitor', + 'type' => TType::STRUCT, + 'class' => '\Airavata\Model\Messaging\Event\JobMonitor', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['jobIdentity'])) { + $this->jobIdentity = $vals['jobIdentity']; + } + if (isset($vals['jobMonitor'])) { + $this->jobMonitor = $vals['jobMonitor']; + } + } + } + + public function getName() { + return 'JobStatusChangeEvent'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->state); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->jobIdentity = new \Airavata\Model\Messaging\Event\JobIdentity(); + $xfer += $this->jobIdentity->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->jobMonitor = new \Airavata\Model\Messaging\Event\JobMonitor(); + $xfer += $this->jobMonitor->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('JobStatusChangeEvent'); + if ($this->state !== null) { + $xfer += $output->writeFieldBegin('state', TType::I32, 1); + $xfer += $output->writeI32($this->state); + $xfer += $output->writeFieldEnd(); + } + if ($this->jobIdentity !== null) { + if (!is_object($this->jobIdentity)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('jobIdentity', TType::STRUCT, 2); + $xfer += $this->jobIdentity->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->jobMonitor !== null) { + if (!is_object($this->jobMonitor)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('jobMonitor', TType::STRUCT, 3); + $xfer += $this->jobMonitor->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +
