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 <[email protected]> Authored: Sat Jul 18 13:41:45 2015 +0530 Committer: Supun Nakandala <[email protected]> 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, }
