airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chath...@apache.org
Subject [22/23] git commit: removing recursively calling publish
Date Mon, 06 Oct 2014 19:55:10 GMT
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/master
Commit: 255dd9e397890ac24aa7853e382613e10102164f
Parents: cc71bac
Author: chathuriw <kamalasini@gmail.com>
Authored: Fri Sep 26 16:03:52 2014 -0400
Committer: Chathuri Wimalasena <kamalasini@gmail.com>
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);
+    }
+  }
+
+}
+


Mime
View raw message