airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chath...@apache.org
Subject [04/23] git commit: adding initial messaging framework changes
Date Mon, 06 Oct 2014 19:54:52 GMT
adding initial messaging framework changes


Project: http://git-wip-us.apache.org/repos/asf/airavata/repo
Commit: http://git-wip-us.apache.org/repos/asf/airavata/commit/1fe3d1d8
Tree: http://git-wip-us.apache.org/repos/asf/airavata/tree/1fe3d1d8
Diff: http://git-wip-us.apache.org/repos/asf/airavata/diff/1fe3d1d8

Branch: refs/heads/master
Commit: 1fe3d1d8e86feb3ade9c55bc8ee13931c5454910
Parents: f29d7e6
Author: Chathuri Wimalasena <kamalasini@gmail.com>
Authored: Fri Aug 8 15:32:57 2014 -0400
Committer: Chathuri Wimalasena <kamalasini@gmail.com>
Committed: Fri Aug 8 15:32:57 2014 -0400

----------------------------------------------------------------------
 .../lib/airavata/airavataDataModel_types.h      |    1 +
 .../lib/airavata/messagingEvents_constants.cpp  |   34 +
 .../lib/airavata/messagingEvents_constants.h    |   41 +
 .../lib/airavata/messagingEvents_types.cpp      |  833 ++++++++++++++
 .../lib/airavata/messagingEvents_types.h        |  488 ++++++++
 .../Airavata/Model/Messaging/Event/Types.php    |  990 +++++++++++++++++
 .../event/ExperimentStatusChangeEvent.java      |  504 +++++++++
 .../model/messaging/event/JobIdentity.java      |  684 ++++++++++++
 .../model/messaging/event/JobMonitor.java       | 1043 ++++++++++++++++++
 .../messaging/event/JobStatusChangeEvent.java   |  610 ++++++++++
 .../model/messaging/event/TaskIdentity.java     |  588 ++++++++++
 .../messaging/event/TaskStatusChangeEvent.java  |  509 +++++++++
 .../model/messaging/event/WorkflowIdentity.java |  492 +++++++++
 .../event/WorkflowNodeStatusChangeEvent.java    |  509 +++++++++
 .../airavataDataModel.thrift                    |    1 +
 .../messagingEvents.thrift                      |   83 ++
 modules/messaging/core/pom.xml                  |   62 ++
 .../airavata/messaging/core/Metadata.java       |   25 +
 .../airavata/messaging/core/Publisher.java      |   13 +
 modules/messaging/pom.xml                       |   41 +
 pom.xml                                         |    1 +
 21 files changed, 7552 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h
index 51dff2f..dfaad45 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/airavataDataModel_types.h
@@ -32,6 +32,7 @@
 #include <thrift/cxxfunctional.h>
 #include "workspaceModel_types.h"
 #include "airavataErrors_types.h"
+#include "messagingEvents_types.h"
 
 
 namespace apache { namespace airavata { namespace model {

http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp
new file mode 100644
index 0000000..a02179a
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.cpp
@@ -0,0 +1,34 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "messagingEvents_constants.h"
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+const messagingEventsConstants g_messagingEvents_constants;
+
+messagingEventsConstants::messagingEventsConstants() {
+}
+
+}}}}} // namespace
+

