You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@storm.apache.org by xi...@apache.org on 2017/07/18 07:44:57 UTC
[3/7] storm git commit: [STORM-2622] Add owner resource summary
http://git-wip-us.apache.org/repos/asf/storm/blob/e5d6d32b/storm-client/src/jvm/org/apache/storm/generated/OwnerResourceSummary.java
----------------------------------------------------------------------
diff --git a/storm-client/src/jvm/org/apache/storm/generated/OwnerResourceSummary.java b/storm-client/src/jvm/org/apache/storm/generated/OwnerResourceSummary.java
new file mode 100644
index 0000000..be1c687
--- /dev/null
+++ b/storm-client/src/jvm/org/apache/storm/generated/OwnerResourceSummary.java
@@ -0,0 +1,2097 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.storm.generated;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class OwnerResourceSummary implements org.apache.thrift.TBase<OwnerResourceSummary, OwnerResourceSummary._Fields>, java.io.Serializable, Cloneable, Comparable<OwnerResourceSummary> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("OwnerResourceSummary");
+
+ private static final org.apache.thrift.protocol.TField OWNER_FIELD_DESC = new org.apache.thrift.protocol.TField("owner", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TOTAL_TOPOLOGIES_FIELD_DESC = new org.apache.thrift.protocol.TField("total_topologies", org.apache.thrift.protocol.TType.I32, (short)2);
+ private static final org.apache.thrift.protocol.TField TOTAL_EXECUTORS_FIELD_DESC = new org.apache.thrift.protocol.TField("total_executors", org.apache.thrift.protocol.TType.I32, (short)3);
+ private static final org.apache.thrift.protocol.TField TOTAL_WORKERS_FIELD_DESC = new org.apache.thrift.protocol.TField("total_workers", org.apache.thrift.protocol.TType.I32, (short)4);
+ private static final org.apache.thrift.protocol.TField MEMORY_USAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("memory_usage", org.apache.thrift.protocol.TType.DOUBLE, (short)5);
+ private static final org.apache.thrift.protocol.TField CPU_USAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("cpu_usage", org.apache.thrift.protocol.TType.DOUBLE, (short)6);
+ private static final org.apache.thrift.protocol.TField MEMORY_GUARANTEE_FIELD_DESC = new org.apache.thrift.protocol.TField("memory_guarantee", org.apache.thrift.protocol.TType.DOUBLE, (short)7);
+ private static final org.apache.thrift.protocol.TField CPU_GUARANTEE_FIELD_DESC = new org.apache.thrift.protocol.TField("cpu_guarantee", org.apache.thrift.protocol.TType.DOUBLE, (short)8);
+ private static final org.apache.thrift.protocol.TField MEMORY_GUARANTEE_REMAINING_FIELD_DESC = new org.apache.thrift.protocol.TField("memory_guarantee_remaining", org.apache.thrift.protocol.TType.DOUBLE, (short)9);
+ private static final org.apache.thrift.protocol.TField CPU_GUARANTEE_REMAINING_FIELD_DESC = new org.apache.thrift.protocol.TField("cpu_guarantee_remaining", org.apache.thrift.protocol.TType.DOUBLE, (short)10);
+ private static final org.apache.thrift.protocol.TField ISOLATED_NODE_GUARANTEE_FIELD_DESC = new org.apache.thrift.protocol.TField("isolated_node_guarantee", org.apache.thrift.protocol.TType.I32, (short)11);
+ private static final org.apache.thrift.protocol.TField TOTAL_TASKS_FIELD_DESC = new org.apache.thrift.protocol.TField("total_tasks", org.apache.thrift.protocol.TType.I32, (short)12);
+ private static final org.apache.thrift.protocol.TField REQUESTED_ON_HEAP_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("requested_on_heap_memory", org.apache.thrift.protocol.TType.DOUBLE, (short)13);
+ private static final org.apache.thrift.protocol.TField REQUESTED_OFF_HEAP_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("requested_off_heap_memory", org.apache.thrift.protocol.TType.DOUBLE, (short)14);
+ private static final org.apache.thrift.protocol.TField REQUESTED_TOTAL_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("requested_total_memory", org.apache.thrift.protocol.TType.DOUBLE, (short)15);
+ private static final org.apache.thrift.protocol.TField REQUESTED_CPU_FIELD_DESC = new org.apache.thrift.protocol.TField("requested_cpu", org.apache.thrift.protocol.TType.DOUBLE, (short)16);
+ private static final org.apache.thrift.protocol.TField ASSIGNED_ON_HEAP_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("assigned_on_heap_memory", org.apache.thrift.protocol.TType.DOUBLE, (short)17);
+ private static final org.apache.thrift.protocol.TField ASSIGNED_OFF_HEAP_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("assigned_off_heap_memory", org.apache.thrift.protocol.TType.DOUBLE, (short)18);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new OwnerResourceSummaryStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new OwnerResourceSummaryTupleSchemeFactory());
+ }
+
+ private String owner; // required
+ private int total_topologies; // optional
+ private int total_executors; // optional
+ private int total_workers; // optional
+ private double memory_usage; // optional
+ private double cpu_usage; // optional
+ private double memory_guarantee; // optional
+ private double cpu_guarantee; // optional
+ private double memory_guarantee_remaining; // optional
+ private double cpu_guarantee_remaining; // optional
+ private int isolated_node_guarantee; // optional
+ private int total_tasks; // optional
+ private double requested_on_heap_memory; // optional
+ private double requested_off_heap_memory; // optional
+ private double requested_total_memory; // optional
+ private double requested_cpu; // optional
+ private double assigned_on_heap_memory; // optional
+ private double assigned_off_heap_memory; // optional
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ OWNER((short)1, "owner"),
+ TOTAL_TOPOLOGIES((short)2, "total_topologies"),
+ TOTAL_EXECUTORS((short)3, "total_executors"),
+ TOTAL_WORKERS((short)4, "total_workers"),
+ MEMORY_USAGE((short)5, "memory_usage"),
+ CPU_USAGE((short)6, "cpu_usage"),
+ MEMORY_GUARANTEE((short)7, "memory_guarantee"),
+ CPU_GUARANTEE((short)8, "cpu_guarantee"),
+ MEMORY_GUARANTEE_REMAINING((short)9, "memory_guarantee_remaining"),
+ CPU_GUARANTEE_REMAINING((short)10, "cpu_guarantee_remaining"),
+ ISOLATED_NODE_GUARANTEE((short)11, "isolated_node_guarantee"),
+ TOTAL_TASKS((short)12, "total_tasks"),
+ REQUESTED_ON_HEAP_MEMORY((short)13, "requested_on_heap_memory"),
+ REQUESTED_OFF_HEAP_MEMORY((short)14, "requested_off_heap_memory"),
+ REQUESTED_TOTAL_MEMORY((short)15, "requested_total_memory"),
+ REQUESTED_CPU((short)16, "requested_cpu"),
+ ASSIGNED_ON_HEAP_MEMORY((short)17, "assigned_on_heap_memory"),
+ ASSIGNED_OFF_HEAP_MEMORY((short)18, "assigned_off_heap_memory");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // OWNER
+ return OWNER;
+ case 2: // TOTAL_TOPOLOGIES
+ return TOTAL_TOPOLOGIES;
+ case 3: // TOTAL_EXECUTORS
+ return TOTAL_EXECUTORS;
+ case 4: // TOTAL_WORKERS
+ return TOTAL_WORKERS;
+ case 5: // MEMORY_USAGE
+ return MEMORY_USAGE;
+ case 6: // CPU_USAGE
+ return CPU_USAGE;
+ case 7: // MEMORY_GUARANTEE
+ return MEMORY_GUARANTEE;
+ case 8: // CPU_GUARANTEE
+ return CPU_GUARANTEE;
+ case 9: // MEMORY_GUARANTEE_REMAINING
+ return MEMORY_GUARANTEE_REMAINING;
+ case 10: // CPU_GUARANTEE_REMAINING
+ return CPU_GUARANTEE_REMAINING;
+ case 11: // ISOLATED_NODE_GUARANTEE
+ return ISOLATED_NODE_GUARANTEE;
+ case 12: // TOTAL_TASKS
+ return TOTAL_TASKS;
+ case 13: // REQUESTED_ON_HEAP_MEMORY
+ return REQUESTED_ON_HEAP_MEMORY;
+ case 14: // REQUESTED_OFF_HEAP_MEMORY
+ return REQUESTED_OFF_HEAP_MEMORY;
+ case 15: // REQUESTED_TOTAL_MEMORY
+ return REQUESTED_TOTAL_MEMORY;
+ case 16: // REQUESTED_CPU
+ return REQUESTED_CPU;
+ case 17: // ASSIGNED_ON_HEAP_MEMORY
+ return ASSIGNED_ON_HEAP_MEMORY;
+ case 18: // ASSIGNED_OFF_HEAP_MEMORY
+ return ASSIGNED_OFF_HEAP_MEMORY;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ private static final int __TOTAL_TOPOLOGIES_ISSET_ID = 0;
+ private static final int __TOTAL_EXECUTORS_ISSET_ID = 1;
+ private static final int __TOTAL_WORKERS_ISSET_ID = 2;
+ private static final int __MEMORY_USAGE_ISSET_ID = 3;
+ private static final int __CPU_USAGE_ISSET_ID = 4;
+ private static final int __MEMORY_GUARANTEE_ISSET_ID = 5;
+ private static final int __CPU_GUARANTEE_ISSET_ID = 6;
+ private static final int __MEMORY_GUARANTEE_REMAINING_ISSET_ID = 7;
+ private static final int __CPU_GUARANTEE_REMAINING_ISSET_ID = 8;
+ private static final int __ISOLATED_NODE_GUARANTEE_ISSET_ID = 9;
+ private static final int __TOTAL_TASKS_ISSET_ID = 10;
+ private static final int __REQUESTED_ON_HEAP_MEMORY_ISSET_ID = 11;
+ private static final int __REQUESTED_OFF_HEAP_MEMORY_ISSET_ID = 12;
+ private static final int __REQUESTED_TOTAL_MEMORY_ISSET_ID = 13;
+ private static final int __REQUESTED_CPU_ISSET_ID = 14;
+ private static final int __ASSIGNED_ON_HEAP_MEMORY_ISSET_ID = 15;
+ private static final int __ASSIGNED_OFF_HEAP_MEMORY_ISSET_ID = 16;
+ private int __isset_bitfield = 0;
+ private static final _Fields optionals[] = {_Fields.TOTAL_TOPOLOGIES,_Fields.TOTAL_EXECUTORS,_Fields.TOTAL_WORKERS,_Fields.MEMORY_USAGE,_Fields.CPU_USAGE,_Fields.MEMORY_GUARANTEE,_Fields.CPU_GUARANTEE,_Fields.MEMORY_GUARANTEE_REMAINING,_Fields.CPU_GUARANTEE_REMAINING,_Fields.ISOLATED_NODE_GUARANTEE,_Fields.TOTAL_TASKS,_Fields.REQUESTED_ON_HEAP_MEMORY,_Fields.REQUESTED_OFF_HEAP_MEMORY,_Fields.REQUESTED_TOTAL_MEMORY,_Fields.REQUESTED_CPU,_Fields.ASSIGNED_ON_HEAP_MEMORY,_Fields.ASSIGNED_OFF_HEAP_MEMORY};
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.OWNER, new org.apache.thrift.meta_data.FieldMetaData("owner", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TOTAL_TOPOLOGIES, new org.apache.thrift.meta_data.FieldMetaData("total_topologies", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.TOTAL_EXECUTORS, new org.apache.thrift.meta_data.FieldMetaData("total_executors", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.TOTAL_WORKERS, new org.apache.thrift.meta_data.FieldMetaData("total_workers", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.MEMORY_USAGE, new org.apache.thrift.meta_data.FieldMetaData("memory_usage", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.CPU_USAGE, new org.apache.thrift.meta_data.FieldMetaData("cpu_usage", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.MEMORY_GUARANTEE, new org.apache.thrift.meta_data.FieldMetaData("memory_guarantee", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.CPU_GUARANTEE, new org.apache.thrift.meta_data.FieldMetaData("cpu_guarantee", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.MEMORY_GUARANTEE_REMAINING, new org.apache.thrift.meta_data.FieldMetaData("memory_guarantee_remaining", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.CPU_GUARANTEE_REMAINING, new org.apache.thrift.meta_data.FieldMetaData("cpu_guarantee_remaining", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.ISOLATED_NODE_GUARANTEE, new org.apache.thrift.meta_data.FieldMetaData("isolated_node_guarantee", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.TOTAL_TASKS, new org.apache.thrift.meta_data.FieldMetaData("total_tasks", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+ tmpMap.put(_Fields.REQUESTED_ON_HEAP_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("requested_on_heap_memory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.REQUESTED_OFF_HEAP_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("requested_off_heap_memory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.REQUESTED_TOTAL_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("requested_total_memory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.REQUESTED_CPU, new org.apache.thrift.meta_data.FieldMetaData("requested_cpu", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.ASSIGNED_ON_HEAP_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("assigned_on_heap_memory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ tmpMap.put(_Fields.ASSIGNED_OFF_HEAP_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("assigned_off_heap_memory", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OwnerResourceSummary.class, metaDataMap);
+ }
+
+ public OwnerResourceSummary() {
+ }
+
+ public OwnerResourceSummary(
+ String owner)
+ {
+ this();
+ this.owner = owner;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public OwnerResourceSummary(OwnerResourceSummary other) {
+ __isset_bitfield = other.__isset_bitfield;
+ if (other.is_set_owner()) {
+ this.owner = other.owner;
+ }
+ this.total_topologies = other.total_topologies;
+ this.total_executors = other.total_executors;
+ this.total_workers = other.total_workers;
+ this.memory_usage = other.memory_usage;
+ this.cpu_usage = other.cpu_usage;
+ this.memory_guarantee = other.memory_guarantee;
+ this.cpu_guarantee = other.cpu_guarantee;
+ this.memory_guarantee_remaining = other.memory_guarantee_remaining;
+ this.cpu_guarantee_remaining = other.cpu_guarantee_remaining;
+ this.isolated_node_guarantee = other.isolated_node_guarantee;
+ this.total_tasks = other.total_tasks;
+ this.requested_on_heap_memory = other.requested_on_heap_memory;
+ this.requested_off_heap_memory = other.requested_off_heap_memory;
+ this.requested_total_memory = other.requested_total_memory;
+ this.requested_cpu = other.requested_cpu;
+ this.assigned_on_heap_memory = other.assigned_on_heap_memory;
+ this.assigned_off_heap_memory = other.assigned_off_heap_memory;
+ }
+
+ public OwnerResourceSummary deepCopy() {
+ return new OwnerResourceSummary(this);
+ }
+
+ @Override
+ public void clear() {
+ this.owner = null;
+ set_total_topologies_isSet(false);
+ this.total_topologies = 0;
+ set_total_executors_isSet(false);
+ this.total_executors = 0;
+ set_total_workers_isSet(false);
+ this.total_workers = 0;
+ set_memory_usage_isSet(false);
+ this.memory_usage = 0.0;
+ set_cpu_usage_isSet(false);
+ this.cpu_usage = 0.0;
+ set_memory_guarantee_isSet(false);
+ this.memory_guarantee = 0.0;
+ set_cpu_guarantee_isSet(false);
+ this.cpu_guarantee = 0.0;
+ set_memory_guarantee_remaining_isSet(false);
+ this.memory_guarantee_remaining = 0.0;
+ set_cpu_guarantee_remaining_isSet(false);
+ this.cpu_guarantee_remaining = 0.0;
+ set_isolated_node_guarantee_isSet(false);
+ this.isolated_node_guarantee = 0;
+ set_total_tasks_isSet(false);
+ this.total_tasks = 0;
+ set_requested_on_heap_memory_isSet(false);
+ this.requested_on_heap_memory = 0.0;
+ set_requested_off_heap_memory_isSet(false);
+ this.requested_off_heap_memory = 0.0;
+ set_requested_total_memory_isSet(false);
+ this.requested_total_memory = 0.0;
+ set_requested_cpu_isSet(false);
+ this.requested_cpu = 0.0;
+ set_assigned_on_heap_memory_isSet(false);
+ this.assigned_on_heap_memory = 0.0;
+ set_assigned_off_heap_memory_isSet(false);
+ this.assigned_off_heap_memory = 0.0;
+ }
+
+ public String get_owner() {
+ return this.owner;
+ }
+
+ public void set_owner(String owner) {
+ this.owner = owner;
+ }
+
+ public void unset_owner() {
+ this.owner = null;
+ }
+
+ /** Returns true if field owner is set (has been assigned a value) and false otherwise */
+ public boolean is_set_owner() {
+ return this.owner != null;
+ }
+
+ public void set_owner_isSet(boolean value) {
+ if (!value) {
+ this.owner = null;
+ }
+ }
+
+ public int get_total_topologies() {
+ return this.total_topologies;
+ }
+
+ public void set_total_topologies(int total_topologies) {
+ this.total_topologies = total_topologies;
+ set_total_topologies_isSet(true);
+ }
+
+ public void unset_total_topologies() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TOTAL_TOPOLOGIES_ISSET_ID);
+ }
+
+ /** Returns true if field total_topologies is set (has been assigned a value) and false otherwise */
+ public boolean is_set_total_topologies() {
+ return EncodingUtils.testBit(__isset_bitfield, __TOTAL_TOPOLOGIES_ISSET_ID);
+ }
+
+ public void set_total_topologies_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TOTAL_TOPOLOGIES_ISSET_ID, value);
+ }
+
+ public int get_total_executors() {
+ return this.total_executors;
+ }
+
+ public void set_total_executors(int total_executors) {
+ this.total_executors = total_executors;
+ set_total_executors_isSet(true);
+ }
+
+ public void unset_total_executors() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TOTAL_EXECUTORS_ISSET_ID);
+ }
+
+ /** Returns true if field total_executors is set (has been assigned a value) and false otherwise */
+ public boolean is_set_total_executors() {
+ return EncodingUtils.testBit(__isset_bitfield, __TOTAL_EXECUTORS_ISSET_ID);
+ }
+
+ public void set_total_executors_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TOTAL_EXECUTORS_ISSET_ID, value);
+ }
+
+ public int get_total_workers() {
+ return this.total_workers;
+ }
+
+ public void set_total_workers(int total_workers) {
+ this.total_workers = total_workers;
+ set_total_workers_isSet(true);
+ }
+
+ public void unset_total_workers() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TOTAL_WORKERS_ISSET_ID);
+ }
+
+ /** Returns true if field total_workers is set (has been assigned a value) and false otherwise */
+ public boolean is_set_total_workers() {
+ return EncodingUtils.testBit(__isset_bitfield, __TOTAL_WORKERS_ISSET_ID);
+ }
+
+ public void set_total_workers_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TOTAL_WORKERS_ISSET_ID, value);
+ }
+
+ public double get_memory_usage() {
+ return this.memory_usage;
+ }
+
+ public void set_memory_usage(double memory_usage) {
+ this.memory_usage = memory_usage;
+ set_memory_usage_isSet(true);
+ }
+
+ public void unset_memory_usage() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MEMORY_USAGE_ISSET_ID);
+ }
+
+ /** Returns true if field memory_usage is set (has been assigned a value) and false otherwise */
+ public boolean is_set_memory_usage() {
+ return EncodingUtils.testBit(__isset_bitfield, __MEMORY_USAGE_ISSET_ID);
+ }
+
+ public void set_memory_usage_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MEMORY_USAGE_ISSET_ID, value);
+ }
+
+ public double get_cpu_usage() {
+ return this.cpu_usage;
+ }
+
+ public void set_cpu_usage(double cpu_usage) {
+ this.cpu_usage = cpu_usage;
+ set_cpu_usage_isSet(true);
+ }
+
+ public void unset_cpu_usage() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CPU_USAGE_ISSET_ID);
+ }
+
+ /** Returns true if field cpu_usage is set (has been assigned a value) and false otherwise */
+ public boolean is_set_cpu_usage() {
+ return EncodingUtils.testBit(__isset_bitfield, __CPU_USAGE_ISSET_ID);
+ }
+
+ public void set_cpu_usage_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CPU_USAGE_ISSET_ID, value);
+ }
+
+ public double get_memory_guarantee() {
+ return this.memory_guarantee;
+ }
+
+ public void set_memory_guarantee(double memory_guarantee) {
+ this.memory_guarantee = memory_guarantee;
+ set_memory_guarantee_isSet(true);
+ }
+
+ public void unset_memory_guarantee() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MEMORY_GUARANTEE_ISSET_ID);
+ }
+
+ /** Returns true if field memory_guarantee is set (has been assigned a value) and false otherwise */
+ public boolean is_set_memory_guarantee() {
+ return EncodingUtils.testBit(__isset_bitfield, __MEMORY_GUARANTEE_ISSET_ID);
+ }
+
+ public void set_memory_guarantee_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MEMORY_GUARANTEE_ISSET_ID, value);
+ }
+
+ public double get_cpu_guarantee() {
+ return this.cpu_guarantee;
+ }
+
+ public void set_cpu_guarantee(double cpu_guarantee) {
+ this.cpu_guarantee = cpu_guarantee;
+ set_cpu_guarantee_isSet(true);
+ }
+
+ public void unset_cpu_guarantee() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CPU_GUARANTEE_ISSET_ID);
+ }
+
+ /** Returns true if field cpu_guarantee is set (has been assigned a value) and false otherwise */
+ public boolean is_set_cpu_guarantee() {
+ return EncodingUtils.testBit(__isset_bitfield, __CPU_GUARANTEE_ISSET_ID);
+ }
+
+ public void set_cpu_guarantee_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CPU_GUARANTEE_ISSET_ID, value);
+ }
+
+ public double get_memory_guarantee_remaining() {
+ return this.memory_guarantee_remaining;
+ }
+
+ public void set_memory_guarantee_remaining(double memory_guarantee_remaining) {
+ this.memory_guarantee_remaining = memory_guarantee_remaining;
+ set_memory_guarantee_remaining_isSet(true);
+ }
+
+ public void unset_memory_guarantee_remaining() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MEMORY_GUARANTEE_REMAINING_ISSET_ID);
+ }
+
+ /** Returns true if field memory_guarantee_remaining is set (has been assigned a value) and false otherwise */
+ public boolean is_set_memory_guarantee_remaining() {
+ return EncodingUtils.testBit(__isset_bitfield, __MEMORY_GUARANTEE_REMAINING_ISSET_ID);
+ }
+
+ public void set_memory_guarantee_remaining_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MEMORY_GUARANTEE_REMAINING_ISSET_ID, value);
+ }
+
+ public double get_cpu_guarantee_remaining() {
+ return this.cpu_guarantee_remaining;
+ }
+
+ public void set_cpu_guarantee_remaining(double cpu_guarantee_remaining) {
+ this.cpu_guarantee_remaining = cpu_guarantee_remaining;
+ set_cpu_guarantee_remaining_isSet(true);
+ }
+
+ public void unset_cpu_guarantee_remaining() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CPU_GUARANTEE_REMAINING_ISSET_ID);
+ }
+
+ /** Returns true if field cpu_guarantee_remaining is set (has been assigned a value) and false otherwise */
+ public boolean is_set_cpu_guarantee_remaining() {
+ return EncodingUtils.testBit(__isset_bitfield, __CPU_GUARANTEE_REMAINING_ISSET_ID);
+ }
+
+ public void set_cpu_guarantee_remaining_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CPU_GUARANTEE_REMAINING_ISSET_ID, value);
+ }
+
+ public int get_isolated_node_guarantee() {
+ return this.isolated_node_guarantee;
+ }
+
+ public void set_isolated_node_guarantee(int isolated_node_guarantee) {
+ this.isolated_node_guarantee = isolated_node_guarantee;
+ set_isolated_node_guarantee_isSet(true);
+ }
+
+ public void unset_isolated_node_guarantee() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISOLATED_NODE_GUARANTEE_ISSET_ID);
+ }
+
+ /** Returns true if field isolated_node_guarantee is set (has been assigned a value) and false otherwise */
+ public boolean is_set_isolated_node_guarantee() {
+ return EncodingUtils.testBit(__isset_bitfield, __ISOLATED_NODE_GUARANTEE_ISSET_ID);
+ }
+
+ public void set_isolated_node_guarantee_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISOLATED_NODE_GUARANTEE_ISSET_ID, value);
+ }
+
+ public int get_total_tasks() {
+ return this.total_tasks;
+ }
+
+ public void set_total_tasks(int total_tasks) {
+ this.total_tasks = total_tasks;
+ set_total_tasks_isSet(true);
+ }
+
+ public void unset_total_tasks() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TOTAL_TASKS_ISSET_ID);
+ }
+
+ /** Returns true if field total_tasks is set (has been assigned a value) and false otherwise */
+ public boolean is_set_total_tasks() {
+ return EncodingUtils.testBit(__isset_bitfield, __TOTAL_TASKS_ISSET_ID);
+ }
+
+ public void set_total_tasks_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TOTAL_TASKS_ISSET_ID, value);
+ }
+
+ public double get_requested_on_heap_memory() {
+ return this.requested_on_heap_memory;
+ }
+
+ public void set_requested_on_heap_memory(double requested_on_heap_memory) {
+ this.requested_on_heap_memory = requested_on_heap_memory;
+ set_requested_on_heap_memory_isSet(true);
+ }
+
+ public void unset_requested_on_heap_memory() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __REQUESTED_ON_HEAP_MEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field requested_on_heap_memory is set (has been assigned a value) and false otherwise */
+ public boolean is_set_requested_on_heap_memory() {
+ return EncodingUtils.testBit(__isset_bitfield, __REQUESTED_ON_HEAP_MEMORY_ISSET_ID);
+ }
+
+ public void set_requested_on_heap_memory_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __REQUESTED_ON_HEAP_MEMORY_ISSET_ID, value);
+ }
+
+ public double get_requested_off_heap_memory() {
+ return this.requested_off_heap_memory;
+ }
+
+ public void set_requested_off_heap_memory(double requested_off_heap_memory) {
+ this.requested_off_heap_memory = requested_off_heap_memory;
+ set_requested_off_heap_memory_isSet(true);
+ }
+
+ public void unset_requested_off_heap_memory() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __REQUESTED_OFF_HEAP_MEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field requested_off_heap_memory is set (has been assigned a value) and false otherwise */
+ public boolean is_set_requested_off_heap_memory() {
+ return EncodingUtils.testBit(__isset_bitfield, __REQUESTED_OFF_HEAP_MEMORY_ISSET_ID);
+ }
+
+ public void set_requested_off_heap_memory_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __REQUESTED_OFF_HEAP_MEMORY_ISSET_ID, value);
+ }
+
+ public double get_requested_total_memory() {
+ return this.requested_total_memory;
+ }
+
+ public void set_requested_total_memory(double requested_total_memory) {
+ this.requested_total_memory = requested_total_memory;
+ set_requested_total_memory_isSet(true);
+ }
+
+ public void unset_requested_total_memory() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __REQUESTED_TOTAL_MEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field requested_total_memory is set (has been assigned a value) and false otherwise */
+ public boolean is_set_requested_total_memory() {
+ return EncodingUtils.testBit(__isset_bitfield, __REQUESTED_TOTAL_MEMORY_ISSET_ID);
+ }
+
+ public void set_requested_total_memory_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __REQUESTED_TOTAL_MEMORY_ISSET_ID, value);
+ }
+
+ public double get_requested_cpu() {
+ return this.requested_cpu;
+ }
+
+ public void set_requested_cpu(double requested_cpu) {
+ this.requested_cpu = requested_cpu;
+ set_requested_cpu_isSet(true);
+ }
+
+ public void unset_requested_cpu() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __REQUESTED_CPU_ISSET_ID);
+ }
+
+ /** Returns true if field requested_cpu is set (has been assigned a value) and false otherwise */
+ public boolean is_set_requested_cpu() {
+ return EncodingUtils.testBit(__isset_bitfield, __REQUESTED_CPU_ISSET_ID);
+ }
+
+ public void set_requested_cpu_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __REQUESTED_CPU_ISSET_ID, value);
+ }
+
+ public double get_assigned_on_heap_memory() {
+ return this.assigned_on_heap_memory;
+ }
+
+ public void set_assigned_on_heap_memory(double assigned_on_heap_memory) {
+ this.assigned_on_heap_memory = assigned_on_heap_memory;
+ set_assigned_on_heap_memory_isSet(true);
+ }
+
+ public void unset_assigned_on_heap_memory() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ASSIGNED_ON_HEAP_MEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field assigned_on_heap_memory is set (has been assigned a value) and false otherwise */
+ public boolean is_set_assigned_on_heap_memory() {
+ return EncodingUtils.testBit(__isset_bitfield, __ASSIGNED_ON_HEAP_MEMORY_ISSET_ID);
+ }
+
+ public void set_assigned_on_heap_memory_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ASSIGNED_ON_HEAP_MEMORY_ISSET_ID, value);
+ }
+
+ public double get_assigned_off_heap_memory() {
+ return this.assigned_off_heap_memory;
+ }
+
+ public void set_assigned_off_heap_memory(double assigned_off_heap_memory) {
+ this.assigned_off_heap_memory = assigned_off_heap_memory;
+ set_assigned_off_heap_memory_isSet(true);
+ }
+
+ public void unset_assigned_off_heap_memory() {
+ __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ASSIGNED_OFF_HEAP_MEMORY_ISSET_ID);
+ }
+
+ /** Returns true if field assigned_off_heap_memory is set (has been assigned a value) and false otherwise */
+ public boolean is_set_assigned_off_heap_memory() {
+ return EncodingUtils.testBit(__isset_bitfield, __ASSIGNED_OFF_HEAP_MEMORY_ISSET_ID);
+ }
+
+ public void set_assigned_off_heap_memory_isSet(boolean value) {
+ __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ASSIGNED_OFF_HEAP_MEMORY_ISSET_ID, value);
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case OWNER:
+ if (value == null) {
+ unset_owner();
+ } else {
+ set_owner((String)value);
+ }
+ break;
+
+ case TOTAL_TOPOLOGIES:
+ if (value == null) {
+ unset_total_topologies();
+ } else {
+ set_total_topologies((Integer)value);
+ }
+ break;
+
+ case TOTAL_EXECUTORS:
+ if (value == null) {
+ unset_total_executors();
+ } else {
+ set_total_executors((Integer)value);
+ }
+ break;
+
+ case TOTAL_WORKERS:
+ if (value == null) {
+ unset_total_workers();
+ } else {
+ set_total_workers((Integer)value);
+ }
+ break;
+
+ case MEMORY_USAGE:
+ if (value == null) {
+ unset_memory_usage();
+ } else {
+ set_memory_usage((Double)value);
+ }
+ break;
+
+ case CPU_USAGE:
+ if (value == null) {
+ unset_cpu_usage();
+ } else {
+ set_cpu_usage((Double)value);
+ }
+ break;
+
+ case MEMORY_GUARANTEE:
+ if (value == null) {
+ unset_memory_guarantee();
+ } else {
+ set_memory_guarantee((Double)value);
+ }
+ break;
+
+ case CPU_GUARANTEE:
+ if (value == null) {
+ unset_cpu_guarantee();
+ } else {
+ set_cpu_guarantee((Double)value);
+ }
+ break;
+
+ case MEMORY_GUARANTEE_REMAINING:
+ if (value == null) {
+ unset_memory_guarantee_remaining();
+ } else {
+ set_memory_guarantee_remaining((Double)value);
+ }
+ break;
+
+ case CPU_GUARANTEE_REMAINING:
+ if (value == null) {
+ unset_cpu_guarantee_remaining();
+ } else {
+ set_cpu_guarantee_remaining((Double)value);
+ }
+ break;
+
+ case ISOLATED_NODE_GUARANTEE:
+ if (value == null) {
+ unset_isolated_node_guarantee();
+ } else {
+ set_isolated_node_guarantee((Integer)value);
+ }
+ break;
+
+ case TOTAL_TASKS:
+ if (value == null) {
+ unset_total_tasks();
+ } else {
+ set_total_tasks((Integer)value);
+ }
+ break;
+
+ case REQUESTED_ON_HEAP_MEMORY:
+ if (value == null) {
+ unset_requested_on_heap_memory();
+ } else {
+ set_requested_on_heap_memory((Double)value);
+ }
+ break;
+
+ case REQUESTED_OFF_HEAP_MEMORY:
+ if (value == null) {
+ unset_requested_off_heap_memory();
+ } else {
+ set_requested_off_heap_memory((Double)value);
+ }
+ break;
+
+ case REQUESTED_TOTAL_MEMORY:
+ if (value == null) {
+ unset_requested_total_memory();
+ } else {
+ set_requested_total_memory((Double)value);
+ }
+ break;
+
+ case REQUESTED_CPU:
+ if (value == null) {
+ unset_requested_cpu();
+ } else {
+ set_requested_cpu((Double)value);
+ }
+ break;
+
+ case ASSIGNED_ON_HEAP_MEMORY:
+ if (value == null) {
+ unset_assigned_on_heap_memory();
+ } else {
+ set_assigned_on_heap_memory((Double)value);
+ }
+ break;
+
+ case ASSIGNED_OFF_HEAP_MEMORY:
+ if (value == null) {
+ unset_assigned_off_heap_memory();
+ } else {
+ set_assigned_off_heap_memory((Double)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case OWNER:
+ return get_owner();
+
+ case TOTAL_TOPOLOGIES:
+ return get_total_topologies();
+
+ case TOTAL_EXECUTORS:
+ return get_total_executors();
+
+ case TOTAL_WORKERS:
+ return get_total_workers();
+
+ case MEMORY_USAGE:
+ return get_memory_usage();
+
+ case CPU_USAGE:
+ return get_cpu_usage();
+
+ case MEMORY_GUARANTEE:
+ return get_memory_guarantee();
+
+ case CPU_GUARANTEE:
+ return get_cpu_guarantee();
+
+ case MEMORY_GUARANTEE_REMAINING:
+ return get_memory_guarantee_remaining();
+
+ case CPU_GUARANTEE_REMAINING:
+ return get_cpu_guarantee_remaining();
+
+ case ISOLATED_NODE_GUARANTEE:
+ return get_isolated_node_guarantee();
+
+ case TOTAL_TASKS:
+ return get_total_tasks();
+
+ case REQUESTED_ON_HEAP_MEMORY:
+ return get_requested_on_heap_memory();
+
+ case REQUESTED_OFF_HEAP_MEMORY:
+ return get_requested_off_heap_memory();
+
+ case REQUESTED_TOTAL_MEMORY:
+ return get_requested_total_memory();
+
+ case REQUESTED_CPU:
+ return get_requested_cpu();
+
+ case ASSIGNED_ON_HEAP_MEMORY:
+ return get_assigned_on_heap_memory();
+
+ case ASSIGNED_OFF_HEAP_MEMORY:
+ return get_assigned_off_heap_memory();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case OWNER:
+ return is_set_owner();
+ case TOTAL_TOPOLOGIES:
+ return is_set_total_topologies();
+ case TOTAL_EXECUTORS:
+ return is_set_total_executors();
+ case TOTAL_WORKERS:
+ return is_set_total_workers();
+ case MEMORY_USAGE:
+ return is_set_memory_usage();
+ case CPU_USAGE:
+ return is_set_cpu_usage();
+ case MEMORY_GUARANTEE:
+ return is_set_memory_guarantee();
+ case CPU_GUARANTEE:
+ return is_set_cpu_guarantee();
+ case MEMORY_GUARANTEE_REMAINING:
+ return is_set_memory_guarantee_remaining();
+ case CPU_GUARANTEE_REMAINING:
+ return is_set_cpu_guarantee_remaining();
+ case ISOLATED_NODE_GUARANTEE:
+ return is_set_isolated_node_guarantee();
+ case TOTAL_TASKS:
+ return is_set_total_tasks();
+ case REQUESTED_ON_HEAP_MEMORY:
+ return is_set_requested_on_heap_memory();
+ case REQUESTED_OFF_HEAP_MEMORY:
+ return is_set_requested_off_heap_memory();
+ case REQUESTED_TOTAL_MEMORY:
+ return is_set_requested_total_memory();
+ case REQUESTED_CPU:
+ return is_set_requested_cpu();
+ case ASSIGNED_ON_HEAP_MEMORY:
+ return is_set_assigned_on_heap_memory();
+ case ASSIGNED_OFF_HEAP_MEMORY:
+ return is_set_assigned_off_heap_memory();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof OwnerResourceSummary)
+ return this.equals((OwnerResourceSummary)that);
+ return false;
+ }
+
+ public boolean equals(OwnerResourceSummary that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_owner = true && this.is_set_owner();
+ boolean that_present_owner = true && that.is_set_owner();
+ if (this_present_owner || that_present_owner) {
+ if (!(this_present_owner && that_present_owner))
+ return false;
+ if (!this.owner.equals(that.owner))
+ return false;
+ }
+
+ boolean this_present_total_topologies = true && this.is_set_total_topologies();
+ boolean that_present_total_topologies = true && that.is_set_total_topologies();
+ if (this_present_total_topologies || that_present_total_topologies) {
+ if (!(this_present_total_topologies && that_present_total_topologies))
+ return false;
+ if (this.total_topologies != that.total_topologies)
+ return false;
+ }
+
+ boolean this_present_total_executors = true && this.is_set_total_executors();
+ boolean that_present_total_executors = true && that.is_set_total_executors();
+ if (this_present_total_executors || that_present_total_executors) {
+ if (!(this_present_total_executors && that_present_total_executors))
+ return false;
+ if (this.total_executors != that.total_executors)
+ return false;
+ }
+
+ boolean this_present_total_workers = true && this.is_set_total_workers();
+ boolean that_present_total_workers = true && that.is_set_total_workers();
+ if (this_present_total_workers || that_present_total_workers) {
+ if (!(this_present_total_workers && that_present_total_workers))
+ return false;
+ if (this.total_workers != that.total_workers)
+ return false;
+ }
+
+ boolean this_present_memory_usage = true && this.is_set_memory_usage();
+ boolean that_present_memory_usage = true && that.is_set_memory_usage();
+ if (this_present_memory_usage || that_present_memory_usage) {
+ if (!(this_present_memory_usage && that_present_memory_usage))
+ return false;
+ if (this.memory_usage != that.memory_usage)
+ return false;
+ }
+
+ boolean this_present_cpu_usage = true && this.is_set_cpu_usage();
+ boolean that_present_cpu_usage = true && that.is_set_cpu_usage();
+ if (this_present_cpu_usage || that_present_cpu_usage) {
+ if (!(this_present_cpu_usage && that_present_cpu_usage))
+ return false;
+ if (this.cpu_usage != that.cpu_usage)
+ return false;
+ }
+
+ boolean this_present_memory_guarantee = true && this.is_set_memory_guarantee();
+ boolean that_present_memory_guarantee = true && that.is_set_memory_guarantee();
+ if (this_present_memory_guarantee || that_present_memory_guarantee) {
+ if (!(this_present_memory_guarantee && that_present_memory_guarantee))
+ return false;
+ if (this.memory_guarantee != that.memory_guarantee)
+ return false;
+ }
+
+ boolean this_present_cpu_guarantee = true && this.is_set_cpu_guarantee();
+ boolean that_present_cpu_guarantee = true && that.is_set_cpu_guarantee();
+ if (this_present_cpu_guarantee || that_present_cpu_guarantee) {
+ if (!(this_present_cpu_guarantee && that_present_cpu_guarantee))
+ return false;
+ if (this.cpu_guarantee != that.cpu_guarantee)
+ return false;
+ }
+
+ boolean this_present_memory_guarantee_remaining = true && this.is_set_memory_guarantee_remaining();
+ boolean that_present_memory_guarantee_remaining = true && that.is_set_memory_guarantee_remaining();
+ if (this_present_memory_guarantee_remaining || that_present_memory_guarantee_remaining) {
+ if (!(this_present_memory_guarantee_remaining && that_present_memory_guarantee_remaining))
+ return false;
+ if (this.memory_guarantee_remaining != that.memory_guarantee_remaining)
+ return false;
+ }
+
+ boolean this_present_cpu_guarantee_remaining = true && this.is_set_cpu_guarantee_remaining();
+ boolean that_present_cpu_guarantee_remaining = true && that.is_set_cpu_guarantee_remaining();
+ if (this_present_cpu_guarantee_remaining || that_present_cpu_guarantee_remaining) {
+ if (!(this_present_cpu_guarantee_remaining && that_present_cpu_guarantee_remaining))
+ return false;
+ if (this.cpu_guarantee_remaining != that.cpu_guarantee_remaining)
+ return false;
+ }
+
+ boolean this_present_isolated_node_guarantee = true && this.is_set_isolated_node_guarantee();
+ boolean that_present_isolated_node_guarantee = true && that.is_set_isolated_node_guarantee();
+ if (this_present_isolated_node_guarantee || that_present_isolated_node_guarantee) {
+ if (!(this_present_isolated_node_guarantee && that_present_isolated_node_guarantee))
+ return false;
+ if (this.isolated_node_guarantee != that.isolated_node_guarantee)
+ return false;
+ }
+
+ boolean this_present_total_tasks = true && this.is_set_total_tasks();
+ boolean that_present_total_tasks = true && that.is_set_total_tasks();
+ if (this_present_total_tasks || that_present_total_tasks) {
+ if (!(this_present_total_tasks && that_present_total_tasks))
+ return false;
+ if (this.total_tasks != that.total_tasks)
+ return false;
+ }
+
+ boolean this_present_requested_on_heap_memory = true && this.is_set_requested_on_heap_memory();
+ boolean that_present_requested_on_heap_memory = true && that.is_set_requested_on_heap_memory();
+ if (this_present_requested_on_heap_memory || that_present_requested_on_heap_memory) {
+ if (!(this_present_requested_on_heap_memory && that_present_requested_on_heap_memory))
+ return false;
+ if (this.requested_on_heap_memory != that.requested_on_heap_memory)
+ return false;
+ }
+
+ boolean this_present_requested_off_heap_memory = true && this.is_set_requested_off_heap_memory();
+ boolean that_present_requested_off_heap_memory = true && that.is_set_requested_off_heap_memory();
+ if (this_present_requested_off_heap_memory || that_present_requested_off_heap_memory) {
+ if (!(this_present_requested_off_heap_memory && that_present_requested_off_heap_memory))
+ return false;
+ if (this.requested_off_heap_memory != that.requested_off_heap_memory)
+ return false;
+ }
+
+ boolean this_present_requested_total_memory = true && this.is_set_requested_total_memory();
+ boolean that_present_requested_total_memory = true && that.is_set_requested_total_memory();
+ if (this_present_requested_total_memory || that_present_requested_total_memory) {
+ if (!(this_present_requested_total_memory && that_present_requested_total_memory))
+ return false;
+ if (this.requested_total_memory != that.requested_total_memory)
+ return false;
+ }
+
+ boolean this_present_requested_cpu = true && this.is_set_requested_cpu();
+ boolean that_present_requested_cpu = true && that.is_set_requested_cpu();
+ if (this_present_requested_cpu || that_present_requested_cpu) {
+ if (!(this_present_requested_cpu && that_present_requested_cpu))
+ return false;
+ if (this.requested_cpu != that.requested_cpu)
+ return false;
+ }
+
+ boolean this_present_assigned_on_heap_memory = true && this.is_set_assigned_on_heap_memory();
+ boolean that_present_assigned_on_heap_memory = true && that.is_set_assigned_on_heap_memory();
+ if (this_present_assigned_on_heap_memory || that_present_assigned_on_heap_memory) {
+ if (!(this_present_assigned_on_heap_memory && that_present_assigned_on_heap_memory))
+ return false;
+ if (this.assigned_on_heap_memory != that.assigned_on_heap_memory)
+ return false;
+ }
+
+ boolean this_present_assigned_off_heap_memory = true && this.is_set_assigned_off_heap_memory();
+ boolean that_present_assigned_off_heap_memory = true && that.is_set_assigned_off_heap_memory();
+ if (this_present_assigned_off_heap_memory || that_present_assigned_off_heap_memory) {
+ if (!(this_present_assigned_off_heap_memory && that_present_assigned_off_heap_memory))
+ return false;
+ if (this.assigned_off_heap_memory != that.assigned_off_heap_memory)
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_owner = true && (is_set_owner());
+ list.add(present_owner);
+ if (present_owner)
+ list.add(owner);
+
+ boolean present_total_topologies = true && (is_set_total_topologies());
+ list.add(present_total_topologies);
+ if (present_total_topologies)
+ list.add(total_topologies);
+
+ boolean present_total_executors = true && (is_set_total_executors());
+ list.add(present_total_executors);
+ if (present_total_executors)
+ list.add(total_executors);
+
+ boolean present_total_workers = true && (is_set_total_workers());
+ list.add(present_total_workers);
+ if (present_total_workers)
+ list.add(total_workers);
+
+ boolean present_memory_usage = true && (is_set_memory_usage());
+ list.add(present_memory_usage);
+ if (present_memory_usage)
+ list.add(memory_usage);
+
+ boolean present_cpu_usage = true && (is_set_cpu_usage());
+ list.add(present_cpu_usage);
+ if (present_cpu_usage)
+ list.add(cpu_usage);
+
+ boolean present_memory_guarantee = true && (is_set_memory_guarantee());
+ list.add(present_memory_guarantee);
+ if (present_memory_guarantee)
+ list.add(memory_guarantee);
+
+ boolean present_cpu_guarantee = true && (is_set_cpu_guarantee());
+ list.add(present_cpu_guarantee);
+ if (present_cpu_guarantee)
+ list.add(cpu_guarantee);
+
+ boolean present_memory_guarantee_remaining = true && (is_set_memory_guarantee_remaining());
+ list.add(present_memory_guarantee_remaining);
+ if (present_memory_guarantee_remaining)
+ list.add(memory_guarantee_remaining);
+
+ boolean present_cpu_guarantee_remaining = true && (is_set_cpu_guarantee_remaining());
+ list.add(present_cpu_guarantee_remaining);
+ if (present_cpu_guarantee_remaining)
+ list.add(cpu_guarantee_remaining);
+
+ boolean present_isolated_node_guarantee = true && (is_set_isolated_node_guarantee());
+ list.add(present_isolated_node_guarantee);
+ if (present_isolated_node_guarantee)
+ list.add(isolated_node_guarantee);
+
+ boolean present_total_tasks = true && (is_set_total_tasks());
+ list.add(present_total_tasks);
+ if (present_total_tasks)
+ list.add(total_tasks);
+
+ boolean present_requested_on_heap_memory = true && (is_set_requested_on_heap_memory());
+ list.add(present_requested_on_heap_memory);
+ if (present_requested_on_heap_memory)
+ list.add(requested_on_heap_memory);
+
+ boolean present_requested_off_heap_memory = true && (is_set_requested_off_heap_memory());
+ list.add(present_requested_off_heap_memory);
+ if (present_requested_off_heap_memory)
+ list.add(requested_off_heap_memory);
+
+ boolean present_requested_total_memory = true && (is_set_requested_total_memory());
+ list.add(present_requested_total_memory);
+ if (present_requested_total_memory)
+ list.add(requested_total_memory);
+
+ boolean present_requested_cpu = true && (is_set_requested_cpu());
+ list.add(present_requested_cpu);
+ if (present_requested_cpu)
+ list.add(requested_cpu);
+
+ boolean present_assigned_on_heap_memory = true && (is_set_assigned_on_heap_memory());
+ list.add(present_assigned_on_heap_memory);
+ if (present_assigned_on_heap_memory)
+ list.add(assigned_on_heap_memory);
+
+ boolean present_assigned_off_heap_memory = true && (is_set_assigned_off_heap_memory());
+ list.add(present_assigned_off_heap_memory);
+ if (present_assigned_off_heap_memory)
+ list.add(assigned_off_heap_memory);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(OwnerResourceSummary other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(is_set_owner()).compareTo(other.is_set_owner());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_owner()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.owner, other.owner);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_total_topologies()).compareTo(other.is_set_total_topologies());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_total_topologies()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total_topologies, other.total_topologies);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_total_executors()).compareTo(other.is_set_total_executors());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_total_executors()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total_executors, other.total_executors);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_total_workers()).compareTo(other.is_set_total_workers());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_total_workers()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total_workers, other.total_workers);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_memory_usage()).compareTo(other.is_set_memory_usage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_memory_usage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.memory_usage, other.memory_usage);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_cpu_usage()).compareTo(other.is_set_cpu_usage());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_cpu_usage()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cpu_usage, other.cpu_usage);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_memory_guarantee()).compareTo(other.is_set_memory_guarantee());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_memory_guarantee()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.memory_guarantee, other.memory_guarantee);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_cpu_guarantee()).compareTo(other.is_set_cpu_guarantee());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_cpu_guarantee()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cpu_guarantee, other.cpu_guarantee);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_memory_guarantee_remaining()).compareTo(other.is_set_memory_guarantee_remaining());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_memory_guarantee_remaining()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.memory_guarantee_remaining, other.memory_guarantee_remaining);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_cpu_guarantee_remaining()).compareTo(other.is_set_cpu_guarantee_remaining());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_cpu_guarantee_remaining()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cpu_guarantee_remaining, other.cpu_guarantee_remaining);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_isolated_node_guarantee()).compareTo(other.is_set_isolated_node_guarantee());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_isolated_node_guarantee()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isolated_node_guarantee, other.isolated_node_guarantee);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_total_tasks()).compareTo(other.is_set_total_tasks());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_total_tasks()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total_tasks, other.total_tasks);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_requested_on_heap_memory()).compareTo(other.is_set_requested_on_heap_memory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_requested_on_heap_memory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requested_on_heap_memory, other.requested_on_heap_memory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_requested_off_heap_memory()).compareTo(other.is_set_requested_off_heap_memory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_requested_off_heap_memory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requested_off_heap_memory, other.requested_off_heap_memory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_requested_total_memory()).compareTo(other.is_set_requested_total_memory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_requested_total_memory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requested_total_memory, other.requested_total_memory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_requested_cpu()).compareTo(other.is_set_requested_cpu());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_requested_cpu()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.requested_cpu, other.requested_cpu);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_assigned_on_heap_memory()).compareTo(other.is_set_assigned_on_heap_memory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_assigned_on_heap_memory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.assigned_on_heap_memory, other.assigned_on_heap_memory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(is_set_assigned_off_heap_memory()).compareTo(other.is_set_assigned_off_heap_memory());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (is_set_assigned_off_heap_memory()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.assigned_off_heap_memory, other.assigned_off_heap_memory);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("OwnerResourceSummary(");
+ boolean first = true;
+
+ sb.append("owner:");
+ if (this.owner == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.owner);
+ }
+ first = false;
+ if (is_set_total_topologies()) {
+ if (!first) sb.append(", ");
+ sb.append("total_topologies:");
+ sb.append(this.total_topologies);
+ first = false;
+ }
+ if (is_set_total_executors()) {
+ if (!first) sb.append(", ");
+ sb.append("total_executors:");
+ sb.append(this.total_executors);
+ first = false;
+ }
+ if (is_set_total_workers()) {
+ if (!first) sb.append(", ");
+ sb.append("total_workers:");
+ sb.append(this.total_workers);
+ first = false;
+ }
+ if (is_set_memory_usage()) {
+ if (!first) sb.append(", ");
+ sb.append("memory_usage:");
+ sb.append(this.memory_usage);
+ first = false;
+ }
+ if (is_set_cpu_usage()) {
+ if (!first) sb.append(", ");
+ sb.append("cpu_usage:");
+ sb.append(this.cpu_usage);
+ first = false;
+ }
+ if (is_set_memory_guarantee()) {
+ if (!first) sb.append(", ");
+ sb.append("memory_guarantee:");
+ sb.append(this.memory_guarantee);
+ first = false;
+ }
+ if (is_set_cpu_guarantee()) {
+ if (!first) sb.append(", ");
+ sb.append("cpu_guarantee:");
+ sb.append(this.cpu_guarantee);
+ first = false;
+ }
+ if (is_set_memory_guarantee_remaining()) {
+ if (!first) sb.append(", ");
+ sb.append("memory_guarantee_remaining:");
+ sb.append(this.memory_guarantee_remaining);
+ first = false;
+ }
+ if (is_set_cpu_guarantee_remaining()) {
+ if (!first) sb.append(", ");
+ sb.append("cpu_guarantee_remaining:");
+ sb.append(this.cpu_guarantee_remaining);
+ first = false;
+ }
+ if (is_set_isolated_node_guarantee()) {
+ if (!first) sb.append(", ");
+ sb.append("isolated_node_guarantee:");
+ sb.append(this.isolated_node_guarantee);
+ first = false;
+ }
+ if (is_set_total_tasks()) {
+ if (!first) sb.append(", ");
+ sb.append("total_tasks:");
+ sb.append(this.total_tasks);
+ first = false;
+ }
+ if (is_set_requested_on_heap_memory()) {
+ if (!first) sb.append(", ");
+ sb.append("requested_on_heap_memory:");
+ sb.append(this.requested_on_heap_memory);
+ first = false;
+ }
+ if (is_set_requested_off_heap_memory()) {
+ if (!first) sb.append(", ");
+ sb.append("requested_off_heap_memory:");
+ sb.append(this.requested_off_heap_memory);
+ first = false;
+ }
+ if (is_set_requested_total_memory()) {
+ if (!first) sb.append(", ");
+ sb.append("requested_total_memory:");
+ sb.append(this.requested_total_memory);
+ first = false;
+ }
+ if (is_set_requested_cpu()) {
+ if (!first) sb.append(", ");
+ sb.append("requested_cpu:");
+ sb.append(this.requested_cpu);
+ first = false;
+ }
+ if (is_set_assigned_on_heap_memory()) {
+ if (!first) sb.append(", ");
+ sb.append("assigned_on_heap_memory:");
+ sb.append(this.assigned_on_heap_memory);
+ first = false;
+ }
+ if (is_set_assigned_off_heap_memory()) {
+ if (!first) sb.append(", ");
+ sb.append("assigned_off_heap_memory:");
+ sb.append(this.assigned_off_heap_memory);
+ first = false;
+ }
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!is_set_owner()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'owner' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+ __isset_bitfield = 0;
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class OwnerResourceSummaryStandardSchemeFactory implements SchemeFactory {
+ public OwnerResourceSummaryStandardScheme getScheme() {
+ return new OwnerResourceSummaryStandardScheme();
+ }
+ }
+
+ private static class OwnerResourceSummaryStandardScheme extends StandardScheme<OwnerResourceSummary> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, OwnerResourceSummary struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // OWNER
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.owner = iprot.readString();
+ struct.set_owner_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TOTAL_TOPOLOGIES
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.total_topologies = iprot.readI32();
+ struct.set_total_topologies_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // TOTAL_EXECUTORS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.total_executors = iprot.readI32();
+ struct.set_total_executors_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // TOTAL_WORKERS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.total_workers = iprot.readI32();
+ struct.set_total_workers_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 5: // MEMORY_USAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.memory_usage = iprot.readDouble();
+ struct.set_memory_usage_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 6: // CPU_USAGE
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.cpu_usage = iprot.readDouble();
+ struct.set_cpu_usage_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 7: // MEMORY_GUARANTEE
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.memory_guarantee = iprot.readDouble();
+ struct.set_memory_guarantee_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 8: // CPU_GUARANTEE
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.cpu_guarantee = iprot.readDouble();
+ struct.set_cpu_guarantee_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 9: // MEMORY_GUARANTEE_REMAINING
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.memory_guarantee_remaining = iprot.readDouble();
+ struct.set_memory_guarantee_remaining_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 10: // CPU_GUARANTEE_REMAINING
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.cpu_guarantee_remaining = iprot.readDouble();
+ struct.set_cpu_guarantee_remaining_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 11: // ISOLATED_NODE_GUARANTEE
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.isolated_node_guarantee = iprot.readI32();
+ struct.set_isolated_node_guarantee_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 12: // TOTAL_TASKS
+ if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+ struct.total_tasks = iprot.readI32();
+ struct.set_total_tasks_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 13: // REQUESTED_ON_HEAP_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.requested_on_heap_memory = iprot.readDouble();
+ struct.set_requested_on_heap_memory_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 14: // REQUESTED_OFF_HEAP_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.requested_off_heap_memory = iprot.readDouble();
+ struct.set_requested_off_heap_memory_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 15: // REQUESTED_TOTAL_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.requested_total_memory = iprot.readDouble();
+ struct.set_requested_total_memory_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 16: // REQUESTED_CPU
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.requested_cpu = iprot.readDouble();
+ struct.set_requested_cpu_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 17: // ASSIGNED_ON_HEAP_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.assigned_on_heap_memory = iprot.readDouble();
+ struct.set_assigned_on_heap_memory_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 18: // ASSIGNED_OFF_HEAP_MEMORY
+ if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+ struct.assigned_off_heap_memory = iprot.readDouble();
+ struct.set_assigned_off_heap_memory_isSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, OwnerResourceSummary struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.owner != null) {
+ oprot.writeFieldBegin(OWNER_FIELD_DESC);
+ oprot.writeString(struct.owner);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_total_topologies()) {
+ oprot.writeFieldBegin(TOTAL_TOPOLOGIES_FIELD_DESC);
+ oprot.writeI32(struct.total_topologies);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_total_executors()) {
+ oprot.writeFieldBegin(TOTAL_EXECUTORS_FIELD_DESC);
+ oprot.writeI32(struct.total_executors);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_total_workers()) {
+ oprot.writeFieldBegin(TOTAL_WORKERS_FIELD_DESC);
+ oprot.writeI32(struct.total_workers);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_memory_usage()) {
+ oprot.writeFieldBegin(MEMORY_USAGE_FIELD_DESC);
+ oprot.writeDouble(struct.memory_usage);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_cpu_usage()) {
+ oprot.writeFieldBegin(CPU_USAGE_FIELD_DESC);
+ oprot.writeDouble(struct.cpu_usage);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_memory_guarantee()) {
+ oprot.writeFieldBegin(MEMORY_GUARANTEE_FIELD_DESC);
+ oprot.writeDouble(struct.memory_guarantee);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_cpu_guarantee()) {
+ oprot.writeFieldBegin(CPU_GUARANTEE_FIELD_DESC);
+ oprot.writeDouble(struct.cpu_guarantee);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_memory_guarantee_remaining()) {
+ oprot.writeFieldBegin(MEMORY_GUARANTEE_REMAINING_FIELD_DESC);
+ oprot.writeDouble(struct.memory_guarantee_remaining);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_cpu_guarantee_remaining()) {
+ oprot.writeFieldBegin(CPU_GUARANTEE_REMAINING_FIELD_DESC);
+ oprot.writeDouble(struct.cpu_guarantee_remaining);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_isolated_node_guarantee()) {
+ oprot.writeFieldBegin(ISOLATED_NODE_GUARANTEE_FIELD_DESC);
+ oprot.writeI32(struct.isolated_node_guarantee);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_total_tasks()) {
+ oprot.writeFieldBegin(TOTAL_TASKS_FIELD_DESC);
+ oprot.writeI32(struct.total_tasks);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_requested_on_heap_memory()) {
+ oprot.writeFieldBegin(REQUESTED_ON_HEAP_MEMORY_FIELD_DESC);
+ oprot.writeDouble(struct.requested_on_heap_memory);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_requested_off_heap_memory()) {
+ oprot.writeFieldBegin(REQUESTED_OFF_HEAP_MEMORY_FIELD_DESC);
+ oprot.writeDouble(struct.requested_off_heap_memory);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_requested_total_memory()) {
+ oprot.writeFieldBegin(REQUESTED_TOTAL_MEMORY_FIELD_DESC);
+ oprot.writeDouble(struct.requested_total_memory);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_requested_cpu()) {
+ oprot.writeFieldBegin(REQUESTED_CPU_FIELD_DESC);
+ oprot.writeDouble(struct.requested_cpu);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_assigned_on_heap_memory()) {
+ oprot.writeFieldBegin(ASSIGNED_ON_HEAP_MEMORY_FIELD_DESC);
+ oprot.writeDouble(struct.assigned_on_heap_memory);
+ oprot.writeFieldEnd();
+ }
+ if (struct.is_set_assigned_off_heap_memory()) {
+ oprot.writeFieldBegin(ASSIGNED_OFF_HEAP_MEMORY_FIELD_DESC);
+ oprot.writeDouble(struct.assigned_off_heap_memory);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class OwnerResourceSummaryTupleSchemeFactory implements SchemeFactory {
+ public OwnerResourceSummaryTupleScheme getScheme() {
+ return new OwnerResourceSummaryTupleScheme();
+ }
+ }
+
+ private static class OwnerResourceSummaryTupleScheme extends TupleScheme<OwnerResourceSummary> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, OwnerResourceSummary struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeString(struct.owner);
+ BitSet optionals = new BitSet();
+ if (struct.is_set_total_topologies()) {
+ optionals.set(0);
+ }
+ if (struct.is_set_total_executors()) {
+ optionals.set(1);
+ }
+ if (struct.is_set_total_workers()) {
+ optionals.set(2);
+ }
+ if (struct.is_set_memory_usage()) {
+ optionals.set(3);
+ }
+ if (struct.is_set_cpu_usage()) {
+ optionals.set(4);
+ }
+ if (struct.is_set_memory_guarantee()) {
+ optionals.set(5);
+ }
+ if (struct.is_set_cpu_guarantee()) {
+ optionals.set(6);
+ }
+ if (struct.is_set_memory_guarantee_remaining()) {
+ optionals.set(7);
+ }
+ if (struct.is_set_cpu_guarantee_remaining()) {
+ optionals.set(8);
+ }
+ if (struct.is_set_isolated_node_guarantee()) {
+ optionals.set(9);
+ }
+ if (struct.is_set_total_tasks()) {
+ optionals.set(10);
+ }
+ if (struct.is_set_requested_on_heap_memory()) {
+ optionals.set(11);
+ }
+ if (struct.is_set_requested_off_heap_memory()) {
+ optionals.set(12);
+ }
+ if (struct.is_set_requested_total_memory()) {
+ optionals.set(13);
+ }
+ if (struct.is_set_requested_cpu()) {
+ optionals.set(14);
+ }
+ if (struct.is_set_assigned_on_heap_memory()) {
+ optionals.set(15);
+ }
+ if (struct.is_set_assigned_off_heap_memory()) {
+ optionals.set(16);
+ }
+ oprot.writeBitSet(optionals, 17);
+ if (struct.is_set_total_topologies()) {
+ oprot.writeI32(struct.total_topologies);
+ }
+ if (struct.is_set_total_executors()) {
+ oprot.writeI32(struct.total_executors);
+ }
+ if (struct.is_set_total_workers()) {
+ oprot.writeI32(struct.total_workers);
+ }
+ if (struct.is_set_memory_usage()) {
+ oprot.writeDouble(struct.memory_usage);
+ }
+ if (struct.is_set_cpu_usage()) {
+ oprot.writeDouble(struct.cpu_usage);
+ }
+ if (struct.is_set_memory_guarantee()) {
+ oprot.writeDouble(struct.memory_guarantee);
+ }
+ if (struct.is_set_cpu_guarantee()) {
+ oprot.writeDouble(struct.cpu_guarantee);
+ }
+ if (struct.is_set_memory_guarantee_remaining()) {
+ oprot.writeDouble(struct.memory_guarantee_remaining);
+ }
+ if (struct.is_set_cpu_guarantee_remaining()) {
+ oprot.writeDouble(struct.cpu_guarantee_remaining);
+ }
+ if (struct.is_set_isolated_node_guarantee()) {
+ oprot.writeI32(struct.isolated_node_guarantee);
+ }
+ if (struct.is_set_total_tasks()) {
+ oprot.writeI32(struct.total_tasks);
+ }
+ if (struct.is_set_requested_on_heap_memory()) {
+ oprot.writeDouble(struct.requested_on_heap_memory);
+ }
+ if (struct.is_set_requested_off_heap_memory()) {
+ oprot.writeDouble(struct.requested_off_heap_memory);
+ }
+ if (struct.is_set_requested_total_memory()) {
+ oprot.writeDouble(struct.requested_total_memory);
+ }
+ if (struct.is_set_requested_cpu()) {
+ oprot.writeDouble(struct.requested_cpu);
+ }
+ if (struct.is_set_assigned_on_heap_memory()) {
+ oprot.writeDouble(struct.assigned_on_heap_memory);
+ }
+ if (struct.is_set_assigned_off_heap_memory()) {
+ oprot.writeDouble(struct.assigned_off_heap_memory);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, OwnerResourceSummary struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.owner = iprot.readString();
+ struct.set_owner_isSet(true);
+ BitSet incoming = iprot.readBitSet(17);
+ if (incoming.get(0)) {
+ struct.total_topologies = iprot.readI32();
+ struct.set_total_topologies_isSet(true);
+ }
+ if (incoming.get(1)) {
+ struct.total_executors = iprot.readI32();
+ struct.set_total_executors_isSet(true);
+ }
+ if (incoming.get(2)) {
+ struct.total_workers = iprot.readI32();
+ struct.set_total_workers_isSet(true);
+ }
+ if (incoming.get(3)) {
+ struct.memory_usage = iprot.readDouble();
+ struct.set_memory_usage_isSet(true);
+ }
+ if (incoming.get(4)) {
+ struct.cpu_usage = iprot.readDouble();
+ struct.set_cpu_usage_isSet(true);
+ }
+ if (incoming.get(5)) {
+ struct.memory_guarantee = iprot.readDouble();
+ struct.set_memory_guarantee_isSet(true);
+ }
+ if (incoming.get(6)) {
+ struct.cpu_guarantee = iprot.readDouble();
+ struct.set_cpu_guarantee_isSet(true);
+ }
+ if (incoming.get(7)) {
+ struct.memory_guarantee_remaining = iprot.readDouble();
+ struct.set_memory_guarantee_remaining_isSet(true);
+ }
+ if (incoming.get(8)) {
+ struct.cpu_guarantee_remaining = iprot.readDouble();
+ struct.set_cpu_guarantee_remaining_isSet(true);
+ }
+ if (incoming.get(9)) {
+ struct.isolated_node_guarantee = iprot.readI32();
+ struct.set_isolated_node_guarantee_isSet(true);
+ }
+ if (incoming.get(10)) {
+ struct.total_tasks = iprot.readI32();
+ struct.set_total_tasks_isSet(true);
+ }
+ if (incoming.get(11)) {
+ struct.requested_on_heap_memory = iprot.readDouble();
+ struct.set_requested_on_heap_memory_isSet(true);
+ }
+ if (incoming.get(12)) {
+ struct.requested_off_heap_memory = iprot.readDouble();
+ struct.set_requested_off_heap_memory_isSet(true);
+ }
+ if (incoming.get(13)) {
+ struct.requested_total_memory = iprot.readDouble();
+ struct.set_requested_total_memory_isSet(true);
+ }
+ if (incoming.get(14)) {
+ struct.requested_cpu = iprot.readDouble();
+ struct.set_requested_cpu_isSet(true);
+ }
+ if (incoming.get(15)) {
+ struct.assigned_on_heap_memory = iprot.readDouble();
+ struct.set_assigned_on_heap_memory_isSet(true);
+ }
+ if (incoming.get(16)) {
+ struct.assigned_off_heap_memory = iprot.readDouble();
+ struct.set_assigned_off_heap_memory_isSet(true);
+ }
+ }
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/storm/blob/e5d6d32b/storm-client/src/jvm/org/apache/storm/scheduler/IScheduler.java
----------------------------------------------------------------------
diff --git a/storm-client/src/jvm/org/apache/storm/scheduler/IScheduler.java b/storm-client/src/jvm/org/apache/storm/scheduler/IScheduler.java
index f97755b..8d475f9 100644
--- a/storm-client/src/jvm/org/apache/storm/scheduler/IScheduler.java
+++ b/storm-client/src/jvm/org/apache/storm/scheduler/IScheduler.java
@@ -37,4 +37,11 @@ public interface IScheduler {
* cluster.setAssignmentById()`
*/
void schedule(Topologies topologies, Cluster cluster);
+
+ /**
+ * This function returns the scheduler's configuration.
+ *
+ * @return The scheduler's configuration.
+ */
+ Map<String, Object> config();
}
http://git-wip-us.apache.org/repos/asf/storm/blob/e5d6d32b/storm-client/src/jvm/org/apache/storm/security/auth/authorizer/SimpleACLAuthorizer.java
----------------------------------------------------------------------
diff --git a/storm-client/src/jvm/org/apache/storm/security/auth/authorizer/SimpleACLAuthorizer.java b/storm-client/src/jvm/org/apache/storm/security/auth/authorizer/SimpleACLAuthorizer.java
index f56537b..b8d02d1 100644
--- a/storm-client/src/jvm/org/apache/storm/security/auth/authorizer/SimpleACLAuthorizer.java
+++ b/storm-client/src/jvm/org/apache/storm/security/auth/authorizer/SimpleACLAuthorizer.java
@@ -47,7 +47,8 @@ public class SimpleACLAuthorizer implements IAuthorizer {
"fileUpload",
"getNimbusConf",
"getClusterInfo",
- "getSupervisorPageInfo"));
+ "getSupervisorPageInfo",
+ "getOwnerResourceSummaries"));
protected Set<String> _supervisorCommands = new HashSet<>(Arrays.asList("fileDownload"));
protected Set<String> _topoReadOnlyCommands = new HashSet<>(Arrays.asList(
"getTopologyConf",
http://git-wip-us.apache.org/repos/asf/storm/blob/e5d6d32b/storm-client/src/py/storm/Nimbus-remote
----------------------------------------------------------------------
diff --git a/storm-client/src/py/storm/Nimbus-remote b/storm-client/src/py/storm/Nimbus-remote
index 0d643c3..7b080cf 100644
--- a/storm-client/src/py/storm/Nimbus-remote
+++ b/storm-client/src/py/storm/Nimbus-remote
@@ -87,6 +87,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help':
print(' StormTopology getTopology(string id)')
print(' StormTopology getUserTopology(string id)')
print(' TopologyHistoryInfo getTopologyHistory(string user)')
+ print(' getOwnerResourceSummaries(string owner)')
print('')
sys.exit(0)
@@ -413,6 +414,12 @@ elif cmd == 'getTopologyHistory':
sys.exit(1)
pp.pprint(client.getTopologyHistory(args[0],))
+elif cmd == 'getOwnerResourceSummaries':
+ if len(args) != 1:
+ print('getOwnerResourceSummaries requires 1 args')
+ sys.exit(1)
+ pp.pprint(client.getOwnerResourceSummaries(args[0],))
+
else:
print('Unrecognized method %s' % cmd)
sys.exit(1)