airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scnakand...@apache.org
Subject [2/2] airavata git commit: Adding more states for the experiment statistics
Date Sat, 18 Jul 2015 08:16:48 GMT
Adding more states for the experiment statistics


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

Branch: refs/heads/airavata-0.15-release-branch
Commit: a403561e378086684fff1908727d9bf5dcf5dc86
Parents: 61c2049
Author: Supun Nakandala <scnakandala@apache.org>
Authored: Sat Jul 18 13:41:45 2015 +0530
Committer: Supun Nakandala <scnakandala@apache.org>
Committed: Sat Jul 18 13:41:45 2015 +0530

----------------------------------------------------------------------
 .../lib/airavata/experimentModel_types.cpp      | 142 ++++-
 .../lib/airavata/experimentModel_types.h        |  44 +-
 .../Model/Workspace/Experiment/Types.php        | 172 +++++-
 .../model/workspace/experiment/ttypes.py        | 110 +++-
 .../experiment/ExperimentStatistics.java        | 616 +++++++++++++++++--
 .../experimentModel.thrift                      |  12 +-
 .../registry/jpa/impl/ExperimentRegistry.java   |  14 +
 .../resources/ExperimentStatisticsResource.java |  36 ++
 .../registry/jpa/resources/WorkerResource.java  |  11 +
 9 files changed, 1027 insertions(+), 130 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.cpp
index 1bc5369..3515f87 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.cpp
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.cpp
@@ -3408,8 +3408,8 @@ void swap(ExperimentSummary &a, ExperimentSummary &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* ExperimentStatistics::ascii_fingerprint = "30185B02179FA7FA5FE94244EB7C415D";
-const uint8_t ExperimentStatistics::binary_fingerprint[16] = {0x30,0x18,0x5B,0x02,0x17,0x9F,0xA7,0xFA,0x5F,0xE9,0x42,0x44,0xEB,0x7C,0x41,0x5D};
+const char* ExperimentStatistics::ascii_fingerprint = "AD5D3509EF72E73D31C85D699863B232";
+const uint8_t ExperimentStatistics::binary_fingerprint[16] = {0xAD,0x5D,0x35,0x09,0xEF,0x72,0xE7,0x3D,0x31,0xC8,0x5D,0x69,0x98,0x63,0xB2,0x32};
 
 uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -3425,6 +3425,8 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
   bool isset_allExperimentCount = false;
   bool isset_completedExperimentCount = false;
   bool isset_failedExperimentCount = false;
+  bool isset_createdExperimentCount = false;
+  bool isset_runningExperimentCount = false;
   bool isset_allExperiments = false;
 
   while (true)
@@ -3468,6 +3470,22 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
         }
         break;
       case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->createdExperimentCount);
+          isset_createdExperimentCount = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->runningExperimentCount);
+          isset_runningExperimentCount = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->allExperiments.clear();
@@ -3487,7 +3505,7 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
           xfer += iprot->skip(ftype);
         }
         break;
-      case 6:
+      case 8:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->completedExperiments.clear();
@@ -3507,7 +3525,7 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
           xfer += iprot->skip(ftype);
         }
         break;
-      case 7:
+      case 9:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->failedExperiments.clear();
@@ -3527,7 +3545,7 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
           xfer += iprot->skip(ftype);
         }
         break;
-      case 8:
+      case 10:
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->cancelledExperiments.clear();
@@ -3547,6 +3565,46 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
           xfer += iprot->skip(ftype);
         }
         break;