http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h
new file mode 100644
index 0000000..c91fd31
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_constants.h
@@ -0,0 +1,41 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef messagingEvents_CONSTANTS_H
+#define messagingEvents_CONSTANTS_H
+
+#include "messagingEvents_types.h"
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+class messagingEventsConstants {
+ public:
+  messagingEventsConstants();
+
+};
+
+extern const messagingEventsConstants g_messagingEvents_constants;
+
+}}}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp
new file mode 100644
index 0000000..0c14c72
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.cpp
@@ -0,0 +1,833 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "messagingEvents_types.h"
+
+#include <algorithm>
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+const char* ExperimentStatusChangeEvent::ascii_fingerprint = "19B5240589E680301A7E32DF3971EFBE";
+const uint8_t ExperimentStatusChangeEvent::binary_fingerprint[16] = {0x19,0xB5,0x24,0x05,0x89,0xE6,0x80,0x30,0x1A,0x7E,0x32,0xDF,0x39,0x71,0xEF,0xBE};
+
+uint32_t ExperimentStatusChangeEvent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_state = false;
+  bool isset_experimentId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast0;
+          xfer += iprot->readI32(ecast0);
+          this->state = ( ::apache::airavata::model::workspace::experiment::ExperimentState::type)ecast0;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t ExperimentStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ExperimentStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.experimentId, b.experimentId);
+}
+
+const char* WorkflowIdentity::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
+const uint8_t WorkflowIdentity::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+uint32_t WorkflowIdentity::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_workflowNodeId = false;
+  bool isset_experimentId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->workflowNodeId);
+          isset_workflowNodeId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_workflowNodeId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WorkflowIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("WorkflowIdentity");
+
+  xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->workflowNodeId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WorkflowIdentity &a, WorkflowIdentity &b) {
+  using ::std::swap;
+  swap(a.workflowNodeId, b.workflowNodeId);
+  swap(a.experimentId, b.experimentId);
+}
+
+const char* WorkflowNodeStatusChangeEvent::ascii_fingerprint = "E9096211D03C8F19468314A49FB23CF0";
+const uint8_t WorkflowNodeStatusChangeEvent::binary_fingerprint[16] = {0xE9,0x09,0x62,0x11,0xD0,0x3C,0x8F,0x19,0x46,0x83,0x14,0xA4,0x9F,0xB2,0x3C,0xF0};
+
+uint32_t WorkflowNodeStatusChangeEvent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_state = false;
+  bool isset_workflowNodeIdentity = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast1;
+          xfer += iprot->readI32(ecast1);
+          this->state = ( ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type)ecast1;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->workflowNodeIdentity.read(iprot);
+          isset_workflowNodeIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_workflowNodeIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WorkflowNodeStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("WorkflowNodeStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("workflowNodeIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->workflowNodeIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.workflowNodeIdentity, b.workflowNodeIdentity);
+}
+
+const char* TaskIdentity::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
+const uint8_t TaskIdentity::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+uint32_t TaskIdentity::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_taskId = false;
+  bool isset_workflowNodeId = false;
+  bool isset_experimentId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->taskId);
+          isset_taskId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->workflowNodeId);
+          isset_workflowNodeId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_taskId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_workflowNodeId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("TaskIdentity");
+
+  xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->taskId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->workflowNodeId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TaskIdentity &a, TaskIdentity &b) {
+  using ::std::swap;
+  swap(a.taskId, b.taskId);
+  swap(a.workflowNodeId, b.workflowNodeId);
+  swap(a.experimentId, b.experimentId);
+}
+
+const char* TaskStatusChangeEvent::ascii_fingerprint = "9686679C94D43D75F2B35A0BED2E4003";
+const uint8_t TaskStatusChangeEvent::binary_fingerprint[16] = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+uint32_t TaskStatusChangeEvent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_state = false;
+  bool isset_taskIdentity = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast2;
+          xfer += iprot->readI32(ecast2);
+          this->state = ( ::apache::airavata::model::workspace::experiment::TaskState::type)ecast2;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->taskIdentity.read(iprot);
+          isset_taskIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t TaskStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("TaskStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->taskIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.taskIdentity, b.taskIdentity);
+}
+
+const char* JobIdentity::ascii_fingerprint = "C93D890311F28844166CF6E571EB3AC2";
+const uint8_t JobIdentity::binary_fingerprint[16] = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2};
+
+uint32_t JobIdentity::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_jobId = false;
+  bool isset_taskId = false;
+  bool isset_workflowNodeId = false;
+  bool isset_experimentId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->jobId);
+          isset_jobId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->taskId);
+          isset_taskId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->workflowNodeId);
+          isset_workflowNodeId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->experimentId);
+          isset_experimentId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_jobId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_taskId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_workflowNodeId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_experimentId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobIdentity::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("JobIdentity");
+
+  xfer += oprot->writeFieldBegin("jobId", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->jobId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->taskId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("workflowNodeId", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->workflowNodeId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("experimentId", ::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->experimentId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(JobIdentity &a, JobIdentity &b) {
+  using ::std::swap;
+  swap(a.jobId, b.jobId);
+  swap(a.taskId, b.taskId);
+  swap(a.workflowNodeId, b.workflowNodeId);
+  swap(a.experimentId, b.experimentId);
+}
+
+const char* JobMonitor::ascii_fingerprint = "D0036787E2FC651CBEB945D6D6CBBEB8";
+const uint8_t JobMonitor::binary_fingerprint[16] = {0xD0,0x03,0x67,0x87,0xE2,0xFC,0x65,0x1C,0xBE,0xB9,0x45,0xD6,0xD6,0xCB,0xBE,0xB8};
+
+uint32_t JobMonitor::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->username);
+          this->__isset.username = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->jobStartedTime);
+          this->__isset.jobStartedTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->lastMonitoredTime);
+          this->__isset.lastMonitoredTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->hostId);
+          this->__isset.hostId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->parameters.clear();
+            uint32_t _size3;
+            ::apache::thrift::protocol::TType _ktype4;
+            ::apache::thrift::protocol::TType _vtype5;
+            xfer += iprot->readMapBegin(_ktype4, _vtype5, _size3);
+            uint32_t _i7;
+            for (_i7 = 0; _i7 < _size3; ++_i7)
+            {
+              std::string _key8;
+              xfer += iprot->readString(_key8);
+              std::string& _val9 = this->parameters[_key8];
+              xfer += iprot->readString(_val9);
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.parameters = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->jobName);
+          this->__isset.jobName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->failedCount);
+          this->__isset.failedCount = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t JobMonitor::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("JobMonitor");
+
+  if (this->__isset.username) {
+    xfer += oprot->writeFieldBegin("username", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->username);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.jobStartedTime) {
+    xfer += oprot->writeFieldBegin("jobStartedTime", ::apache::thrift::protocol::T_I64, 2);
+    xfer += oprot->writeI64(this->jobStartedTime);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.lastMonitoredTime) {
+    xfer += oprot->writeFieldBegin("lastMonitoredTime", ::apache::thrift::protocol::T_I64, 3);
+    xfer += oprot->writeI64(this->lastMonitoredTime);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.hostId) {
+    xfer += oprot->writeFieldBegin("hostId", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->hostId);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.parameters) {
+    xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 5);
+    {
+      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size()));
+      std::map<std::string, std::string> ::const_iterator _iter10;
+      for (_iter10 = this->parameters.begin(); _iter10 != this->parameters.end(); ++_iter10)
+      {
+        xfer += oprot->writeString(_iter10->first);
+        xfer += oprot->writeString(_iter10->second);
+      }
+      xfer += oprot->writeMapEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.jobName) {
+    xfer += oprot->writeFieldBegin("jobName", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->jobName);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.failedCount) {
+    xfer += oprot->writeFieldBegin("failedCount", ::apache::thrift::protocol::T_I32, 7);
+    xfer += oprot->writeI32(this->failedCount);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(JobMonitor &a, JobMonitor &b) {
+  using ::std::swap;
+  swap(a.username, b.username);
+  swap(a.jobStartedTime, b.jobStartedTime);
+  swap(a.lastMonitoredTime, b.lastMonitoredTime);
+  swap(a.hostId, b.hostId);
+  swap(a.parameters, b.parameters);
+  swap(a.jobName, b.jobName);
+  swap(a.failedCount, b.failedCount);
+  swap(a.__isset, b.__isset);
+}
+
+const char* JobStatusChangeEvent::ascii_fingerprint = "A4467EF21DF0026B864BF2B95C34A774";
+const uint8_t JobStatusChangeEvent::binary_fingerprint[16] = {0xA4,0x46,0x7E,0xF2,0x1D,0xF0,0x02,0x6B,0x86,0x4B,0xF2,0xB9,0x5C,0x34,0xA7,0x74};
+
+uint32_t JobStatusChangeEvent::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_state = false;
+  bool isset_jobIdentity = false;
+  bool isset_jobMonitor = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast11;
+          xfer += iprot->readI32(ecast11);
+          this->state = ( ::apache::airavata::model::workspace::experiment::JobState::type)ecast11;
+          isset_state = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->jobIdentity.read(iprot);
+          isset_jobIdentity = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->jobMonitor.read(iprot);
+          isset_jobMonitor = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_state)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_jobIdentity)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_jobMonitor)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t JobStatusChangeEvent::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("JobStatusChangeEvent");
+
+  xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->state);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("jobIdentity", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->jobIdentity.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("jobMonitor", ::apache::thrift::protocol::T_STRUCT, 3);
+  xfer += this->jobMonitor.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b) {
+  using ::std::swap;
+  swap(a.state, b.state);
+  swap(a.jobIdentity, b.jobIdentity);
+  swap(a.jobMonitor, b.jobMonitor);
+}
+
+}}}}} // namespace

