removing recursively calling publish
Project: http://git-wip-us.apache.org/repos/asf/airavata/repo Commit: http://git-wip-us.apache.org/repos/asf/airavata/commit/255dd9e3 Tree: http://git-wip-us.apache.org/repos/asf/airavata/tree/255dd9e3 Diff: http://git-wip-us.apache.org/repos/asf/airavata/diff/255dd9e3 Branch: refs/heads/messaging_framework Commit: 255dd9e397890ac24aa7853e382613e10102164f Parents: cc71bac Author: chathuriw <[email protected]> Authored: Fri Sep 26 16:03:52 2014 -0400 Committer: Chathuri Wimalasena <[email protected]> Committed: Fri Sep 26 16:03:52 2014 -0400 ---------------------------------------------------------------------- .../AiravataExperimentStatusUpdator.java | 6 +- .../lib/airavata/messagingEvents_types.cpp | 238 +++- .../lib/airavata/messagingEvents_types.h | 146 ++- .../Airavata/Model/Messaging/Event/Types.php | 228 +++- .../client/samples/CreateLaunchExperiment.java | 12 +- .../model/messaging/event/JobIdentifier.java | 684 ++++++++++++ .../model/messaging/event/JobIdentity.java | 684 ------------ .../model/messaging/event/JobMonitor.java | 1043 ------------------ .../messaging/event/JobStatusChangeEvent.java | 18 +- .../event/JobStatusChangeRequestEvent.java | 509 +++++++++ .../model/messaging/event/TaskIdentifier.java | 588 ++++++++++ .../model/messaging/event/TaskIdentity.java | 588 ---------- .../messaging/event/TaskOutputChangeEvent.java | 18 +- .../messaging/event/TaskStatusChangeEvent.java | 18 +- .../event/TaskStatusChangeRequestEvent.java | 509 +++++++++ .../messaging/event/WorkflowIdentifier.java | 492 +++++++++ .../model/messaging/event/WorkflowIdentity.java | 492 --------- .../event/WorkflowNodeStatusChangeEvent.java | 18 +- .../messagingEvents.thrift | 25 +- .../main/resources/airavata-server.properties | 2 +- .../airavata/gfac/core/cpi/BetterGfacImpl.java | 21 +- .../apache/airavata/gfac/core/cpi/GFacImpl.java | 10 +- .../core/monitor/AiravataJobStatusUpdator.java | 12 +- .../core/monitor/AiravataTaskStatusUpdator.java | 46 +- .../AiravataWorkflowNodeStatusUpdator.java | 12 +- .../gfac/core/monitor/ExperimentIdentity.java | 72 +- .../airavata/gfac/core/monitor/JobIdentity.java | 78 +- .../gfac/core/monitor/TaskIdentity.java | 76 +- .../gfac/core/monitor/WorkflowNodeIdentity.java | 74 +- .../state/GfacExperimentStateChangeRequest.java | 12 +- .../gfac/local/provider/impl/LocalProvider.java | 8 +- .../monitor/impl/pull/qstat/HPCPullMonitor.java | 29 +- .../monitor/impl/push/amqp/AMQPMonitor.java | 4 +- .../messaging/core/impl/RabbitMQPublisher.java | 7 +- 34 files changed, 3609 insertions(+), 3170 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/airavata-api/airavata-api-server/src/main/java/org/apache/airavata/api/server/listener/AiravataExperimentStatusUpdator.java ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-api-server/src/main/java/org/apache/airavata/api/server/listener/AiravataExperimentStatusUpdator.java b/airavata-api/airavata-api-server/src/main/java/org/apache/airavata/api/server/listener/AiravataExperimentStatusUpdator.java index e448fec..5d0996f 100644 --- a/airavata-api/airavata-api-server/src/main/java/org/apache/airavata/api/server/listener/AiravataExperimentStatusUpdator.java +++ b/airavata-api/airavata-api-server/src/main/java/org/apache/airavata/api/server/listener/AiravataExperimentStatusUpdator.java @@ -89,10 +89,10 @@ public class AiravataExperimentStatusUpdator implements AbstractActivityListener } updateExperimentStatus(nodeStatus.getWorkflowNodeIdentity().getExperimentId(), state); logger.debug("Publishing experiment status for "+nodeStatus.getWorkflowNodeIdentity().getExperimentId()+":"+state.toString()); - monitorPublisher.publish(new ExperimentStatusChangeEvent(state, nodeStatus.getWorkflowNodeIdentity().getExperimentId())); - ExperimentStatusChangeEvent experimentStatusChangeEvent = new ExperimentStatusChangeEvent(state, nodeStatus.getWorkflowNodeIdentity().getExperimentId()); + ExperimentStatusChangeEvent event = new ExperimentStatusChangeEvent(state, nodeStatus.getWorkflowNodeIdentity().getExperimentId()); + monitorPublisher.publish(event); String messageId = AiravataUtils.getId("EXPERIMENT"); - MessageContext msgCntxt = new MessageContext(experimentStatusChangeEvent, MessageType.EXPERIMENT, messageId); + MessageContext msgCntxt = new MessageContext(event, MessageType.EXPERIMENT, messageId); msgCntxt.setUpdatedTime(AiravataUtils.getCurrentTimestamp()); if ( ServerSettings.isRabbitMqPublishEnabled()){ publisher.publish(msgCntxt); http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/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 index fae1f5d..f7c123a 100644 --- 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 @@ -137,10 +137,10 @@ void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b) { 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}; +const char* WorkflowIdentifier::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972"; +const uint8_t WorkflowIdentifier::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 WorkflowIdentifier::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; std::string fname; @@ -194,9 +194,9 @@ uint32_t WorkflowIdentity::read(::apache::thrift::protocol::TProtocol* iprot) { return xfer; } -uint32_t WorkflowIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t WorkflowIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("WorkflowIdentity"); + xfer += oprot->writeStructBegin("WorkflowIdentifier"); xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->workflowNodeId); @@ -211,7 +211,7 @@ uint32_t WorkflowIdentity::write(::apache::thrift::protocol::TProtocol* oprot) c return xfer; } -void swap(WorkflowIdentity &a, WorkflowIdentity &b) { +void swap(WorkflowIdentifier &a, WorkflowIdentifier &b) { using ::std::swap; swap(a.workflowNodeId, b.workflowNodeId); swap(a.experimentId, b.experimentId); @@ -299,10 +299,10 @@ void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b) { 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}; +const char* TaskIdentifier::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; +const uint8_t TaskIdentifier::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 TaskIdentifier::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; std::string fname; @@ -367,9 +367,9 @@ uint32_t TaskIdentity::read(::apache::thrift::protocol::TProtocol* iprot) { return xfer; } -uint32_t TaskIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t TaskIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("TaskIdentity"); + xfer += oprot->writeStructBegin("TaskIdentifier"); xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->taskId); @@ -388,7 +388,7 @@ uint32_t TaskIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const return xfer; } -void swap(TaskIdentity &a, TaskIdentity &b) { +void swap(TaskIdentifier &a, TaskIdentifier &b) { using ::std::swap; swap(a.taskId, b.taskId); swap(a.workflowNodeId, b.workflowNodeId); @@ -477,6 +477,88 @@ void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b) { swap(a.taskIdentity, b.taskIdentity); } +const char* TaskStatusChangeRequestEvent::ascii_fingerprint = "9686679C94D43D75F2B35A0BED2E4003"; +const uint8_t TaskStatusChangeRequestEvent::binary_fingerprint[16] = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03}; + +uint32_t TaskStatusChangeRequestEvent::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 ecast3; + xfer += iprot->readI32(ecast3); + this->state = ( ::apache::airavata::model::workspace::experiment::TaskState::type)ecast3; + 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 TaskStatusChangeRequestEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("TaskStatusChangeRequestEvent"); + + 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(TaskStatusChangeRequestEvent &a, TaskStatusChangeRequestEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.taskIdentity, b.taskIdentity); +} + const char* TaskOutputChangeEvent::ascii_fingerprint = "6488123A3A8B4CF758D069C9B693C7EB"; const uint8_t TaskOutputChangeEvent::binary_fingerprint[16] = {0x64,0x88,0x12,0x3A,0x3A,0x8B,0x4C,0xF7,0x58,0xD0,0x69,0xC9,0xB6,0x93,0xC7,0xEB}; @@ -506,14 +588,14 @@ uint32_t TaskOutputChangeEvent::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->output.clear(); - uint32_t _size3; - ::apache::thrift::protocol::TType _etype6; - xfer += iprot->readListBegin(_etype6, _size3); - this->output.resize(_size3); - uint32_t _i7; - for (_i7 = 0; _i7 < _size3; ++_i7) + uint32_t _size4; + ::apache::thrift::protocol::TType _etype7; + xfer += iprot->readListBegin(_etype7, _size4); + this->output.resize(_size4); + uint32_t _i8; + for (_i8 = 0; _i8 < _size4; ++_i8) { - xfer += this->output[_i7].read(iprot); + xfer += this->output[_i8].read(iprot); } xfer += iprot->readListEnd(); } @@ -553,10 +635,10 @@ uint32_t TaskOutputChangeEvent::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("output", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->output.size())); - std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> ::const_iterator _iter8; - for (_iter8 = this->output.begin(); _iter8 != this->output.end(); ++_iter8) + std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> ::const_iterator _iter9; + for (_iter9 = this->output.begin(); _iter9 != this->output.end(); ++_iter9) { - xfer += (*_iter8).write(oprot); + xfer += (*_iter9).write(oprot); } xfer += oprot->writeListEnd(); } @@ -577,10 +659,10 @@ void swap(TaskOutputChangeEvent &a, TaskOutputChangeEvent &b) { 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}; +const char* JobIdentifier::ascii_fingerprint = "C93D890311F28844166CF6E571EB3AC2"; +const uint8_t JobIdentifier::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 JobIdentifier::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; std::string fname; @@ -656,9 +738,9 @@ uint32_t JobIdentity::read(::apache::thrift::protocol::TProtocol* iprot) { return xfer; } -uint32_t JobIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t JobIdentifier::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("JobIdentity"); + xfer += oprot->writeStructBegin("JobIdentifier"); xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->jobId); @@ -681,7 +763,7 @@ uint32_t JobIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const return xfer; } -void swap(JobIdentity &a, JobIdentity &b) { +void swap(JobIdentifier &a, JobIdentifier &b) { using ::std::swap; swap(a.jobId, b.jobId); swap(a.taskId, b.taskId); @@ -716,9 +798,9 @@ uint32_t JobStatusChangeEvent::read(::apache::thrift::protocol::TProtocol* iprot { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast9; - xfer += iprot->readI32(ecast9); - this->state = ( ::apache::airavata::model::workspace::experiment::JobState::type)ecast9; + int32_t ecast10; + xfer += iprot->readI32(ecast10); + this->state = ( ::apache::airavata::model::workspace::experiment::JobState::type)ecast10; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -771,6 +853,88 @@ void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b) { swap(a.jobIdentity, b.jobIdentity); } +const char* JobStatusChangeRequestEvent::ascii_fingerprint = "8D18A3CD1822DBC67D7BD8CB98E7B4F1"; +const uint8_t JobStatusChangeRequestEvent::binary_fingerprint[16] = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1}; + +uint32_t JobStatusChangeRequestEvent::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; + + 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; + 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); + return xfer; +} + +uint32_t JobStatusChangeRequestEvent::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("JobStatusChangeRequestEvent"); + + 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->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(JobStatusChangeRequestEvent &a, JobStatusChangeRequestEvent &b) { + using ::std::swap; + swap(a.state, b.state); + swap(a.jobIdentity, b.jobIdentity); +} + const char* Message::ascii_fingerprint = "6904C391426E568AF9DEAF69860C076A"; const uint8_t Message::binary_fingerprint[16] = {0x69,0x04,0xC3,0x91,0x42,0x6E,0x56,0x8A,0xF9,0xDE,0xAF,0x69,0x86,0x0C,0x07,0x6A}; @@ -815,9 +979,9 @@ uint32_t Message::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast10; - xfer += iprot->readI32(ecast10); - this->messageType = (MessageType::type)ecast10; + int32_t ecast12; + xfer += iprot->readI32(ecast12); + this->messageType = (MessageType::type)ecast12; isset_messageType = true; } else { xfer += iprot->skip(ftype); @@ -833,9 +997,9 @@ uint32_t Message::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast11; - xfer += iprot->readI32(ecast11); - this->messageLevel = (MessageLevel::type)ecast11; + int32_t ecast13; + xfer += iprot->readI32(ecast13); + this->messageLevel = (MessageLevel::type)ecast13; this->__isset.messageLevel = true; } else { xfer += iprot->skip(ftype); http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/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 index fe80785..3ce8e79 100644 --- 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 @@ -102,16 +102,16 @@ class ExperimentStatusChangeEvent { void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b); -class WorkflowIdentity { +class WorkflowIdentifier { 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() { + WorkflowIdentifier() : workflowNodeId(), experimentId() { } - virtual ~WorkflowIdentity() throw() {} + virtual ~WorkflowIdentifier() throw() {} std::string workflowNodeId; std::string experimentId; @@ -124,7 +124,7 @@ class WorkflowIdentity { experimentId = val; } - bool operator == (const WorkflowIdentity & rhs) const + bool operator == (const WorkflowIdentifier & rhs) const { if (!(workflowNodeId == rhs.workflowNodeId)) return false; @@ -132,18 +132,18 @@ class WorkflowIdentity { return false; return true; } - bool operator != (const WorkflowIdentity &rhs) const { + bool operator != (const WorkflowIdentifier &rhs) const { return !(*this == rhs); } - bool operator < (const WorkflowIdentity & ) const; + bool operator < (const WorkflowIdentifier & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -void swap(WorkflowIdentity &a, WorkflowIdentity &b); +void swap(WorkflowIdentifier &a, WorkflowIdentifier &b); class WorkflowNodeStatusChangeEvent { @@ -158,13 +158,13 @@ class WorkflowNodeStatusChangeEvent { virtual ~WorkflowNodeStatusChangeEvent() throw() {} ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type state; - WorkflowIdentity workflowNodeIdentity; + WorkflowIdentifier workflowNodeIdentity; void __set_state(const ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type val) { state = val; } - void __set_workflowNodeIdentity(const WorkflowIdentity& val) { + void __set_workflowNodeIdentity(const WorkflowIdentifier& val) { workflowNodeIdentity = val; } @@ -190,16 +190,16 @@ class WorkflowNodeStatusChangeEvent { void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b); -class TaskIdentity { +class TaskIdentifier { 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() { + TaskIdentifier() : taskId(), workflowNodeId(), experimentId() { } - virtual ~TaskIdentity() throw() {} + virtual ~TaskIdentifier() throw() {} std::string taskId; std::string workflowNodeId; @@ -217,7 +217,7 @@ class TaskIdentity { experimentId = val; } - bool operator == (const TaskIdentity & rhs) const + bool operator == (const TaskIdentifier & rhs) const { if (!(taskId == rhs.taskId)) return false; @@ -227,18 +227,18 @@ class TaskIdentity { return false; return true; } - bool operator != (const TaskIdentity &rhs) const { + bool operator != (const TaskIdentifier &rhs) const { return !(*this == rhs); } - bool operator < (const TaskIdentity & ) const; + bool operator < (const TaskIdentifier & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -void swap(TaskIdentity &a, TaskIdentity &b); +void swap(TaskIdentifier &a, TaskIdentifier &b); class TaskStatusChangeEvent { @@ -253,13 +253,13 @@ class TaskStatusChangeEvent { virtual ~TaskStatusChangeEvent() throw() {} ::apache::airavata::model::workspace::experiment::TaskState::type state; - TaskIdentity taskIdentity; + TaskIdentifier taskIdentity; void __set_state(const ::apache::airavata::model::workspace::experiment::TaskState::type val) { state = val; } - void __set_taskIdentity(const TaskIdentity& val) { + void __set_taskIdentity(const TaskIdentifier& val) { taskIdentity = val; } @@ -285,6 +285,50 @@ class TaskStatusChangeEvent { void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b); +class TaskStatusChangeRequestEvent { + 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}; + + TaskStatusChangeRequestEvent() : state(( ::apache::airavata::model::workspace::experiment::TaskState::type)0) { + } + + virtual ~TaskStatusChangeRequestEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::TaskState::type state; + TaskIdentifier taskIdentity; + + void __set_state(const ::apache::airavata::model::workspace::experiment::TaskState::type val) { + state = val; + } + + void __set_taskIdentity(const TaskIdentifier& val) { + taskIdentity = val; + } + + bool operator == (const TaskStatusChangeRequestEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(taskIdentity == rhs.taskIdentity)) + return false; + return true; + } + bool operator != (const TaskStatusChangeRequestEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const TaskStatusChangeRequestEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(TaskStatusChangeRequestEvent &a, TaskStatusChangeRequestEvent &b); + + class TaskOutputChangeEvent { public: @@ -297,13 +341,13 @@ class TaskOutputChangeEvent { virtual ~TaskOutputChangeEvent() throw() {} std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> output; - TaskIdentity taskIdentity; + TaskIdentifier taskIdentity; void __set_output(const std::vector< ::apache::airavata::model::workspace::experiment::DataObjectType> & val) { output = val; } - void __set_taskIdentity(const TaskIdentity& val) { + void __set_taskIdentity(const TaskIdentifier& val) { taskIdentity = val; } @@ -329,16 +373,16 @@ class TaskOutputChangeEvent { void swap(TaskOutputChangeEvent &a, TaskOutputChangeEvent &b); -class JobIdentity { +class JobIdentifier { 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() { + JobIdentifier() : jobId(), taskId(), workflowNodeId(), experimentId() { } - virtual ~JobIdentity() throw() {} + virtual ~JobIdentifier() throw() {} std::string jobId; std::string taskId; @@ -361,7 +405,7 @@ class JobIdentity { experimentId = val; } - bool operator == (const JobIdentity & rhs) const + bool operator == (const JobIdentifier & rhs) const { if (!(jobId == rhs.jobId)) return false; @@ -373,18 +417,18 @@ class JobIdentity { return false; return true; } - bool operator != (const JobIdentity &rhs) const { + bool operator != (const JobIdentifier &rhs) const { return !(*this == rhs); } - bool operator < (const JobIdentity & ) const; + bool operator < (const JobIdentifier & ) const; uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; }; -void swap(JobIdentity &a, JobIdentity &b); +void swap(JobIdentifier &a, JobIdentifier &b); class JobStatusChangeEvent { @@ -399,13 +443,13 @@ class JobStatusChangeEvent { virtual ~JobStatusChangeEvent() throw() {} ::apache::airavata::model::workspace::experiment::JobState::type state; - JobIdentity jobIdentity; + JobIdentifier jobIdentity; void __set_state(const ::apache::airavata::model::workspace::experiment::JobState::type val) { state = val; } - void __set_jobIdentity(const JobIdentity& val) { + void __set_jobIdentity(const JobIdentifier& val) { jobIdentity = val; } @@ -430,6 +474,50 @@ class JobStatusChangeEvent { void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b); + +class JobStatusChangeRequestEvent { + public: + + static const char* ascii_fingerprint; // = "8D18A3CD1822DBC67D7BD8CB98E7B4F1"; + static const uint8_t binary_fingerprint[16]; // = {0x8D,0x18,0xA3,0xCD,0x18,0x22,0xDB,0xC6,0x7D,0x7B,0xD8,0xCB,0x98,0xE7,0xB4,0xF1}; + + JobStatusChangeRequestEvent() : state(( ::apache::airavata::model::workspace::experiment::JobState::type)0) { + } + + virtual ~JobStatusChangeRequestEvent() throw() {} + + ::apache::airavata::model::workspace::experiment::JobState::type state; + JobIdentifier jobIdentity; + + void __set_state(const ::apache::airavata::model::workspace::experiment::JobState::type val) { + state = val; + } + + void __set_jobIdentity(const JobIdentifier& val) { + jobIdentity = val; + } + + bool operator == (const JobStatusChangeRequestEvent & rhs) const + { + if (!(state == rhs.state)) + return false; + if (!(jobIdentity == rhs.jobIdentity)) + return false; + return true; + } + bool operator != (const JobStatusChangeRequestEvent &rhs) const { + return !(*this == rhs); + } + + bool operator < (const JobStatusChangeRequestEvent & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(JobStatusChangeRequestEvent &a, JobStatusChangeRequestEvent &b); + typedef struct _Message__isset { _Message__isset() : updatedTime(false), messageLevel(false) {} bool updatedTime; http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/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 index 989e7b2..bb950ab 100644 --- 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 @@ -135,7 +135,7 @@ class ExperimentStatusChangeEvent { } -class WorkflowIdentity { +class WorkflowIdentifier { static $_TSPEC; public $workflowNodeId = null; @@ -165,7 +165,7 @@ class WorkflowIdentity { } public function getName() { - return 'WorkflowIdentity'; + return 'WorkflowIdentifier'; } public function read($input) @@ -209,7 +209,7 @@ class WorkflowIdentity { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('WorkflowIdentity'); + $xfer += $output->writeStructBegin('WorkflowIdentifier'); if ($this->workflowNodeId !== null) { $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 1); $xfer += $output->writeString($this->workflowNodeId); @@ -243,7 +243,7 @@ class WorkflowNodeStatusChangeEvent { 2 => array( 'var' => 'workflowNodeIdentity', 'type' => TType::STRUCT, - 'class' => '\Airavata\Model\Messaging\Event\WorkflowIdentity', + 'class' => '\Airavata\Model\Messaging\Event\WorkflowIdentifier', ), ); } @@ -285,7 +285,7 @@ class WorkflowNodeStatusChangeEvent { break; case 2: if ($ftype == TType::STRUCT) { - $this->workflowNodeIdentity = new \Airavata\Model\Messaging\Event\WorkflowIdentity(); + $this->workflowNodeIdentity = new \Airavata\Model\Messaging\Event\WorkflowIdentifier(); $xfer += $this->workflowNodeIdentity->read($input); } else { $xfer += $input->skip($ftype); @@ -324,7 +324,7 @@ class WorkflowNodeStatusChangeEvent { } -class TaskIdentity { +class TaskIdentifier { static $_TSPEC; public $taskId = null; @@ -362,7 +362,7 @@ class TaskIdentity { } public function getName() { - return 'TaskIdentity'; + return 'TaskIdentifier'; } public function read($input) @@ -413,7 +413,7 @@ class TaskIdentity { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('TaskIdentity'); + $xfer += $output->writeStructBegin('TaskIdentifier'); if ($this->taskId !== null) { $xfer += $output->writeFieldBegin('taskId', TType::STRING, 1); $xfer += $output->writeString($this->taskId); @@ -452,7 +452,7 @@ class TaskStatusChangeEvent { 2 => array( 'var' => 'taskIdentity', 'type' => TType::STRUCT, - 'class' => '\Airavata\Model\Messaging\Event\TaskIdentity', + 'class' => '\Airavata\Model\Messaging\Event\TaskIdentifier', ), ); } @@ -494,7 +494,7 @@ class TaskStatusChangeEvent { break; case 2: if ($ftype == TType::STRUCT) { - $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentity(); + $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentifier(); $xfer += $this->taskIdentity->read($input); } else { $xfer += $input->skip($ftype); @@ -533,6 +533,103 @@ class TaskStatusChangeEvent { } +class TaskStatusChangeRequestEvent { + 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\TaskIdentifier', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['taskIdentity'])) { + $this->taskIdentity = $vals['taskIdentity']; + } + } + } + + public function getName() { + return 'TaskStatusChangeRequestEvent'; + } + + 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\TaskIdentifier(); + $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('TaskStatusChangeRequestEvent'); + 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 TaskOutputChangeEvent { static $_TSPEC; @@ -554,7 +651,7 @@ class TaskOutputChangeEvent { 2 => array( 'var' => 'taskIdentity', 'type' => TType::STRUCT, - 'class' => '\Airavata\Model\Messaging\Event\TaskIdentity', + 'class' => '\Airavata\Model\Messaging\Event\TaskIdentifier', ), ); } @@ -607,7 +704,7 @@ class TaskOutputChangeEvent { break; case 2: if ($ftype == TType::STRUCT) { - $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentity(); + $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentifier(); $xfer += $this->taskIdentity->read($input); } else { $xfer += $input->skip($ftype); @@ -658,7 +755,7 @@ class TaskOutputChangeEvent { } -class JobIdentity { +class JobIdentifier { static $_TSPEC; public $jobId = null; @@ -704,7 +801,7 @@ class JobIdentity { } public function getName() { - return 'JobIdentity'; + return 'JobIdentifier'; } public function read($input) @@ -762,7 +859,7 @@ class JobIdentity { public function write($output) { $xfer = 0; - $xfer += $output->writeStructBegin('JobIdentity'); + $xfer += $output->writeStructBegin('JobIdentifier'); if ($this->jobId !== null) { $xfer += $output->writeFieldBegin('jobId', TType::STRING, 1); $xfer += $output->writeString($this->jobId); @@ -806,7 +903,7 @@ class JobStatusChangeEvent { 2 => array( 'var' => 'jobIdentity', 'type' => TType::STRUCT, - 'class' => '\Airavata\Model\Messaging\Event\JobIdentity', + 'class' => '\Airavata\Model\Messaging\Event\JobIdentifier', ), ); } @@ -848,7 +945,7 @@ class JobStatusChangeEvent { break; case 2: if ($ftype == TType::STRUCT) { - $this->jobIdentity = new \Airavata\Model\Messaging\Event\JobIdentity(); + $this->jobIdentity = new \Airavata\Model\Messaging\Event\JobIdentifier(); $xfer += $this->jobIdentity->read($input); } else { $xfer += $input->skip($ftype); @@ -887,6 +984,103 @@ class JobStatusChangeEvent { } +class JobStatusChangeRequestEvent { + static $_TSPEC; + + public $state = null; + public $jobIdentity = 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\JobIdentifier', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['state'])) { + $this->state = $vals['state']; + } + if (isset($vals['jobIdentity'])) { + $this->jobIdentity = $vals['jobIdentity']; + } + } + } + + public function getName() { + return 'JobStatusChangeRequestEvent'; + } + + 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\JobIdentifier(); + $xfer += $this->jobIdentity->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('JobStatusChangeRequestEvent'); + 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(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class Message { static $_TSPEC; http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/airavata-api/airavata-client-sdks/java-client-samples/src/main/java/org/apache/airavata/client/samples/CreateLaunchExperiment.java ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-client-sdks/java-client-samples/src/main/java/org/apache/airavata/client/samples/CreateLaunchExperiment.java b/airavata-api/airavata-client-sdks/java-client-samples/src/main/java/org/apache/airavata/client/samples/CreateLaunchExperiment.java index 967577c..e9b74f5 100644 --- a/airavata-api/airavata-client-sdks/java-client-samples/src/main/java/org/apache/airavata/client/samples/CreateLaunchExperiment.java +++ b/airavata-api/airavata-client-sdks/java-client-samples/src/main/java/org/apache/airavata/client/samples/CreateLaunchExperiment.java @@ -58,10 +58,10 @@ public class CreateLaunchExperiment { private static final String DEFAULT_USER = "default.registry.user"; private static final String DEFAULT_GATEWAY = "default.registry.gateway"; private static Airavata.Client client; - private static String localHostAppId = "localhost_9c5b098c-8906-4be1-9ef3-a7706c9b1e2c,SimpleEcho0_315d9b93-2cdb-4c1b-8dc3-d2077936f5ae"; + private static String localHostAppId = "localhost_de131adb-fd50-492e-a68d-292b17db4faf,SimpleEcho0_23670b88-3ea2-48ff-9b6d-cca9d7b297e6"; private static String sshHostAppId; - private static String pbsEchoAppId = "trestles.sdsc.edu_849a1136-7e0a-4f4a-b835-322a83b967b6,SimpleEcho2_f89d3b8c-6f22-4a77-a9f5-a4df88785ab6"; - private static String pbsWRFAppId = "trestles.sdsc.edu_00482169-8fc4-4633-b779-5ca1f66f27c1,WRF_0f1e90d3-5915-4629-a5a4-73346c1e7535"; + private static String pbsEchoAppId = "trestles.sdsc.edu_07053ec9-2e8f-4d72-bb4d-3a12fe4360de,SimpleEcho2_c81741d5-47d0-4aa7-9ee5-2a6ad5f586e2"; + private static String pbsWRFAppId = "trestles.sdsc.edu_5fc718ca-b298-4284-a99b-b23e06b10f06,WRF_e304f95a-83d7-46ba-8292-083aa6a46880"; private static String slurmAppId = "stampede.tacc.xsede.org_b2ef59cb-f626-4767-9ca0-601f94c42ba4,SimpleEcho3_b81c2559-a088-42a3-84ce-40119d874918"; private static String sgeAppId; private static String br2EchoAppId = "bigred2_9c1e6be8-f7d8-4494-98f2-bf508790e8c6,SimpleEchoBR_149fd613-98e2-46e7-ac7c-4d393349469e"; @@ -77,12 +77,12 @@ public class CreateLaunchExperiment { AiravataUtils.setExecutionAsClient(); client = AiravataClientFactory.createAiravataClient(THRIFT_SERVER_HOST, THRIFT_SERVER_PORT); System.out.println("API version is " + client.getAPIVersion()); - addDescriptors(); +// addDescriptors(); //// final String expId = createExperimentForSSHHost(airavata); -//// final String expId = createExperimentForTrestles(client); + final String expId = createExperimentForTrestles(client); //// final String expId = createExperimentForStampede(client); - final String expId = createExperimentForLocalHost(client); +// final String expId = createExperimentForLocalHost(client); // final String expId = createExperimentForLonestar(airavata); // final String expId = createExperimentWRFTrestles(client); // final String expId = createExperimentForBR2(client); http://git-wip-us.apache.org/repos/asf/airavata/blob/255dd9e3/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/messaging/event/JobIdentifier.java ---------------------------------------------------------------------- diff --git a/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/messaging/event/JobIdentifier.java b/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/messaging/event/JobIdentifier.java new file mode 100644 index 0000000..ef2eb40 --- /dev/null +++ b/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/messaging/event/JobIdentifier.java @@ -0,0 +1,684 @@ +/** + * 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 + */ +package org.apache.airavata.model.messaging.event; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings("all") public class JobIdentifier implements org.apache.thrift.TBase<JobIdentifier, JobIdentifier._Fields>, java.io.Serializable, Cloneable, Comparable<JobIdentifier> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("JobIdentifier"); + + private static final org.apache.thrift.protocol.TField JOB_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("jobId", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TASK_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("taskId", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField WORKFLOW_NODE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("workflowNodeId", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField EXPERIMENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("experimentId", org.apache.thrift.protocol.TType.STRING, (short)4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new JobIdentifierStandardSchemeFactory()); + schemes.put(TupleScheme.class, new JobIdentifierTupleSchemeFactory()); + } + + private String jobId; // required + private String taskId; // required + private String workflowNodeId; // required + private String experimentId; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + @SuppressWarnings("all") public enum _Fields implements org.apache.thrift.TFieldIdEnum { + JOB_ID((short)1, "jobId"), + TASK_ID((short)2, "taskId"), + WORKFLOW_NODE_ID((short)3, "workflowNodeId"), + EXPERIMENT_ID((short)4, "experimentId"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // JOB_ID + return JOB_ID; + case 2: // TASK_ID + return TASK_ID; + case 3: // WORKFLOW_NODE_ID + return WORKFLOW_NODE_ID; + case 4: // EXPERIMENT_ID + return EXPERIMENT_ID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.JOB_ID, new org.apache.thrift.meta_data.FieldMetaData("jobId", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TASK_ID, new org.apache.thrift.meta_data.FieldMetaData("taskId", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.WORKFLOW_NODE_ID, new org.apache.thrift.meta_data.FieldMetaData("workflowNodeId", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EXPERIMENT_ID, new org.apache.thrift.meta_data.FieldMetaData("experimentId", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(JobIdentifier.class, metaDataMap); + } + + public JobIdentifier() { + } + + public JobIdentifier( + String jobId, + String taskId, + String workflowNodeId, + String experimentId) + { + this(); + this.jobId = jobId; + this.taskId = taskId; + this.workflowNodeId = workflowNodeId; + this.experimentId = experimentId; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public JobIdentifier(JobIdentifier other) { + if (other.isSetJobId()) { + this.jobId = other.jobId; + } + if (other.isSetTaskId()) { + this.taskId = other.taskId; + } + if (other.isSetWorkflowNodeId()) { + this.workflowNodeId = other.workflowNodeId; + } + if (other.isSetExperimentId()) { + this.experimentId = other.experimentId; + } + } + + public JobIdentifier deepCopy() { + return new JobIdentifier(this); + } + + @Override + public void clear() { + this.jobId = null; + this.taskId = null; + this.workflowNodeId = null; + this.experimentId = null; + } + + public String getJobId() { + return this.jobId; + } + + public void setJobId(String jobId) { + this.jobId = jobId; + } + + public void unsetJobId() { + this.jobId = null; + } + + /** Returns true if field jobId is set (has been assigned a value) and false otherwise */ + public boolean isSetJobId() { + return this.jobId != null; + } + + public void setJobIdIsSet(boolean value) { + if (!value) { + this.jobId = null; + } + } + + public String getTaskId() { + return this.taskId; + } + + public void setTaskId(String taskId) { + this.taskId = taskId; + } + + public void unsetTaskId() { + this.taskId = null; + } + + /** Returns true if field taskId is set (has been assigned a value) and false otherwise */ + public boolean isSetTaskId() { + return this.taskId != null; + } + + public void setTaskIdIsSet(boolean value) { + if (!value) { + this.taskId = null; + } + } + + public String getWorkflowNodeId() { + return this.workflowNodeId; + } + + public void setWorkflowNodeId(String workflowNodeId) { + this.workflowNodeId = workflowNodeId; + } + + public void unsetWorkflowNodeId() { + this.workflowNodeId = null; + } + + /** Returns true if field workflowNodeId is set (has been assigned a value) and false otherwise */ + public boolean isSetWorkflowNodeId() { + return this.workflowNodeId != null; + } + + public void setWorkflowNodeIdIsSet(boolean value) { + if (!value) { + this.workflowNodeId = null; + } + } + + public String getExperimentId() { + return this.experimentId; + } + + public void setExperimentId(String experimentId) { + this.experimentId = experimentId; + } + + public void unsetExperimentId() { + this.experimentId = null; + } + + /** Returns true if field experimentId is set (has been assigned a value) and false otherwise */ + public boolean isSetExperimentId() { + return this.experimentId != null; + } + + public void setExperimentIdIsSet(boolean value) { + if (!value) { + this.experimentId = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case JOB_ID: + if (value == null) { + unsetJobId(); + } else { + setJobId((String)value); + } + break; + + case TASK_ID: + if (value == null) { + unsetTaskId(); + } else { + setTaskId((String)value); + } + break; + + case WORKFLOW_NODE_ID: + if (value == null) { + unsetWorkflowNodeId(); + } else { + setWorkflowNodeId((String)value); + } + break; + + case EXPERIMENT_ID: + if (value == null) { + unsetExperimentId(); + } else { + setExperimentId((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case JOB_ID: + return getJobId(); + + case TASK_ID: + return getTaskId(); + + case WORKFLOW_NODE_ID: + return getWorkflowNodeId(); + + case EXPERIMENT_ID: + return getExperimentId(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case JOB_ID: + return isSetJobId(); + case TASK_ID: + return isSetTaskId(); + case WORKFLOW_NODE_ID: + return isSetWorkflowNodeId(); + case EXPERIMENT_ID: + return isSetExperimentId(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof JobIdentifier) + return this.equals((JobIdentifier)that); + return false; + } + + public boolean equals(JobIdentifier that) { + if (that == null) + return false; + + boolean this_present_jobId = true && this.isSetJobId(); + boolean that_present_jobId = true && that.isSetJobId(); + if (this_present_jobId || that_present_jobId) { + if (!(this_present_jobId && that_present_jobId)) + return false; + if (!this.jobId.equals(that.jobId)) + return false; + } + + boolean this_present_taskId = true && this.isSetTaskId(); + boolean that_present_taskId = true && that.isSetTaskId(); + if (this_present_taskId || that_present_taskId) { + if (!(this_present_taskId && that_present_taskId)) + return false; + if (!this.taskId.equals(that.taskId)) + return false; + } + + boolean this_present_workflowNodeId = true && this.isSetWorkflowNodeId(); + boolean that_present_workflowNodeId = true && that.isSetWorkflowNodeId(); + if (this_present_workflowNodeId || that_present_workflowNodeId) { + if (!(this_present_workflowNodeId && that_present_workflowNodeId)) + return false; + if (!this.workflowNodeId.equals(that.workflowNodeId)) + return false; + } + + boolean this_present_experimentId = true && this.isSetExperimentId(); + boolean that_present_experimentId = true && that.isSetExperimentId(); + if (this_present_experimentId || that_present_experimentId) { + if (!(this_present_experimentId && that_present_experimentId)) + return false; + if (!this.experimentId.equals(that.experimentId)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + return 0; + } + + @Override + public int compareTo(JobIdentifier other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetJobId()).compareTo(other.isSetJobId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetJobId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.jobId, other.jobId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTaskId()).compareTo(other.isSetTaskId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTaskId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.taskId, other.taskId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetWorkflowNodeId()).compareTo(other.isSetWorkflowNodeId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetWorkflowNodeId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.workflowNodeId, other.workflowNodeId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetExperimentId()).compareTo(other.isSetExperimentId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExperimentId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.experimentId, other.experimentId); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("JobIdentifier("); + boolean first = true; + + sb.append("jobId:"); + if (this.jobId == null) { + sb.append("null"); + } else { + sb.append(this.jobId); + } + first = false; + if (!first) sb.append(", "); + sb.append("taskId:"); + if (this.taskId == null) { + sb.append("null"); + } else { + sb.append(this.taskId); + } + first = false; + if (!first) sb.append(", "); + sb.append("workflowNodeId:"); + if (this.workflowNodeId == null) { + sb.append("null"); + } else { + sb.append(this.workflowNodeId); + } + first = false; + if (!first) sb.append(", "); + sb.append("experimentId:"); + if (this.experimentId == null) { + sb.append("null"); + } else { + sb.append(this.experimentId); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetJobId()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'jobId' is unset! Struct:" + toString()); + } + + if (!isSetTaskId()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'taskId' is unset! Struct:" + toString()); + } + + if (!isSetWorkflowNodeId()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'workflowNodeId' is unset! Struct:" + toString()); + } + + if (!isSetExperimentId()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'experimentId' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class JobIdentifierStandardSchemeFactory implements SchemeFactory { + public JobIdentifierStandardScheme getScheme() { + return new JobIdentifierStandardScheme(); + } + } + + private static class JobIdentifierStandardScheme extends StandardScheme<JobIdentifier> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, JobIdentifier struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // JOB_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.jobId = iprot.readString(); + struct.setJobIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TASK_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.taskId = iprot.readString(); + struct.setTaskIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // WORKFLOW_NODE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.workflowNodeId = iprot.readString(); + struct.setWorkflowNodeIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // EXPERIMENT_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.experimentId = iprot.readString(); + struct.setExperimentIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, JobIdentifier struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.jobId != null) { + oprot.writeFieldBegin(JOB_ID_FIELD_DESC); + oprot.writeString(struct.jobId); + oprot.writeFieldEnd(); + } + if (struct.taskId != null) { + oprot.writeFieldBegin(TASK_ID_FIELD_DESC); + oprot.writeString(struct.taskId); + oprot.writeFieldEnd(); + } + if (struct.workflowNodeId != null) { + oprot.writeFieldBegin(WORKFLOW_NODE_ID_FIELD_DESC); + oprot.writeString(struct.workflowNodeId); + oprot.writeFieldEnd(); + } + if (struct.experimentId != null) { + oprot.writeFieldBegin(EXPERIMENT_ID_FIELD_DESC); + oprot.writeString(struct.experimentId); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class JobIdentifierTupleSchemeFactory implements SchemeFactory { + public JobIdentifierTupleScheme getScheme() { + return new JobIdentifierTupleScheme(); + } + } + + private static class JobIdentifierTupleScheme extends TupleScheme<JobIdentifier> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, JobIdentifier struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeString(struct.jobId); + oprot.writeString(struct.taskId); + oprot.writeString(struct.workflowNodeId); + oprot.writeString(struct.experimentId); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, JobIdentifier struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.jobId = iprot.readString(); + struct.setJobIdIsSet(true); + struct.taskId = iprot.readString(); + struct.setTaskIdIsSet(true); + struct.workflowNodeId = iprot.readString(); + struct.setWorkflowNodeIdIsSet(true); + struct.experimentId = iprot.readString(); + struct.setExperimentIdIsSet(true); + } + } + +} +