+      case 11:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->createdExperiments.clear();
+            uint32_t _size143;
+            ::apache::thrift::protocol::TType _etype146;
+            xfer += iprot->readListBegin(_etype146, _size143);
+            this->createdExperiments.resize(_size143);
+            uint32_t _i147;
+            for (_i147 = 0; _i147 < _size143; ++_i147)
+            {
+              xfer += this->createdExperiments[_i147].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.createdExperiments = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 12:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->runningExperiments.clear();
+            uint32_t _size148;
+            ::apache::thrift::protocol::TType _etype151;
+            xfer += iprot->readListBegin(_etype151, _size148);
+            this->runningExperiments.resize(_size148);
+            uint32_t _i152;
+            for (_i152 = 0; _i152 < _size148; ++_i152)
+            {
+              xfer += this->runningExperiments[_i152].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.runningExperiments = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -3562,6 +3620,10 @@ uint32_t ExperimentStatistics::read(::apache::thrift::protocol::TProtocol* iprot
     throw TProtocolException(TProtocolException::INVALID_DATA);
   if (!isset_failedExperimentCount)
     throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_createdExperimentCount)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_runningExperimentCount)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
   if (!isset_allExperiments)
     throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
@@ -3588,52 +3650,86 @@ uint32_t ExperimentStatistics::write(::apache::thrift::protocol::TProtocol* opro
   xfer += oprot->writeI32(this->failedExperimentCount);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("allExperiments", ::apache::thrift::protocol::T_LIST, 5);
+  xfer += oprot->writeFieldBegin("createdExperimentCount", ::apache::thrift::protocol::T_I32, 5);
+  xfer += oprot->writeI32(this->createdExperimentCount);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("runningExperimentCount", ::apache::thrift::protocol::T_I32, 6);
+  xfer += oprot->writeI32(this->runningExperimentCount);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("allExperiments", ::apache::thrift::protocol::T_LIST, 7);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->allExperiments.size()));
-    std::vector<ExperimentSummary> ::const_iterator _iter143;
-    for (_iter143 = this->allExperiments.begin(); _iter143 != this->allExperiments.end(); ++_iter143)
+    std::vector<ExperimentSummary> ::const_iterator _iter153;
+    for (_iter153 = this->allExperiments.begin(); _iter153 != this->allExperiments.end(); ++_iter153)
     {
-      xfer += (*_iter143).write(oprot);
+      xfer += (*_iter153).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
   xfer += oprot->writeFieldEnd();
 
   if (this->__isset.completedExperiments) {
-    xfer += oprot->writeFieldBegin("completedExperiments", ::apache::thrift::protocol::T_LIST, 6);
+    xfer += oprot->writeFieldBegin("completedExperiments", ::apache::thrift::protocol::T_LIST, 8);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->completedExperiments.size()));
-      std::vector<ExperimentSummary> ::const_iterator _iter144;
-      for (_iter144 = this->completedExperiments.begin(); _iter144 != this->completedExperiments.end(); ++_iter144)
+      std::vector<ExperimentSummary> ::const_iterator _iter154;
+      for (_iter154 = this->completedExperiments.begin(); _iter154 != this->completedExperiments.end(); ++_iter154)
       {
-        xfer += (*_iter144).write(oprot);
+        xfer += (*_iter154).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.failedExperiments) {
-    xfer += oprot->writeFieldBegin("failedExperiments", ::apache::thrift::protocol::T_LIST, 7);
+    xfer += oprot->writeFieldBegin("failedExperiments", ::apache::thrift::protocol::T_LIST, 9);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->failedExperiments.size()));
-      std::vector<ExperimentSummary> ::const_iterator _iter145;
-      for (_iter145 = this->failedExperiments.begin(); _iter145 != this->failedExperiments.end(); ++_iter145)
+      std::vector<ExperimentSummary> ::const_iterator _iter155;
+      for (_iter155 = this->failedExperiments.begin(); _iter155 != this->failedExperiments.end(); ++_iter155)
       {
-        xfer += (*_iter145).write(oprot);
+        xfer += (*_iter155).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.cancelledExperiments) {
-    xfer += oprot->writeFieldBegin("cancelledExperiments", ::apache::thrift::protocol::T_LIST, 8);
+    xfer += oprot->writeFieldBegin("cancelledExperiments", ::apache::thrift::protocol::T_LIST, 10);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->cancelledExperiments.size()));
-      std::vector<ExperimentSummary> ::const_iterator _iter146;
-      for (_iter146 = this->cancelledExperiments.begin(); _iter146 != this->cancelledExperiments.end(); ++_iter146)
+      std::vector<ExperimentSummary> ::const_iterator _iter156;
+      for (_iter156 = this->cancelledExperiments.begin(); _iter156 != this->cancelledExperiments.end(); ++_iter156)
+      {
+        xfer += (*_iter156).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.createdExperiments) {
+    xfer += oprot->writeFieldBegin("createdExperiments", ::apache::thrift::protocol::T_LIST, 11);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->createdExperiments.size()));
+      std::vector<ExperimentSummary> ::const_iterator _iter157;
+      for (_iter157 = this->createdExperiments.begin(); _iter157 != this->createdExperiments.end(); ++_iter157)
+      {
+        xfer += (*_iter157).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.runningExperiments) {
+    xfer += oprot->writeFieldBegin("runningExperiments", ::apache::thrift::protocol::T_LIST, 12);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->runningExperiments.size()));
+      std::vector<ExperimentSummary> ::const_iterator _iter158;
+      for (_iter158 = this->runningExperiments.begin(); _iter158 != this->runningExperiments.end(); ++_iter158)
       {
-        xfer += (*_iter146).write(oprot);
+        xfer += (*_iter158).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -3650,10 +3746,14 @@ void swap(ExperimentStatistics &a, ExperimentStatistics &b) {
   swap(a.completedExperimentCount, b.completedExperimentCount);
   swap(a.cancelledExperimentCount, b.cancelledExperimentCount);
   swap(a.failedExperimentCount, b.failedExperimentCount);
+  swap(a.createdExperimentCount, b.createdExperimentCount);
+  swap(a.runningExperimentCount, b.runningExperimentCount);
   swap(a.allExperiments, b.allExperiments);
   swap(a.completedExperiments, b.completedExperiments);
   swap(a.failedExperiments, b.failedExperiments);
   swap(a.cancelledExperiments, b.cancelledExperiments);
+  swap(a.createdExperiments, b.createdExperiments);
+  swap(a.runningExperiments, b.runningExperiments);
   swap(a.__isset, b.__isset);
 }
 

http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
index d041d2f..6cd91a3 100644
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
+++ b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/airavata/experimentModel_types.h
@@ -2128,20 +2128,22 @@ class ExperimentSummary {
 void swap(ExperimentSummary &a, ExperimentSummary &b);
 
 typedef struct _ExperimentStatistics__isset {
-  _ExperimentStatistics__isset() : cancelledExperimentCount(false), completedExperiments(false), failedExperiments(false), cancelledExperiments(false) {}
+  _ExperimentStatistics__isset() : cancelledExperimentCount(false), completedExperiments(false), failedExperiments(false), cancelledExperiments(false), createdExperiments(false), runningExperiments(false) {}
   bool cancelledExperimentCount;
   bool completedExperiments;
   bool failedExperiments;
   bool cancelledExperiments;
+  bool createdExperiments;
+  bool runningExperiments;
 } _ExperimentStatistics__isset;
 
 class ExperimentStatistics {
  public:
 
-  static const char* ascii_fingerprint; // = "30185B02179FA7FA5FE94244EB7C415D";
-  static const uint8_t binary_fingerprint[16]; // = {0x30,0x18,0x5B,0x02,0x17,0x9F,0xA7,0xFA,0x5F,0xE9,0x42,0x44,0xEB,0x7C,0x41,0x5D};
+  static const char* ascii_fingerprint; // = "AD5D3509EF72E73D31C85D699863B232";
+  static const uint8_t binary_fingerprint[16]; // = {0xAD,0x5D,0x35,0x09,0xEF,0x72,0xE7,0x3D,0x31,0xC8,0x5D,0x69,0x98,0x63,0xB2,0x32};
 
-  ExperimentStatistics() : allExperimentCount(0), completedExperimentCount(0), cancelledExperimentCount(0), failedExperimentCount(0) {
+  ExperimentStatistics() : allExperimentCount(0), completedExperimentCount(0), cancelledExperimentCount(0), failedExperimentCount(0), createdExperimentCount(0), runningExperimentCount(0) {
   }
 
   virtual ~ExperimentStatistics() throw() {}
@@ -2150,10 +2152,14 @@ class ExperimentStatistics {
   int32_t completedExperimentCount;
   int32_t cancelledExperimentCount;
   int32_t failedExperimentCount;
+  int32_t createdExperimentCount;
+  int32_t runningExperimentCount;
   std::vector<ExperimentSummary>  allExperiments;
   std::vector<ExperimentSummary>  completedExperiments;
   std::vector<ExperimentSummary>  failedExperiments;
   std::vector<ExperimentSummary>  cancelledExperiments;
+  std::vector<ExperimentSummary>  createdExperiments;
+  std::vector<ExperimentSummary>  runningExperiments;
 
   _ExperimentStatistics__isset __isset;
 
@@ -2174,6 +2180,14 @@ class ExperimentStatistics {
     failedExperimentCount = val;
   }
 
+  void __set_createdExperimentCount(const int32_t val) {
+    createdExperimentCount = val;
+  }
+
+  void __set_runningExperimentCount(const int32_t val) {
+    runningExperimentCount = val;
+  }
+
   void __set_allExperiments(const std::vector<ExperimentSummary> & val) {
     allExperiments = val;
   }
@@ -2193,6 +2207,16 @@ class ExperimentStatistics {
     __isset.cancelledExperiments = true;
   }
 
+  void __set_createdExperiments(const std::vector<ExperimentSummary> & val) {
+    createdExperiments = val;
+    __isset.createdExperiments = true;
+  }
+
+  void __set_runningExperiments(const std::vector<ExperimentSummary> & val) {
+    runningExperiments = val;
+    __isset.runningExperiments = true;
+  }
+
   bool operator == (const ExperimentStatistics & rhs) const
   {
     if (!(allExperimentCount == rhs.allExperimentCount))
@@ -2205,6 +2229,10 @@ class ExperimentStatistics {
       return false;
     if (!(failedExperimentCount == rhs.failedExperimentCount))
       return false;
+    if (!(createdExperimentCount == rhs.createdExperimentCount))
+      return false;
+    if (!(runningExperimentCount == rhs.runningExperimentCount))
+      return false;
     if (!(allExperiments == rhs.allExperiments))
       return false;
     if (__isset.completedExperiments != rhs.__isset.completedExperiments)
@@ -2219,6 +2247,14 @@ class ExperimentStatistics {
       return false;
     else if (__isset.cancelledExperiments && !(cancelledExperiments == rhs.cancelledExperiments))
       return false;
+    if (__isset.createdExperiments != rhs.__isset.createdExperiments)
+      return false;
+    else if (__isset.createdExperiments && !(createdExperiments == rhs.createdExperiments))
+      return false;
+    if (__isset.runningExperiments != rhs.__isset.runningExperiments)
+      return false;
+    else if (__isset.runningExperiments && !(runningExperiments == rhs.runningExperiments))
+      return false;
     return true;
   }
   bool operator != (const ExperimentStatistics &rhs) const {

http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Workspace/Experiment/Types.php
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Workspace/Experiment/Types.php b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Workspace/Experiment/Types.php
index db58bf9..9b352cf 100644
--- a/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Workspace/Experiment/Types.php
+++ b/airavata-api/airavata-client-sdks/airavata-php-sdk/src/main/resources/lib/Airavata/Model/Workspace/Experiment/Types.php
@@ -4341,10 +4341,14 @@ class ExperimentStatistics {
   public $completedExperimentCount = null;
   public $cancelledExperimentCount = null;
   public $failedExperimentCount = null;
+  public $createdExperimentCount = null;
+  public $runningExperimentCount = null;
   public $allExperiments = null;
   public $completedExperiments = null;
   public $failedExperiments = null;
   public $cancelledExperiments = null;
+  public $createdExperiments = null;
+  public $runningExperiments = null;
 
   public function __construct($vals=null) {
     if (!isset(self::$_TSPEC)) {
@@ -4366,6 +4370,14 @@ class ExperimentStatistics {
           'type' => TType::I32,
           ),
         5 => array(
+          'var' => 'createdExperimentCount',
+          'type' => TType::I32,
+          ),
+        6 => array(
+          'var' => 'runningExperimentCount',
+          'type' => TType::I32,
+          ),
+        7 => array(
           'var' => 'allExperiments',
           'type' => TType::LST,
           'etype' => TType::STRUCT,
@@ -4374,7 +4386,7 @@ class ExperimentStatistics {
             'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
             ),
           ),
-        6 => array(
+        8 => array(
           'var' => 'completedExperiments',
           'type' => TType::LST,
           'etype' => TType::STRUCT,
@@ -4383,7 +4395,7 @@ class ExperimentStatistics {
             'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
             ),
           ),
-        7 => array(
+        9 => array(
           'var' => 'failedExperiments',
           'type' => TType::LST,
           'etype' => TType::STRUCT,
@@ -4392,7 +4404,7 @@ class ExperimentStatistics {
             'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
             ),
           ),
-        8 => array(
+        10 => array(
           'var' => 'cancelledExperiments',
           'type' => TType::LST,
           'etype' => TType::STRUCT,
@@ -4401,6 +4413,24 @@ class ExperimentStatistics {
             'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
             ),
           ),
+        11 => array(
+          'var' => 'createdExperiments',
+          'type' => TType::LST,
+          'etype' => TType::STRUCT,
+          'elem' => array(
+            'type' => TType::STRUCT,
+            'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
+            ),
+          ),
+        12 => array(
+          'var' => 'runningExperiments',
+          'type' => TType::LST,
+          'etype' => TType::STRUCT,
+          'elem' => array(
+            'type' => TType::STRUCT,
+            'class' => '\Airavata\Model\Workspace\Experiment\ExperimentSummary',
+            ),
+          ),
         );
     }
     if (is_array($vals)) {
@@ -4416,6 +4446,12 @@ class ExperimentStatistics {
       if (isset($vals['failedExperimentCount'])) {
         $this->failedExperimentCount = $vals['failedExperimentCount'];
       }
+      if (isset($vals['createdExperimentCount'])) {
+        $this->createdExperimentCount = $vals['createdExperimentCount'];
+      }
+      if (isset($vals['runningExperimentCount'])) {
+        $this->runningExperimentCount = $vals['runningExperimentCount'];
+      }
       if (isset($vals['allExperiments'])) {
         $this->allExperiments = $vals['allExperiments'];
       }
@@ -4428,6 +4464,12 @@ class ExperimentStatistics {
       if (isset($vals['cancelledExperiments'])) {
         $this->cancelledExperiments = $vals['cancelledExperiments'];
       }
+      if (isset($vals['createdExperiments'])) {
+        $this->createdExperiments = $vals['createdExperiments'];
+      }
+      if (isset($vals['runningExperiments'])) {
+        $this->runningExperiments = $vals['runningExperiments'];
+      }
     }
   }
 
@@ -4479,6 +4521,20 @@ class ExperimentStatistics {
           }
           break;
         case 5:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->createdExperimentCount);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 6:
+          if ($ftype == TType::I32) {
+            $xfer += $input->readI32($this->runningExperimentCount);
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 7:
           if ($ftype == TType::LST) {
             $this->allExperiments = array();
             $_size133 = 0;
@@ -4496,7 +4552,7 @@ class ExperimentStatistics {
             $xfer += $input->skip($ftype);
           }
           break;
-        case 6:
+        case 8:
           if ($ftype == TType::LST) {
             $this->completedExperiments = array();
             $_size139 = 0;
@@ -4514,7 +4570,7 @@ class ExperimentStatistics {
             $xfer += $input->skip($ftype);
           }
           break;
-        case 7:
+        case 9:
           if ($ftype == TType::LST) {
             $this->failedExperiments = array();
             $_size145 = 0;
@@ -4532,7 +4588,7 @@ class ExperimentStatistics {
             $xfer += $input->skip($ftype);
           }
           break;
-        case 8:
+        case 10:
           if ($ftype == TType::LST) {
             $this->cancelledExperiments = array();
             $_size151 = 0;
@@ -4550,6 +4606,42 @@ class ExperimentStatistics {
             $xfer += $input->skip($ftype);
           }
           break;
+        case 11:
+          if ($ftype == TType::LST) {
+            $this->createdExperiments = array();
+            $_size157 = 0;
+            $_etype160 = 0;
+            $xfer += $input->readListBegin($_etype160, $_size157);
+            for ($_i161 = 0; $_i161 < $_size157; ++$_i161)
+            {
+              $elem162 = null;
+              $elem162 = new \Airavata\Model\Workspace\Experiment\ExperimentSummary();
+              $xfer += $elem162->read($input);
+              $this->createdExperiments []= $elem162;
+            }
+            $xfer += $input->readListEnd();
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
+        case 12:
+          if ($ftype == TType::LST) {
+            $this->runningExperiments = array();
+            $_size163 = 0;
+            $_etype166 = 0;
+            $xfer += $input->readListBegin($_etype166, $_size163);
+            for ($_i167 = 0; $_i167 < $_size163; ++$_i167)
+            {
+              $elem168 = null;
+              $elem168 = new \Airavata\Model\Workspace\Experiment\ExperimentSummary();
+              $xfer += $elem168->read($input);
+              $this->runningExperiments []= $elem168;
+            }
+            $xfer += $input->readListEnd();
+          } else {
+            $xfer += $input->skip($ftype);
+          }
+          break;
         default:
           $xfer += $input->skip($ftype);
           break;
@@ -4583,17 +4675,27 @@ class ExperimentStatistics {
       $xfer += $output->writeI32($this->failedExperimentCount);
       $xfer += $output->writeFieldEnd();
     }
+    if ($this->createdExperimentCount !== null) {
+      $xfer += $output->writeFieldBegin('createdExperimentCount', TType::I32, 5);
+      $xfer += $output->writeI32($this->createdExperimentCount);
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->runningExperimentCount !== null) {
+      $xfer += $output->writeFieldBegin('runningExperimentCount', TType::I32, 6);
+      $xfer += $output->writeI32($this->runningExperimentCount);
+      $xfer += $output->writeFieldEnd();
+    }
     if ($this->allExperiments !== null) {
       if (!is_array($this->allExperiments)) {
         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
       }
-      $xfer += $output->writeFieldBegin('allExperiments', TType::LST, 5);
+      $xfer += $output->writeFieldBegin('allExperiments', TType::LST, 7);
       {
         $output->writeListBegin(TType::STRUCT, count($this->allExperiments));
         {
-          foreach ($this->allExperiments as $iter157)
+          foreach ($this->allExperiments as $iter169)
           {
-            $xfer += $iter157->write($output);
+            $xfer += $iter169->write($output);
           }
         }
         $output->writeListEnd();
@@ -4604,13 +4706,13 @@ class ExperimentStatistics {
       if (!is_array($this->completedExperiments)) {
         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
       }
-      $xfer += $output->writeFieldBegin('completedExperiments', TType::LST, 6);
+      $xfer += $output->writeFieldBegin('completedExperiments', TType::LST, 8);
       {
         $output->writeListBegin(TType::STRUCT, count($this->completedExperiments));
         {
-          foreach ($this->completedExperiments as $iter158)
+          foreach ($this->completedExperiments as $iter170)
           {
-            $xfer += $iter158->write($output);
+            $xfer += $iter170->write($output);
           }
         }
         $output->writeListEnd();
@@ -4621,13 +4723,13 @@ class ExperimentStatistics {
       if (!is_array($this->failedExperiments)) {
         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
       }
-      $xfer += $output->writeFieldBegin('failedExperiments', TType::LST, 7);
+      $xfer += $output->writeFieldBegin('failedExperiments', TType::LST, 9);
       {
         $output->writeListBegin(TType::STRUCT, count($this->failedExperiments));
         {
-          foreach ($this->failedExperiments as $iter159)
+          foreach ($this->failedExperiments as $iter171)
           {
-            $xfer += $iter159->write($output);
+            $xfer += $iter171->write($output);
           }
         }
         $output->writeListEnd();
@@ -4638,13 +4740,47 @@ class ExperimentStatistics {
       if (!is_array($this->cancelledExperiments)) {
         throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
       }
-      $xfer += $output->writeFieldBegin('cancelledExperiments', TType::LST, 8);
+      $xfer += $output->writeFieldBegin('cancelledExperiments', TType::LST, 10);
       {
         $output->writeListBegin(TType::STRUCT, count($this->cancelledExperiments));
         {
-          foreach ($this->cancelledExperiments as $iter160)
+          foreach ($this->cancelledExperiments as $iter172)
+          {
+            $xfer += $iter172->write($output);
+          }
+        }
+        $output->writeListEnd();
+      }
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->createdExperiments !== null) {
+      if (!is_array($this->createdExperiments)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('createdExperiments', TType::LST, 11);
+      {
+        $output->writeListBegin(TType::STRUCT, count($this->createdExperiments));
+        {
+          foreach ($this->createdExperiments as $iter173)
+          {
+            $xfer += $iter173->write($output);
+          }
+        }
+        $output->writeListEnd();
+      }
+      $xfer += $output->writeFieldEnd();
+    }
+    if ($this->runningExperiments !== null) {
+      if (!is_array($this->runningExperiments)) {
+        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+      }
+      $xfer += $output->writeFieldBegin('runningExperiments', TType::LST, 12);
+      {
+        $output->writeListBegin(TType::STRUCT, count($this->runningExperiments));
+        {
+          foreach ($this->runningExperiments as $iter174)
           {
-            $xfer += $iter160->write($output);
+            $xfer += $iter174->write($output);
           }
         }
         $output->writeListEnd();

http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/airavata-client-sdks/airavata-python-sdk/src/main/resources/lib/apache/airavata/model/workspace/experiment/ttypes.py
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-python-sdk/src/main/resources/lib/apache/airavata/model/workspace/experiment/ttypes.py b/airavata-api/airavata-client-sdks/airavata-python-sdk/src/main/resources/lib/apache/airavata/model/workspace/experiment/ttypes.py
index 125fec6..ccd1ddd 100644
--- a/airavata-api/airavata-client-sdks/airavata-python-sdk/src/main/resources/lib/apache/airavata/model/workspace/experiment/ttypes.py
+++ b/airavata-api/airavata-client-sdks/airavata-python-sdk/src/main/resources/lib/apache/airavata/model/workspace/experiment/ttypes.py
@@ -3077,10 +3077,14 @@ class ExperimentStatistics:
    - completedExperimentCount
    - cancelledExperimentCount
    - failedExperimentCount
+   - createdExperimentCount
+   - runningExperimentCount
    - allExperiments
    - completedExperiments
    - failedExperiments
    - cancelledExperiments
+   - createdExperiments
+   - runningExperiments
   """
 
   thrift_spec = (
@@ -3089,21 +3093,29 @@ class ExperimentStatistics:
     (2, TType.I32, 'completedExperimentCount', None, None, ), # 2
     (3, TType.I32, 'cancelledExperimentCount', None, None, ), # 3
     (4, TType.I32, 'failedExperimentCount', None, None, ), # 4
-    (5, TType.LIST, 'allExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 5
-    (6, TType.LIST, 'completedExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 6
-    (7, TType.LIST, 'failedExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 7
-    (8, TType.LIST, 'cancelledExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 8
+    (5, TType.I32, 'createdExperimentCount', None, None, ), # 5
+    (6, TType.I32, 'runningExperimentCount', None, None, ), # 6
+    (7, TType.LIST, 'allExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 7
+    (8, TType.LIST, 'completedExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 8
+    (9, TType.LIST, 'failedExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 9
+    (10, TType.LIST, 'cancelledExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 10
+    (11, TType.LIST, 'createdExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 11
+    (12, TType.LIST, 'runningExperiments', (TType.STRUCT,(ExperimentSummary, ExperimentSummary.thrift_spec)), None, ), # 12
   )
 
-  def __init__(self, allExperimentCount=None, completedExperimentCount=None, cancelledExperimentCount=None, failedExperimentCount=None, allExperiments=None, completedExperiments=None, failedExperiments=None, cancelledExperiments=None,):
+  def __init__(self, allExperimentCount=None, completedExperimentCount=None, cancelledExperimentCount=None, failedExperimentCount=None, createdExperimentCount=None, runningExperimentCount=None, allExperiments=None, completedExperiments=None, failedExperiments=None, cancelledExperiments=None, createdExperiments=None, runningExperiments=None,):
     self.allExperimentCount = allExperimentCount
     self.completedExperimentCount = completedExperimentCount
     self.cancelledExperimentCount = cancelledExperimentCount
     self.failedExperimentCount = failedExperimentCount
+    self.createdExperimentCount = createdExperimentCount
+    self.runningExperimentCount = runningExperimentCount
     self.allExperiments = allExperiments
     self.completedExperiments = completedExperiments
     self.failedExperiments = failedExperiments
     self.cancelledExperiments = cancelledExperiments
+    self.createdExperiments = createdExperiments
+    self.runningExperiments = runningExperiments
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -3135,6 +3147,16 @@ class ExperimentStatistics:
         else:
           iprot.skip(ftype)
       elif fid == 5:
+        if ftype == TType.I32:
+          self.createdExperimentCount = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.I32:
+          self.runningExperimentCount = iprot.readI32();
+        else:
+          iprot.skip(ftype)
+      elif fid == 7:
         if ftype == TType.LIST:
           self.allExperiments = []
           (_etype136, _size133) = iprot.readListBegin()
@@ -3145,7 +3167,7 @@ class ExperimentStatistics:
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
-      elif fid == 6:
+      elif fid == 8:
         if ftype == TType.LIST:
           self.completedExperiments = []
           (_etype142, _size139) = iprot.readListBegin()
@@ -3156,7 +3178,7 @@ class ExperimentStatistics:
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
-      elif fid == 7:
+      elif fid == 9:
         if ftype == TType.LIST:
           self.failedExperiments = []
           (_etype148, _size145) = iprot.readListBegin()
@@ -3167,7 +3189,7 @@ class ExperimentStatistics:
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
-      elif fid == 8:
+      elif fid == 10:
         if ftype == TType.LIST:
           self.cancelledExperiments = []
           (_etype154, _size151) = iprot.readListBegin()
@@ -3178,6 +3200,28 @@ class ExperimentStatistics:
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
+      elif fid == 11:
+        if ftype == TType.LIST:
+          self.createdExperiments = []
+          (_etype160, _size157) = iprot.readListBegin()
+          for _i161 in xrange(_size157):
+            _elem162 = ExperimentSummary()
+            _elem162.read(iprot)
+            self.createdExperiments.append(_elem162)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 12:
+        if ftype == TType.LIST:
+          self.runningExperiments = []
+          (_etype166, _size163) = iprot.readListBegin()
+          for _i167 in xrange(_size163):
+            _elem168 = ExperimentSummary()
+            _elem168.read(iprot)
+            self.runningExperiments.append(_elem168)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -3204,32 +3248,54 @@ class ExperimentStatistics:
       oprot.writeFieldBegin('failedExperimentCount', TType.I32, 4)
       oprot.writeI32(self.failedExperimentCount)
       oprot.writeFieldEnd()
+    if self.createdExperimentCount is not None:
+      oprot.writeFieldBegin('createdExperimentCount', TType.I32, 5)
+      oprot.writeI32(self.createdExperimentCount)
+      oprot.writeFieldEnd()
+    if self.runningExperimentCount is not None:
+      oprot.writeFieldBegin('runningExperimentCount', TType.I32, 6)
+      oprot.writeI32(self.runningExperimentCount)
+      oprot.writeFieldEnd()
     if self.allExperiments is not None:
-      oprot.writeFieldBegin('allExperiments', TType.LIST, 5)
+      oprot.writeFieldBegin('allExperiments', TType.LIST, 7)
       oprot.writeListBegin(TType.STRUCT, len(self.allExperiments))
-      for iter157 in self.allExperiments:
-        iter157.write(oprot)
+      for iter169 in self.allExperiments:
+        iter169.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.completedExperiments is not None:
-      oprot.writeFieldBegin('completedExperiments', TType.LIST, 6)
+      oprot.writeFieldBegin('completedExperiments', TType.LIST, 8)
       oprot.writeListBegin(TType.STRUCT, len(self.completedExperiments))
-      for iter158 in self.completedExperiments:
-        iter158.write(oprot)
+      for iter170 in self.completedExperiments:
+        iter170.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.failedExperiments is not None:
-      oprot.writeFieldBegin('failedExperiments', TType.LIST, 7)
+      oprot.writeFieldBegin('failedExperiments', TType.LIST, 9)
       oprot.writeListBegin(TType.STRUCT, len(self.failedExperiments))
-      for iter159 in self.failedExperiments:
-        iter159.write(oprot)
+      for iter171 in self.failedExperiments:
+        iter171.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.cancelledExperiments is not None:
-      oprot.writeFieldBegin('cancelledExperiments', TType.LIST, 8)
+      oprot.writeFieldBegin('cancelledExperiments', TType.LIST, 10)
       oprot.writeListBegin(TType.STRUCT, len(self.cancelledExperiments))
-      for iter160 in self.cancelledExperiments:
-        iter160.write(oprot)
+      for iter172 in self.cancelledExperiments:
+        iter172.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.createdExperiments is not None:
+      oprot.writeFieldBegin('createdExperiments', TType.LIST, 11)
+      oprot.writeListBegin(TType.STRUCT, len(self.createdExperiments))
+      for iter173 in self.createdExperiments:
+        iter173.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.runningExperiments is not None:
+      oprot.writeFieldBegin('runningExperiments', TType.LIST, 12)
+      oprot.writeListBegin(TType.STRUCT, len(self.runningExperiments))
+      for iter174 in self.runningExperiments:
+        iter174.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -3242,6 +3308,10 @@ class ExperimentStatistics:
       raise TProtocol.TProtocolException(message='Required field completedExperimentCount is unset!')
     if self.failedExperimentCount is None:
       raise TProtocol.TProtocolException(message='Required field failedExperimentCount is unset!')
+    if self.createdExperimentCount is None:
+      raise TProtocol.TProtocolException(message='Required field createdExperimentCount is unset!')
+    if self.runningExperimentCount is None:
+      raise TProtocol.TProtocolException(message='Required field runningExperimentCount is unset!')
     if self.allExperiments is None:
       raise TProtocol.TProtocolException(message='Required field allExperiments is unset!')
     return

http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/workspace/experiment/ExperimentStatistics.java
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/workspace/experiment/ExperimentStatistics.java b/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/workspace/experiment/ExperimentStatistics.java
index 5e074ea..5f61572 100644
--- a/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/workspace/experiment/ExperimentStatistics.java
+++ b/airavata-api/airavata-data-models/src/main/java/org/apache/airavata/model/workspace/experiment/ExperimentStatistics.java
@@ -56,10 +56,14 @@ import org.slf4j.LoggerFactory;
   private static final org.apache.thrift.protocol.TField COMPLETED_EXPERIMENT_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("completedExperimentCount", org.apache.thrift.protocol.TType.I32, (short)2);
   private static final org.apache.thrift.protocol.TField CANCELLED_EXPERIMENT_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("cancelledExperimentCount", org.apache.thrift.protocol.TType.I32, (short)3);
   private static final org.apache.thrift.protocol.TField FAILED_EXPERIMENT_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("failedExperimentCount", org.apache.thrift.protocol.TType.I32, (short)4);
-  private static final org.apache.thrift.protocol.TField ALL_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("allExperiments", org.apache.thrift.protocol.TType.LIST, (short)5);
-  private static final org.apache.thrift.protocol.TField COMPLETED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("completedExperiments", org.apache.thrift.protocol.TType.LIST, (short)6);
-  private static final org.apache.thrift.protocol.TField FAILED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("failedExperiments", org.apache.thrift.protocol.TType.LIST, (short)7);
-  private static final org.apache.thrift.protocol.TField CANCELLED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("cancelledExperiments", org.apache.thrift.protocol.TType.LIST, (short)8);
+  private static final org.apache.thrift.protocol.TField CREATED_EXPERIMENT_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("createdExperimentCount", org.apache.thrift.protocol.TType.I32, (short)5);
+  private static final org.apache.thrift.protocol.TField RUNNING_EXPERIMENT_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("runningExperimentCount", org.apache.thrift.protocol.TType.I32, (short)6);
+  private static final org.apache.thrift.protocol.TField ALL_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("allExperiments", org.apache.thrift.protocol.TType.LIST, (short)7);
+  private static final org.apache.thrift.protocol.TField COMPLETED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("completedExperiments", org.apache.thrift.protocol.TType.LIST, (short)8);
+  private static final org.apache.thrift.protocol.TField FAILED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("failedExperiments", org.apache.thrift.protocol.TType.LIST, (short)9);
+  private static final org.apache.thrift.protocol.TField CANCELLED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("cancelledExperiments", org.apache.thrift.protocol.TType.LIST, (short)10);
+  private static final org.apache.thrift.protocol.TField CREATED_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("createdExperiments", org.apache.thrift.protocol.TType.LIST, (short)11);
+  private static final org.apache.thrift.protocol.TField RUNNING_EXPERIMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("runningExperiments", org.apache.thrift.protocol.TType.LIST, (short)12);
 
   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
   static {
@@ -71,10 +75,14 @@ import org.slf4j.LoggerFactory;
   private int completedExperimentCount; // required
   private int cancelledExperimentCount; // optional
   private int failedExperimentCount; // required
+  private int createdExperimentCount; // required
+  private int runningExperimentCount; // required
   private List<ExperimentSummary> allExperiments; // required
   private List<ExperimentSummary> completedExperiments; // optional
   private List<ExperimentSummary> failedExperiments; // optional
   private List<ExperimentSummary> cancelledExperiments; // optional
+  private List<ExperimentSummary> createdExperiments; // optional
+  private List<ExperimentSummary> runningExperiments; // optional
 
   /** 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 {
@@ -82,10 +90,14 @@ import org.slf4j.LoggerFactory;
     COMPLETED_EXPERIMENT_COUNT((short)2, "completedExperimentCount"),
     CANCELLED_EXPERIMENT_COUNT((short)3, "cancelledExperimentCount"),
     FAILED_EXPERIMENT_COUNT((short)4, "failedExperimentCount"),
-    ALL_EXPERIMENTS((short)5, "allExperiments"),
-    COMPLETED_EXPERIMENTS((short)6, "completedExperiments"),
-    FAILED_EXPERIMENTS((short)7, "failedExperiments"),
-    CANCELLED_EXPERIMENTS((short)8, "cancelledExperiments");
+    CREATED_EXPERIMENT_COUNT((short)5, "createdExperimentCount"),
+    RUNNING_EXPERIMENT_COUNT((short)6, "runningExperimentCount"),
+    ALL_EXPERIMENTS((short)7, "allExperiments"),
+    COMPLETED_EXPERIMENTS((short)8, "completedExperiments"),
+    FAILED_EXPERIMENTS((short)9, "failedExperiments"),
+    CANCELLED_EXPERIMENTS((short)10, "cancelledExperiments"),
+    CREATED_EXPERIMENTS((short)11, "createdExperiments"),
+    RUNNING_EXPERIMENTS((short)12, "runningExperiments");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
 
@@ -108,14 +120,22 @@ import org.slf4j.LoggerFactory;
           return CANCELLED_EXPERIMENT_COUNT;
         case 4: // FAILED_EXPERIMENT_COUNT
           return FAILED_EXPERIMENT_COUNT;
-        case 5: // ALL_EXPERIMENTS
+        case 5: // CREATED_EXPERIMENT_COUNT
+          return CREATED_EXPERIMENT_COUNT;
+        case 6: // RUNNING_EXPERIMENT_COUNT
+          return RUNNING_EXPERIMENT_COUNT;
+        case 7: // ALL_EXPERIMENTS
           return ALL_EXPERIMENTS;
-        case 6: // COMPLETED_EXPERIMENTS
+        case 8: // COMPLETED_EXPERIMENTS
           return COMPLETED_EXPERIMENTS;
-        case 7: // FAILED_EXPERIMENTS
+        case 9: // FAILED_EXPERIMENTS
           return FAILED_EXPERIMENTS;
-        case 8: // CANCELLED_EXPERIMENTS
+        case 10: // CANCELLED_EXPERIMENTS
           return CANCELLED_EXPERIMENTS;
+        case 11: // CREATED_EXPERIMENTS
+          return CREATED_EXPERIMENTS;
+        case 12: // RUNNING_EXPERIMENTS
+          return RUNNING_EXPERIMENTS;
         default:
           return null;
       }
@@ -160,8 +180,10 @@ import org.slf4j.LoggerFactory;
   private static final int __COMPLETEDEXPERIMENTCOUNT_ISSET_ID = 1;
   private static final int __CANCELLEDEXPERIMENTCOUNT_ISSET_ID = 2;
   private static final int __FAILEDEXPERIMENTCOUNT_ISSET_ID = 3;
+  private static final int __CREATEDEXPERIMENTCOUNT_ISSET_ID = 4;
+  private static final int __RUNNINGEXPERIMENTCOUNT_ISSET_ID = 5;
   private byte __isset_bitfield = 0;
-  private _Fields optionals[] = {_Fields.CANCELLED_EXPERIMENT_COUNT,_Fields.COMPLETED_EXPERIMENTS,_Fields.FAILED_EXPERIMENTS,_Fields.CANCELLED_EXPERIMENTS};
+  private _Fields optionals[] = {_Fields.CANCELLED_EXPERIMENT_COUNT,_Fields.COMPLETED_EXPERIMENTS,_Fields.FAILED_EXPERIMENTS,_Fields.CANCELLED_EXPERIMENTS,_Fields.CREATED_EXPERIMENTS,_Fields.RUNNING_EXPERIMENTS};
   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);
@@ -173,6 +195,10 @@ import org.slf4j.LoggerFactory;
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
     tmpMap.put(_Fields.FAILED_EXPERIMENT_COUNT, new org.apache.thrift.meta_data.FieldMetaData("failedExperimentCount", org.apache.thrift.TFieldRequirementType.REQUIRED, 
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.CREATED_EXPERIMENT_COUNT, new org.apache.thrift.meta_data.FieldMetaData("createdExperimentCount", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.RUNNING_EXPERIMENT_COUNT, new org.apache.thrift.meta_data.FieldMetaData("runningExperimentCount", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
     tmpMap.put(_Fields.ALL_EXPERIMENTS, new org.apache.thrift.meta_data.FieldMetaData("allExperiments", org.apache.thrift.TFieldRequirementType.REQUIRED, 
         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
             new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ExperimentSummary.class))));
@@ -185,6 +211,12 @@ import org.slf4j.LoggerFactory;
     tmpMap.put(_Fields.CANCELLED_EXPERIMENTS, new org.apache.thrift.meta_data.FieldMetaData("cancelledExperiments", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
             new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ExperimentSummary.class))));
+    tmpMap.put(_Fields.CREATED_EXPERIMENTS, new org.apache.thrift.meta_data.FieldMetaData("createdExperiments", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ExperimentSummary.class))));
+    tmpMap.put(_Fields.RUNNING_EXPERIMENTS, new org.apache.thrift.meta_data.FieldMetaData("runningExperiments", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ExperimentSummary.class))));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ExperimentStatistics.class, metaDataMap);
   }
@@ -196,6 +228,8 @@ import org.slf4j.LoggerFactory;
     int allExperimentCount,
     int completedExperimentCount,
     int failedExperimentCount,
+    int createdExperimentCount,
+    int runningExperimentCount,
     List<ExperimentSummary> allExperiments)
   {
     this();
@@ -205,6 +239,10 @@ import org.slf4j.LoggerFactory;
     setCompletedExperimentCountIsSet(true);
     this.failedExperimentCount = failedExperimentCount;
     setFailedExperimentCountIsSet(true);
+    this.createdExperimentCount = createdExperimentCount;
+    setCreatedExperimentCountIsSet(true);
+    this.runningExperimentCount = runningExperimentCount;
+    setRunningExperimentCountIsSet(true);
     this.allExperiments = allExperiments;
   }
 
@@ -217,6 +255,8 @@ import org.slf4j.LoggerFactory;
     this.completedExperimentCount = other.completedExperimentCount;
     this.cancelledExperimentCount = other.cancelledExperimentCount;
     this.failedExperimentCount = other.failedExperimentCount;
+    this.createdExperimentCount = other.createdExperimentCount;
+    this.runningExperimentCount = other.runningExperimentCount;
     if (other.isSetAllExperiments()) {
       List<ExperimentSummary> __this__allExperiments = new ArrayList<ExperimentSummary>(other.allExperiments.size());
       for (ExperimentSummary other_element : other.allExperiments) {
@@ -245,6 +285,20 @@ import org.slf4j.LoggerFactory;
       }
       this.cancelledExperiments = __this__cancelledExperiments;
     }
+    if (other.isSetCreatedExperiments()) {
+      List<ExperimentSummary> __this__createdExperiments = new ArrayList<ExperimentSummary>(other.createdExperiments.size());
+      for (ExperimentSummary other_element : other.createdExperiments) {
+        __this__createdExperiments.add(new ExperimentSummary(other_element));
+      }
+      this.createdExperiments = __this__createdExperiments;
+    }
+    if (other.isSetRunningExperiments()) {
+      List<ExperimentSummary> __this__runningExperiments = new ArrayList<ExperimentSummary>(other.runningExperiments.size());
+      for (ExperimentSummary other_element : other.runningExperiments) {
+        __this__runningExperiments.add(new ExperimentSummary(other_element));
+      }
+      this.runningExperiments = __this__runningExperiments;
+    }
   }
 
   public ExperimentStatistics deepCopy() {
@@ -261,10 +315,16 @@ import org.slf4j.LoggerFactory;
     this.cancelledExperimentCount = 0;
     setFailedExperimentCountIsSet(false);
     this.failedExperimentCount = 0;
+    setCreatedExperimentCountIsSet(false);
+    this.createdExperimentCount = 0;
+    setRunningExperimentCountIsSet(false);
+    this.runningExperimentCount = 0;
     this.allExperiments = null;
     this.completedExperiments = null;
     this.failedExperiments = null;
     this.cancelledExperiments = null;
+    this.createdExperiments = null;
+    this.runningExperiments = null;
   }
 
   public int getAllExperimentCount() {
@@ -355,6 +415,50 @@ import org.slf4j.LoggerFactory;
     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FAILEDEXPERIMENTCOUNT_ISSET_ID, value);
   }
 
+  public int getCreatedExperimentCount() {
+    return this.createdExperimentCount;
+  }
+
+  public void setCreatedExperimentCount(int createdExperimentCount) {
+    this.createdExperimentCount = createdExperimentCount;
+    setCreatedExperimentCountIsSet(true);
+  }
+
+  public void unsetCreatedExperimentCount() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CREATEDEXPERIMENTCOUNT_ISSET_ID);
+  }
+
+  /** Returns true if field createdExperimentCount is set (has been assigned a value) and false otherwise */
+  public boolean isSetCreatedExperimentCount() {
+    return EncodingUtils.testBit(__isset_bitfield, __CREATEDEXPERIMENTCOUNT_ISSET_ID);
+  }
+
+  public void setCreatedExperimentCountIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CREATEDEXPERIMENTCOUNT_ISSET_ID, value);
+  }
+
+  public int getRunningExperimentCount() {
+    return this.runningExperimentCount;
+  }
+
+  public void setRunningExperimentCount(int runningExperimentCount) {
+    this.runningExperimentCount = runningExperimentCount;
+    setRunningExperimentCountIsSet(true);
+  }
+
+  public void unsetRunningExperimentCount() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __RUNNINGEXPERIMENTCOUNT_ISSET_ID);
+  }
+
+  /** Returns true if field runningExperimentCount is set (has been assigned a value) and false otherwise */
+  public boolean isSetRunningExperimentCount() {
+    return EncodingUtils.testBit(__isset_bitfield, __RUNNINGEXPERIMENTCOUNT_ISSET_ID);
+  }
+
+  public void setRunningExperimentCountIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __RUNNINGEXPERIMENTCOUNT_ISSET_ID, value);
+  }
+
   public int getAllExperimentsSize() {
     return (this.allExperiments == null) ? 0 : this.allExperiments.size();
   }
@@ -507,6 +611,82 @@ import org.slf4j.LoggerFactory;
     }
   }
 
+  public int getCreatedExperimentsSize() {
+    return (this.createdExperiments == null) ? 0 : this.createdExperiments.size();
+  }
+
+  public java.util.Iterator<ExperimentSummary> getCreatedExperimentsIterator() {
+    return (this.createdExperiments == null) ? null : this.createdExperiments.iterator();
+  }
+
+  public void addToCreatedExperiments(ExperimentSummary elem) {
+    if (this.createdExperiments == null) {
+      this.createdExperiments = new ArrayList<ExperimentSummary>();
+    }
+    this.createdExperiments.add(elem);
+  }
+
+  public List<ExperimentSummary> getCreatedExperiments() {
+    return this.createdExperiments;
+  }
+
+  public void setCreatedExperiments(List<ExperimentSummary> createdExperiments) {
+    this.createdExperiments = createdExperiments;
+  }
+
+  public void unsetCreatedExperiments() {
+    this.createdExperiments = null;
+  }
+
+  /** Returns true if field createdExperiments is set (has been assigned a value) and false otherwise */
+  public boolean isSetCreatedExperiments() {
+    return this.createdExperiments != null;
+  }
+
+  public void setCreatedExperimentsIsSet(boolean value) {
+    if (!value) {
+      this.createdExperiments = null;
+    }
+  }
+
+  public int getRunningExperimentsSize() {
+    return (this.runningExperiments == null) ? 0 : this.runningExperiments.size();
+  }
+
+  public java.util.Iterator<ExperimentSummary> getRunningExperimentsIterator() {
+    return (this.runningExperiments == null) ? null : this.runningExperiments.iterator();
+  }
+
+  public void addToRunningExperiments(ExperimentSummary elem) {
+    if (this.runningExperiments == null) {
+      this.runningExperiments = new ArrayList<ExperimentSummary>();
+    }
+    this.runningExperiments.add(elem);
+  }
+
+  public List<ExperimentSummary> getRunningExperiments() {
+    return this.runningExperiments;
+  }
+
+  public void setRunningExperiments(List<ExperimentSummary> runningExperiments) {
+    this.runningExperiments = runningExperiments;
+  }
+
+  public void unsetRunningExperiments() {
+    this.runningExperiments = null;
+  }
+
+  /** Returns true if field runningExperiments is set (has been assigned a value) and false otherwise */
+  public boolean isSetRunningExperiments() {
+    return this.runningExperiments != null;
+  }
+
+  public void setRunningExperimentsIsSet(boolean value) {
+    if (!value) {
+      this.runningExperiments = null;
+    }
+  }
+
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case ALL_EXPERIMENT_COUNT:
@@ -541,6 +721,22 @@ import org.slf4j.LoggerFactory;
       }
       break;
 
+    case CREATED_EXPERIMENT_COUNT:
+      if (value == null) {
+        unsetCreatedExperimentCount();
+      } else {
+        setCreatedExperimentCount((Integer)value);
+      }
+      break;
+
+    case RUNNING_EXPERIMENT_COUNT:
+      if (value == null) {
+        unsetRunningExperimentCount();
+      } else {
+        setRunningExperimentCount((Integer)value);
+      }
+      break;
+
     case ALL_EXPERIMENTS:
       if (value == null) {
         unsetAllExperiments();
@@ -573,6 +769,22 @@ import org.slf4j.LoggerFactory;
       }
       break;
 
+    case CREATED_EXPERIMENTS:
+      if (value == null) {
+        unsetCreatedExperiments();
+      } else {
+        setCreatedExperiments((List<ExperimentSummary>)value);
+      }
+      break;
+
+    case RUNNING_EXPERIMENTS:
+      if (value == null) {
+        unsetRunningExperiments();
+      } else {
+        setRunningExperiments((List<ExperimentSummary>)value);
+      }
+      break;
+
     }
   }
 
@@ -590,6 +802,12 @@ import org.slf4j.LoggerFactory;
     case FAILED_EXPERIMENT_COUNT:
       return Integer.valueOf(getFailedExperimentCount());
 
+    case CREATED_EXPERIMENT_COUNT:
+      return Integer.valueOf(getCreatedExperimentCount());
+
+    case RUNNING_EXPERIMENT_COUNT:
+      return Integer.valueOf(getRunningExperimentCount());
+
     case ALL_EXPERIMENTS:
       return getAllExperiments();
 
@@ -602,6 +820,12 @@ import org.slf4j.LoggerFactory;
     case CANCELLED_EXPERIMENTS:
       return getCancelledExperiments();
 
+    case CREATED_EXPERIMENTS:
+      return getCreatedExperiments();
+
+    case RUNNING_EXPERIMENTS:
+      return getRunningExperiments();
+
     }
     throw new IllegalStateException();
   }
@@ -621,6 +845,10 @@ import org.slf4j.LoggerFactory;
       return isSetCancelledExperimentCount();
     case FAILED_EXPERIMENT_COUNT:
       return isSetFailedExperimentCount();
+    case CREATED_EXPERIMENT_COUNT:
+      return isSetCreatedExperimentCount();
+    case RUNNING_EXPERIMENT_COUNT:
+      return isSetRunningExperimentCount();
     case ALL_EXPERIMENTS:
       return isSetAllExperiments();
     case COMPLETED_EXPERIMENTS:
@@ -629,6 +857,10 @@ import org.slf4j.LoggerFactory;
       return isSetFailedExperiments();
     case CANCELLED_EXPERIMENTS:
       return isSetCancelledExperiments();
+    case CREATED_EXPERIMENTS:
+      return isSetCreatedExperiments();
+    case RUNNING_EXPERIMENTS:
+      return isSetRunningExperiments();
     }
     throw new IllegalStateException();
   }
@@ -682,6 +914,24 @@ import org.slf4j.LoggerFactory;
         return false;
     }
 
+    boolean this_present_createdExperimentCount = true;
+    boolean that_present_createdExperimentCount = true;
+    if (this_present_createdExperimentCount || that_present_createdExperimentCount) {
+      if (!(this_present_createdExperimentCount && that_present_createdExperimentCount))
+        return false;
+      if (this.createdExperimentCount != that.createdExperimentCount)
+        return false;
+    }
+
+    boolean this_present_runningExperimentCount = true;
+    boolean that_present_runningExperimentCount = true;
+    if (this_present_runningExperimentCount || that_present_runningExperimentCount) {
+      if (!(this_present_runningExperimentCount && that_present_runningExperimentCount))
+        return false;
+      if (this.runningExperimentCount != that.runningExperimentCount)
+        return false;
+    }
+
     boolean this_present_allExperiments = true && this.isSetAllExperiments();
     boolean that_present_allExperiments = true && that.isSetAllExperiments();
     if (this_present_allExperiments || that_present_allExperiments) {
@@ -718,6 +968,24 @@ import org.slf4j.LoggerFactory;
         return false;
     }
 
+    boolean this_present_createdExperiments = true && this.isSetCreatedExperiments();
+    boolean that_present_createdExperiments = true && that.isSetCreatedExperiments();
+    if (this_present_createdExperiments || that_present_createdExperiments) {
+      if (!(this_present_createdExperiments && that_present_createdExperiments))
+        return false;
+      if (!this.createdExperiments.equals(that.createdExperiments))
+        return false;
+    }
+
+    boolean this_present_runningExperiments = true && this.isSetRunningExperiments();
+    boolean that_present_runningExperiments = true && that.isSetRunningExperiments();
+    if (this_present_runningExperiments || that_present_runningExperiments) {
+      if (!(this_present_runningExperiments && that_present_runningExperiments))
+        return false;
+      if (!this.runningExperiments.equals(that.runningExperiments))
+        return false;
+    }
+
     return true;
   }
 
@@ -774,6 +1042,26 @@ import org.slf4j.LoggerFactory;
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetCreatedExperimentCount()).compareTo(other.isSetCreatedExperimentCount());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetCreatedExperimentCount()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.createdExperimentCount, other.createdExperimentCount);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRunningExperimentCount()).compareTo(other.isSetRunningExperimentCount());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRunningExperimentCount()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.runningExperimentCount, other.runningExperimentCount);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     lastComparison = Boolean.valueOf(isSetAllExperiments()).compareTo(other.isSetAllExperiments());
     if (lastComparison != 0) {
       return lastComparison;
@@ -814,6 +1102,26 @@ import org.slf4j.LoggerFactory;
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetCreatedExperiments()).compareTo(other.isSetCreatedExperiments());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetCreatedExperiments()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.createdExperiments, other.createdExperiments);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRunningExperiments()).compareTo(other.isSetRunningExperiments());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRunningExperiments()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.runningExperiments, other.runningExperiments);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     return 0;
   }
 
@@ -852,6 +1160,14 @@ import org.slf4j.LoggerFactory;
     sb.append(this.failedExperimentCount);
     first = false;
     if (!first) sb.append(", ");
+    sb.append("createdExperimentCount:");
+    sb.append(this.createdExperimentCount);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("runningExperimentCount:");
+    sb.append(this.runningExperimentCount);
+    first = false;
+    if (!first) sb.append(", ");
     sb.append("allExperiments:");
     if (this.allExperiments == null) {
       sb.append("null");
@@ -889,6 +1205,26 @@ import org.slf4j.LoggerFactory;
       }
       first = false;
     }
+    if (isSetCreatedExperiments()) {
+      if (!first) sb.append(", ");
+      sb.append("createdExperiments:");
+      if (this.createdExperiments == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.createdExperiments);
+      }
+      first = false;
+    }
+    if (isSetRunningExperiments()) {
+      if (!first) sb.append(", ");
+      sb.append("runningExperiments:");
+      if (this.runningExperiments == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.runningExperiments);
+      }
+      first = false;
+    }
     sb.append(")");
     return sb.toString();
   }
@@ -907,6 +1243,14 @@ import org.slf4j.LoggerFactory;
       throw new org.apache.thrift.protocol.TProtocolException("Required field 'failedExperimentCount' is unset! Struct:" + toString());
     }
 
+    if (!isSetCreatedExperimentCount()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'createdExperimentCount' is unset! Struct:" + toString());
+    }
+
+    if (!isSetRunningExperimentCount()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'runningExperimentCount' is unset! Struct:" + toString());
+    }
+
     if (!isSetAllExperiments()) {
       throw new org.apache.thrift.protocol.TProtocolException("Required field 'allExperiments' is unset! Struct:" + toString());
     }
@@ -982,7 +1326,23 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
-          case 5: // ALL_EXPERIMENTS
+          case 5: // CREATED_EXPERIMENT_COUNT
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.createdExperimentCount = iprot.readI32();
+              struct.setCreatedExperimentCountIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 6: // RUNNING_EXPERIMENT_COUNT
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.runningExperimentCount = iprot.readI32();
+              struct.setRunningExperimentCountIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 7: // ALL_EXPERIMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
                 org.apache.thrift.protocol.TList _list152 = iprot.readListBegin();
@@ -1001,7 +1361,7 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
-          case 6: // COMPLETED_EXPERIMENTS
+          case 8: // COMPLETED_EXPERIMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
                 org.apache.thrift.protocol.TList _list155 = iprot.readListBegin();
@@ -1020,7 +1380,7 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
-          case 7: // FAILED_EXPERIMENTS
+          case 9: // FAILED_EXPERIMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
                 org.apache.thrift.protocol.TList _list158 = iprot.readListBegin();
@@ -1039,7 +1399,7 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
-          case 8: // CANCELLED_EXPERIMENTS
+          case 10: // CANCELLED_EXPERIMENTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
                 org.apache.thrift.protocol.TList _list161 = iprot.readListBegin();
@@ -1058,6 +1418,44 @@ import org.slf4j.LoggerFactory;
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
+          case 11: // CREATED_EXPERIMENTS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list164 = iprot.readListBegin();
+                struct.createdExperiments = new ArrayList<ExperimentSummary>(_list164.size);
+                for (int _i165 = 0; _i165 < _list164.size; ++_i165)
+                {
+                  ExperimentSummary _elem166;
+                  _elem166 = new ExperimentSummary();
+                  _elem166.read(iprot);
+                  struct.createdExperiments.add(_elem166);
+                }
+                iprot.readListEnd();
+              }
+              struct.setCreatedExperimentsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 12: // RUNNING_EXPERIMENTS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list167 = iprot.readListBegin();
+                struct.runningExperiments = new ArrayList<ExperimentSummary>(_list167.size);
+                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
+                {
+                  ExperimentSummary _elem169;
+                  _elem169 = new ExperimentSummary();
+                  _elem169.read(iprot);
+                  struct.runningExperiments.add(_elem169);
+                }
+                iprot.readListEnd();
+              }
+              struct.setRunningExperimentsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
           default:
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
         }
@@ -1085,13 +1483,19 @@ import org.slf4j.LoggerFactory;
       oprot.writeFieldBegin(FAILED_EXPERIMENT_COUNT_FIELD_DESC);
       oprot.writeI32(struct.failedExperimentCount);
       oprot.writeFieldEnd();
+      oprot.writeFieldBegin(CREATED_EXPERIMENT_COUNT_FIELD_DESC);
+      oprot.writeI32(struct.createdExperimentCount);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(RUNNING_EXPERIMENT_COUNT_FIELD_DESC);
+      oprot.writeI32(struct.runningExperimentCount);
+      oprot.writeFieldEnd();
       if (struct.allExperiments != null) {
         oprot.writeFieldBegin(ALL_EXPERIMENTS_FIELD_DESC);
         {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.allExperiments.size()));
-          for (ExperimentSummary _iter164 : struct.allExperiments)
+          for (ExperimentSummary _iter170 : struct.allExperiments)
           {
-            _iter164.write(oprot);
+            _iter170.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -1102,9 +1506,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(COMPLETED_EXPERIMENTS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.completedExperiments.size()));
-            for (ExperimentSummary _iter165 : struct.completedExperiments)
+            for (ExperimentSummary _iter171 : struct.completedExperiments)
             {
-              _iter165.write(oprot);
+              _iter171.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -1116,9 +1520,9 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(FAILED_EXPERIMENTS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.failedExperiments.size()));
-            for (ExperimentSummary _iter166 : struct.failedExperiments)
+            for (ExperimentSummary _iter172 : struct.failedExperiments)
             {
-              _iter166.write(oprot);
+              _iter172.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -1130,9 +1534,37 @@ import org.slf4j.LoggerFactory;
           oprot.writeFieldBegin(CANCELLED_EXPERIMENTS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.cancelledExperiments.size()));
-            for (ExperimentSummary _iter167 : struct.cancelledExperiments)
+            for (ExperimentSummary _iter173 : struct.cancelledExperiments)
+            {
+              _iter173.write(oprot);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.createdExperiments != null) {
+        if (struct.isSetCreatedExperiments()) {
+          oprot.writeFieldBegin(CREATED_EXPERIMENTS_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.createdExperiments.size()));
+            for (ExperimentSummary _iter174 : struct.createdExperiments)
             {
-              _iter167.write(oprot);
+              _iter174.write(oprot);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.runningExperiments != null) {
+        if (struct.isSetRunningExperiments()) {
+          oprot.writeFieldBegin(RUNNING_EXPERIMENTS_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.runningExperiments.size()));
+            for (ExperimentSummary _iter175 : struct.runningExperiments)
+            {
+              _iter175.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -1159,11 +1591,13 @@ import org.slf4j.LoggerFactory;
       oprot.writeI32(struct.allExperimentCount);
       oprot.writeI32(struct.completedExperimentCount);
       oprot.writeI32(struct.failedExperimentCount);
+      oprot.writeI32(struct.createdExperimentCount);
+      oprot.writeI32(struct.runningExperimentCount);
       {
         oprot.writeI32(struct.allExperiments.size());
-        for (ExperimentSummary _iter168 : struct.allExperiments)
+        for (ExperimentSummary _iter176 : struct.allExperiments)
         {
-          _iter168.write(oprot);
+          _iter176.write(oprot);
         }
       }
       BitSet optionals = new BitSet();
@@ -1179,34 +1613,58 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetCancelledExperiments()) {
         optionals.set(3);
       }
-      oprot.writeBitSet(optionals, 4);
+      if (struct.isSetCreatedExperiments()) {
+        optionals.set(4);
+      }
+      if (struct.isSetRunningExperiments()) {
+        optionals.set(5);
+      }
+      oprot.writeBitSet(optionals, 6);
       if (struct.isSetCancelledExperimentCount()) {
         oprot.writeI32(struct.cancelledExperimentCount);
       }
       if (struct.isSetCompletedExperiments()) {
         {
           oprot.writeI32(struct.completedExperiments.size());
-          for (ExperimentSummary _iter169 : struct.completedExperiments)
+          for (ExperimentSummary _iter177 : struct.completedExperiments)
           {
-            _iter169.write(oprot);
+            _iter177.write(oprot);
           }
         }
       }
       if (struct.isSetFailedExperiments()) {
         {
           oprot.writeI32(struct.failedExperiments.size());
-          for (ExperimentSummary _iter170 : struct.failedExperiments)
+          for (ExperimentSummary _iter178 : struct.failedExperiments)
           {
-            _iter170.write(oprot);
+            _iter178.write(oprot);
           }
         }
       }
       if (struct.isSetCancelledExperiments()) {
         {
           oprot.writeI32(struct.cancelledExperiments.size());
-          for (ExperimentSummary _iter171 : struct.cancelledExperiments)
+          for (ExperimentSummary _iter179 : struct.cancelledExperiments)
+          {
+            _iter179.write(oprot);
+          }
+        }
+      }
+      if (struct.isSetCreatedExperiments()) {
+        {
+          oprot.writeI32(struct.createdExperiments.size());
+          for (ExperimentSummary _iter180 : struct.createdExperiments)
+          {
+            _iter180.write(oprot);
+          }
+        }
+      }
+      if (struct.isSetRunningExperiments()) {
+        {
+          oprot.writeI32(struct.runningExperiments.size());
+          for (ExperimentSummary _iter181 : struct.runningExperiments)
           {
-            _iter171.write(oprot);
+            _iter181.write(oprot);
           }
         }
       }
@@ -1221,65 +1679,97 @@ import org.slf4j.LoggerFactory;
       struct.setCompletedExperimentCountIsSet(true);
       struct.failedExperimentCount = iprot.readI32();
       struct.setFailedExperimentCountIsSet(true);
+      struct.createdExperimentCount = iprot.readI32();
+      struct.setCreatedExperimentCountIsSet(true);
+      struct.runningExperimentCount = iprot.readI32();
+      struct.setRunningExperimentCountIsSet(true);
       {
-        org.apache.thrift.protocol.TList _list172 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-        struct.allExperiments = new ArrayList<ExperimentSummary>(_list172.size);
-        for (int _i173 = 0; _i173 < _list172.size; ++_i173)
+        org.apache.thrift.protocol.TList _list182 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+        struct.allExperiments = new ArrayList<ExperimentSummary>(_list182.size);
+        for (int _i183 = 0; _i183 < _list182.size; ++_i183)
         {
-          ExperimentSummary _elem174;
-          _elem174 = new ExperimentSummary();
-          _elem174.read(iprot);
-          struct.allExperiments.add(_elem174);
+          ExperimentSummary _elem184;
+          _elem184 = new ExperimentSummary();
+          _elem184.read(iprot);
+          struct.allExperiments.add(_elem184);
         }
       }
       struct.setAllExperimentsIsSet(true);
-      BitSet incoming = iprot.readBitSet(4);
+      BitSet incoming = iprot.readBitSet(6);
       if (incoming.get(0)) {
         struct.cancelledExperimentCount = iprot.readI32();
         struct.setCancelledExperimentCountIsSet(true);
       }
       if (incoming.get(1)) {
         {
-          org.apache.thrift.protocol.TList _list175 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.completedExperiments = new ArrayList<ExperimentSummary>(_list175.size);
-          for (int _i176 = 0; _i176 < _list175.size; ++_i176)
+          org.apache.thrift.protocol.TList _list185 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.completedExperiments = new ArrayList<ExperimentSummary>(_list185.size);
+          for (int _i186 = 0; _i186 < _list185.size; ++_i186)
           {
-            ExperimentSummary _elem177;
-            _elem177 = new ExperimentSummary();
-            _elem177.read(iprot);
-            struct.completedExperiments.add(_elem177);
+            ExperimentSummary _elem187;
+            _elem187 = new ExperimentSummary();
+            _elem187.read(iprot);
+            struct.completedExperiments.add(_elem187);
           }
         }
         struct.setCompletedExperimentsIsSet(true);
       }
       if (incoming.get(2)) {
         {
-          org.apache.thrift.protocol.TList _list178 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.failedExperiments = new ArrayList<ExperimentSummary>(_list178.size);
-          for (int _i179 = 0; _i179 < _list178.size; ++_i179)
+          org.apache.thrift.protocol.TList _list188 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.failedExperiments = new ArrayList<ExperimentSummary>(_list188.size);
+          for (int _i189 = 0; _i189 < _list188.size; ++_i189)
           {
-            ExperimentSummary _elem180;
-            _elem180 = new ExperimentSummary();
-            _elem180.read(iprot);
-            struct.failedExperiments.add(_elem180);
+            ExperimentSummary _elem190;
+            _elem190 = new ExperimentSummary();
+            _elem190.read(iprot);
+            struct.failedExperiments.add(_elem190);
           }
         }
         struct.setFailedExperimentsIsSet(true);
       }
       if (incoming.get(3)) {
         {
-          org.apache.thrift.protocol.TList _list181 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.cancelledExperiments = new ArrayList<ExperimentSummary>(_list181.size);
-          for (int _i182 = 0; _i182 < _list181.size; ++_i182)
+          org.apache.thrift.protocol.TList _list191 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.cancelledExperiments = new ArrayList<ExperimentSummary>(_list191.size);
+          for (int _i192 = 0; _i192 < _list191.size; ++_i192)
           {
-            ExperimentSummary _elem183;
-            _elem183 = new ExperimentSummary();
-            _elem183.read(iprot);
-            struct.cancelledExperiments.add(_elem183);
+            ExperimentSummary _elem193;
+            _elem193 = new ExperimentSummary();
+            _elem193.read(iprot);
+            struct.cancelledExperiments.add(_elem193);
           }
         }
         struct.setCancelledExperimentsIsSet(true);
       }
+      if (incoming.get(4)) {
+        {
+          org.apache.thrift.protocol.TList _list194 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.createdExperiments = new ArrayList<ExperimentSummary>(_list194.size);
+          for (int _i195 = 0; _i195 < _list194.size; ++_i195)
+          {
+            ExperimentSummary _elem196;
+            _elem196 = new ExperimentSummary();
+            _elem196.read(iprot);
+            struct.createdExperiments.add(_elem196);
+          }
+        }
+        struct.setCreatedExperimentsIsSet(true);
+      }
+      if (incoming.get(5)) {
+        {
+          org.apache.thrift.protocol.TList _list197 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.runningExperiments = new ArrayList<ExperimentSummary>(_list197.size);
+          for (int _i198 = 0; _i198 < _list197.size; ++_i198)
+          {
+            ExperimentSummary _elem199;
+            _elem199 = new ExperimentSummary();
+            _elem199.read(iprot);
+            struct.runningExperiments.add(_elem199);
+          }
+        }
+        struct.setRunningExperimentsIsSet(true);
+      }
     }
   }
 

http://git-wip-us.apache.org/repos/asf/airavata/blob/a403561e/airavata-api/thrift-interface-descriptions/experimentModel.thrift
----------------------------------------------------------------------
diff --git a/airavata-api/thrift-interface-descriptions/experimentModel.thrift b/airavata-api/thrift-interface-descriptions/experimentModel.thrift
index f9d76ab..7666c8e 100644
--- a/airavata-api/thrift-interface-descriptions/experimentModel.thrift
+++ b/airavata-api/thrift-interface-descriptions/experimentModel.thrift
@@ -415,8 +415,12 @@ struct ExperimentStatistics {
     2: required i32 completedExperimentCount,
     3: optional i32 cancelledExperimentCount,
     4: required i32 failedExperimentCount,
-    5: required list<ExperimentSummary> allExperiments,
-    6: optional list<ExperimentSummary> completedExperiments,
-    7: optional list<ExperimentSummary> failedExperiments,
-    8: optional list<ExperimentSummary> cancelledExperiments,
+    5: required i32 createdExperimentCount,
+    6: required i32 runningExperimentCount,
+    7: required list<ExperimentSummary> allExperiments,
+    8: optional list<ExperimentSummary> completedExperiments,
+    9: optional list<ExperimentSummary> failedExperiments,
+    10: optional list<ExperimentSummary> cancelledExperiments,
+    11: optional list<ExperimentSummary> createdExperiments,
+    12: optional list<ExperimentSummary> runningExperiments,
 }


Mime
View raw message