http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h
new file mode 100644
index 0000000..baeb37f
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/messagingEvents_types.h
@@ -0,0 +1,488 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef messagingEvents_TYPES_H
+#define messagingEvents_TYPES_H
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <thrift/cxxfunctional.h>
+#include "experimentModel_types.h"
+
+
+namespace apache { namespace airavata { namespace model { namespace messaging { namespace event {
+
+
+class ExperimentStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "19B5240589E680301A7E32DF3971EFBE";
+  static const uint8_t binary_fingerprint[16]; // = {0x19,0xB5,0x24,0x05,0x89,0xE6,0x80,0x30,0x1A,0x7E,0x32,0xDF,0x39,0x71,0xEF,0xBE};
+
+  ExperimentStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::ExperimentState::type)0), experimentId() {
+  }
+
+  virtual ~ExperimentStatusChangeEvent() throw() {}
+
+   ::apache::airavata::model::workspace::experiment::ExperimentState::type state;
+  std::string experimentId;
+
+  void __set_state(const  ::apache::airavata::model::workspace::experiment::ExperimentState::type val) {
+    state = val;
+  }
+
+  void __set_experimentId(const std::string& val) {
+    experimentId = val;
+  }
+
+  bool operator == (const ExperimentStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    return true;
+  }
+  bool operator != (const ExperimentStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ExperimentStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(ExperimentStatusChangeEvent &a, ExperimentStatusChangeEvent &b);
+
+
+class WorkflowIdentity {
+ public:
+
+  static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
+  static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
+  WorkflowIdentity() : workflowNodeId(), experimentId() {
+  }
+
+  virtual ~WorkflowIdentity() throw() {}
+
+  std::string workflowNodeId;
+  std::string experimentId;
+
+  void __set_workflowNodeId(const std::string& val) {
+    workflowNodeId = val;
+  }
+
+  void __set_experimentId(const std::string& val) {
+    experimentId = val;
+  }
+
+  bool operator == (const WorkflowIdentity & rhs) const
+  {
+    if (!(workflowNodeId == rhs.workflowNodeId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    return true;
+  }
+  bool operator != (const WorkflowIdentity &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WorkflowIdentity & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(WorkflowIdentity &a, WorkflowIdentity &b);
+
+
+class WorkflowNodeStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "E9096211D03C8F19468314A49FB23CF0";
+  static const uint8_t binary_fingerprint[16]; // = {0xE9,0x09,0x62,0x11,0xD0,0x3C,0x8F,0x19,0x46,0x83,0x14,0xA4,0x9F,0xB2,0x3C,0xF0};
+
+  WorkflowNodeStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type)0) {
+  }
+
+  virtual ~WorkflowNodeStatusChangeEvent() throw() {}
+
+   ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type state;
+  WorkflowIdentity workflowNodeIdentity;
+
+  void __set_state(const  ::apache::airavata::model::workspace::experiment::WorkflowNodeState::type val) {
+    state = val;
+  }
+
+  void __set_workflowNodeIdentity(const WorkflowIdentity& val) {
+    workflowNodeIdentity = val;
+  }
+
+  bool operator == (const WorkflowNodeStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(workflowNodeIdentity == rhs.workflowNodeIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const WorkflowNodeStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WorkflowNodeStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(WorkflowNodeStatusChangeEvent &a, WorkflowNodeStatusChangeEvent &b);
+
+
+class TaskIdentity {
+ public:
+
+  static const char* ascii_fingerprint; // = "AB879940BD15B6B25691265F7384B271";
+  static const uint8_t binary_fingerprint[16]; // = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
+
+  TaskIdentity() : taskId(), workflowNodeId(), experimentId() {
+  }
+
+  virtual ~TaskIdentity() throw() {}
+
+  std::string taskId;
+  std::string workflowNodeId;
+  std::string experimentId;
+
+  void __set_taskId(const std::string& val) {
+    taskId = val;
+  }
+
+  void __set_workflowNodeId(const std::string& val) {
+    workflowNodeId = val;
+  }
+
+  void __set_experimentId(const std::string& val) {
+    experimentId = val;
+  }
+
+  bool operator == (const TaskIdentity & rhs) const
+  {
+    if (!(taskId == rhs.taskId))
+      return false;
+    if (!(workflowNodeId == rhs.workflowNodeId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskIdentity &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskIdentity & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TaskIdentity &a, TaskIdentity &b);
+
+
+class TaskStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "9686679C94D43D75F2B35A0BED2E4003";
+  static const uint8_t binary_fingerprint[16]; // = {0x96,0x86,0x67,0x9C,0x94,0xD4,0x3D,0x75,0xF2,0xB3,0x5A,0x0B,0xED,0x2E,0x40,0x03};
+
+  TaskStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::TaskState::type)0) {
+  }
+
+  virtual ~TaskStatusChangeEvent() throw() {}
+
+   ::apache::airavata::model::workspace::experiment::TaskState::type state;
+  TaskIdentity taskIdentity;
+
+  void __set_state(const  ::apache::airavata::model::workspace::experiment::TaskState::type val) {
+    state = val;
+  }
+
+  void __set_taskIdentity(const TaskIdentity& val) {
+    taskIdentity = val;
+  }
+
+  bool operator == (const TaskStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(taskIdentity == rhs.taskIdentity))
+      return false;
+    return true;
+  }
+  bool operator != (const TaskStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TaskStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TaskStatusChangeEvent &a, TaskStatusChangeEvent &b);
+
+
+class JobIdentity {
+ public:
+
+  static const char* ascii_fingerprint; // = "C93D890311F28844166CF6E571EB3AC2";
+  static const uint8_t binary_fingerprint[16]; // = {0xC9,0x3D,0x89,0x03,0x11,0xF2,0x88,0x44,0x16,0x6C,0xF6,0xE5,0x71,0xEB,0x3A,0xC2};
+
+  JobIdentity() : jobId(), taskId(), workflowNodeId(), experimentId() {
+  }
+
+  virtual ~JobIdentity() throw() {}
+
+  std::string jobId;
+  std::string taskId;
+  std::string workflowNodeId;
+  std::string experimentId;
+
+  void __set_jobId(const std::string& val) {
+    jobId = val;
+  }
+
+  void __set_taskId(const std::string& val) {
+    taskId = val;
+  }
+
+  void __set_workflowNodeId(const std::string& val) {
+    workflowNodeId = val;
+  }
+
+  void __set_experimentId(const std::string& val) {
+    experimentId = val;
+  }
+
+  bool operator == (const JobIdentity & rhs) const
+  {
+    if (!(jobId == rhs.jobId))
+      return false;
+    if (!(taskId == rhs.taskId))
+      return false;
+    if (!(workflowNodeId == rhs.workflowNodeId))
+      return false;
+    if (!(experimentId == rhs.experimentId))
+      return false;
+    return true;
+  }
+  bool operator != (const JobIdentity &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobIdentity & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobIdentity &a, JobIdentity &b);
+
+typedef struct _JobMonitor__isset {
+  _JobMonitor__isset() : username(false), jobStartedTime(false), lastMonitoredTime(false), hostId(false), parameters(false), jobName(false), failedCount(true) {}
+  bool username;
+  bool jobStartedTime;
+  bool lastMonitoredTime;
+  bool hostId;
+  bool parameters;
+  bool jobName;
+  bool failedCount;
+} _JobMonitor__isset;
+
+class JobMonitor {
+ public:
+
+  static const char* ascii_fingerprint; // = "D0036787E2FC651CBEB945D6D6CBBEB8";
+  static const uint8_t binary_fingerprint[16]; // = {0xD0,0x03,0x67,0x87,0xE2,0xFC,0x65,0x1C,0xBE,0xB9,0x45,0xD6,0xD6,0xCB,0xBE,0xB8};
+
+  JobMonitor() : username(), jobStartedTime(0), lastMonitoredTime(0), hostId(), jobName(), failedCount(0) {
+  }
+
+  virtual ~JobMonitor() throw() {}
+
+  std::string username;
+  int64_t jobStartedTime;
+  int64_t lastMonitoredTime;
+  std::string hostId;
+  std::map<std::string, std::string>  parameters;
+  std::string jobName;
+  int32_t failedCount;
+
+  _JobMonitor__isset __isset;
+
+  void __set_username(const std::string& val) {
+    username = val;
+    __isset.username = true;
+  }
+
+  void __set_jobStartedTime(const int64_t val) {
+    jobStartedTime = val;
+    __isset.jobStartedTime = true;
+  }
+
+  void __set_lastMonitoredTime(const int64_t val) {
+    lastMonitoredTime = val;
+    __isset.lastMonitoredTime = true;
+  }
+
+  void __set_hostId(const std::string& val) {
+    hostId = val;
+    __isset.hostId = true;
+  }
+
+  void __set_parameters(const std::map<std::string, std::string> & val) {
+    parameters = val;
+    __isset.parameters = true;
+  }
+
+  void __set_jobName(const std::string& val) {
+    jobName = val;
+    __isset.jobName = true;
+  }
+
+  void __set_failedCount(const int32_t val) {
+    failedCount = val;
+    __isset.failedCount = true;
+  }
+
+  bool operator == (const JobMonitor & rhs) const
+  {
+    if (__isset.username != rhs.__isset.username)
+      return false;
+    else if (__isset.username && !(username == rhs.username))
+      return false;
+    if (__isset.jobStartedTime != rhs.__isset.jobStartedTime)
+      return false;
+    else if (__isset.jobStartedTime && !(jobStartedTime == rhs.jobStartedTime))
+      return false;
+    if (__isset.lastMonitoredTime != rhs.__isset.lastMonitoredTime)
+      return false;
+    else if (__isset.lastMonitoredTime && !(lastMonitoredTime == rhs.lastMonitoredTime))
+      return false;
+    if (__isset.hostId != rhs.__isset.hostId)
+      return false;
+    else if (__isset.hostId && !(hostId == rhs.hostId))
+      return false;
+    if (__isset.parameters != rhs.__isset.parameters)
+      return false;
+    else if (__isset.parameters && !(parameters == rhs.parameters))
+      return false;
+    if (__isset.jobName != rhs.__isset.jobName)
+      return false;
+    else if (__isset.jobName && !(jobName == rhs.jobName))
+      return false;
+    if (__isset.failedCount != rhs.__isset.failedCount)
+      return false;
+    else if (__isset.failedCount && !(failedCount == rhs.failedCount))
+      return false;
+    return true;
+  }
+  bool operator != (const JobMonitor &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobMonitor & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobMonitor &a, JobMonitor &b);
+
+
+class JobStatusChangeEvent {
+ public:
+
+  static const char* ascii_fingerprint; // = "A4467EF21DF0026B864BF2B95C34A774";
+  static const uint8_t binary_fingerprint[16]; // = {0xA4,0x46,0x7E,0xF2,0x1D,0xF0,0x02,0x6B,0x86,0x4B,0xF2,0xB9,0x5C,0x34,0xA7,0x74};
+
+  JobStatusChangeEvent() : state(( ::apache::airavata::model::workspace::experiment::JobState::type)0) {
+  }
+
+  virtual ~JobStatusChangeEvent() throw() {}
+
+   ::apache::airavata::model::workspace::experiment::JobState::type state;
+  JobIdentity jobIdentity;
+  JobMonitor jobMonitor;
+
+  void __set_state(const  ::apache::airavata::model::workspace::experiment::JobState::type val) {
+    state = val;
+  }
+
+  void __set_jobIdentity(const JobIdentity& val) {
+    jobIdentity = val;
+  }
+
+  void __set_jobMonitor(const JobMonitor& val) {
+    jobMonitor = val;
+  }
+
+  bool operator == (const JobStatusChangeEvent & rhs) const
+  {
+    if (!(state == rhs.state))
+      return false;
+    if (!(jobIdentity == rhs.jobIdentity))
+      return false;
+    if (!(jobMonitor == rhs.jobMonitor))
+      return false;
+    return true;
+  }
+  bool operator != (const JobStatusChangeEvent &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const JobStatusChangeEvent & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(JobStatusChangeEvent &a, JobStatusChangeEvent &b);
+
+}}}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/airavata/blob/1fe3d1d8/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php
new file mode 100644
index 0000000..569f523
--- /dev/null
+++ b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Messaging/Event/Types.php
@@ -0,0 +1,990 @@
+<?php
+namespace Airavata\Model\Messaging\Event;
+
+/**
+ * Autogenerated by Thrift Compiler (0.9.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+
+class ExperimentStatusChangeEvent {
+  static $_TSPEC;
+
+  public $state = null;
+  public $experimentId = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'state',
+          'type' => TType::I32,
+          ),
+        2 => array(
+          'var' => 'experimentId',
+          'type' => TType::STRING,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['state'])) {
+        $this->state = $vals['state'];
+      }
+      if (isset($vals['experimentId'])) {
+        $this->experimentId = $vals['experimentId'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'ExperimentStatusChangeEvent';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->state);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->experimentId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('ExperimentStatusChangeEvent');
+    if ($this->state !== null) {
+      $xfer += $output->writeFieldBegin('state', TType::I32, 1);
+      $xfer += $output->writeI32($this->state);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->experimentId !== null) {
+      $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 2);
+      $xfer += $output->writeString($this->experimentId);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class WorkflowIdentity {
+  static $_TSPEC;
+
+  public $workflowNodeId = null;
+  public $experimentId = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'workflowNodeId',
+          'type' => TType::STRING,
+          ),
+        2 => array(
+          'var' => 'experimentId',
+          'type' => TType::STRING,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['workflowNodeId'])) {
+        $this->workflowNodeId = $vals['workflowNodeId'];
+      }
+      if (isset($vals['experimentId'])) {
+        $this->experimentId = $vals['experimentId'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'WorkflowIdentity';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->workflowNodeId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->experimentId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('WorkflowIdentity');
+    if ($this->workflowNodeId !== null) {
+      $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 1);
+      $xfer += $output->writeString($this->workflowNodeId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->experimentId !== null) {
+      $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 2);
+      $xfer += $output->writeString($this->experimentId);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class WorkflowNodeStatusChangeEvent {
+  static $_TSPEC;
+
+  public $state = null;
+  public $workflowNodeIdentity = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'state',
+          'type' => TType::I32,
+          ),
+        2 => array(
+          'var' => 'workflowNodeIdentity',
+          'type' => TType::STRUCT,
+          'class' => '\Airavata\Model\Messaging\Event\WorkflowIdentity',
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['state'])) {
+        $this->state = $vals['state'];
+      }
+      if (isset($vals['workflowNodeIdentity'])) {
+        $this->workflowNodeIdentity = $vals['workflowNodeIdentity'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'WorkflowNodeStatusChangeEvent';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->state);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRUCT) {
+            $this->workflowNodeIdentity = new \Airavata\Model\Messaging\Event\WorkflowIdentity();
+            $xfer += $this->workflowNodeIdentity->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('WorkflowNodeStatusChangeEvent');
+    if ($this->state !== null) {
+      $xfer += $output->writeFieldBegin('state', TType::I32, 1);
+      $xfer += $output->writeI32($this->state);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->workflowNodeIdentity !== null) {
+      if (!is_object($this->workflowNodeIdentity)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('workflowNodeIdentity', TType::STRUCT, 2);
+      $xfer += $this->workflowNodeIdentity->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class TaskIdentity {
+  static $_TSPEC;
+
+  public $taskId = null;
+  public $workflowNodeId = null;
+  public $experimentId = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'taskId',
+          'type' => TType::STRING,
+          ),
+        2 => array(
+          'var' => 'workflowNodeId',
+          'type' => TType::STRING,
+          ),
+        3 => array(
+          'var' => 'experimentId',
+          'type' => TType::STRING,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['taskId'])) {
+        $this->taskId = $vals['taskId'];
+      }
+      if (isset($vals['workflowNodeId'])) {
+        $this->workflowNodeId = $vals['workflowNodeId'];
+      }
+      if (isset($vals['experimentId'])) {
+        $this->experimentId = $vals['experimentId'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'TaskIdentity';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->taskId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->workflowNodeId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->experimentId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('TaskIdentity');
+    if ($this->taskId !== null) {
+      $xfer += $output->writeFieldBegin('taskId', TType::STRING, 1);
+      $xfer += $output->writeString($this->taskId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->workflowNodeId !== null) {
+      $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 2);
+      $xfer += $output->writeString($this->workflowNodeId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->experimentId !== null) {
+      $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 3);
+      $xfer += $output->writeString($this->experimentId);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class TaskStatusChangeEvent {
+  static $_TSPEC;
+
+  public $state = null;
+  public $taskIdentity = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'state',
+          'type' => TType::I32,
+          ),
+        2 => array(
+          'var' => 'taskIdentity',
+          'type' => TType::STRUCT,
+          'class' => '\Airavata\Model\Messaging\Event\TaskIdentity',
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['state'])) {
+        $this->state = $vals['state'];
+      }
+      if (isset($vals['taskIdentity'])) {
+        $this->taskIdentity = $vals['taskIdentity'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'TaskStatusChangeEvent';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->state);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRUCT) {
+            $this->taskIdentity = new \Airavata\Model\Messaging\Event\TaskIdentity();
+            $xfer += $this->taskIdentity->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('TaskStatusChangeEvent');
+    if ($this->state !== null) {
+      $xfer += $output->writeFieldBegin('state', TType::I32, 1);
+      $xfer += $output->writeI32($this->state);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->taskIdentity !== null) {
+      if (!is_object($this->taskIdentity)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('taskIdentity', TType::STRUCT, 2);
+      $xfer += $this->taskIdentity->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class JobIdentity {
+  static $_TSPEC;
+
+  public $jobId = null;
+  public $taskId = null;
+  public $workflowNodeId = null;
+  public $experimentId = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'jobId',
+          'type' => TType::STRING,
+          ),
+        2 => array(
+          'var' => 'taskId',
+          'type' => TType::STRING,
+          ),
+        3 => array(
+          'var' => 'workflowNodeId',
+          'type' => TType::STRING,
+          ),
+        4 => array(
+          'var' => 'experimentId',
+          'type' => TType::STRING,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['jobId'])) {
+        $this->jobId = $vals['jobId'];
+      }
+      if (isset($vals['taskId'])) {
+        $this->taskId = $vals['taskId'];
+      }
+      if (isset($vals['workflowNodeId'])) {
+        $this->workflowNodeId = $vals['workflowNodeId'];
+      }
+      if (isset($vals['experimentId'])) {
+        $this->experimentId = $vals['experimentId'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'JobIdentity';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->jobId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->taskId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->workflowNodeId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 4:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->experimentId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('JobIdentity');
+    if ($this->jobId !== null) {
+      $xfer += $output->writeFieldBegin('jobId', TType::STRING, 1);
+      $xfer += $output->writeString($this->jobId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->taskId !== null) {
+      $xfer += $output->writeFieldBegin('taskId', TType::STRING, 2);
+      $xfer += $output->writeString($this->taskId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->workflowNodeId !== null) {
+      $xfer += $output->writeFieldBegin('workflowNodeId', TType::STRING, 3);
+      $xfer += $output->writeString($this->workflowNodeId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->experimentId !== null) {
+      $xfer += $output->writeFieldBegin('experimentId', TType::STRING, 4);
+      $xfer += $output->writeString($this->experimentId);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class JobMonitor {
+  static $_TSPEC;
+
+  public $username = null;
+  public $jobStartedTime = null;
+  public $lastMonitoredTime = null;
+  public $hostId = null;
+  public $parameters = null;
+  public $jobName = null;
+  public $failedCount = 0;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'username',
+          'type' => TType::STRING,
+          ),
+        2 => array(
+          'var' => 'jobStartedTime',
+          'type' => TType::I64,
+          ),
+        3 => array(
+          'var' => 'lastMonitoredTime',
+          'type' => TType::I64,
+          ),
+        4 => array(
+          'var' => 'hostId',
+          'type' => TType::STRING,
+          ),
+        5 => array(
+          'var' => 'parameters',
+          'type' => TType::MAP,
+          'ktype' => TType::STRING,
+          'vtype' => TType::STRING,
+          'key' => array(
+            'type' => TType::STRING,
+          ),
+          'val' => array(
+            'type' => TType::STRING,
+            ),
+          ),
+        6 => array(
+          'var' => 'jobName',
+          'type' => TType::STRING,
+          ),
+        7 => array(
+          'var' => 'failedCount',
+          'type' => TType::I32,
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['username'])) {
+        $this->username = $vals['username'];
+      }
+      if (isset($vals['jobStartedTime'])) {
+        $this->jobStartedTime = $vals['jobStartedTime'];
+      }
+      if (isset($vals['lastMonitoredTime'])) {
+        $this->lastMonitoredTime = $vals['lastMonitoredTime'];
+      }
+      if (isset($vals['hostId'])) {
+        $this->hostId = $vals['hostId'];
+      }
+      if (isset($vals['parameters'])) {
+        $this->parameters = $vals['parameters'];
+      }
+      if (isset($vals['jobName'])) {
+        $this->jobName = $vals['jobName'];
+      }
+      if (isset($vals['failedCount'])) {
+        $this->failedCount = $vals['failedCount'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'JobMonitor';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->username);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::I64) {
+            $xfer += $input->readI64($this->jobStartedTime);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::I64) {
+            $xfer += $input->readI64($this->lastMonitoredTime);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 4:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->hostId);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 5:
+          if ($ftype == TType::MAP) {
+            $this->parameters = array();
+            $_size0 = 0;
+            $_ktype1 = 0;
+            $_vtype2 = 0;
+            $xfer += $input->readMapBegin($_ktype1, $_vtype2, $_size0);
+            for ($_i4 = 0; $_i4 < $_size0; ++$_i4)
+            {
+              $key5 = '';
+              $val6 = '';
+              $xfer += $input->readString($key5);
+              $xfer += $input->readString($val6);
+              $this->parameters[$key5] = $val6;
+            }
+            $xfer += $input->readMapEnd();
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 6:
+          if ($ftype == TType::STRING) {
+            $xfer += $input->readString($this->jobName);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 7:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->failedCount);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('JobMonitor');
+    if ($this->username !== null) {
+      $xfer += $output->writeFieldBegin('username', TType::STRING, 1);
+      $xfer += $output->writeString($this->username);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->jobStartedTime !== null) {
+      $xfer += $output->writeFieldBegin('jobStartedTime', TType::I64, 2);
+      $xfer += $output->writeI64($this->jobStartedTime);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->lastMonitoredTime !== null) {
+      $xfer += $output->writeFieldBegin('lastMonitoredTime', TType::I64, 3);
+      $xfer += $output->writeI64($this->lastMonitoredTime);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->hostId !== null) {
+      $xfer += $output->writeFieldBegin('hostId', TType::STRING, 4);
+      $xfer += $output->writeString($this->hostId);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->parameters !== null) {
+      if (!is_array($this->parameters)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('parameters', TType::MAP, 5);
+      {
+        $output->writeMapBegin(TType::STRING, TType::STRING, count($this->parameters));
+        {
+          foreach ($this->parameters as $kiter7 => $viter8)
+          {
+            $xfer += $output->writeString($kiter7);
+            $xfer += $output->writeString($viter8);
+          }
+        }
+        $output->writeMapEnd();
+      }
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->jobName !== null) {
+      $xfer += $output->writeFieldBegin('jobName', TType::STRING, 6);
+      $xfer += $output->writeString($this->jobName);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->failedCount !== null) {
+      $xfer += $output->writeFieldBegin('failedCount', TType::I32, 7);
+      $xfer += $output->writeI32($this->failedCount);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+class JobStatusChangeEvent {
+  static $_TSPEC;
+
+  public $state = null;
+  public $jobIdentity = null;
+  public $jobMonitor = null;
+
+  public function __construct($vals=null) {
+    if (!isset(self::$_TSPEC)) {
+      self::$_TSPEC = array(
+        1 => array(
+          'var' => 'state',
+          'type' => TType::I32,
+          ),
+        2 => array(
+          'var' => 'jobIdentity',
+          'type' => TType::STRUCT,
+          'class' => '\Airavata\Model\Messaging\Event\JobIdentity',
+          ),
+        3 => array(
+          'var' => 'jobMonitor',
+          'type' => TType::STRUCT,
+          'class' => '\Airavata\Model\Messaging\Event\JobMonitor',
+          ),
+        );
+    }
+    if (is_array($vals)) {
+      if (isset($vals['state'])) {
+        $this->state = $vals['state'];
+      }
+      if (isset($vals['jobIdentity'])) {
+        $this->jobIdentity = $vals['jobIdentity'];
+      }
+      if (isset($vals['jobMonitor'])) {
+        $this->jobMonitor = $vals['jobMonitor'];
+      }
+    }
+  }
+
+  public function getName() {
+    return 'JobStatusChangeEvent';
+  }
+
+  public function read($input)
+  {
+    $xfer = 0;
+    $fname = null;
+    $ftype = 0;
+    $fid = 0;
+    $xfer += $input->readStructBegin($fname);
+    while (true)
+    {
+      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+      if ($ftype == TType::STOP) {
+        break;
+      }
+      switch ($fid)
+      {
+        case 1:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->state);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 2:
+          if ($ftype == TType::STRUCT) {
+            $this->jobIdentity = new \Airavata\Model\Messaging\Event\JobIdentity();
+            $xfer += $this->jobIdentity->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 3:
+          if ($ftype == TType::STRUCT) {
+            $this->jobMonitor = new \Airavata\Model\Messaging\Event\JobMonitor();
+            $xfer += $this->jobMonitor->read($input);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        default:
+          $xfer += $input->skip($ftype);
+          break;
+      }
+      $xfer += $input->readFieldEnd();
+    }
+    $xfer += $input->readStructEnd();
+    return $xfer;
+  }
+
+  public function write($output) {
+    $xfer = 0;
+    $xfer += $output->writeStructBegin('JobStatusChangeEvent');
+    if ($this->state !== null) {
+      $xfer += $output->writeFieldBegin('state', TType::I32, 1);
+      $xfer += $output->writeI32($this->state);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->jobIdentity !== null) {
+      if (!is_object($this->jobIdentity)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('jobIdentity', TType::STRUCT, 2);
+      $xfer += $this->jobIdentity->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->jobMonitor !== null) {
+      if (!is_object($this->jobMonitor)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('jobMonitor', TType::STRUCT, 3);
+      $xfer += $this->jobMonitor->write($output);
+      $xfer += $output->writeFieldEnd();
+    }
+    $xfer += $output->writeFieldStop();
+    $xfer += $output->writeStructEnd();
+    return $xfer;
+  }
+
+}
+
+


Mime
View raw message