UniversalVesAdapter/src/main/java/org/onap/dcaegen2/ves/domain/ves7_0/DiskUsageArray.java

   1 /*\r
   2 * ============LICENSE_START=======================================================\r
   3 * ONAP : DCAE\r
   4 * ================================================================================\r
   5 * Copyright 2018 TechMahindra\r
   6 *=================================================================================\r
   7 * Licensed under the Apache License, Version 2.0 (the "License");\r
   8 * you may not use this file except in compliance with the License.\r
   9 * You may obtain a copy of the License at\r
  10 *\r
  11 *     http://www.apache.org/licenses/LICENSE-2.0\r
  12 *\r
  13 * Unless required by applicable law or agreed to in writing, software\r
  14 * distributed under the License is distributed on an "AS IS" BASIS,\r
  15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  16 * See the License for the specific language governing permissions and\r
  17 * limitations under the License.\r
  18 * ============LICENSE_END=========================================================\r
  19 */\r
  20 package org.onap.dcaegen2.ves.domain.ves7_0;\r
  21 \r
  22 import com.fasterxml.jackson.annotation.JsonInclude;\r
  23 import com.fasterxml.jackson.annotation.JsonProperty;\r
  24 import com.fasterxml.jackson.annotation.JsonPropertyDescription;\r
  25 import com.fasterxml.jackson.annotation.JsonPropertyOrder;\r
  26 import org.apache.commons.lang.builder.EqualsBuilder;\r
  27 import org.apache.commons.lang.builder.HashCodeBuilder;\r
  28 import org.apache.commons.lang.builder.ToStringBuilder;\r
  29 \r
  30 \r
  31 /**\r
  32  * usage of an identified disk\r
  33  * \r
  34  */\r
  35 @JsonInclude(JsonInclude.Include.NON_NULL)\r
  36 @JsonPropertyOrder({\r
  37     "diskBusResets",\r
  38     "diskCommandsAborted",\r
  39     "diskCommandsAvg",\r
  40     "diskFlushRequests",\r
  41     "diskFlushTime",\r
  42     "diskIdentifier",\r
  43     "diskIoTimeAvg",\r
  44     "diskIoTimeLast",\r
  45     "diskIoTimeMax",\r
  46     "diskIoTimeMin",\r
  47     "diskMergedReadAvg",\r
  48     "diskMergedReadLast",\r
  49     "diskMergedReadMax",\r
  50     "diskMergedReadMin",\r
  51     "diskMergedWriteAvg",\r
  52     "diskMergedWriteLast",\r
  53     "diskMergedWriteMax",\r
  54     "diskMergedWriteMin",\r
  55     "diskOctetsReadAvg",\r
  56     "diskOctetsReadLast",\r
  57     "diskOctetsReadMax",\r
  58     "diskOctetsReadMin",\r
  59     "diskOctetsWriteAvg",\r
  60     "diskOctetsWriteLast",\r
  61     "diskOctetsWriteMax",\r
  62     "diskOctetsWriteMin",\r
  63     "diskOpsReadAvg",\r
  64     "diskOpsReadLast",\r
  65     "diskOpsReadMax",\r
  66     "diskOpsReadMin",\r
  67     "diskOpsWriteAvg",\r
  68     "diskOpsWriteLast",\r
  69     "diskOpsWriteMax",\r
  70     "diskOpsWriteMin",\r
  71     "diskPendingOperationsAvg",\r
  72     "diskPendingOperationsLast",\r
  73     "diskPendingOperationsMax",\r
  74     "diskPendingOperationsMin",\r
  75     "diskReadCommandsAvg",\r
  76     "diskTime",\r
  77     "diskTimeReadAvg",\r
  78     "diskTimeReadLast",\r
  79     "diskTimeReadMax",\r
  80     "diskTimeReadMin",\r
  81     "diskTimeWriteAvg",\r
  82     "diskTimeWriteLast",\r
  83     "diskTimeWriteMax",\r
  84     "diskTimeWriteMin",\r
  85     "diskTotalReadLatencyAvg",\r
  86     "diskTotalWriteLatencyAvg",\r
  87     "diskWeightedIoTimeAvg",\r
  88     "diskWeightedIoTimeLast",\r
  89     "diskWeightedIoTimeMax",\r
  90     "diskWeightedIoTimeMin",\r
  91     "diskWriteCommandsAvg"\r
  92 })\r
  93 public class DiskUsageArray {\r
  94 \r
  95     /**\r
  96      * number of bus resets over the measurementInterval\r
  97      * \r
  98      */\r
  99     @JsonProperty("diskBusResets")\r
 100     @JsonPropertyDescription("number of bus resets over the measurementInterval")\r
 101     private Double diskBusResets;\r
 102     /**\r
 103      * number of disk commands aborted over the measurementInterval\r
 104      * \r
 105      */\r
 106     @JsonProperty("diskCommandsAborted")\r
 107     @JsonPropertyDescription("number of disk commands aborted over the measurementInterval")\r
 108     private Double diskCommandsAborted;\r
 109     /**\r
 110      * average number of commands per second over the measurementInterval\r
 111      * \r
 112      */\r
 113     @JsonProperty("diskCommandsAvg")\r
 114     @JsonPropertyDescription("average number of commands per second over the measurementInterval")\r
 115     private Double diskCommandsAvg;\r
 116     /**\r
 117      * total flush requests of the disk cache over the measurementInterval\r
 118      * \r
 119      */\r
 120     @JsonProperty("diskFlushRequests")\r
 121     @JsonPropertyDescription("total flush requests of the disk cache over the measurementInterval")\r
 122     private Double diskFlushRequests;\r
 123     /**\r
 124      * milliseconds spent on disk cache flushing over the measurementInterval\r
 125      * \r
 126      */\r
 127     @JsonProperty("diskFlushTime")\r
 128     @JsonPropertyDescription("milliseconds spent on disk cache flushing over the measurementInterval")\r
 129     private Double diskFlushTime;\r
 130     /**\r
 131      * disk identifier\r
 132      * (Required)\r
 133      * \r
 134      */\r
 135     @JsonProperty("diskIdentifier")\r
 136     @JsonPropertyDescription("disk identifier")\r
 137     private String diskIdentifier;\r
 138     /**\r
 139      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the average over the measurement interval\r
 140      * \r
 141      */\r
 142     @JsonProperty("diskIoTimeAvg")\r
 143     @JsonPropertyDescription("milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the average over the measurement interval")\r
 144     private Double diskIoTimeAvg;\r
 145     /**\r
 146      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the last value measurement within the measurement interval\r
 147      * \r
 148      */\r
 149     @JsonProperty("diskIoTimeLast")\r
 150     @JsonPropertyDescription("milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the last value measurement within the measurement interval")\r
 151     private Double diskIoTimeLast;\r
 152     /**\r
 153      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the maximum value measurement within the measurement interval\r
 154      * \r
 155      */\r
 156     @JsonProperty("diskIoTimeMax")\r
 157     @JsonPropertyDescription("milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the maximum value measurement within the measurement interval")\r
 158     private Double diskIoTimeMax;\r
 159     /**\r
 160      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the minimum value measurement within the measurement interval\r
 161      * \r
 162      */\r
 163     @JsonProperty("diskIoTimeMin")\r
 164     @JsonPropertyDescription("milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the minimum value measurement within the measurement interval")\r
 165     private Double diskIoTimeMin;\r
 166     /**\r
 167      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the average measurement within the measurement interval\r
 168      * \r
 169      */\r
 170     @JsonProperty("diskMergedReadAvg")\r
 171     @JsonPropertyDescription("number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the average measurement within the measurement interval")\r
 172     private Double diskMergedReadAvg;\r
 173     /**\r
 174      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the last value measurement within the measurement interval\r
 175      * \r
 176      */\r
 177     @JsonProperty("diskMergedReadLast")\r
 178     @JsonPropertyDescription("number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the last value measurement within the measurement interval")\r
 179     private Double diskMergedReadLast;\r
 180     /**\r
 181      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 182      * \r
 183      */\r
 184     @JsonProperty("diskMergedReadMax")\r
 185     @JsonPropertyDescription("number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the maximum value measurement within the measurement interval")\r
 186     private Double diskMergedReadMax;\r
 187     /**\r
 188      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 189      * \r
 190      */\r
 191     @JsonProperty("diskMergedReadMin")\r
 192     @JsonPropertyDescription("number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the minimum value measurement within the measurement interval")\r
 193     private Double diskMergedReadMin;\r
 194     /**\r
 195      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the average measurement within the measurement interval\r
 196      * \r
 197      */\r
 198     @JsonProperty("diskMergedWriteAvg")\r
 199     @JsonPropertyDescription("number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the average measurement within the measurement interval")\r
 200     private Double diskMergedWriteAvg;\r
 201     /**\r
 202      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the last value measurement within the measurement interval\r
 203      * \r
 204      */\r
 205     @JsonProperty("diskMergedWriteLast")\r
 206     @JsonPropertyDescription("number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the last value measurement within the measurement interval")\r
 207     private Double diskMergedWriteLast;\r
 208     /**\r
 209      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 210      * \r
 211      */\r
 212     @JsonProperty("diskMergedWriteMax")\r
 213     @JsonPropertyDescription("number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the maximum value measurement within the measurement interval")\r
 214     private Double diskMergedWriteMax;\r
 215     /**\r
 216      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 217      * \r
 218      */\r
 219     @JsonProperty("diskMergedWriteMin")\r
 220     @JsonPropertyDescription("number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the minimum value measurement within the measurement interval")\r
 221     private Double diskMergedWriteMin;\r
 222     /**\r
 223      * number of octets per second read from a disk or partition; provide the average measurement within the measurement interval\r
 224      * \r
 225      */\r
 226     @JsonProperty("diskOctetsReadAvg")\r
 227     @JsonPropertyDescription("number of octets per second read from a disk or partition; provide the average measurement within the measurement interval")\r
 228     private Double diskOctetsReadAvg;\r
 229     /**\r
 230      * number of octets per second read from a disk or partition; provide the last measurement within the measurement interval\r
 231      * \r
 232      */\r
 233     @JsonProperty("diskOctetsReadLast")\r
 234     @JsonPropertyDescription("number of octets per second read from a disk or partition; provide the last measurement within the measurement interval")\r
 235     private Double diskOctetsReadLast;\r
 236     /**\r
 237      * number of octets per second read from a disk or partition; provide the maximum measurement within the measurement interval\r
 238      * \r
 239      */\r
 240     @JsonProperty("diskOctetsReadMax")\r
 241     @JsonPropertyDescription("number of octets per second read from a disk or partition; provide the maximum measurement within the measurement interval")\r
 242     private Double diskOctetsReadMax;\r
 243     /**\r
 244      * number of octets per second read from a disk or partition; provide the minimum measurement within the measurement interval\r
 245      * \r
 246      */\r
 247     @JsonProperty("diskOctetsReadMin")\r
 248     @JsonPropertyDescription("number of octets per second read from a disk or partition; provide the minimum measurement within the measurement interval")\r
 249     private Double diskOctetsReadMin;\r
 250     /**\r
 251      * number of octets per second written to a disk or partition; provide the average measurement within the measurement interval\r
 252      * \r
 253      */\r
 254     @JsonProperty("diskOctetsWriteAvg")\r
 255     @JsonPropertyDescription("number of octets per second written to a disk or partition; provide the average measurement within the measurement interval")\r
 256     private Double diskOctetsWriteAvg;\r
 257     /**\r
 258      * number of octets per second written to a disk or partition; provide the last measurement within the measurement interval\r
 259      * \r
 260      */\r
 261     @JsonProperty("diskOctetsWriteLast")\r
 262     @JsonPropertyDescription("number of octets per second written to a disk or partition; provide the last measurement within the measurement interval")\r
 263     private Double diskOctetsWriteLast;\r
 264     /**\r
 265      * number of octets per second written to a disk or partition; provide the maximum measurement within the measurement interval\r
 266      * \r
 267      */\r
 268     @JsonProperty("diskOctetsWriteMax")\r
 269     @JsonPropertyDescription("number of octets per second written to a disk or partition; provide the maximum measurement within the measurement interval")\r
 270     private Double diskOctetsWriteMax;\r
 271     /**\r
 272      * number of octets per second written to a disk or partition; provide the minimum measurement within the measurement interval\r
 273      * \r
 274      */\r
 275     @JsonProperty("diskOctetsWriteMin")\r
 276     @JsonPropertyDescription("number of octets per second written to a disk or partition; provide the minimum measurement within the measurement interval")\r
 277     private Double diskOctetsWriteMin;\r
 278     /**\r
 279      * number of read operations per second issued to the disk; provide the average measurement within the measurement interval\r
 280      * \r
 281      */\r
 282     @JsonProperty("diskOpsReadAvg")\r
 283     @JsonPropertyDescription("number of read operations per second issued to the disk; provide the average measurement within the measurement interval")\r
 284     private Double diskOpsReadAvg;\r
 285     /**\r
 286      * number of read operations per second issued to the disk; provide the last measurement within the measurement interval\r
 287      * \r
 288      */\r
 289     @JsonProperty("diskOpsReadLast")\r
 290     @JsonPropertyDescription("number of read operations per second issued to the disk; provide the last measurement within the measurement interval")\r
 291     private Double diskOpsReadLast;\r
 292     /**\r
 293      * number of read operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
 294      * \r
 295      */\r
 296     @JsonProperty("diskOpsReadMax")\r
 297     @JsonPropertyDescription("number of read operations per second issued to the disk; provide the maximum measurement within the measurement interval")\r
 298     private Double diskOpsReadMax;\r
 299     /**\r
 300      * number of read operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
 301      * \r
 302      */\r
 303     @JsonProperty("diskOpsReadMin")\r
 304     @JsonPropertyDescription("number of read operations per second issued to the disk; provide the minimum measurement within the measurement interval")\r
 305     private Double diskOpsReadMin;\r
 306     /**\r
 307      * number of write operations per second issued to the disk; provide the average measurement within the measurement interval\r
 308      * \r
 309      */\r
 310     @JsonProperty("diskOpsWriteAvg")\r
 311     @JsonPropertyDescription("number of write operations per second issued to the disk; provide the average measurement within the measurement interval")\r
 312     private Double diskOpsWriteAvg;\r
 313     /**\r
 314      * number of write operations per second issued to the disk; provide the last measurement within the measurement interval\r
 315      * \r
 316      */\r
 317     @JsonProperty("diskOpsWriteLast")\r
 318     @JsonPropertyDescription("number of write operations per second issued to the disk; provide the last measurement within the measurement interval")\r
 319     private Double diskOpsWriteLast;\r
 320     /**\r
 321      * number of write operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
 322      * \r
 323      */\r
 324     @JsonProperty("diskOpsWriteMax")\r
 325     @JsonPropertyDescription("number of write operations per second issued to the disk; provide the maximum measurement within the measurement interval")\r
 326     private Double diskOpsWriteMax;\r
 327     /**\r
 328      * number of write operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
 329      * \r
 330      */\r
 331     @JsonProperty("diskOpsWriteMin")\r
 332     @JsonPropertyDescription("number of write operations per second issued to the disk; provide the minimum measurement within the measurement interval")\r
 333     private Double diskOpsWriteMin;\r
 334     /**\r
 335      * queue size of pending I/O operations per second; provide the average measurement within the measurement interval\r
 336      * \r
 337      */\r
 338     @JsonProperty("diskPendingOperationsAvg")\r
 339     @JsonPropertyDescription("queue size of pending I/O operations per second; provide the average measurement within the measurement interval")\r
 340     private Double diskPendingOperationsAvg;\r
 341     /**\r
 342      * queue size of pending I/O operations per second; provide the last measurement within the measurement interval\r
 343      * \r
 344      */\r
 345     @JsonProperty("diskPendingOperationsLast")\r
 346     @JsonPropertyDescription("queue size of pending I/O operations per second; provide the last measurement within the measurement interval")\r
 347     private Double diskPendingOperationsLast;\r
 348     /**\r
 349      * queue size of pending I/O operations per second; provide the maximum measurement within the measurement interval\r
 350      * \r
 351      */\r
 352     @JsonProperty("diskPendingOperationsMax")\r
 353     @JsonPropertyDescription("queue size of pending I/O operations per second; provide the maximum measurement within the measurement interval")\r
 354     private Double diskPendingOperationsMax;\r
 355     /**\r
 356      * queue size of pending I/O operations per second; provide the minimum measurement within the measurement interval\r
 357      * \r
 358      */\r
 359     @JsonProperty("diskPendingOperationsMin")\r
 360     @JsonPropertyDescription("queue size of pending I/O operations per second; provide the minimum measurement within the measurement interval")\r
 361     private Double diskPendingOperationsMin;\r
 362     /**\r
 363      * average number of read commands issued per second to the disk over the measurementInterval\r
 364      * \r
 365      */\r
 366     @JsonProperty("diskReadCommandsAvg")\r
 367     @JsonPropertyDescription("average number of read commands issued per second to the disk over the measurementInterval")\r
 368     private Double diskReadCommandsAvg;\r
 369     /**\r
 370      * nanoseconds spent on disk cache reads/writes within the measurement interval\r
 371      * \r
 372      */\r
 373     @JsonProperty("diskTime")\r
 374     @JsonPropertyDescription("nanoseconds spent on disk cache reads/writes within the measurement interval")\r
 375     private Double diskTime;\r
 376     /**\r
 377      * milliseconds a read operation took to complete; provide the average measurement within the measurement interval\r
 378      * \r
 379      */\r
 380     @JsonProperty("diskTimeReadAvg")\r
 381     @JsonPropertyDescription("milliseconds a read operation took to complete; provide the average measurement within the measurement interval")\r
 382     private Double diskTimeReadAvg;\r
 383     /**\r
 384      * milliseconds a read operation took to complete; provide the last measurement within the measurement interval\r
 385      * \r
 386      */\r
 387     @JsonProperty("diskTimeReadLast")\r
 388     @JsonPropertyDescription("milliseconds a read operation took to complete; provide the last measurement within the measurement interval")\r
 389     private Double diskTimeReadLast;\r
 390     /**\r
 391      * milliseconds a read operation took to complete; provide the maximum measurement within the measurement interval\r
 392      * \r
 393      */\r
 394     @JsonProperty("diskTimeReadMax")\r
 395     @JsonPropertyDescription("milliseconds a read operation took to complete; provide the maximum measurement within the measurement interval")\r
 396     private Double diskTimeReadMax;\r
 397     /**\r
 398      * milliseconds a read operation took to complete; provide the minimum measurement within the measurement interval\r
 399      * \r
 400      */\r
 401     @JsonProperty("diskTimeReadMin")\r
 402     @JsonPropertyDescription("milliseconds a read operation took to complete; provide the minimum measurement within the measurement interval")\r
 403     private Double diskTimeReadMin;\r
 404     /**\r
 405      * milliseconds a write operation took to complete; provide the average measurement within the measurement interval\r
 406      * \r
 407      */\r
 408     @JsonProperty("diskTimeWriteAvg")\r
 409     @JsonPropertyDescription("milliseconds a write operation took to complete; provide the average measurement within the measurement interval")\r
 410     private Double diskTimeWriteAvg;\r
 411     /**\r
 412      * milliseconds a write operation took to complete; provide the last measurement within the measurement interval\r
 413      * \r
 414      */\r
 415     @JsonProperty("diskTimeWriteLast")\r
 416     @JsonPropertyDescription("milliseconds a write operation took to complete; provide the last measurement within the measurement interval")\r
 417     private Double diskTimeWriteLast;\r
 418     /**\r
 419      * milliseconds a write operation took to complete; provide the maximum measurement within the measurement interval\r
 420      * \r
 421      */\r
 422     @JsonProperty("diskTimeWriteMax")\r
 423     @JsonPropertyDescription("milliseconds a write operation took to complete; provide the maximum measurement within the measurement interval")\r
 424     private Double diskTimeWriteMax;\r
 425     /**\r
 426      * milliseconds a write operation took to complete; provide the minimum measurement within the measurement interval\r
 427      * \r
 428      */\r
 429     @JsonProperty("diskTimeWriteMin")\r
 430     @JsonPropertyDescription("milliseconds a write operation took to complete; provide the minimum measurement within the measurement interval")\r
 431     private Double diskTimeWriteMin;\r
 432     /**\r
 433      * average read time from the perspective of a Guest OS: sum of the Kernel Read Latency and Physical Device Read Latency in milliseconds over the measurement interval\r
 434      * \r
 435      */\r
 436     @JsonProperty("diskTotalReadLatencyAvg")\r
 437     @JsonPropertyDescription("average read time from the perspective of a Guest OS: sum of the Kernel Read Latency and Physical Device Read Latency in milliseconds over the measurement interval")\r
 438     private Double diskTotalReadLatencyAvg;\r
 439     /**\r
 440      * average write time from the perspective of a Guest OS: sum of the Kernel Write Latency and Physical Device Write Latency in milliseconds over the measurement interval\r
 441      * \r
 442      */\r
 443     @JsonProperty("diskTotalWriteLatencyAvg")\r
 444     @JsonPropertyDescription("average write time from the perspective of a Guest OS: sum of the Kernel Write Latency and Physical Device Write Latency in milliseconds over the measurement interval")\r
 445     private Double diskTotalWriteLatencyAvg;\r
 446     /**\r
 447      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the average within the collection interval\r
 448      * \r
 449      */\r
 450     @JsonProperty("diskWeightedIoTimeAvg")\r
 451     @JsonPropertyDescription("measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the average within the collection interval")\r
 452     private Double diskWeightedIoTimeAvg;\r
 453     /**\r
 454      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the last within the collection interval\r
 455      * \r
 456      */\r
 457     @JsonProperty("diskWeightedIoTimeLast")\r
 458     @JsonPropertyDescription("measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the last within the collection interval")\r
 459     private Double diskWeightedIoTimeLast;\r
 460     /**\r
 461      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the maximum within the collection interval\r
 462      * \r
 463      */\r
 464     @JsonProperty("diskWeightedIoTimeMax")\r
 465     @JsonPropertyDescription("measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the maximum within the collection interval")\r
 466     private Double diskWeightedIoTimeMax;\r
 467     /**\r
 468      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the minimum within the collection interval\r
 469      * \r
 470      */\r
 471     @JsonProperty("diskWeightedIoTimeMin")\r
 472     @JsonPropertyDescription("measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the minimum within the collection interval")\r
 473     private Double diskWeightedIoTimeMin;\r
 474     /**\r
 475      * average number of write commands issued per second to the disk over the measurementInterval\r
 476      * \r
 477      */\r
 478     @JsonProperty("diskWriteCommandsAvg")\r
 479     @JsonPropertyDescription("average number of write commands issued per second to the disk over the measurementInterval")\r
 480     private Double diskWriteCommandsAvg;\r
 481 \r
 482     /**\r
 483      * number of bus resets over the measurementInterval\r
 484      * \r
 485      */\r
 486     @JsonProperty("diskBusResets")\r
 487     public Double getDiskBusResets() {\r
 488         return diskBusResets;\r
 489     }\r
 490 \r
 491     /**\r
 492      * number of bus resets over the measurementInterval\r
 493      * \r
 494      */\r
 495     @JsonProperty("diskBusResets")\r
 496     public void setDiskBusResets(Double diskBusResets) {\r
 497         this.diskBusResets = diskBusResets;\r
 498     }\r
 499 \r
 500     /**\r
 501      * number of disk commands aborted over the measurementInterval\r
 502      * \r
 503      */\r
 504     @JsonProperty("diskCommandsAborted")\r
 505     public Double getDiskCommandsAborted() {\r
 506         return diskCommandsAborted;\r
 507     }\r
 508 \r
 509     /**\r
 510      * number of disk commands aborted over the measurementInterval\r
 511      * \r
 512      */\r
 513     @JsonProperty("diskCommandsAborted")\r
 514     public void setDiskCommandsAborted(Double diskCommandsAborted) {\r
 515         this.diskCommandsAborted = diskCommandsAborted;\r
 516     }\r
 517 \r
 518     /**\r
 519      * average number of commands per second over the measurementInterval\r
 520      * \r
 521      */\r
 522     @JsonProperty("diskCommandsAvg")\r
 523     public Double getDiskCommandsAvg() {\r
 524         return diskCommandsAvg;\r
 525     }\r
 526 \r
 527     /**\r
 528      * average number of commands per second over the measurementInterval\r
 529      * \r
 530      */\r
 531     @JsonProperty("diskCommandsAvg")\r
 532     public void setDiskCommandsAvg(Double diskCommandsAvg) {\r
 533         this.diskCommandsAvg = diskCommandsAvg;\r
 534     }\r
 535 \r
 536     /**\r
 537      * total flush requests of the disk cache over the measurementInterval\r
 538      * \r
 539      */\r
 540     @JsonProperty("diskFlushRequests")\r
 541     public Double getDiskFlushRequests() {\r
 542         return diskFlushRequests;\r
 543     }\r
 544 \r
 545     /**\r
 546      * total flush requests of the disk cache over the measurementInterval\r
 547      * \r
 548      */\r
 549     @JsonProperty("diskFlushRequests")\r
 550     public void setDiskFlushRequests(Double diskFlushRequests) {\r
 551         this.diskFlushRequests = diskFlushRequests;\r
 552     }\r
 553 \r
 554     /**\r
 555      * milliseconds spent on disk cache flushing over the measurementInterval\r
 556      * \r
 557      */\r
 558     @JsonProperty("diskFlushTime")\r
 559     public Double getDiskFlushTime() {\r
 560         return diskFlushTime;\r
 561     }\r
 562 \r
 563     /**\r
 564      * milliseconds spent on disk cache flushing over the measurementInterval\r
 565      * \r
 566      */\r
 567     @JsonProperty("diskFlushTime")\r
 568     public void setDiskFlushTime(Double diskFlushTime) {\r
 569         this.diskFlushTime = diskFlushTime;\r
 570     }\r
 571 \r
 572     /**\r
 573      * disk identifier\r
 574      * (Required)\r
 575      * \r
 576      */\r
 577     @JsonProperty("diskIdentifier")\r
 578     public String getDiskIdentifier() {\r
 579         return diskIdentifier;\r
 580     }\r
 581 \r
 582     /**\r
 583      * disk identifier\r
 584      * (Required)\r
 585      * \r
 586      */\r
 587     @JsonProperty("diskIdentifier")\r
 588     public void setDiskIdentifier(String diskIdentifier) {\r
 589         this.diskIdentifier = diskIdentifier;\r
 590     }\r
 591 \r
 592     /**\r
 593      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the average over the measurement interval\r
 594      * \r
 595      */\r
 596     @JsonProperty("diskIoTimeAvg")\r
 597     public Double getDiskIoTimeAvg() {\r
 598         return diskIoTimeAvg;\r
 599     }\r
 600 \r
 601     /**\r
 602      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the average over the measurement interval\r
 603      * \r
 604      */\r
 605     @JsonProperty("diskIoTimeAvg")\r
 606     public void setDiskIoTimeAvg(Double diskIoTimeAvg) {\r
 607         this.diskIoTimeAvg = diskIoTimeAvg;\r
 608     }\r
 609 \r
 610     /**\r
 611      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the last value measurement within the measurement interval\r
 612      * \r
 613      */\r
 614     @JsonProperty("diskIoTimeLast")\r
 615     public Double getDiskIoTimeLast() {\r
 616         return diskIoTimeLast;\r
 617     }\r
 618 \r
 619     /**\r
 620      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the last value measurement within the measurement interval\r
 621      * \r
 622      */\r
 623     @JsonProperty("diskIoTimeLast")\r
 624     public void setDiskIoTimeLast(Double diskIoTimeLast) {\r
 625         this.diskIoTimeLast = diskIoTimeLast;\r
 626     }\r
 627 \r
 628     /**\r
 629      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the maximum value measurement within the measurement interval\r
 630      * \r
 631      */\r
 632     @JsonProperty("diskIoTimeMax")\r
 633     public Double getDiskIoTimeMax() {\r
 634         return diskIoTimeMax;\r
 635     }\r
 636 \r
 637     /**\r
 638      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the maximum value measurement within the measurement interval\r
 639      * \r
 640      */\r
 641     @JsonProperty("diskIoTimeMax")\r
 642     public void setDiskIoTimeMax(Double diskIoTimeMax) {\r
 643         this.diskIoTimeMax = diskIoTimeMax;\r
 644     }\r
 645 \r
 646     /**\r
 647      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the minimum value measurement within the measurement interval\r
 648      * \r
 649      */\r
 650     @JsonProperty("diskIoTimeMin")\r
 651     public Double getDiskIoTimeMin() {\r
 652         return diskIoTimeMin;\r
 653     }\r
 654 \r
 655     /**\r
 656      * milliseconds spent doing input/output operations over 1 sec; treat this metric as a device load percentage where 1000ms  matches 100% load; provide the minimum value measurement within the measurement interval\r
 657      * \r
 658      */\r
 659     @JsonProperty("diskIoTimeMin")\r
 660     public void setDiskIoTimeMin(Double diskIoTimeMin) {\r
 661         this.diskIoTimeMin = diskIoTimeMin;\r
 662     }\r
 663 \r
 664     /**\r
 665      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the average measurement within the measurement interval\r
 666      * \r
 667      */\r
 668     @JsonProperty("diskMergedReadAvg")\r
 669     public Double getDiskMergedReadAvg() {\r
 670         return diskMergedReadAvg;\r
 671     }\r
 672 \r
 673     /**\r
 674      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the average measurement within the measurement interval\r
 675      * \r
 676      */\r
 677     @JsonProperty("diskMergedReadAvg")\r
 678     public void setDiskMergedReadAvg(Double diskMergedReadAvg) {\r
 679         this.diskMergedReadAvg = diskMergedReadAvg;\r
 680     }\r
 681 \r
 682     /**\r
 683      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the last value measurement within the measurement interval\r
 684      * \r
 685      */\r
 686     @JsonProperty("diskMergedReadLast")\r
 687     public Double getDiskMergedReadLast() {\r
 688         return diskMergedReadLast;\r
 689     }\r
 690 \r
 691     /**\r
 692      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the last value measurement within the measurement interval\r
 693      * \r
 694      */\r
 695     @JsonProperty("diskMergedReadLast")\r
 696     public void setDiskMergedReadLast(Double diskMergedReadLast) {\r
 697         this.diskMergedReadLast = diskMergedReadLast;\r
 698     }\r
 699 \r
 700     /**\r
 701      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 702      * \r
 703      */\r
 704     @JsonProperty("diskMergedReadMax")\r
 705     public Double getDiskMergedReadMax() {\r
 706         return diskMergedReadMax;\r
 707     }\r
 708 \r
 709     /**\r
 710      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 711      * \r
 712      */\r
 713     @JsonProperty("diskMergedReadMax")\r
 714     public void setDiskMergedReadMax(Double diskMergedReadMax) {\r
 715         this.diskMergedReadMax = diskMergedReadMax;\r
 716     }\r
 717 \r
 718     /**\r
 719      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 720      * \r
 721      */\r
 722     @JsonProperty("diskMergedReadMin")\r
 723     public Double getDiskMergedReadMin() {\r
 724         return diskMergedReadMin;\r
 725     }\r
 726 \r
 727     /**\r
 728      * number of logical read operations that were merged into physical read operations, e.g., two logical reads were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 729      * \r
 730      */\r
 731     @JsonProperty("diskMergedReadMin")\r
 732     public void setDiskMergedReadMin(Double diskMergedReadMin) {\r
 733         this.diskMergedReadMin = diskMergedReadMin;\r
 734     }\r
 735 \r
 736     /**\r
 737      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the average measurement within the measurement interval\r
 738      * \r
 739      */\r
 740     @JsonProperty("diskMergedWriteAvg")\r
 741     public Double getDiskMergedWriteAvg() {\r
 742         return diskMergedWriteAvg;\r
 743     }\r
 744 \r
 745     /**\r
 746      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the average measurement within the measurement interval\r
 747      * \r
 748      */\r
 749     @JsonProperty("diskMergedWriteAvg")\r
 750     public void setDiskMergedWriteAvg(Double diskMergedWriteAvg) {\r
 751         this.diskMergedWriteAvg = diskMergedWriteAvg;\r
 752     }\r
 753 \r
 754     /**\r
 755      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the last value measurement within the measurement interval\r
 756      * \r
 757      */\r
 758     @JsonProperty("diskMergedWriteLast")\r
 759     public Double getDiskMergedWriteLast() {\r
 760         return diskMergedWriteLast;\r
 761     }\r
 762 \r
 763     /**\r
 764      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the last value measurement within the measurement interval\r
 765      * \r
 766      */\r
 767     @JsonProperty("diskMergedWriteLast")\r
 768     public void setDiskMergedWriteLast(Double diskMergedWriteLast) {\r
 769         this.diskMergedWriteLast = diskMergedWriteLast;\r
 770     }\r
 771 \r
 772     /**\r
 773      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 774      * \r
 775      */\r
 776     @JsonProperty("diskMergedWriteMax")\r
 777     public Double getDiskMergedWriteMax() {\r
 778         return diskMergedWriteMax;\r
 779     }\r
 780 \r
 781     /**\r
 782      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the maximum value measurement within the measurement interval\r
 783      * \r
 784      */\r
 785     @JsonProperty("diskMergedWriteMax")\r
 786     public void setDiskMergedWriteMax(Double diskMergedWriteMax) {\r
 787         this.diskMergedWriteMax = diskMergedWriteMax;\r
 788     }\r
 789 \r
 790     /**\r
 791      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 792      * \r
 793      */\r
 794     @JsonProperty("diskMergedWriteMin")\r
 795     public Double getDiskMergedWriteMin() {\r
 796         return diskMergedWriteMin;\r
 797     }\r
 798 \r
 799     /**\r
 800      * number of logical write operations that were merged into physical write operations, e.g., two logical writes were served by one physical disk access; provide the minimum value measurement within the measurement interval\r
 801      * \r
 802      */\r
 803     @JsonProperty("diskMergedWriteMin")\r
 804     public void setDiskMergedWriteMin(Double diskMergedWriteMin) {\r
 805         this.diskMergedWriteMin = diskMergedWriteMin;\r
 806     }\r
 807 \r
 808     /**\r
 809      * number of octets per second read from a disk or partition; provide the average measurement within the measurement interval\r
 810      * \r
 811      */\r
 812     @JsonProperty("diskOctetsReadAvg")\r
 813     public Double getDiskOctetsReadAvg() {\r
 814         return diskOctetsReadAvg;\r
 815     }\r
 816 \r
 817     /**\r
 818      * number of octets per second read from a disk or partition; provide the average measurement within the measurement interval\r
 819      * \r
 820      */\r
 821     @JsonProperty("diskOctetsReadAvg")\r
 822     public void setDiskOctetsReadAvg(Double diskOctetsReadAvg) {\r
 823         this.diskOctetsReadAvg = diskOctetsReadAvg;\r
 824     }\r
 825 \r
 826     /**\r
 827      * number of octets per second read from a disk or partition; provide the last measurement within the measurement interval\r
 828      * \r
 829      */\r
 830     @JsonProperty("diskOctetsReadLast")\r
 831     public Double getDiskOctetsReadLast() {\r
 832         return diskOctetsReadLast;\r
 833     }\r
 834 \r
 835     /**\r
 836      * number of octets per second read from a disk or partition; provide the last measurement within the measurement interval\r
 837      * \r
 838      */\r
 839     @JsonProperty("diskOctetsReadLast")\r
 840     public void setDiskOctetsReadLast(Double diskOctetsReadLast) {\r
 841         this.diskOctetsReadLast = diskOctetsReadLast;\r
 842     }\r
 843 \r
 844     /**\r
 845      * number of octets per second read from a disk or partition; provide the maximum measurement within the measurement interval\r
 846      * \r
 847      */\r
 848     @JsonProperty("diskOctetsReadMax")\r
 849     public Double getDiskOctetsReadMax() {\r
 850         return diskOctetsReadMax;\r
 851     }\r
 852 \r
 853     /**\r
 854      * number of octets per second read from a disk or partition; provide the maximum measurement within the measurement interval\r
 855      * \r
 856      */\r
 857     @JsonProperty("diskOctetsReadMax")\r
 858     public void setDiskOctetsReadMax(Double diskOctetsReadMax) {\r
 859         this.diskOctetsReadMax = diskOctetsReadMax;\r
 860     }\r
 861 \r
 862     /**\r
 863      * number of octets per second read from a disk or partition; provide the minimum measurement within the measurement interval\r
 864      * \r
 865      */\r
 866     @JsonProperty("diskOctetsReadMin")\r
 867     public Double getDiskOctetsReadMin() {\r
 868         return diskOctetsReadMin;\r
 869     }\r
 870 \r
 871     /**\r
 872      * number of octets per second read from a disk or partition; provide the minimum measurement within the measurement interval\r
 873      * \r
 874      */\r
 875     @JsonProperty("diskOctetsReadMin")\r
 876     public void setDiskOctetsReadMin(Double diskOctetsReadMin) {\r
 877         this.diskOctetsReadMin = diskOctetsReadMin;\r
 878     }\r
 879 \r
 880     /**\r
 881      * number of octets per second written to a disk or partition; provide the average measurement within the measurement interval\r
 882      * \r
 883      */\r
 884     @JsonProperty("diskOctetsWriteAvg")\r
 885     public Double getDiskOctetsWriteAvg() {\r
 886         return diskOctetsWriteAvg;\r
 887     }\r
 888 \r
 889     /**\r
 890      * number of octets per second written to a disk or partition; provide the average measurement within the measurement interval\r
 891      * \r
 892      */\r
 893     @JsonProperty("diskOctetsWriteAvg")\r
 894     public void setDiskOctetsWriteAvg(Double diskOctetsWriteAvg) {\r
 895         this.diskOctetsWriteAvg = diskOctetsWriteAvg;\r
 896     }\r
 897 \r
 898     /**\r
 899      * number of octets per second written to a disk or partition; provide the last measurement within the measurement interval\r
 900      * \r
 901      */\r
 902     @JsonProperty("diskOctetsWriteLast")\r
 903     public Double getDiskOctetsWriteLast() {\r
 904         return diskOctetsWriteLast;\r
 905     }\r
 906 \r
 907     /**\r
 908      * number of octets per second written to a disk or partition; provide the last measurement within the measurement interval\r
 909      * \r
 910      */\r
 911     @JsonProperty("diskOctetsWriteLast")\r
 912     public void setDiskOctetsWriteLast(Double diskOctetsWriteLast) {\r
 913         this.diskOctetsWriteLast = diskOctetsWriteLast;\r
 914     }\r
 915 \r
 916     /**\r
 917      * number of octets per second written to a disk or partition; provide the maximum measurement within the measurement interval\r
 918      * \r
 919      */\r
 920     @JsonProperty("diskOctetsWriteMax")\r
 921     public Double getDiskOctetsWriteMax() {\r
 922         return diskOctetsWriteMax;\r
 923     }\r
 924 \r
 925     /**\r
 926      * number of octets per second written to a disk or partition; provide the maximum measurement within the measurement interval\r
 927      * \r
 928      */\r
 929     @JsonProperty("diskOctetsWriteMax")\r
 930     public void setDiskOctetsWriteMax(Double diskOctetsWriteMax) {\r
 931         this.diskOctetsWriteMax = diskOctetsWriteMax;\r
 932     }\r
 933 \r
 934     /**\r
 935      * number of octets per second written to a disk or partition; provide the minimum measurement within the measurement interval\r
 936      * \r
 937      */\r
 938     @JsonProperty("diskOctetsWriteMin")\r
 939     public Double getDiskOctetsWriteMin() {\r
 940         return diskOctetsWriteMin;\r
 941     }\r
 942 \r
 943     /**\r
 944      * number of octets per second written to a disk or partition; provide the minimum measurement within the measurement interval\r
 945      * \r
 946      */\r
 947     @JsonProperty("diskOctetsWriteMin")\r
 948     public void setDiskOctetsWriteMin(Double diskOctetsWriteMin) {\r
 949         this.diskOctetsWriteMin = diskOctetsWriteMin;\r
 950     }\r
 951 \r
 952     /**\r
 953      * number of read operations per second issued to the disk; provide the average measurement within the measurement interval\r
 954      * \r
 955      */\r
 956     @JsonProperty("diskOpsReadAvg")\r
 957     public Double getDiskOpsReadAvg() {\r
 958         return diskOpsReadAvg;\r
 959     }\r
 960 \r
 961     /**\r
 962      * number of read operations per second issued to the disk; provide the average measurement within the measurement interval\r
 963      * \r
 964      */\r
 965     @JsonProperty("diskOpsReadAvg")\r
 966     public void setDiskOpsReadAvg(Double diskOpsReadAvg) {\r
 967         this.diskOpsReadAvg = diskOpsReadAvg;\r
 968     }\r
 969 \r
 970     /**\r
 971      * number of read operations per second issued to the disk; provide the last measurement within the measurement interval\r
 972      * \r
 973      */\r
 974     @JsonProperty("diskOpsReadLast")\r
 975     public Double getDiskOpsReadLast() {\r
 976         return diskOpsReadLast;\r
 977     }\r
 978 \r
 979     /**\r
 980      * number of read operations per second issued to the disk; provide the last measurement within the measurement interval\r
 981      * \r
 982      */\r
 983     @JsonProperty("diskOpsReadLast")\r
 984     public void setDiskOpsReadLast(Double diskOpsReadLast) {\r
 985         this.diskOpsReadLast = diskOpsReadLast;\r
 986     }\r
 987 \r
 988     /**\r
 989      * number of read operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
 990      * \r
 991      */\r
 992     @JsonProperty("diskOpsReadMax")\r
 993     public Double getDiskOpsReadMax() {\r
 994         return diskOpsReadMax;\r
 995     }\r
 996 \r
 997     /**\r
 998      * number of read operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
 999      * \r
1000      */\r
1001     @JsonProperty("diskOpsReadMax")\r
1002     public void setDiskOpsReadMax(Double diskOpsReadMax) {\r
1003         this.diskOpsReadMax = diskOpsReadMax;\r
1004     }\r
1005 \r
1006     /**\r
1007      * number of read operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
1008      * \r
1009      */\r
1010     @JsonProperty("diskOpsReadMin")\r
1011     public Double getDiskOpsReadMin() {\r
1012         return diskOpsReadMin;\r
1013     }\r
1014 \r
1015     /**\r
1016      * number of read operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
1017      * \r
1018      */\r
1019     @JsonProperty("diskOpsReadMin")\r
1020     public void setDiskOpsReadMin(Double diskOpsReadMin) {\r
1021         this.diskOpsReadMin = diskOpsReadMin;\r
1022     }\r
1023 \r
1024     /**\r
1025      * number of write operations per second issued to the disk; provide the average measurement within the measurement interval\r
1026      * \r
1027      */\r
1028     @JsonProperty("diskOpsWriteAvg")\r
1029     public Double getDiskOpsWriteAvg() {\r
1030         return diskOpsWriteAvg;\r
1031     }\r
1032 \r
1033     /**\r
1034      * number of write operations per second issued to the disk; provide the average measurement within the measurement interval\r
1035      * \r
1036      */\r
1037     @JsonProperty("diskOpsWriteAvg")\r
1038     public void setDiskOpsWriteAvg(Double diskOpsWriteAvg) {\r
1039         this.diskOpsWriteAvg = diskOpsWriteAvg;\r
1040     }\r
1041 \r
1042     /**\r
1043      * number of write operations per second issued to the disk; provide the last measurement within the measurement interval\r
1044      * \r
1045      */\r
1046     @JsonProperty("diskOpsWriteLast")\r
1047     public Double getDiskOpsWriteLast() {\r
1048         return diskOpsWriteLast;\r
1049     }\r
1050 \r
1051     /**\r
1052      * number of write operations per second issued to the disk; provide the last measurement within the measurement interval\r
1053      * \r
1054      */\r
1055     @JsonProperty("diskOpsWriteLast")\r
1056     public void setDiskOpsWriteLast(Double diskOpsWriteLast) {\r
1057         this.diskOpsWriteLast = diskOpsWriteLast;\r
1058     }\r
1059 \r
1060     /**\r
1061      * number of write operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
1062      * \r
1063      */\r
1064     @JsonProperty("diskOpsWriteMax")\r
1065     public Double getDiskOpsWriteMax() {\r
1066         return diskOpsWriteMax;\r
1067     }\r
1068 \r
1069     /**\r
1070      * number of write operations per second issued to the disk; provide the maximum measurement within the measurement interval\r
1071      * \r
1072      */\r
1073     @JsonProperty("diskOpsWriteMax")\r
1074     public void setDiskOpsWriteMax(Double diskOpsWriteMax) {\r
1075         this.diskOpsWriteMax = diskOpsWriteMax;\r
1076     }\r
1077 \r
1078     /**\r
1079      * number of write operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
1080      * \r
1081      */\r
1082     @JsonProperty("diskOpsWriteMin")\r
1083     public Double getDiskOpsWriteMin() {\r
1084         return diskOpsWriteMin;\r
1085     }\r
1086 \r
1087     /**\r
1088      * number of write operations per second issued to the disk; provide the minimum measurement within the measurement interval\r
1089      * \r
1090      */\r
1091     @JsonProperty("diskOpsWriteMin")\r
1092     public void setDiskOpsWriteMin(Double diskOpsWriteMin) {\r
1093         this.diskOpsWriteMin = diskOpsWriteMin;\r
1094     }\r
1095 \r
1096     /**\r
1097      * queue size of pending I/O operations per second; provide the average measurement within the measurement interval\r
1098      * \r
1099      */\r
1100     @JsonProperty("diskPendingOperationsAvg")\r
1101     public Double getDiskPendingOperationsAvg() {\r
1102         return diskPendingOperationsAvg;\r
1103     }\r
1104 \r
1105     /**\r
1106      * queue size of pending I/O operations per second; provide the average measurement within the measurement interval\r
1107      * \r
1108      */\r
1109     @JsonProperty("diskPendingOperationsAvg")\r
1110     public void setDiskPendingOperationsAvg(Double diskPendingOperationsAvg) {\r
1111         this.diskPendingOperationsAvg = diskPendingOperationsAvg;\r
1112     }\r
1113 \r
1114     /**\r
1115      * queue size of pending I/O operations per second; provide the last measurement within the measurement interval\r
1116      * \r
1117      */\r
1118     @JsonProperty("diskPendingOperationsLast")\r
1119     public Double getDiskPendingOperationsLast() {\r
1120         return diskPendingOperationsLast;\r
1121     }\r
1122 \r
1123     /**\r
1124      * queue size of pending I/O operations per second; provide the last measurement within the measurement interval\r
1125      * \r
1126      */\r
1127     @JsonProperty("diskPendingOperationsLast")\r
1128     public void setDiskPendingOperationsLast(Double diskPendingOperationsLast) {\r
1129         this.diskPendingOperationsLast = diskPendingOperationsLast;\r
1130     }\r
1131 \r
1132     /**\r
1133      * queue size of pending I/O operations per second; provide the maximum measurement within the measurement interval\r
1134      * \r
1135      */\r
1136     @JsonProperty("diskPendingOperationsMax")\r
1137     public Double getDiskPendingOperationsMax() {\r
1138         return diskPendingOperationsMax;\r
1139     }\r
1140 \r
1141     /**\r
1142      * queue size of pending I/O operations per second; provide the maximum measurement within the measurement interval\r
1143      * \r
1144      */\r
1145     @JsonProperty("diskPendingOperationsMax")\r
1146     public void setDiskPendingOperationsMax(Double diskPendingOperationsMax) {\r
1147         this.diskPendingOperationsMax = diskPendingOperationsMax;\r
1148     }\r
1149 \r
1150     /**\r
1151      * queue size of pending I/O operations per second; provide the minimum measurement within the measurement interval\r
1152      * \r
1153      */\r
1154     @JsonProperty("diskPendingOperationsMin")\r
1155     public Double getDiskPendingOperationsMin() {\r
1156         return diskPendingOperationsMin;\r
1157     }\r
1158 \r
1159     /**\r
1160      * queue size of pending I/O operations per second; provide the minimum measurement within the measurement interval\r
1161      * \r
1162      */\r
1163     @JsonProperty("diskPendingOperationsMin")\r
1164     public void setDiskPendingOperationsMin(Double diskPendingOperationsMin) {\r
1165         this.diskPendingOperationsMin = diskPendingOperationsMin;\r
1166     }\r
1167 \r
1168     /**\r
1169      * average number of read commands issued per second to the disk over the measurementInterval\r
1170      * \r
1171      */\r
1172     @JsonProperty("diskReadCommandsAvg")\r
1173     public Double getDiskReadCommandsAvg() {\r
1174         return diskReadCommandsAvg;\r
1175     }\r
1176 \r
1177     /**\r
1178      * average number of read commands issued per second to the disk over the measurementInterval\r
1179      * \r
1180      */\r
1181     @JsonProperty("diskReadCommandsAvg")\r
1182     public void setDiskReadCommandsAvg(Double diskReadCommandsAvg) {\r
1183         this.diskReadCommandsAvg = diskReadCommandsAvg;\r
1184     }\r
1185 \r
1186     /**\r
1187      * nanoseconds spent on disk cache reads/writes within the measurement interval\r
1188      * \r
1189      */\r
1190     @JsonProperty("diskTime")\r
1191     public Double getDiskTime() {\r
1192         return diskTime;\r
1193     }\r
1194 \r
1195     /**\r
1196      * nanoseconds spent on disk cache reads/writes within the measurement interval\r
1197      * \r
1198      */\r
1199     @JsonProperty("diskTime")\r
1200     public void setDiskTime(Double diskTime) {\r
1201         this.diskTime = diskTime;\r
1202     }\r
1203 \r
1204     /**\r
1205      * milliseconds a read operation took to complete; provide the average measurement within the measurement interval\r
1206      * \r
1207      */\r
1208     @JsonProperty("diskTimeReadAvg")\r
1209     public Double getDiskTimeReadAvg() {\r
1210         return diskTimeReadAvg;\r
1211     }\r
1212 \r
1213     /**\r
1214      * milliseconds a read operation took to complete; provide the average measurement within the measurement interval\r
1215      * \r
1216      */\r
1217     @JsonProperty("diskTimeReadAvg")\r
1218     public void setDiskTimeReadAvg(Double diskTimeReadAvg) {\r
1219         this.diskTimeReadAvg = diskTimeReadAvg;\r
1220     }\r
1221 \r
1222     /**\r
1223      * milliseconds a read operation took to complete; provide the last measurement within the measurement interval\r
1224      * \r
1225      */\r
1226     @JsonProperty("diskTimeReadLast")\r
1227     public Double getDiskTimeReadLast() {\r
1228         return diskTimeReadLast;\r
1229     }\r
1230 \r
1231     /**\r
1232      * milliseconds a read operation took to complete; provide the last measurement within the measurement interval\r
1233      * \r
1234      */\r
1235     @JsonProperty("diskTimeReadLast")\r
1236     public void setDiskTimeReadLast(Double diskTimeReadLast) {\r
1237         this.diskTimeReadLast = diskTimeReadLast;\r
1238     }\r
1239 \r
1240     /**\r
1241      * milliseconds a read operation took to complete; provide the maximum measurement within the measurement interval\r
1242      * \r
1243      */\r
1244     @JsonProperty("diskTimeReadMax")\r
1245     public Double getDiskTimeReadMax() {\r
1246         return diskTimeReadMax;\r
1247     }\r
1248 \r
1249     /**\r
1250      * milliseconds a read operation took to complete; provide the maximum measurement within the measurement interval\r
1251      * \r
1252      */\r
1253     @JsonProperty("diskTimeReadMax")\r
1254     public void setDiskTimeReadMax(Double diskTimeReadMax) {\r
1255         this.diskTimeReadMax = diskTimeReadMax;\r
1256     }\r
1257 \r
1258     /**\r
1259      * milliseconds a read operation took to complete; provide the minimum measurement within the measurement interval\r
1260      * \r
1261      */\r
1262     @JsonProperty("diskTimeReadMin")\r
1263     public Double getDiskTimeReadMin() {\r
1264         return diskTimeReadMin;\r
1265     }\r
1266 \r
1267     /**\r
1268      * milliseconds a read operation took to complete; provide the minimum measurement within the measurement interval\r
1269      * \r
1270      */\r
1271     @JsonProperty("diskTimeReadMin")\r
1272     public void setDiskTimeReadMin(Double diskTimeReadMin) {\r
1273         this.diskTimeReadMin = diskTimeReadMin;\r
1274     }\r
1275 \r
1276     /**\r
1277      * milliseconds a write operation took to complete; provide the average measurement within the measurement interval\r
1278      * \r
1279      */\r
1280     @JsonProperty("diskTimeWriteAvg")\r
1281     public Double getDiskTimeWriteAvg() {\r
1282         return diskTimeWriteAvg;\r
1283     }\r
1284 \r
1285     /**\r
1286      * milliseconds a write operation took to complete; provide the average measurement within the measurement interval\r
1287      * \r
1288      */\r
1289     @JsonProperty("diskTimeWriteAvg")\r
1290     public void setDiskTimeWriteAvg(Double diskTimeWriteAvg) {\r
1291         this.diskTimeWriteAvg = diskTimeWriteAvg;\r
1292     }\r
1293 \r
1294     /**\r
1295      * milliseconds a write operation took to complete; provide the last measurement within the measurement interval\r
1296      * \r
1297      */\r
1298     @JsonProperty("diskTimeWriteLast")\r
1299     public Double getDiskTimeWriteLast() {\r
1300         return diskTimeWriteLast;\r
1301     }\r
1302 \r
1303     /**\r
1304      * milliseconds a write operation took to complete; provide the last measurement within the measurement interval\r
1305      * \r
1306      */\r
1307     @JsonProperty("diskTimeWriteLast")\r
1308     public void setDiskTimeWriteLast(Double diskTimeWriteLast) {\r
1309         this.diskTimeWriteLast = diskTimeWriteLast;\r
1310     }\r
1311 \r
1312     /**\r
1313      * milliseconds a write operation took to complete; provide the maximum measurement within the measurement interval\r
1314      * \r
1315      */\r
1316     @JsonProperty("diskTimeWriteMax")\r
1317     public Double getDiskTimeWriteMax() {\r
1318         return diskTimeWriteMax;\r
1319     }\r
1320 \r
1321     /**\r
1322      * milliseconds a write operation took to complete; provide the maximum measurement within the measurement interval\r
1323      * \r
1324      */\r
1325     @JsonProperty("diskTimeWriteMax")\r
1326     public void setDiskTimeWriteMax(Double diskTimeWriteMax) {\r
1327         this.diskTimeWriteMax = diskTimeWriteMax;\r
1328     }\r
1329 \r
1330     /**\r
1331      * milliseconds a write operation took to complete; provide the minimum measurement within the measurement interval\r
1332      * \r
1333      */\r
1334     @JsonProperty("diskTimeWriteMin")\r
1335     public Double getDiskTimeWriteMin() {\r
1336         return diskTimeWriteMin;\r
1337     }\r
1338 \r
1339     /**\r
1340      * milliseconds a write operation took to complete; provide the minimum measurement within the measurement interval\r
1341      * \r
1342      */\r
1343     @JsonProperty("diskTimeWriteMin")\r
1344     public void setDiskTimeWriteMin(Double diskTimeWriteMin) {\r
1345         this.diskTimeWriteMin = diskTimeWriteMin;\r
1346     }\r
1347 \r
1348     /**\r
1349      * average read time from the perspective of a Guest OS: sum of the Kernel Read Latency and Physical Device Read Latency in milliseconds over the measurement interval\r
1350      * \r
1351      */\r
1352     @JsonProperty("diskTotalReadLatencyAvg")\r
1353     public Double getDiskTotalReadLatencyAvg() {\r
1354         return diskTotalReadLatencyAvg;\r
1355     }\r
1356 \r
1357     /**\r
1358      * average read time from the perspective of a Guest OS: sum of the Kernel Read Latency and Physical Device Read Latency in milliseconds over the measurement interval\r
1359      * \r
1360      */\r
1361     @JsonProperty("diskTotalReadLatencyAvg")\r
1362     public void setDiskTotalReadLatencyAvg(Double diskTotalReadLatencyAvg) {\r
1363         this.diskTotalReadLatencyAvg = diskTotalReadLatencyAvg;\r
1364     }\r
1365 \r
1366     /**\r
1367      * average write time from the perspective of a Guest OS: sum of the Kernel Write Latency and Physical Device Write Latency in milliseconds over the measurement interval\r
1368      * \r
1369      */\r
1370     @JsonProperty("diskTotalWriteLatencyAvg")\r
1371     public Double getDiskTotalWriteLatencyAvg() {\r
1372         return diskTotalWriteLatencyAvg;\r
1373     }\r
1374 \r
1375     /**\r
1376      * average write time from the perspective of a Guest OS: sum of the Kernel Write Latency and Physical Device Write Latency in milliseconds over the measurement interval\r
1377      * \r
1378      */\r
1379     @JsonProperty("diskTotalWriteLatencyAvg")\r
1380     public void setDiskTotalWriteLatencyAvg(Double diskTotalWriteLatencyAvg) {\r
1381         this.diskTotalWriteLatencyAvg = diskTotalWriteLatencyAvg;\r
1382     }\r
1383 \r
1384     /**\r
1385      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the average within the collection interval\r
1386      * \r
1387      */\r
1388     @JsonProperty("diskWeightedIoTimeAvg")\r
1389     public Double getDiskWeightedIoTimeAvg() {\r
1390         return diskWeightedIoTimeAvg;\r
1391     }\r
1392 \r
1393     /**\r
1394      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the average within the collection interval\r
1395      * \r
1396      */\r
1397     @JsonProperty("diskWeightedIoTimeAvg")\r
1398     public void setDiskWeightedIoTimeAvg(Double diskWeightedIoTimeAvg) {\r
1399         this.diskWeightedIoTimeAvg = diskWeightedIoTimeAvg;\r
1400     }\r
1401 \r
1402     /**\r
1403      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the last within the collection interval\r
1404      * \r
1405      */\r
1406     @JsonProperty("diskWeightedIoTimeLast")\r
1407     public Double getDiskWeightedIoTimeLast() {\r
1408         return diskWeightedIoTimeLast;\r
1409     }\r
1410 \r
1411     /**\r
1412      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the last within the collection interval\r
1413      * \r
1414      */\r
1415     @JsonProperty("diskWeightedIoTimeLast")\r
1416     public void setDiskWeightedIoTimeLast(Double diskWeightedIoTimeLast) {\r
1417         this.diskWeightedIoTimeLast = diskWeightedIoTimeLast;\r
1418     }\r
1419 \r
1420     /**\r
1421      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the maximum within the collection interval\r
1422      * \r
1423      */\r
1424     @JsonProperty("diskWeightedIoTimeMax")\r
1425     public Double getDiskWeightedIoTimeMax() {\r
1426         return diskWeightedIoTimeMax;\r
1427     }\r
1428 \r
1429     /**\r
1430      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the maximum within the collection interval\r
1431      * \r
1432      */\r
1433     @JsonProperty("diskWeightedIoTimeMax")\r
1434     public void setDiskWeightedIoTimeMax(Double diskWeightedIoTimeMax) {\r
1435         this.diskWeightedIoTimeMax = diskWeightedIoTimeMax;\r
1436     }\r
1437 \r
1438     /**\r
1439      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the minimum within the collection interval\r
1440      * \r
1441      */\r
1442     @JsonProperty("diskWeightedIoTimeMin")\r
1443     public Double getDiskWeightedIoTimeMin() {\r
1444         return diskWeightedIoTimeMin;\r
1445     }\r
1446 \r
1447     /**\r
1448      * measure in ms over 1 sec of both I/O completion time and the backlog that may be accumulating; value is the minimum within the collection interval\r
1449      * \r
1450      */\r
1451     @JsonProperty("diskWeightedIoTimeMin")\r
1452     public void setDiskWeightedIoTimeMin(Double diskWeightedIoTimeMin) {\r
1453         this.diskWeightedIoTimeMin = diskWeightedIoTimeMin;\r
1454     }\r
1455 \r
1456     /**\r
1457      * average number of write commands issued per second to the disk over the measurementInterval\r
1458      * \r
1459      */\r
1460     @JsonProperty("diskWriteCommandsAvg")\r
1461     public Double getDiskWriteCommandsAvg() {\r
1462         return diskWriteCommandsAvg;\r
1463     }\r
1464 \r
1465     /**\r
1466      * average number of write commands issued per second to the disk over the measurementInterval\r
1467      * \r
1468      */\r
1469     @JsonProperty("diskWriteCommandsAvg")\r
1470     public void setDiskWriteCommandsAvg(Double diskWriteCommandsAvg) {\r
1471         this.diskWriteCommandsAvg = diskWriteCommandsAvg;\r
1472     }\r
1473 \r
1474     @Override\r
1475     public String toString() {\r
1476         return ToStringBuilder.reflectionToString(this);\r
1477     }\r
1478 \r
1479     @Override\r
1480     public int hashCode() {\r
1481         return new HashCodeBuilder().append(diskBusResets).append(diskCommandsAborted).append(diskCommandsAvg).append(diskFlushRequests).append(diskFlushTime).append(diskIdentifier).append(diskIoTimeAvg).append(diskIoTimeLast).append(diskIoTimeMax).append(diskIoTimeMin).append(diskMergedReadAvg).append(diskMergedReadLast).append(diskMergedReadMax).append(diskMergedReadMin).append(diskMergedWriteAvg).append(diskMergedWriteLast).append(diskMergedWriteMax).append(diskMergedWriteMin).append(diskOctetsReadAvg).append(diskOctetsReadLast).append(diskOctetsReadMax).append(diskOctetsReadMin).append(diskOctetsWriteAvg).append(diskOctetsWriteLast).append(diskOctetsWriteMax).append(diskOctetsWriteMin).append(diskOpsReadAvg).append(diskOpsReadLast).append(diskOpsReadMax).append(diskOpsReadMin).append(diskOpsWriteAvg).append(diskOpsWriteLast).append(diskOpsWriteMax).append(diskOpsWriteMin).append(diskPendingOperationsAvg).append(diskPendingOperationsLast).append(diskPendingOperationsMax).append(diskPendingOperationsMin).append(diskReadCommandsAvg).append(diskTime).append(diskTimeReadAvg).append(diskTimeReadLast).append(diskTimeReadMax).append(diskTimeReadMin).append(diskTimeWriteAvg).append(diskTimeWriteLast).append(diskTimeWriteMax).append(diskTimeWriteMin).append(diskTotalReadLatencyAvg).append(diskTotalWriteLatencyAvg).append(diskWeightedIoTimeAvg).append(diskWeightedIoTimeLast).append(diskWeightedIoTimeMax).append(diskWeightedIoTimeMin).append(diskWriteCommandsAvg).toHashCode();\r
1482     }\r
1483 \r
1484     @Override\r
1485     public boolean equals(Object other) {\r
1486         if (other == this) {\r
1487             return true;\r
1488         }\r
1489         if ((other instanceof DiskUsageArray) == false) {\r
1490             return false;\r
1491         }\r
1492         DiskUsageArray rhs = ((DiskUsageArray) other);\r
1493         return new EqualsBuilder().append(diskBusResets, rhs.diskBusResets).append(diskCommandsAborted, rhs.diskCommandsAborted).append(diskCommandsAvg, rhs.diskCommandsAvg).append(diskFlushRequests, rhs.diskFlushRequests).append(diskFlushTime, rhs.diskFlushTime).append(diskIdentifier, rhs.diskIdentifier).append(diskIoTimeAvg, rhs.diskIoTimeAvg).append(diskIoTimeLast, rhs.diskIoTimeLast).append(diskIoTimeMax, rhs.diskIoTimeMax).append(diskIoTimeMin, rhs.diskIoTimeMin).append(diskMergedReadAvg, rhs.diskMergedReadAvg).append(diskMergedReadLast, rhs.diskMergedReadLast).append(diskMergedReadMax, rhs.diskMergedReadMax).append(diskMergedReadMin, rhs.diskMergedReadMin).append(diskMergedWriteAvg, rhs.diskMergedWriteAvg).append(diskMergedWriteLast, rhs.diskMergedWriteLast).append(diskMergedWriteMax, rhs.diskMergedWriteMax).append(diskMergedWriteMin, rhs.diskMergedWriteMin).append(diskOctetsReadAvg, rhs.diskOctetsReadAvg).append(diskOctetsReadLast, rhs.diskOctetsReadLast).append(diskOctetsReadMax, rhs.diskOctetsReadMax).append(diskOctetsReadMin, rhs.diskOctetsReadMin).append(diskOctetsWriteAvg, rhs.diskOctetsWriteAvg).append(diskOctetsWriteLast, rhs.diskOctetsWriteLast).append(diskOctetsWriteMax, rhs.diskOctetsWriteMax).append(diskOctetsWriteMin, rhs.diskOctetsWriteMin).append(diskOpsReadAvg, rhs.diskOpsReadAvg).append(diskOpsReadLast, rhs.diskOpsReadLast).append(diskOpsReadMax, rhs.diskOpsReadMax).append(diskOpsReadMin, rhs.diskOpsReadMin).append(diskOpsWriteAvg, rhs.diskOpsWriteAvg).append(diskOpsWriteLast, rhs.diskOpsWriteLast).append(diskOpsWriteMax, rhs.diskOpsWriteMax).append(diskOpsWriteMin, rhs.diskOpsWriteMin).append(diskPendingOperationsAvg, rhs.diskPendingOperationsAvg).append(diskPendingOperationsLast, rhs.diskPendingOperationsLast).append(diskPendingOperationsMax, rhs.diskPendingOperationsMax).append(diskPendingOperationsMin, rhs.diskPendingOperationsMin).append(diskReadCommandsAvg, rhs.diskReadCommandsAvg).append(diskTime, rhs.diskTime).append(diskTimeReadAvg, rhs.diskTimeReadAvg).append(diskTimeReadLast, rhs.diskTimeReadLast).append(diskTimeReadMax, rhs.diskTimeReadMax).append(diskTimeReadMin, rhs.diskTimeReadMin).append(diskTimeWriteAvg, rhs.diskTimeWriteAvg).append(diskTimeWriteLast, rhs.diskTimeWriteLast).append(diskTimeWriteMax, rhs.diskTimeWriteMax).append(diskTimeWriteMin, rhs.diskTimeWriteMin).append(diskTotalReadLatencyAvg, rhs.diskTotalReadLatencyAvg).append(diskTotalWriteLatencyAvg, rhs.diskTotalWriteLatencyAvg).append(diskWeightedIoTimeAvg, rhs.diskWeightedIoTimeAvg).append(diskWeightedIoTimeLast, rhs.diskWeightedIoTimeLast).append(diskWeightedIoTimeMax, rhs.diskWeightedIoTimeMax).append(diskWeightedIoTimeMin, rhs.diskWeightedIoTimeMin).append(diskWriteCommandsAvg, rhs.diskWriteCommandsAvg).isEquals();\r
1494     }\r
1495 \r
1496 }\r