#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
#[derive(PartialEq,Clone,Default)]
pub struct Metrics {
pub hugetlb: ::protobuf::RepeatedField<HugetlbStat>,
pub pids: ::protobuf::SingularPtrField<PidsStat>,
pub cpu: ::protobuf::SingularPtrField<CPUStat>,
pub memory: ::protobuf::SingularPtrField<MemoryStat>,
pub blkio: ::protobuf::SingularPtrField<BlkIOStat>,
pub rdma: ::protobuf::SingularPtrField<RdmaStat>,
pub network: ::protobuf::RepeatedField<NetworkStat>,
pub cgroup_stats: ::protobuf::SingularPtrField<CgroupStats>,
pub memory_oom_control: ::protobuf::SingularPtrField<MemoryOomControl>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Metrics {
fn default() -> &'a Metrics {
<Metrics as ::protobuf::Message>::default_instance()
}
}
impl Metrics {
pub fn new() -> Metrics {
::std::default::Default::default()
}
pub fn get_hugetlb(&self) -> &[HugetlbStat] {
&self.hugetlb
}
pub fn clear_hugetlb(&mut self) {
self.hugetlb.clear();
}
pub fn set_hugetlb(&mut self, v: ::protobuf::RepeatedField<HugetlbStat>) {
self.hugetlb = v;
}
pub fn mut_hugetlb(&mut self) -> &mut ::protobuf::RepeatedField<HugetlbStat> {
&mut self.hugetlb
}
pub fn take_hugetlb(&mut self) -> ::protobuf::RepeatedField<HugetlbStat> {
::std::mem::replace(&mut self.hugetlb, ::protobuf::RepeatedField::new())
}
pub fn get_pids(&self) -> &PidsStat {
self.pids.as_ref().unwrap_or_else(|| <PidsStat as ::protobuf::Message>::default_instance())
}
pub fn clear_pids(&mut self) {
self.pids.clear();
}
pub fn has_pids(&self) -> bool {
self.pids.is_some()
}
pub fn set_pids(&mut self, v: PidsStat) {
self.pids = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_pids(&mut self) -> &mut PidsStat {
if self.pids.is_none() {
self.pids.set_default();
}
self.pids.as_mut().unwrap()
}
pub fn take_pids(&mut self) -> PidsStat {
self.pids.take().unwrap_or_else(|| PidsStat::new())
}
pub fn get_cpu(&self) -> &CPUStat {
self.cpu.as_ref().unwrap_or_else(|| <CPUStat as ::protobuf::Message>::default_instance())
}
pub fn clear_cpu(&mut self) {
self.cpu.clear();
}
pub fn has_cpu(&self) -> bool {
self.cpu.is_some()
}
pub fn set_cpu(&mut self, v: CPUStat) {
self.cpu = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_cpu(&mut self) -> &mut CPUStat {
if self.cpu.is_none() {
self.cpu.set_default();
}
self.cpu.as_mut().unwrap()
}
pub fn take_cpu(&mut self) -> CPUStat {
self.cpu.take().unwrap_or_else(|| CPUStat::new())
}
pub fn get_memory(&self) -> &MemoryStat {
self.memory.as_ref().unwrap_or_else(|| <MemoryStat as ::protobuf::Message>::default_instance())
}
pub fn clear_memory(&mut self) {
self.memory.clear();
}
pub fn has_memory(&self) -> bool {
self.memory.is_some()
}
pub fn set_memory(&mut self, v: MemoryStat) {
self.memory = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_memory(&mut self) -> &mut MemoryStat {
if self.memory.is_none() {
self.memory.set_default();
}
self.memory.as_mut().unwrap()
}
pub fn take_memory(&mut self) -> MemoryStat {
self.memory.take().unwrap_or_else(|| MemoryStat::new())
}
pub fn get_blkio(&self) -> &BlkIOStat {
self.blkio.as_ref().unwrap_or_else(|| <BlkIOStat as ::protobuf::Message>::default_instance())
}
pub fn clear_blkio(&mut self) {
self.blkio.clear();
}
pub fn has_blkio(&self) -> bool {
self.blkio.is_some()
}
pub fn set_blkio(&mut self, v: BlkIOStat) {
self.blkio = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_blkio(&mut self) -> &mut BlkIOStat {
if self.blkio.is_none() {
self.blkio.set_default();
}
self.blkio.as_mut().unwrap()
}
pub fn take_blkio(&mut self) -> BlkIOStat {
self.blkio.take().unwrap_or_else(|| BlkIOStat::new())
}
pub fn get_rdma(&self) -> &RdmaStat {
self.rdma.as_ref().unwrap_or_else(|| <RdmaStat as ::protobuf::Message>::default_instance())
}
pub fn clear_rdma(&mut self) {
self.rdma.clear();
}
pub fn has_rdma(&self) -> bool {
self.rdma.is_some()
}
pub fn set_rdma(&mut self, v: RdmaStat) {
self.rdma = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_rdma(&mut self) -> &mut RdmaStat {
if self.rdma.is_none() {
self.rdma.set_default();
}
self.rdma.as_mut().unwrap()
}
pub fn take_rdma(&mut self) -> RdmaStat {
self.rdma.take().unwrap_or_else(|| RdmaStat::new())
}
pub fn get_network(&self) -> &[NetworkStat] {
&self.network
}
pub fn clear_network(&mut self) {
self.network.clear();
}
pub fn set_network(&mut self, v: ::protobuf::RepeatedField<NetworkStat>) {
self.network = v;
}
pub fn mut_network(&mut self) -> &mut ::protobuf::RepeatedField<NetworkStat> {
&mut self.network
}
pub fn take_network(&mut self) -> ::protobuf::RepeatedField<NetworkStat> {
::std::mem::replace(&mut self.network, ::protobuf::RepeatedField::new())
}
pub fn get_cgroup_stats(&self) -> &CgroupStats {
self.cgroup_stats.as_ref().unwrap_or_else(|| <CgroupStats as ::protobuf::Message>::default_instance())
}
pub fn clear_cgroup_stats(&mut self) {
self.cgroup_stats.clear();
}
pub fn has_cgroup_stats(&self) -> bool {
self.cgroup_stats.is_some()
}
pub fn set_cgroup_stats(&mut self, v: CgroupStats) {
self.cgroup_stats = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_cgroup_stats(&mut self) -> &mut CgroupStats {
if self.cgroup_stats.is_none() {
self.cgroup_stats.set_default();
}
self.cgroup_stats.as_mut().unwrap()
}
pub fn take_cgroup_stats(&mut self) -> CgroupStats {
self.cgroup_stats.take().unwrap_or_else(|| CgroupStats::new())
}
pub fn get_memory_oom_control(&self) -> &MemoryOomControl {
self.memory_oom_control.as_ref().unwrap_or_else(|| <MemoryOomControl as ::protobuf::Message>::default_instance())
}
pub fn clear_memory_oom_control(&mut self) {
self.memory_oom_control.clear();
}
pub fn has_memory_oom_control(&self) -> bool {
self.memory_oom_control.is_some()
}
pub fn set_memory_oom_control(&mut self, v: MemoryOomControl) {
self.memory_oom_control = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_memory_oom_control(&mut self) -> &mut MemoryOomControl {
if self.memory_oom_control.is_none() {
self.memory_oom_control.set_default();
}
self.memory_oom_control.as_mut().unwrap()
}
pub fn take_memory_oom_control(&mut self) -> MemoryOomControl {
self.memory_oom_control.take().unwrap_or_else(|| MemoryOomControl::new())
}
}
impl ::protobuf::Message for Metrics {
fn is_initialized(&self) -> bool {
for v in &self.hugetlb {
if !v.is_initialized() {
return false;
}
};
for v in &self.pids {
if !v.is_initialized() {
return false;
}
};
for v in &self.cpu {
if !v.is_initialized() {
return false;
}
};
for v in &self.memory {
if !v.is_initialized() {
return false;
}
};
for v in &self.blkio {
if !v.is_initialized() {
return false;
}
};
for v in &self.rdma {
if !v.is_initialized() {
return false;
}
};
for v in &self.network {
if !v.is_initialized() {
return false;
}
};
for v in &self.cgroup_stats {
if !v.is_initialized() {
return false;
}
};
for v in &self.memory_oom_control {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.hugetlb)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.pids)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cpu)?;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.memory)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.blkio)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.rdma)?;
},
7 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.network)?;
},
8 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.cgroup_stats)?;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.memory_oom_control)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.hugetlb {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.pids.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.cpu.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.memory.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.blkio.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.rdma.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.network {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if let Some(ref v) = self.cgroup_stats.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.memory_oom_control.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.hugetlb {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(ref v) = self.pids.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.cpu.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.memory.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.blkio.as_ref() {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.rdma.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.network {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if let Some(ref v) = self.cgroup_stats.as_ref() {
os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.memory_oom_control.as_ref() {
os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Metrics {
Metrics::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<HugetlbStat>>(
"hugetlb",
|m: &Metrics| { &m.hugetlb },
|m: &mut Metrics| { &mut m.hugetlb },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PidsStat>>(
"pids",
|m: &Metrics| { &m.pids },
|m: &mut Metrics| { &mut m.pids },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CPUStat>>(
"cpu",
|m: &Metrics| { &m.cpu },
|m: &mut Metrics| { &mut m.cpu },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryStat>>(
"memory",
|m: &Metrics| { &m.memory },
|m: &mut Metrics| { &mut m.memory },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOStat>>(
"blkio",
|m: &Metrics| { &m.blkio },
|m: &mut Metrics| { &mut m.blkio },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RdmaStat>>(
"rdma",
|m: &Metrics| { &m.rdma },
|m: &mut Metrics| { &mut m.rdma },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NetworkStat>>(
"network",
|m: &Metrics| { &m.network },
|m: &mut Metrics| { &mut m.network },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CgroupStats>>(
"cgroup_stats",
|m: &Metrics| { &m.cgroup_stats },
|m: &mut Metrics| { &mut m.cgroup_stats },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryOomControl>>(
"memory_oom_control",
|m: &Metrics| { &m.memory_oom_control },
|m: &mut Metrics| { &mut m.memory_oom_control },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Metrics>(
"Metrics",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Metrics {
static instance: ::protobuf::rt::LazyV2<Metrics> = ::protobuf::rt::LazyV2::INIT;
instance.get(Metrics::new)
}
}
impl ::protobuf::Clear for Metrics {
fn clear(&mut self) {
self.hugetlb.clear();
self.pids.clear();
self.cpu.clear();
self.memory.clear();
self.blkio.clear();
self.rdma.clear();
self.network.clear();
self.cgroup_stats.clear();
self.memory_oom_control.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Metrics {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Metrics {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct HugetlbStat {
pub usage: u64,
pub max: u64,
pub failcnt: u64,
pub pagesize: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a HugetlbStat {
fn default() -> &'a HugetlbStat {
<HugetlbStat as ::protobuf::Message>::default_instance()
}
}
impl HugetlbStat {
pub fn new() -> HugetlbStat {
::std::default::Default::default()
}
pub fn get_usage(&self) -> u64 {
self.usage
}
pub fn clear_usage(&mut self) {
self.usage = 0;
}
pub fn set_usage(&mut self, v: u64) {
self.usage = v;
}
pub fn get_max(&self) -> u64 {
self.max
}
pub fn clear_max(&mut self) {
self.max = 0;
}
pub fn set_max(&mut self, v: u64) {
self.max = v;
}
pub fn get_failcnt(&self) -> u64 {
self.failcnt
}
pub fn clear_failcnt(&mut self) {
self.failcnt = 0;
}
pub fn set_failcnt(&mut self, v: u64) {
self.failcnt = v;
}
pub fn get_pagesize(&self) -> &str {
&self.pagesize
}
pub fn clear_pagesize(&mut self) {
self.pagesize.clear();
}
pub fn set_pagesize(&mut self, v: ::std::string::String) {
self.pagesize = v;
}
pub fn mut_pagesize(&mut self) -> &mut ::std::string::String {
&mut self.pagesize
}
pub fn take_pagesize(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.pagesize, ::std::string::String::new())
}
}
impl ::protobuf::Message for HugetlbStat {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.usage = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.failcnt = tmp;
},
4 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.pagesize)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.usage != 0 {
my_size += ::protobuf::rt::value_size(1, self.usage, ::protobuf::wire_format::WireTypeVarint);
}
if self.max != 0 {
my_size += ::protobuf::rt::value_size(2, self.max, ::protobuf::wire_format::WireTypeVarint);
}
if self.failcnt != 0 {
my_size += ::protobuf::rt::value_size(3, self.failcnt, ::protobuf::wire_format::WireTypeVarint);
}
if !self.pagesize.is_empty() {
my_size += ::protobuf::rt::string_size(4, &self.pagesize);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.usage != 0 {
os.write_uint64(1, self.usage)?;
}
if self.max != 0 {
os.write_uint64(2, self.max)?;
}
if self.failcnt != 0 {
os.write_uint64(3, self.failcnt)?;
}
if !self.pagesize.is_empty() {
os.write_string(4, &self.pagesize)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> HugetlbStat {
HugetlbStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"usage",
|m: &HugetlbStat| { &m.usage },
|m: &mut HugetlbStat| { &mut m.usage },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"max",
|m: &HugetlbStat| { &m.max },
|m: &mut HugetlbStat| { &mut m.max },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"failcnt",
|m: &HugetlbStat| { &m.failcnt },
|m: &mut HugetlbStat| { &mut m.failcnt },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"pagesize",
|m: &HugetlbStat| { &m.pagesize },
|m: &mut HugetlbStat| { &mut m.pagesize },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<HugetlbStat>(
"HugetlbStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static HugetlbStat {
static instance: ::protobuf::rt::LazyV2<HugetlbStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(HugetlbStat::new)
}
}
impl ::protobuf::Clear for HugetlbStat {
fn clear(&mut self) {
self.usage = 0;
self.max = 0;
self.failcnt = 0;
self.pagesize.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for HugetlbStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for HugetlbStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct PidsStat {
pub current: u64,
pub limit: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PidsStat {
fn default() -> &'a PidsStat {
<PidsStat as ::protobuf::Message>::default_instance()
}
}
impl PidsStat {
pub fn new() -> PidsStat {
::std::default::Default::default()
}
pub fn get_current(&self) -> u64 {
self.current
}
pub fn clear_current(&mut self) {
self.current = 0;
}
pub fn set_current(&mut self, v: u64) {
self.current = v;
}
pub fn get_limit(&self) -> u64 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u64) {
self.limit = v;
}
}
impl ::protobuf::Message for PidsStat {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.current = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.limit = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.current != 0 {
my_size += ::protobuf::rt::value_size(1, self.current, ::protobuf::wire_format::WireTypeVarint);
}
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(2, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.current != 0 {
os.write_uint64(1, self.current)?;
}
if self.limit != 0 {
os.write_uint64(2, self.limit)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PidsStat {
PidsStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"current",
|m: &PidsStat| { &m.current },
|m: &mut PidsStat| { &mut m.current },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"limit",
|m: &PidsStat| { &m.limit },
|m: &mut PidsStat| { &mut m.limit },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<PidsStat>(
"PidsStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static PidsStat {
static instance: ::protobuf::rt::LazyV2<PidsStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(PidsStat::new)
}
}
impl ::protobuf::Clear for PidsStat {
fn clear(&mut self) {
self.current = 0;
self.limit = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PidsStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PidsStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CPUStat {
pub usage: ::protobuf::SingularPtrField<CPUUsage>,
pub throttling: ::protobuf::SingularPtrField<Throttle>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CPUStat {
fn default() -> &'a CPUStat {
<CPUStat as ::protobuf::Message>::default_instance()
}
}
impl CPUStat {
pub fn new() -> CPUStat {
::std::default::Default::default()
}
pub fn get_usage(&self) -> &CPUUsage {
self.usage.as_ref().unwrap_or_else(|| <CPUUsage as ::protobuf::Message>::default_instance())
}
pub fn clear_usage(&mut self) {
self.usage.clear();
}
pub fn has_usage(&self) -> bool {
self.usage.is_some()
}
pub fn set_usage(&mut self, v: CPUUsage) {
self.usage = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_usage(&mut self) -> &mut CPUUsage {
if self.usage.is_none() {
self.usage.set_default();
}
self.usage.as_mut().unwrap()
}
pub fn take_usage(&mut self) -> CPUUsage {
self.usage.take().unwrap_or_else(|| CPUUsage::new())
}
pub fn get_throttling(&self) -> &Throttle {
self.throttling.as_ref().unwrap_or_else(|| <Throttle as ::protobuf::Message>::default_instance())
}
pub fn clear_throttling(&mut self) {
self.throttling.clear();
}
pub fn has_throttling(&self) -> bool {
self.throttling.is_some()
}
pub fn set_throttling(&mut self, v: Throttle) {
self.throttling = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_throttling(&mut self) -> &mut Throttle {
if self.throttling.is_none() {
self.throttling.set_default();
}
self.throttling.as_mut().unwrap()
}
pub fn take_throttling(&mut self) -> Throttle {
self.throttling.take().unwrap_or_else(|| Throttle::new())
}
}
impl ::protobuf::Message for CPUStat {
fn is_initialized(&self) -> bool {
for v in &self.usage {
if !v.is_initialized() {
return false;
}
};
for v in &self.throttling {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.usage)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.throttling)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.usage.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.throttling.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let Some(ref v) = self.usage.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.throttling.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CPUStat {
CPUStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CPUUsage>>(
"usage",
|m: &CPUStat| { &m.usage },
|m: &mut CPUStat| { &mut m.usage },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Throttle>>(
"throttling",
|m: &CPUStat| { &m.throttling },
|m: &mut CPUStat| { &mut m.throttling },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CPUStat>(
"CPUStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CPUStat {
static instance: ::protobuf::rt::LazyV2<CPUStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(CPUStat::new)
}
}
impl ::protobuf::Clear for CPUStat {
fn clear(&mut self) {
self.usage.clear();
self.throttling.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CPUStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CPUStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CPUUsage {
pub total: u64,
pub kernel: u64,
pub user: u64,
pub per_cpu: ::std::vec::Vec<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CPUUsage {
fn default() -> &'a CPUUsage {
<CPUUsage as ::protobuf::Message>::default_instance()
}
}
impl CPUUsage {
pub fn new() -> CPUUsage {
::std::default::Default::default()
}
pub fn get_total(&self) -> u64 {
self.total
}
pub fn clear_total(&mut self) {
self.total = 0;
}
pub fn set_total(&mut self, v: u64) {
self.total = v;
}
pub fn get_kernel(&self) -> u64 {
self.kernel
}
pub fn clear_kernel(&mut self) {
self.kernel = 0;
}
pub fn set_kernel(&mut self, v: u64) {
self.kernel = v;
}
pub fn get_user(&self) -> u64 {
self.user
}
pub fn clear_user(&mut self) {
self.user = 0;
}
pub fn set_user(&mut self, v: u64) {
self.user = v;
}
pub fn get_per_cpu(&self) -> &[u64] {
&self.per_cpu
}
pub fn clear_per_cpu(&mut self) {
self.per_cpu.clear();
}
pub fn set_per_cpu(&mut self, v: ::std::vec::Vec<u64>) {
self.per_cpu = v;
}
pub fn mut_per_cpu(&mut self) -> &mut ::std::vec::Vec<u64> {
&mut self.per_cpu
}
pub fn take_per_cpu(&mut self) -> ::std::vec::Vec<u64> {
::std::mem::replace(&mut self.per_cpu, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CPUUsage {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.kernel = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.user = tmp;
},
4 => {
::protobuf::rt::read_repeated_uint64_into(wire_type, is, &mut self.per_cpu)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.total != 0 {
my_size += ::protobuf::rt::value_size(1, self.total, ::protobuf::wire_format::WireTypeVarint);
}
if self.kernel != 0 {
my_size += ::protobuf::rt::value_size(2, self.kernel, ::protobuf::wire_format::WireTypeVarint);
}
if self.user != 0 {
my_size += ::protobuf::rt::value_size(3, self.user, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.per_cpu {
my_size += ::protobuf::rt::value_size(4, *value, ::protobuf::wire_format::WireTypeVarint);
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.total != 0 {
os.write_uint64(1, self.total)?;
}
if self.kernel != 0 {
os.write_uint64(2, self.kernel)?;
}
if self.user != 0 {
os.write_uint64(3, self.user)?;
}
for v in &self.per_cpu {
os.write_uint64(4, *v)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CPUUsage {
CPUUsage::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total",
|m: &CPUUsage| { &m.total },
|m: &mut CPUUsage| { &mut m.total },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"kernel",
|m: &CPUUsage| { &m.kernel },
|m: &mut CPUUsage| { &mut m.kernel },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"user",
|m: &CPUUsage| { &m.user },
|m: &mut CPUUsage| { &mut m.user },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"per_cpu",
|m: &CPUUsage| { &m.per_cpu },
|m: &mut CPUUsage| { &mut m.per_cpu },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CPUUsage>(
"CPUUsage",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CPUUsage {
static instance: ::protobuf::rt::LazyV2<CPUUsage> = ::protobuf::rt::LazyV2::INIT;
instance.get(CPUUsage::new)
}
}
impl ::protobuf::Clear for CPUUsage {
fn clear(&mut self) {
self.total = 0;
self.kernel = 0;
self.user = 0;
self.per_cpu.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CPUUsage {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CPUUsage {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Throttle {
pub periods: u64,
pub throttled_periods: u64,
pub throttled_time: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Throttle {
fn default() -> &'a Throttle {
<Throttle as ::protobuf::Message>::default_instance()
}
}
impl Throttle {
pub fn new() -> Throttle {
::std::default::Default::default()
}
pub fn get_periods(&self) -> u64 {
self.periods
}
pub fn clear_periods(&mut self) {
self.periods = 0;
}
pub fn set_periods(&mut self, v: u64) {
self.periods = v;
}
pub fn get_throttled_periods(&self) -> u64 {
self.throttled_periods
}
pub fn clear_throttled_periods(&mut self) {
self.throttled_periods = 0;
}
pub fn set_throttled_periods(&mut self, v: u64) {
self.throttled_periods = v;
}
pub fn get_throttled_time(&self) -> u64 {
self.throttled_time
}
pub fn clear_throttled_time(&mut self) {
self.throttled_time = 0;
}
pub fn set_throttled_time(&mut self, v: u64) {
self.throttled_time = v;
}
}
impl ::protobuf::Message for Throttle {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.periods = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.throttled_periods = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.throttled_time = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.periods != 0 {
my_size += ::protobuf::rt::value_size(1, self.periods, ::protobuf::wire_format::WireTypeVarint);
}
if self.throttled_periods != 0 {
my_size += ::protobuf::rt::value_size(2, self.throttled_periods, ::protobuf::wire_format::WireTypeVarint);
}
if self.throttled_time != 0 {
my_size += ::protobuf::rt::value_size(3, self.throttled_time, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.periods != 0 {
os.write_uint64(1, self.periods)?;
}
if self.throttled_periods != 0 {
os.write_uint64(2, self.throttled_periods)?;
}
if self.throttled_time != 0 {
os.write_uint64(3, self.throttled_time)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Throttle {
Throttle::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"periods",
|m: &Throttle| { &m.periods },
|m: &mut Throttle| { &mut m.periods },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"throttled_periods",
|m: &Throttle| { &m.throttled_periods },
|m: &mut Throttle| { &mut m.throttled_periods },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"throttled_time",
|m: &Throttle| { &m.throttled_time },
|m: &mut Throttle| { &mut m.throttled_time },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Throttle>(
"Throttle",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static Throttle {
static instance: ::protobuf::rt::LazyV2<Throttle> = ::protobuf::rt::LazyV2::INIT;
instance.get(Throttle::new)
}
}
impl ::protobuf::Clear for Throttle {
fn clear(&mut self) {
self.periods = 0;
self.throttled_periods = 0;
self.throttled_time = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Throttle {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Throttle {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MemoryStat {
pub cache: u64,
pub rss: u64,
pub rss_huge: u64,
pub mapped_file: u64,
pub dirty: u64,
pub writeback: u64,
pub pg_pg_in: u64,
pub pg_pg_out: u64,
pub pg_fault: u64,
pub pg_maj_fault: u64,
pub inactive_anon: u64,
pub active_anon: u64,
pub inactive_file: u64,
pub active_file: u64,
pub unevictable: u64,
pub hierarchical_memory_limit: u64,
pub hierarchical_swap_limit: u64,
pub total_cache: u64,
pub total_rss: u64,
pub total_rss_huge: u64,
pub total_mapped_file: u64,
pub total_dirty: u64,
pub total_writeback: u64,
pub total_pg_pg_in: u64,
pub total_pg_pg_out: u64,
pub total_pg_fault: u64,
pub total_pg_maj_fault: u64,
pub total_inactive_anon: u64,
pub total_active_anon: u64,
pub total_inactive_file: u64,
pub total_active_file: u64,
pub total_unevictable: u64,
pub usage: ::protobuf::SingularPtrField<MemoryEntry>,
pub swap: ::protobuf::SingularPtrField<MemoryEntry>,
pub kernel: ::protobuf::SingularPtrField<MemoryEntry>,
pub kernel_tcp: ::protobuf::SingularPtrField<MemoryEntry>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MemoryStat {
fn default() -> &'a MemoryStat {
<MemoryStat as ::protobuf::Message>::default_instance()
}
}
impl MemoryStat {
pub fn new() -> MemoryStat {
::std::default::Default::default()
}
pub fn get_cache(&self) -> u64 {
self.cache
}
pub fn clear_cache(&mut self) {
self.cache = 0;
}
pub fn set_cache(&mut self, v: u64) {
self.cache = v;
}
pub fn get_rss(&self) -> u64 {
self.rss
}
pub fn clear_rss(&mut self) {
self.rss = 0;
}
pub fn set_rss(&mut self, v: u64) {
self.rss = v;
}
pub fn get_rss_huge(&self) -> u64 {
self.rss_huge
}
pub fn clear_rss_huge(&mut self) {
self.rss_huge = 0;
}
pub fn set_rss_huge(&mut self, v: u64) {
self.rss_huge = v;
}
pub fn get_mapped_file(&self) -> u64 {
self.mapped_file
}
pub fn clear_mapped_file(&mut self) {
self.mapped_file = 0;
}
pub fn set_mapped_file(&mut self, v: u64) {
self.mapped_file = v;
}
pub fn get_dirty(&self) -> u64 {
self.dirty
}
pub fn clear_dirty(&mut self) {
self.dirty = 0;
}
pub fn set_dirty(&mut self, v: u64) {
self.dirty = v;
}
pub fn get_writeback(&self) -> u64 {
self.writeback
}
pub fn clear_writeback(&mut self) {
self.writeback = 0;
}
pub fn set_writeback(&mut self, v: u64) {
self.writeback = v;
}
pub fn get_pg_pg_in(&self) -> u64 {
self.pg_pg_in
}
pub fn clear_pg_pg_in(&mut self) {
self.pg_pg_in = 0;
}
pub fn set_pg_pg_in(&mut self, v: u64) {
self.pg_pg_in = v;
}
pub fn get_pg_pg_out(&self) -> u64 {
self.pg_pg_out
}
pub fn clear_pg_pg_out(&mut self) {
self.pg_pg_out = 0;
}
pub fn set_pg_pg_out(&mut self, v: u64) {
self.pg_pg_out = v;
}
pub fn get_pg_fault(&self) -> u64 {
self.pg_fault
}
pub fn clear_pg_fault(&mut self) {
self.pg_fault = 0;
}
pub fn set_pg_fault(&mut self, v: u64) {
self.pg_fault = v;
}
pub fn get_pg_maj_fault(&self) -> u64 {
self.pg_maj_fault
}
pub fn clear_pg_maj_fault(&mut self) {
self.pg_maj_fault = 0;
}
pub fn set_pg_maj_fault(&mut self, v: u64) {
self.pg_maj_fault = v;
}
pub fn get_inactive_anon(&self) -> u64 {
self.inactive_anon
}
pub fn clear_inactive_anon(&mut self) {
self.inactive_anon = 0;
}
pub fn set_inactive_anon(&mut self, v: u64) {
self.inactive_anon = v;
}
pub fn get_active_anon(&self) -> u64 {
self.active_anon
}
pub fn clear_active_anon(&mut self) {
self.active_anon = 0;
}
pub fn set_active_anon(&mut self, v: u64) {
self.active_anon = v;
}
pub fn get_inactive_file(&self) -> u64 {
self.inactive_file
}
pub fn clear_inactive_file(&mut self) {
self.inactive_file = 0;
}
pub fn set_inactive_file(&mut self, v: u64) {
self.inactive_file = v;
}
pub fn get_active_file(&self) -> u64 {
self.active_file
}
pub fn clear_active_file(&mut self) {
self.active_file = 0;
}
pub fn set_active_file(&mut self, v: u64) {
self.active_file = v;
}
pub fn get_unevictable(&self) -> u64 {
self.unevictable
}
pub fn clear_unevictable(&mut self) {
self.unevictable = 0;
}
pub fn set_unevictable(&mut self, v: u64) {
self.unevictable = v;
}
pub fn get_hierarchical_memory_limit(&self) -> u64 {
self.hierarchical_memory_limit
}
pub fn clear_hierarchical_memory_limit(&mut self) {
self.hierarchical_memory_limit = 0;
}
pub fn set_hierarchical_memory_limit(&mut self, v: u64) {
self.hierarchical_memory_limit = v;
}
pub fn get_hierarchical_swap_limit(&self) -> u64 {
self.hierarchical_swap_limit
}
pub fn clear_hierarchical_swap_limit(&mut self) {
self.hierarchical_swap_limit = 0;
}
pub fn set_hierarchical_swap_limit(&mut self, v: u64) {
self.hierarchical_swap_limit = v;
}
pub fn get_total_cache(&self) -> u64 {
self.total_cache
}
pub fn clear_total_cache(&mut self) {
self.total_cache = 0;
}
pub fn set_total_cache(&mut self, v: u64) {
self.total_cache = v;
}
pub fn get_total_rss(&self) -> u64 {
self.total_rss
}
pub fn clear_total_rss(&mut self) {
self.total_rss = 0;
}
pub fn set_total_rss(&mut self, v: u64) {
self.total_rss = v;
}
pub fn get_total_rss_huge(&self) -> u64 {
self.total_rss_huge
}
pub fn clear_total_rss_huge(&mut self) {
self.total_rss_huge = 0;
}
pub fn set_total_rss_huge(&mut self, v: u64) {
self.total_rss_huge = v;
}
pub fn get_total_mapped_file(&self) -> u64 {
self.total_mapped_file
}
pub fn clear_total_mapped_file(&mut self) {
self.total_mapped_file = 0;
}
pub fn set_total_mapped_file(&mut self, v: u64) {
self.total_mapped_file = v;
}
pub fn get_total_dirty(&self) -> u64 {
self.total_dirty
}
pub fn clear_total_dirty(&mut self) {
self.total_dirty = 0;
}
pub fn set_total_dirty(&mut self, v: u64) {
self.total_dirty = v;
}
pub fn get_total_writeback(&self) -> u64 {
self.total_writeback
}
pub fn clear_total_writeback(&mut self) {
self.total_writeback = 0;
}
pub fn set_total_writeback(&mut self, v: u64) {
self.total_writeback = v;
}
pub fn get_total_pg_pg_in(&self) -> u64 {
self.total_pg_pg_in
}
pub fn clear_total_pg_pg_in(&mut self) {
self.total_pg_pg_in = 0;
}
pub fn set_total_pg_pg_in(&mut self, v: u64) {
self.total_pg_pg_in = v;
}
pub fn get_total_pg_pg_out(&self) -> u64 {
self.total_pg_pg_out
}
pub fn clear_total_pg_pg_out(&mut self) {
self.total_pg_pg_out = 0;
}
pub fn set_total_pg_pg_out(&mut self, v: u64) {
self.total_pg_pg_out = v;
}
pub fn get_total_pg_fault(&self) -> u64 {
self.total_pg_fault
}
pub fn clear_total_pg_fault(&mut self) {
self.total_pg_fault = 0;
}
pub fn set_total_pg_fault(&mut self, v: u64) {
self.total_pg_fault = v;
}
pub fn get_total_pg_maj_fault(&self) -> u64 {
self.total_pg_maj_fault
}
pub fn clear_total_pg_maj_fault(&mut self) {
self.total_pg_maj_fault = 0;
}
pub fn set_total_pg_maj_fault(&mut self, v: u64) {
self.total_pg_maj_fault = v;
}
pub fn get_total_inactive_anon(&self) -> u64 {
self.total_inactive_anon
}
pub fn clear_total_inactive_anon(&mut self) {
self.total_inactive_anon = 0;
}
pub fn set_total_inactive_anon(&mut self, v: u64) {
self.total_inactive_anon = v;
}
pub fn get_total_active_anon(&self) -> u64 {
self.total_active_anon
}
pub fn clear_total_active_anon(&mut self) {
self.total_active_anon = 0;
}
pub fn set_total_active_anon(&mut self, v: u64) {
self.total_active_anon = v;
}
pub fn get_total_inactive_file(&self) -> u64 {
self.total_inactive_file
}
pub fn clear_total_inactive_file(&mut self) {
self.total_inactive_file = 0;
}
pub fn set_total_inactive_file(&mut self, v: u64) {
self.total_inactive_file = v;
}
pub fn get_total_active_file(&self) -> u64 {
self.total_active_file
}
pub fn clear_total_active_file(&mut self) {
self.total_active_file = 0;
}
pub fn set_total_active_file(&mut self, v: u64) {
self.total_active_file = v;
}
pub fn get_total_unevictable(&self) -> u64 {
self.total_unevictable
}
pub fn clear_total_unevictable(&mut self) {
self.total_unevictable = 0;
}
pub fn set_total_unevictable(&mut self, v: u64) {
self.total_unevictable = v;
}
pub fn get_usage(&self) -> &MemoryEntry {
self.usage.as_ref().unwrap_or_else(|| <MemoryEntry as ::protobuf::Message>::default_instance())
}
pub fn clear_usage(&mut self) {
self.usage.clear();
}
pub fn has_usage(&self) -> bool {
self.usage.is_some()
}
pub fn set_usage(&mut self, v: MemoryEntry) {
self.usage = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_usage(&mut self) -> &mut MemoryEntry {
if self.usage.is_none() {
self.usage.set_default();
}
self.usage.as_mut().unwrap()
}
pub fn take_usage(&mut self) -> MemoryEntry {
self.usage.take().unwrap_or_else(|| MemoryEntry::new())
}
pub fn get_swap(&self) -> &MemoryEntry {
self.swap.as_ref().unwrap_or_else(|| <MemoryEntry as ::protobuf::Message>::default_instance())
}
pub fn clear_swap(&mut self) {
self.swap.clear();
}
pub fn has_swap(&self) -> bool {
self.swap.is_some()
}
pub fn set_swap(&mut self, v: MemoryEntry) {
self.swap = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_swap(&mut self) -> &mut MemoryEntry {
if self.swap.is_none() {
self.swap.set_default();
}
self.swap.as_mut().unwrap()
}
pub fn take_swap(&mut self) -> MemoryEntry {
self.swap.take().unwrap_or_else(|| MemoryEntry::new())
}
pub fn get_kernel(&self) -> &MemoryEntry {
self.kernel.as_ref().unwrap_or_else(|| <MemoryEntry as ::protobuf::Message>::default_instance())
}
pub fn clear_kernel(&mut self) {
self.kernel.clear();
}
pub fn has_kernel(&self) -> bool {
self.kernel.is_some()
}
pub fn set_kernel(&mut self, v: MemoryEntry) {
self.kernel = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_kernel(&mut self) -> &mut MemoryEntry {
if self.kernel.is_none() {
self.kernel.set_default();
}
self.kernel.as_mut().unwrap()
}
pub fn take_kernel(&mut self) -> MemoryEntry {
self.kernel.take().unwrap_or_else(|| MemoryEntry::new())
}
pub fn get_kernel_tcp(&self) -> &MemoryEntry {
self.kernel_tcp.as_ref().unwrap_or_else(|| <MemoryEntry as ::protobuf::Message>::default_instance())
}
pub fn clear_kernel_tcp(&mut self) {
self.kernel_tcp.clear();
}
pub fn has_kernel_tcp(&self) -> bool {
self.kernel_tcp.is_some()
}
pub fn set_kernel_tcp(&mut self, v: MemoryEntry) {
self.kernel_tcp = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_kernel_tcp(&mut self) -> &mut MemoryEntry {
if self.kernel_tcp.is_none() {
self.kernel_tcp.set_default();
}
self.kernel_tcp.as_mut().unwrap()
}
pub fn take_kernel_tcp(&mut self) -> MemoryEntry {
self.kernel_tcp.take().unwrap_or_else(|| MemoryEntry::new())
}
}
impl ::protobuf::Message for MemoryStat {
fn is_initialized(&self) -> bool {
for v in &self.usage {
if !v.is_initialized() {
return false;
}
};
for v in &self.swap {
if !v.is_initialized() {
return false;
}
};
for v in &self.kernel {
if !v.is_initialized() {
return false;
}
};
for v in &self.kernel_tcp {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.cache = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rss = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rss_huge = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.mapped_file = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.dirty = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.writeback = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.pg_pg_in = tmp;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.pg_pg_out = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.pg_fault = tmp;
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.pg_maj_fault = tmp;
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.inactive_anon = tmp;
},
12 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.active_anon = tmp;
},
13 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.inactive_file = tmp;
},
14 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.active_file = tmp;
},
15 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.unevictable = tmp;
},
16 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.hierarchical_memory_limit = tmp;
},
17 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.hierarchical_swap_limit = tmp;
},
18 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_cache = tmp;
},
19 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_rss = tmp;
},
20 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_rss_huge = tmp;
},
21 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_mapped_file = tmp;
},
22 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_dirty = tmp;
},
23 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_writeback = tmp;
},
24 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_pg_pg_in = tmp;
},
25 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_pg_pg_out = tmp;
},
26 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_pg_fault = tmp;
},
27 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_pg_maj_fault = tmp;
},
28 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_inactive_anon = tmp;
},
29 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_active_anon = tmp;
},
30 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_inactive_file = tmp;
},
31 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_active_file = tmp;
},
32 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_unevictable = tmp;
},
33 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.usage)?;
},
34 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.swap)?;
},
35 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.kernel)?;
},
36 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.kernel_tcp)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.cache != 0 {
my_size += ::protobuf::rt::value_size(1, self.cache, ::protobuf::wire_format::WireTypeVarint);
}
if self.rss != 0 {
my_size += ::protobuf::rt::value_size(2, self.rss, ::protobuf::wire_format::WireTypeVarint);
}
if self.rss_huge != 0 {
my_size += ::protobuf::rt::value_size(3, self.rss_huge, ::protobuf::wire_format::WireTypeVarint);
}
if self.mapped_file != 0 {
my_size += ::protobuf::rt::value_size(4, self.mapped_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.dirty != 0 {
my_size += ::protobuf::rt::value_size(5, self.dirty, ::protobuf::wire_format::WireTypeVarint);
}
if self.writeback != 0 {
my_size += ::protobuf::rt::value_size(6, self.writeback, ::protobuf::wire_format::WireTypeVarint);
}
if self.pg_pg_in != 0 {
my_size += ::protobuf::rt::value_size(7, self.pg_pg_in, ::protobuf::wire_format::WireTypeVarint);
}
if self.pg_pg_out != 0 {
my_size += ::protobuf::rt::value_size(8, self.pg_pg_out, ::protobuf::wire_format::WireTypeVarint);
}
if self.pg_fault != 0 {
my_size += ::protobuf::rt::value_size(9, self.pg_fault, ::protobuf::wire_format::WireTypeVarint);
}
if self.pg_maj_fault != 0 {
my_size += ::protobuf::rt::value_size(10, self.pg_maj_fault, ::protobuf::wire_format::WireTypeVarint);
}
if self.inactive_anon != 0 {
my_size += ::protobuf::rt::value_size(11, self.inactive_anon, ::protobuf::wire_format::WireTypeVarint);
}
if self.active_anon != 0 {
my_size += ::protobuf::rt::value_size(12, self.active_anon, ::protobuf::wire_format::WireTypeVarint);
}
if self.inactive_file != 0 {
my_size += ::protobuf::rt::value_size(13, self.inactive_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.active_file != 0 {
my_size += ::protobuf::rt::value_size(14, self.active_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.unevictable != 0 {
my_size += ::protobuf::rt::value_size(15, self.unevictable, ::protobuf::wire_format::WireTypeVarint);
}
if self.hierarchical_memory_limit != 0 {
my_size += ::protobuf::rt::value_size(16, self.hierarchical_memory_limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.hierarchical_swap_limit != 0 {
my_size += ::protobuf::rt::value_size(17, self.hierarchical_swap_limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_cache != 0 {
my_size += ::protobuf::rt::value_size(18, self.total_cache, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_rss != 0 {
my_size += ::protobuf::rt::value_size(19, self.total_rss, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_rss_huge != 0 {
my_size += ::protobuf::rt::value_size(20, self.total_rss_huge, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_mapped_file != 0 {
my_size += ::protobuf::rt::value_size(21, self.total_mapped_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_dirty != 0 {
my_size += ::protobuf::rt::value_size(22, self.total_dirty, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_writeback != 0 {
my_size += ::protobuf::rt::value_size(23, self.total_writeback, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_pg_pg_in != 0 {
my_size += ::protobuf::rt::value_size(24, self.total_pg_pg_in, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_pg_pg_out != 0 {
my_size += ::protobuf::rt::value_size(25, self.total_pg_pg_out, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_pg_fault != 0 {
my_size += ::protobuf::rt::value_size(26, self.total_pg_fault, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_pg_maj_fault != 0 {
my_size += ::protobuf::rt::value_size(27, self.total_pg_maj_fault, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_inactive_anon != 0 {
my_size += ::protobuf::rt::value_size(28, self.total_inactive_anon, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_active_anon != 0 {
my_size += ::protobuf::rt::value_size(29, self.total_active_anon, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_inactive_file != 0 {
my_size += ::protobuf::rt::value_size(30, self.total_inactive_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_active_file != 0 {
my_size += ::protobuf::rt::value_size(31, self.total_active_file, ::protobuf::wire_format::WireTypeVarint);
}
if self.total_unevictable != 0 {
my_size += ::protobuf::rt::value_size(32, self.total_unevictable, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.usage.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.swap.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.kernel.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.kernel_tcp.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.cache != 0 {
os.write_uint64(1, self.cache)?;
}
if self.rss != 0 {
os.write_uint64(2, self.rss)?;
}
if self.rss_huge != 0 {
os.write_uint64(3, self.rss_huge)?;
}
if self.mapped_file != 0 {
os.write_uint64(4, self.mapped_file)?;
}
if self.dirty != 0 {
os.write_uint64(5, self.dirty)?;
}
if self.writeback != 0 {
os.write_uint64(6, self.writeback)?;
}
if self.pg_pg_in != 0 {
os.write_uint64(7, self.pg_pg_in)?;
}
if self.pg_pg_out != 0 {
os.write_uint64(8, self.pg_pg_out)?;
}
if self.pg_fault != 0 {
os.write_uint64(9, self.pg_fault)?;
}
if self.pg_maj_fault != 0 {
os.write_uint64(10, self.pg_maj_fault)?;
}
if self.inactive_anon != 0 {
os.write_uint64(11, self.inactive_anon)?;
}
if self.active_anon != 0 {
os.write_uint64(12, self.active_anon)?;
}
if self.inactive_file != 0 {
os.write_uint64(13, self.inactive_file)?;
}
if self.active_file != 0 {
os.write_uint64(14, self.active_file)?;
}
if self.unevictable != 0 {
os.write_uint64(15, self.unevictable)?;
}
if self.hierarchical_memory_limit != 0 {
os.write_uint64(16, self.hierarchical_memory_limit)?;
}
if self.hierarchical_swap_limit != 0 {
os.write_uint64(17, self.hierarchical_swap_limit)?;
}
if self.total_cache != 0 {
os.write_uint64(18, self.total_cache)?;
}
if self.total_rss != 0 {
os.write_uint64(19, self.total_rss)?;
}
if self.total_rss_huge != 0 {
os.write_uint64(20, self.total_rss_huge)?;
}
if self.total_mapped_file != 0 {
os.write_uint64(21, self.total_mapped_file)?;
}
if self.total_dirty != 0 {
os.write_uint64(22, self.total_dirty)?;
}
if self.total_writeback != 0 {
os.write_uint64(23, self.total_writeback)?;
}
if self.total_pg_pg_in != 0 {
os.write_uint64(24, self.total_pg_pg_in)?;
}
if self.total_pg_pg_out != 0 {
os.write_uint64(25, self.total_pg_pg_out)?;
}
if self.total_pg_fault != 0 {
os.write_uint64(26, self.total_pg_fault)?;
}
if self.total_pg_maj_fault != 0 {
os.write_uint64(27, self.total_pg_maj_fault)?;
}
if self.total_inactive_anon != 0 {
os.write_uint64(28, self.total_inactive_anon)?;
}
if self.total_active_anon != 0 {
os.write_uint64(29, self.total_active_anon)?;
}
if self.total_inactive_file != 0 {
os.write_uint64(30, self.total_inactive_file)?;
}
if self.total_active_file != 0 {
os.write_uint64(31, self.total_active_file)?;
}
if self.total_unevictable != 0 {
os.write_uint64(32, self.total_unevictable)?;
}
if let Some(ref v) = self.usage.as_ref() {
os.write_tag(33, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.swap.as_ref() {
os.write_tag(34, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.kernel.as_ref() {
os.write_tag(35, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.kernel_tcp.as_ref() {
os.write_tag(36, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MemoryStat {
MemoryStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"cache",
|m: &MemoryStat| { &m.cache },
|m: &mut MemoryStat| { &mut m.cache },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rss",
|m: &MemoryStat| { &m.rss },
|m: &mut MemoryStat| { &mut m.rss },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rss_huge",
|m: &MemoryStat| { &m.rss_huge },
|m: &mut MemoryStat| { &mut m.rss_huge },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"mapped_file",
|m: &MemoryStat| { &m.mapped_file },
|m: &mut MemoryStat| { &mut m.mapped_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"dirty",
|m: &MemoryStat| { &m.dirty },
|m: &mut MemoryStat| { &mut m.dirty },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"writeback",
|m: &MemoryStat| { &m.writeback },
|m: &mut MemoryStat| { &mut m.writeback },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"pg_pg_in",
|m: &MemoryStat| { &m.pg_pg_in },
|m: &mut MemoryStat| { &mut m.pg_pg_in },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"pg_pg_out",
|m: &MemoryStat| { &m.pg_pg_out },
|m: &mut MemoryStat| { &mut m.pg_pg_out },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"pg_fault",
|m: &MemoryStat| { &m.pg_fault },
|m: &mut MemoryStat| { &mut m.pg_fault },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"pg_maj_fault",
|m: &MemoryStat| { &m.pg_maj_fault },
|m: &mut MemoryStat| { &mut m.pg_maj_fault },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"inactive_anon",
|m: &MemoryStat| { &m.inactive_anon },
|m: &mut MemoryStat| { &mut m.inactive_anon },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"active_anon",
|m: &MemoryStat| { &m.active_anon },
|m: &mut MemoryStat| { &mut m.active_anon },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"inactive_file",
|m: &MemoryStat| { &m.inactive_file },
|m: &mut MemoryStat| { &mut m.inactive_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"active_file",
|m: &MemoryStat| { &m.active_file },
|m: &mut MemoryStat| { &mut m.active_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"unevictable",
|m: &MemoryStat| { &m.unevictable },
|m: &mut MemoryStat| { &mut m.unevictable },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"hierarchical_memory_limit",
|m: &MemoryStat| { &m.hierarchical_memory_limit },
|m: &mut MemoryStat| { &mut m.hierarchical_memory_limit },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"hierarchical_swap_limit",
|m: &MemoryStat| { &m.hierarchical_swap_limit },
|m: &mut MemoryStat| { &mut m.hierarchical_swap_limit },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_cache",
|m: &MemoryStat| { &m.total_cache },
|m: &mut MemoryStat| { &mut m.total_cache },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_rss",
|m: &MemoryStat| { &m.total_rss },
|m: &mut MemoryStat| { &mut m.total_rss },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_rss_huge",
|m: &MemoryStat| { &m.total_rss_huge },
|m: &mut MemoryStat| { &mut m.total_rss_huge },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_mapped_file",
|m: &MemoryStat| { &m.total_mapped_file },
|m: &mut MemoryStat| { &mut m.total_mapped_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_dirty",
|m: &MemoryStat| { &m.total_dirty },
|m: &mut MemoryStat| { &mut m.total_dirty },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_writeback",
|m: &MemoryStat| { &m.total_writeback },
|m: &mut MemoryStat| { &mut m.total_writeback },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_pg_pg_in",
|m: &MemoryStat| { &m.total_pg_pg_in },
|m: &mut MemoryStat| { &mut m.total_pg_pg_in },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_pg_pg_out",
|m: &MemoryStat| { &m.total_pg_pg_out },
|m: &mut MemoryStat| { &mut m.total_pg_pg_out },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_pg_fault",
|m: &MemoryStat| { &m.total_pg_fault },
|m: &mut MemoryStat| { &mut m.total_pg_fault },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_pg_maj_fault",
|m: &MemoryStat| { &m.total_pg_maj_fault },
|m: &mut MemoryStat| { &mut m.total_pg_maj_fault },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_inactive_anon",
|m: &MemoryStat| { &m.total_inactive_anon },
|m: &mut MemoryStat| { &mut m.total_inactive_anon },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_active_anon",
|m: &MemoryStat| { &m.total_active_anon },
|m: &mut MemoryStat| { &mut m.total_active_anon },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_inactive_file",
|m: &MemoryStat| { &m.total_inactive_file },
|m: &mut MemoryStat| { &mut m.total_inactive_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_active_file",
|m: &MemoryStat| { &m.total_active_file },
|m: &mut MemoryStat| { &mut m.total_active_file },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_unevictable",
|m: &MemoryStat| { &m.total_unevictable },
|m: &mut MemoryStat| { &mut m.total_unevictable },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryEntry>>(
"usage",
|m: &MemoryStat| { &m.usage },
|m: &mut MemoryStat| { &mut m.usage },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryEntry>>(
"swap",
|m: &MemoryStat| { &m.swap },
|m: &mut MemoryStat| { &mut m.swap },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryEntry>>(
"kernel",
|m: &MemoryStat| { &m.kernel },
|m: &mut MemoryStat| { &mut m.kernel },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MemoryEntry>>(
"kernel_tcp",
|m: &MemoryStat| { &m.kernel_tcp },
|m: &mut MemoryStat| { &mut m.kernel_tcp },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MemoryStat>(
"MemoryStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MemoryStat {
static instance: ::protobuf::rt::LazyV2<MemoryStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(MemoryStat::new)
}
}
impl ::protobuf::Clear for MemoryStat {
fn clear(&mut self) {
self.cache = 0;
self.rss = 0;
self.rss_huge = 0;
self.mapped_file = 0;
self.dirty = 0;
self.writeback = 0;
self.pg_pg_in = 0;
self.pg_pg_out = 0;
self.pg_fault = 0;
self.pg_maj_fault = 0;
self.inactive_anon = 0;
self.active_anon = 0;
self.inactive_file = 0;
self.active_file = 0;
self.unevictable = 0;
self.hierarchical_memory_limit = 0;
self.hierarchical_swap_limit = 0;
self.total_cache = 0;
self.total_rss = 0;
self.total_rss_huge = 0;
self.total_mapped_file = 0;
self.total_dirty = 0;
self.total_writeback = 0;
self.total_pg_pg_in = 0;
self.total_pg_pg_out = 0;
self.total_pg_fault = 0;
self.total_pg_maj_fault = 0;
self.total_inactive_anon = 0;
self.total_active_anon = 0;
self.total_inactive_file = 0;
self.total_active_file = 0;
self.total_unevictable = 0;
self.usage.clear();
self.swap.clear();
self.kernel.clear();
self.kernel_tcp.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MemoryStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MemoryStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MemoryEntry {
pub limit: u64,
pub usage: u64,
pub max: u64,
pub failcnt: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MemoryEntry {
fn default() -> &'a MemoryEntry {
<MemoryEntry as ::protobuf::Message>::default_instance()
}
}
impl MemoryEntry {
pub fn new() -> MemoryEntry {
::std::default::Default::default()
}
pub fn get_limit(&self) -> u64 {
self.limit
}
pub fn clear_limit(&mut self) {
self.limit = 0;
}
pub fn set_limit(&mut self, v: u64) {
self.limit = v;
}
pub fn get_usage(&self) -> u64 {
self.usage
}
pub fn clear_usage(&mut self) {
self.usage = 0;
}
pub fn set_usage(&mut self, v: u64) {
self.usage = v;
}
pub fn get_max(&self) -> u64 {
self.max
}
pub fn clear_max(&mut self) {
self.max = 0;
}
pub fn set_max(&mut self, v: u64) {
self.max = v;
}
pub fn get_failcnt(&self) -> u64 {
self.failcnt
}
pub fn clear_failcnt(&mut self) {
self.failcnt = 0;
}
pub fn set_failcnt(&mut self, v: u64) {
self.failcnt = v;
}
}
impl ::protobuf::Message for MemoryEntry {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.limit = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.usage = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.max = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.failcnt = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.limit != 0 {
my_size += ::protobuf::rt::value_size(1, self.limit, ::protobuf::wire_format::WireTypeVarint);
}
if self.usage != 0 {
my_size += ::protobuf::rt::value_size(2, self.usage, ::protobuf::wire_format::WireTypeVarint);
}
if self.max != 0 {
my_size += ::protobuf::rt::value_size(3, self.max, ::protobuf::wire_format::WireTypeVarint);
}
if self.failcnt != 0 {
my_size += ::protobuf::rt::value_size(4, self.failcnt, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.limit != 0 {
os.write_uint64(1, self.limit)?;
}
if self.usage != 0 {
os.write_uint64(2, self.usage)?;
}
if self.max != 0 {
os.write_uint64(3, self.max)?;
}
if self.failcnt != 0 {
os.write_uint64(4, self.failcnt)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MemoryEntry {
MemoryEntry::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"limit",
|m: &MemoryEntry| { &m.limit },
|m: &mut MemoryEntry| { &mut m.limit },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"usage",
|m: &MemoryEntry| { &m.usage },
|m: &mut MemoryEntry| { &mut m.usage },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"max",
|m: &MemoryEntry| { &m.max },
|m: &mut MemoryEntry| { &mut m.max },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"failcnt",
|m: &MemoryEntry| { &m.failcnt },
|m: &mut MemoryEntry| { &mut m.failcnt },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MemoryEntry>(
"MemoryEntry",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MemoryEntry {
static instance: ::protobuf::rt::LazyV2<MemoryEntry> = ::protobuf::rt::LazyV2::INIT;
instance.get(MemoryEntry::new)
}
}
impl ::protobuf::Clear for MemoryEntry {
fn clear(&mut self) {
self.limit = 0;
self.usage = 0;
self.max = 0;
self.failcnt = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MemoryEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MemoryEntry {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MemoryOomControl {
pub oom_kill_disable: u64,
pub under_oom: u64,
pub oom_kill: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MemoryOomControl {
fn default() -> &'a MemoryOomControl {
<MemoryOomControl as ::protobuf::Message>::default_instance()
}
}
impl MemoryOomControl {
pub fn new() -> MemoryOomControl {
::std::default::Default::default()
}
pub fn get_oom_kill_disable(&self) -> u64 {
self.oom_kill_disable
}
pub fn clear_oom_kill_disable(&mut self) {
self.oom_kill_disable = 0;
}
pub fn set_oom_kill_disable(&mut self, v: u64) {
self.oom_kill_disable = v;
}
pub fn get_under_oom(&self) -> u64 {
self.under_oom
}
pub fn clear_under_oom(&mut self) {
self.under_oom = 0;
}
pub fn set_under_oom(&mut self, v: u64) {
self.under_oom = v;
}
pub fn get_oom_kill(&self) -> u64 {
self.oom_kill
}
pub fn clear_oom_kill(&mut self) {
self.oom_kill = 0;
}
pub fn set_oom_kill(&mut self, v: u64) {
self.oom_kill = v;
}
}
impl ::protobuf::Message for MemoryOomControl {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.oom_kill_disable = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.under_oom = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.oom_kill = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.oom_kill_disable != 0 {
my_size += ::protobuf::rt::value_size(1, self.oom_kill_disable, ::protobuf::wire_format::WireTypeVarint);
}
if self.under_oom != 0 {
my_size += ::protobuf::rt::value_size(2, self.under_oom, ::protobuf::wire_format::WireTypeVarint);
}
if self.oom_kill != 0 {
my_size += ::protobuf::rt::value_size(3, self.oom_kill, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.oom_kill_disable != 0 {
os.write_uint64(1, self.oom_kill_disable)?;
}
if self.under_oom != 0 {
os.write_uint64(2, self.under_oom)?;
}
if self.oom_kill != 0 {
os.write_uint64(3, self.oom_kill)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MemoryOomControl {
MemoryOomControl::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"oom_kill_disable",
|m: &MemoryOomControl| { &m.oom_kill_disable },
|m: &mut MemoryOomControl| { &mut m.oom_kill_disable },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"under_oom",
|m: &MemoryOomControl| { &m.under_oom },
|m: &mut MemoryOomControl| { &mut m.under_oom },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"oom_kill",
|m: &MemoryOomControl| { &m.oom_kill },
|m: &mut MemoryOomControl| { &mut m.oom_kill },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MemoryOomControl>(
"MemoryOomControl",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MemoryOomControl {
static instance: ::protobuf::rt::LazyV2<MemoryOomControl> = ::protobuf::rt::LazyV2::INIT;
instance.get(MemoryOomControl::new)
}
}
impl ::protobuf::Clear for MemoryOomControl {
fn clear(&mut self) {
self.oom_kill_disable = 0;
self.under_oom = 0;
self.oom_kill = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MemoryOomControl {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MemoryOomControl {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BlkIOStat {
pub io_service_bytes_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_serviced_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_queued_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_service_time_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_wait_time_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_merged_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub io_time_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub sectors_recursive: ::protobuf::RepeatedField<BlkIOEntry>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BlkIOStat {
fn default() -> &'a BlkIOStat {
<BlkIOStat as ::protobuf::Message>::default_instance()
}
}
impl BlkIOStat {
pub fn new() -> BlkIOStat {
::std::default::Default::default()
}
pub fn get_io_service_bytes_recursive(&self) -> &[BlkIOEntry] {
&self.io_service_bytes_recursive
}
pub fn clear_io_service_bytes_recursive(&mut self) {
self.io_service_bytes_recursive.clear();
}
pub fn set_io_service_bytes_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_service_bytes_recursive = v;
}
pub fn mut_io_service_bytes_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_service_bytes_recursive
}
pub fn take_io_service_bytes_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_service_bytes_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_serviced_recursive(&self) -> &[BlkIOEntry] {
&self.io_serviced_recursive
}
pub fn clear_io_serviced_recursive(&mut self) {
self.io_serviced_recursive.clear();
}
pub fn set_io_serviced_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_serviced_recursive = v;
}
pub fn mut_io_serviced_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_serviced_recursive
}
pub fn take_io_serviced_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_serviced_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_queued_recursive(&self) -> &[BlkIOEntry] {
&self.io_queued_recursive
}
pub fn clear_io_queued_recursive(&mut self) {
self.io_queued_recursive.clear();
}
pub fn set_io_queued_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_queued_recursive = v;
}
pub fn mut_io_queued_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_queued_recursive
}
pub fn take_io_queued_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_queued_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_service_time_recursive(&self) -> &[BlkIOEntry] {
&self.io_service_time_recursive
}
pub fn clear_io_service_time_recursive(&mut self) {
self.io_service_time_recursive.clear();
}
pub fn set_io_service_time_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_service_time_recursive = v;
}
pub fn mut_io_service_time_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_service_time_recursive
}
pub fn take_io_service_time_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_service_time_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_wait_time_recursive(&self) -> &[BlkIOEntry] {
&self.io_wait_time_recursive
}
pub fn clear_io_wait_time_recursive(&mut self) {
self.io_wait_time_recursive.clear();
}
pub fn set_io_wait_time_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_wait_time_recursive = v;
}
pub fn mut_io_wait_time_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_wait_time_recursive
}
pub fn take_io_wait_time_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_wait_time_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_merged_recursive(&self) -> &[BlkIOEntry] {
&self.io_merged_recursive
}
pub fn clear_io_merged_recursive(&mut self) {
self.io_merged_recursive.clear();
}
pub fn set_io_merged_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_merged_recursive = v;
}
pub fn mut_io_merged_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_merged_recursive
}
pub fn take_io_merged_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_merged_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_io_time_recursive(&self) -> &[BlkIOEntry] {
&self.io_time_recursive
}
pub fn clear_io_time_recursive(&mut self) {
self.io_time_recursive.clear();
}
pub fn set_io_time_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.io_time_recursive = v;
}
pub fn mut_io_time_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.io_time_recursive
}
pub fn take_io_time_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.io_time_recursive, ::protobuf::RepeatedField::new())
}
pub fn get_sectors_recursive(&self) -> &[BlkIOEntry] {
&self.sectors_recursive
}
pub fn clear_sectors_recursive(&mut self) {
self.sectors_recursive.clear();
}
pub fn set_sectors_recursive(&mut self, v: ::protobuf::RepeatedField<BlkIOEntry>) {
self.sectors_recursive = v;
}
pub fn mut_sectors_recursive(&mut self) -> &mut ::protobuf::RepeatedField<BlkIOEntry> {
&mut self.sectors_recursive
}
pub fn take_sectors_recursive(&mut self) -> ::protobuf::RepeatedField<BlkIOEntry> {
::std::mem::replace(&mut self.sectors_recursive, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for BlkIOStat {
fn is_initialized(&self) -> bool {
for v in &self.io_service_bytes_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_serviced_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_queued_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_service_time_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_wait_time_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_merged_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.io_time_recursive {
if !v.is_initialized() {
return false;
}
};
for v in &self.sectors_recursive {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_service_bytes_recursive)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_serviced_recursive)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_queued_recursive)?;
},
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_service_time_recursive)?;
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_wait_time_recursive)?;
},
6 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_merged_recursive)?;
},
7 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.io_time_recursive)?;
},
8 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sectors_recursive)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.io_service_bytes_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_serviced_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_queued_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_service_time_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_wait_time_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_merged_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.io_time_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.sectors_recursive {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.io_service_bytes_recursive {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_serviced_recursive {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_queued_recursive {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_service_time_recursive {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_wait_time_recursive {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_merged_recursive {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.io_time_recursive {
os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.sectors_recursive {
os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BlkIOStat {
BlkIOStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_service_bytes_recursive",
|m: &BlkIOStat| { &m.io_service_bytes_recursive },
|m: &mut BlkIOStat| { &mut m.io_service_bytes_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_serviced_recursive",
|m: &BlkIOStat| { &m.io_serviced_recursive },
|m: &mut BlkIOStat| { &mut m.io_serviced_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_queued_recursive",
|m: &BlkIOStat| { &m.io_queued_recursive },
|m: &mut BlkIOStat| { &mut m.io_queued_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_service_time_recursive",
|m: &BlkIOStat| { &m.io_service_time_recursive },
|m: &mut BlkIOStat| { &mut m.io_service_time_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_wait_time_recursive",
|m: &BlkIOStat| { &m.io_wait_time_recursive },
|m: &mut BlkIOStat| { &mut m.io_wait_time_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_merged_recursive",
|m: &BlkIOStat| { &m.io_merged_recursive },
|m: &mut BlkIOStat| { &mut m.io_merged_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"io_time_recursive",
|m: &BlkIOStat| { &m.io_time_recursive },
|m: &mut BlkIOStat| { &mut m.io_time_recursive },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<BlkIOEntry>>(
"sectors_recursive",
|m: &BlkIOStat| { &m.sectors_recursive },
|m: &mut BlkIOStat| { &mut m.sectors_recursive },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<BlkIOStat>(
"BlkIOStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static BlkIOStat {
static instance: ::protobuf::rt::LazyV2<BlkIOStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(BlkIOStat::new)
}
}
impl ::protobuf::Clear for BlkIOStat {
fn clear(&mut self) {
self.io_service_bytes_recursive.clear();
self.io_serviced_recursive.clear();
self.io_queued_recursive.clear();
self.io_service_time_recursive.clear();
self.io_wait_time_recursive.clear();
self.io_merged_recursive.clear();
self.io_time_recursive.clear();
self.sectors_recursive.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for BlkIOStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for BlkIOStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct BlkIOEntry {
pub op: ::std::string::String,
pub device: ::std::string::String,
pub major: u64,
pub minor: u64,
pub value: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a BlkIOEntry {
fn default() -> &'a BlkIOEntry {
<BlkIOEntry as ::protobuf::Message>::default_instance()
}
}
impl BlkIOEntry {
pub fn new() -> BlkIOEntry {
::std::default::Default::default()
}
pub fn get_op(&self) -> &str {
&self.op
}
pub fn clear_op(&mut self) {
self.op.clear();
}
pub fn set_op(&mut self, v: ::std::string::String) {
self.op = v;
}
pub fn mut_op(&mut self) -> &mut ::std::string::String {
&mut self.op
}
pub fn take_op(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.op, ::std::string::String::new())
}
pub fn get_device(&self) -> &str {
&self.device
}
pub fn clear_device(&mut self) {
self.device.clear();
}
pub fn set_device(&mut self, v: ::std::string::String) {
self.device = v;
}
pub fn mut_device(&mut self) -> &mut ::std::string::String {
&mut self.device
}
pub fn take_device(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.device, ::std::string::String::new())
}
pub fn get_major(&self) -> u64 {
self.major
}
pub fn clear_major(&mut self) {
self.major = 0;
}
pub fn set_major(&mut self, v: u64) {
self.major = v;
}
pub fn get_minor(&self) -> u64 {
self.minor
}
pub fn clear_minor(&mut self) {
self.minor = 0;
}
pub fn set_minor(&mut self, v: u64) {
self.minor = v;
}
pub fn get_value(&self) -> u64 {
self.value
}
pub fn clear_value(&mut self) {
self.value = 0;
}
pub fn set_value(&mut self, v: u64) {
self.value = v;
}
}
impl ::protobuf::Message for BlkIOEntry {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.op)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.device)?;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.major = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.minor = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.value = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.op.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.op);
}
if !self.device.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.device);
}
if self.major != 0 {
my_size += ::protobuf::rt::value_size(3, self.major, ::protobuf::wire_format::WireTypeVarint);
}
if self.minor != 0 {
my_size += ::protobuf::rt::value_size(4, self.minor, ::protobuf::wire_format::WireTypeVarint);
}
if self.value != 0 {
my_size += ::protobuf::rt::value_size(5, self.value, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.op.is_empty() {
os.write_string(1, &self.op)?;
}
if !self.device.is_empty() {
os.write_string(2, &self.device)?;
}
if self.major != 0 {
os.write_uint64(3, self.major)?;
}
if self.minor != 0 {
os.write_uint64(4, self.minor)?;
}
if self.value != 0 {
os.write_uint64(5, self.value)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> BlkIOEntry {
BlkIOEntry::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"op",
|m: &BlkIOEntry| { &m.op },
|m: &mut BlkIOEntry| { &mut m.op },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"device",
|m: &BlkIOEntry| { &m.device },
|m: &mut BlkIOEntry| { &mut m.device },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"major",
|m: &BlkIOEntry| { &m.major },
|m: &mut BlkIOEntry| { &mut m.major },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"minor",
|m: &BlkIOEntry| { &m.minor },
|m: &mut BlkIOEntry| { &mut m.minor },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"value",
|m: &BlkIOEntry| { &m.value },
|m: &mut BlkIOEntry| { &mut m.value },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<BlkIOEntry>(
"BlkIOEntry",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static BlkIOEntry {
static instance: ::protobuf::rt::LazyV2<BlkIOEntry> = ::protobuf::rt::LazyV2::INIT;
instance.get(BlkIOEntry::new)
}
}
impl ::protobuf::Clear for BlkIOEntry {
fn clear(&mut self) {
self.op.clear();
self.device.clear();
self.major = 0;
self.minor = 0;
self.value = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for BlkIOEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for BlkIOEntry {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RdmaStat {
pub current: ::protobuf::RepeatedField<RdmaEntry>,
pub limit: ::protobuf::RepeatedField<RdmaEntry>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RdmaStat {
fn default() -> &'a RdmaStat {
<RdmaStat as ::protobuf::Message>::default_instance()
}
}
impl RdmaStat {
pub fn new() -> RdmaStat {
::std::default::Default::default()
}
pub fn get_current(&self) -> &[RdmaEntry] {
&self.current
}
pub fn clear_current(&mut self) {
self.current.clear();
}
pub fn set_current(&mut self, v: ::protobuf::RepeatedField<RdmaEntry>) {
self.current = v;
}
pub fn mut_current(&mut self) -> &mut ::protobuf::RepeatedField<RdmaEntry> {
&mut self.current
}
pub fn take_current(&mut self) -> ::protobuf::RepeatedField<RdmaEntry> {
::std::mem::replace(&mut self.current, ::protobuf::RepeatedField::new())
}
pub fn get_limit(&self) -> &[RdmaEntry] {
&self.limit
}
pub fn clear_limit(&mut self) {
self.limit.clear();
}
pub fn set_limit(&mut self, v: ::protobuf::RepeatedField<RdmaEntry>) {
self.limit = v;
}
pub fn mut_limit(&mut self) -> &mut ::protobuf::RepeatedField<RdmaEntry> {
&mut self.limit
}
pub fn take_limit(&mut self) -> ::protobuf::RepeatedField<RdmaEntry> {
::std::mem::replace(&mut self.limit, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for RdmaStat {
fn is_initialized(&self) -> bool {
for v in &self.current {
if !v.is_initialized() {
return false;
}
};
for v in &self.limit {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.current)?;
},
2 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.limit)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.current {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.limit {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
for v in &self.current {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.limit {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RdmaStat {
RdmaStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RdmaEntry>>(
"current",
|m: &RdmaStat| { &m.current },
|m: &mut RdmaStat| { &mut m.current },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RdmaEntry>>(
"limit",
|m: &RdmaStat| { &m.limit },
|m: &mut RdmaStat| { &mut m.limit },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<RdmaStat>(
"RdmaStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static RdmaStat {
static instance: ::protobuf::rt::LazyV2<RdmaStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(RdmaStat::new)
}
}
impl ::protobuf::Clear for RdmaStat {
fn clear(&mut self) {
self.current.clear();
self.limit.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for RdmaStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RdmaStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct RdmaEntry {
pub device: ::std::string::String,
pub hca_handles: u32,
pub hca_objects: u32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a RdmaEntry {
fn default() -> &'a RdmaEntry {
<RdmaEntry as ::protobuf::Message>::default_instance()
}
}
impl RdmaEntry {
pub fn new() -> RdmaEntry {
::std::default::Default::default()
}
pub fn get_device(&self) -> &str {
&self.device
}
pub fn clear_device(&mut self) {
self.device.clear();
}
pub fn set_device(&mut self, v: ::std::string::String) {
self.device = v;
}
pub fn mut_device(&mut self) -> &mut ::std::string::String {
&mut self.device
}
pub fn take_device(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.device, ::std::string::String::new())
}
pub fn get_hca_handles(&self) -> u32 {
self.hca_handles
}
pub fn clear_hca_handles(&mut self) {
self.hca_handles = 0;
}
pub fn set_hca_handles(&mut self, v: u32) {
self.hca_handles = v;
}
pub fn get_hca_objects(&self) -> u32 {
self.hca_objects
}
pub fn clear_hca_objects(&mut self) {
self.hca_objects = 0;
}
pub fn set_hca_objects(&mut self, v: u32) {
self.hca_objects = v;
}
}
impl ::protobuf::Message for RdmaEntry {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.device)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.hca_handles = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.hca_objects = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.device.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.device);
}
if self.hca_handles != 0 {
my_size += ::protobuf::rt::value_size(2, self.hca_handles, ::protobuf::wire_format::WireTypeVarint);
}
if self.hca_objects != 0 {
my_size += ::protobuf::rt::value_size(3, self.hca_objects, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.device.is_empty() {
os.write_string(1, &self.device)?;
}
if self.hca_handles != 0 {
os.write_uint32(2, self.hca_handles)?;
}
if self.hca_objects != 0 {
os.write_uint32(3, self.hca_objects)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> RdmaEntry {
RdmaEntry::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"device",
|m: &RdmaEntry| { &m.device },
|m: &mut RdmaEntry| { &mut m.device },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"hca_handles",
|m: &RdmaEntry| { &m.hca_handles },
|m: &mut RdmaEntry| { &mut m.hca_handles },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"hca_objects",
|m: &RdmaEntry| { &m.hca_objects },
|m: &mut RdmaEntry| { &mut m.hca_objects },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<RdmaEntry>(
"RdmaEntry",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static RdmaEntry {
static instance: ::protobuf::rt::LazyV2<RdmaEntry> = ::protobuf::rt::LazyV2::INIT;
instance.get(RdmaEntry::new)
}
}
impl ::protobuf::Clear for RdmaEntry {
fn clear(&mut self) {
self.device.clear();
self.hca_handles = 0;
self.hca_objects = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for RdmaEntry {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RdmaEntry {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct NetworkStat {
pub name: ::std::string::String,
pub rx_bytes: u64,
pub rx_packets: u64,
pub rx_errors: u64,
pub rx_dropped: u64,
pub tx_bytes: u64,
pub tx_packets: u64,
pub tx_errors: u64,
pub tx_dropped: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a NetworkStat {
fn default() -> &'a NetworkStat {
<NetworkStat as ::protobuf::Message>::default_instance()
}
}
impl NetworkStat {
pub fn new() -> NetworkStat {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_rx_bytes(&self) -> u64 {
self.rx_bytes
}
pub fn clear_rx_bytes(&mut self) {
self.rx_bytes = 0;
}
pub fn set_rx_bytes(&mut self, v: u64) {
self.rx_bytes = v;
}
pub fn get_rx_packets(&self) -> u64 {
self.rx_packets
}
pub fn clear_rx_packets(&mut self) {
self.rx_packets = 0;
}
pub fn set_rx_packets(&mut self, v: u64) {
self.rx_packets = v;
}
pub fn get_rx_errors(&self) -> u64 {
self.rx_errors
}
pub fn clear_rx_errors(&mut self) {
self.rx_errors = 0;
}
pub fn set_rx_errors(&mut self, v: u64) {
self.rx_errors = v;
}
pub fn get_rx_dropped(&self) -> u64 {
self.rx_dropped
}
pub fn clear_rx_dropped(&mut self) {
self.rx_dropped = 0;
}
pub fn set_rx_dropped(&mut self, v: u64) {
self.rx_dropped = v;
}
pub fn get_tx_bytes(&self) -> u64 {
self.tx_bytes
}
pub fn clear_tx_bytes(&mut self) {
self.tx_bytes = 0;
}
pub fn set_tx_bytes(&mut self, v: u64) {
self.tx_bytes = v;
}
pub fn get_tx_packets(&self) -> u64 {
self.tx_packets
}
pub fn clear_tx_packets(&mut self) {
self.tx_packets = 0;
}
pub fn set_tx_packets(&mut self, v: u64) {
self.tx_packets = v;
}
pub fn get_tx_errors(&self) -> u64 {
self.tx_errors
}
pub fn clear_tx_errors(&mut self) {
self.tx_errors = 0;
}
pub fn set_tx_errors(&mut self, v: u64) {
self.tx_errors = v;
}
pub fn get_tx_dropped(&self) -> u64 {
self.tx_dropped
}
pub fn clear_tx_dropped(&mut self) {
self.tx_dropped = 0;
}
pub fn set_tx_dropped(&mut self, v: u64) {
self.tx_dropped = v;
}
}
impl ::protobuf::Message for NetworkStat {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rx_bytes = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rx_packets = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rx_errors = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.rx_dropped = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.tx_bytes = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.tx_packets = tmp;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.tx_errors = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.tx_dropped = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if self.rx_bytes != 0 {
my_size += ::protobuf::rt::value_size(2, self.rx_bytes, ::protobuf::wire_format::WireTypeVarint);
}
if self.rx_packets != 0 {
my_size += ::protobuf::rt::value_size(3, self.rx_packets, ::protobuf::wire_format::WireTypeVarint);
}
if self.rx_errors != 0 {
my_size += ::protobuf::rt::value_size(4, self.rx_errors, ::protobuf::wire_format::WireTypeVarint);
}
if self.rx_dropped != 0 {
my_size += ::protobuf::rt::value_size(5, self.rx_dropped, ::protobuf::wire_format::WireTypeVarint);
}
if self.tx_bytes != 0 {
my_size += ::protobuf::rt::value_size(6, self.tx_bytes, ::protobuf::wire_format::WireTypeVarint);
}
if self.tx_packets != 0 {
my_size += ::protobuf::rt::value_size(7, self.tx_packets, ::protobuf::wire_format::WireTypeVarint);
}
if self.tx_errors != 0 {
my_size += ::protobuf::rt::value_size(8, self.tx_errors, ::protobuf::wire_format::WireTypeVarint);
}
if self.tx_dropped != 0 {
my_size += ::protobuf::rt::value_size(9, self.tx_dropped, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if self.rx_bytes != 0 {
os.write_uint64(2, self.rx_bytes)?;
}
if self.rx_packets != 0 {
os.write_uint64(3, self.rx_packets)?;
}
if self.rx_errors != 0 {
os.write_uint64(4, self.rx_errors)?;
}
if self.rx_dropped != 0 {
os.write_uint64(5, self.rx_dropped)?;
}
if self.tx_bytes != 0 {
os.write_uint64(6, self.tx_bytes)?;
}
if self.tx_packets != 0 {
os.write_uint64(7, self.tx_packets)?;
}
if self.tx_errors != 0 {
os.write_uint64(8, self.tx_errors)?;
}
if self.tx_dropped != 0 {
os.write_uint64(9, self.tx_dropped)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> NetworkStat {
NetworkStat::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &NetworkStat| { &m.name },
|m: &mut NetworkStat| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rx_bytes",
|m: &NetworkStat| { &m.rx_bytes },
|m: &mut NetworkStat| { &mut m.rx_bytes },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rx_packets",
|m: &NetworkStat| { &m.rx_packets },
|m: &mut NetworkStat| { &mut m.rx_packets },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rx_errors",
|m: &NetworkStat| { &m.rx_errors },
|m: &mut NetworkStat| { &mut m.rx_errors },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"rx_dropped",
|m: &NetworkStat| { &m.rx_dropped },
|m: &mut NetworkStat| { &mut m.rx_dropped },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"tx_bytes",
|m: &NetworkStat| { &m.tx_bytes },
|m: &mut NetworkStat| { &mut m.tx_bytes },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"tx_packets",
|m: &NetworkStat| { &m.tx_packets },
|m: &mut NetworkStat| { &mut m.tx_packets },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"tx_errors",
|m: &NetworkStat| { &m.tx_errors },
|m: &mut NetworkStat| { &mut m.tx_errors },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"tx_dropped",
|m: &NetworkStat| { &m.tx_dropped },
|m: &mut NetworkStat| { &mut m.tx_dropped },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<NetworkStat>(
"NetworkStat",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static NetworkStat {
static instance: ::protobuf::rt::LazyV2<NetworkStat> = ::protobuf::rt::LazyV2::INIT;
instance.get(NetworkStat::new)
}
}
impl ::protobuf::Clear for NetworkStat {
fn clear(&mut self) {
self.name.clear();
self.rx_bytes = 0;
self.rx_packets = 0;
self.rx_errors = 0;
self.rx_dropped = 0;
self.tx_bytes = 0;
self.tx_packets = 0;
self.tx_errors = 0;
self.tx_dropped = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for NetworkStat {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NetworkStat {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CgroupStats {
pub nr_sleeping: u64,
pub nr_running: u64,
pub nr_stopped: u64,
pub nr_uninterruptible: u64,
pub nr_io_wait: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CgroupStats {
fn default() -> &'a CgroupStats {
<CgroupStats as ::protobuf::Message>::default_instance()
}
}
impl CgroupStats {
pub fn new() -> CgroupStats {
::std::default::Default::default()
}
pub fn get_nr_sleeping(&self) -> u64 {
self.nr_sleeping
}
pub fn clear_nr_sleeping(&mut self) {
self.nr_sleeping = 0;
}
pub fn set_nr_sleeping(&mut self, v: u64) {
self.nr_sleeping = v;
}
pub fn get_nr_running(&self) -> u64 {
self.nr_running
}
pub fn clear_nr_running(&mut self) {
self.nr_running = 0;
}
pub fn set_nr_running(&mut self, v: u64) {
self.nr_running = v;
}
pub fn get_nr_stopped(&self) -> u64 {
self.nr_stopped
}
pub fn clear_nr_stopped(&mut self) {
self.nr_stopped = 0;
}
pub fn set_nr_stopped(&mut self, v: u64) {
self.nr_stopped = v;
}
pub fn get_nr_uninterruptible(&self) -> u64 {
self.nr_uninterruptible
}
pub fn clear_nr_uninterruptible(&mut self) {
self.nr_uninterruptible = 0;
}
pub fn set_nr_uninterruptible(&mut self, v: u64) {
self.nr_uninterruptible = v;
}
pub fn get_nr_io_wait(&self) -> u64 {
self.nr_io_wait
}
pub fn clear_nr_io_wait(&mut self) {
self.nr_io_wait = 0;
}
pub fn set_nr_io_wait(&mut self, v: u64) {
self.nr_io_wait = v;
}
}
impl ::protobuf::Message for CgroupStats {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.nr_sleeping = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.nr_running = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.nr_stopped = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.nr_uninterruptible = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.nr_io_wait = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.nr_sleeping != 0 {
my_size += ::protobuf::rt::value_size(1, self.nr_sleeping, ::protobuf::wire_format::WireTypeVarint);
}
if self.nr_running != 0 {
my_size += ::protobuf::rt::value_size(2, self.nr_running, ::protobuf::wire_format::WireTypeVarint);
}
if self.nr_stopped != 0 {
my_size += ::protobuf::rt::value_size(3, self.nr_stopped, ::protobuf::wire_format::WireTypeVarint);
}
if self.nr_uninterruptible != 0 {
my_size += ::protobuf::rt::value_size(4, self.nr_uninterruptible, ::protobuf::wire_format::WireTypeVarint);
}
if self.nr_io_wait != 0 {
my_size += ::protobuf::rt::value_size(5, self.nr_io_wait, ::protobuf::wire_format::WireTypeVarint);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.nr_sleeping != 0 {
os.write_uint64(1, self.nr_sleeping)?;
}
if self.nr_running != 0 {
os.write_uint64(2, self.nr_running)?;
}
if self.nr_stopped != 0 {
os.write_uint64(3, self.nr_stopped)?;
}
if self.nr_uninterruptible != 0 {
os.write_uint64(4, self.nr_uninterruptible)?;
}
if self.nr_io_wait != 0 {
os.write_uint64(5, self.nr_io_wait)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CgroupStats {
CgroupStats::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"nr_sleeping",
|m: &CgroupStats| { &m.nr_sleeping },
|m: &mut CgroupStats| { &mut m.nr_sleeping },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"nr_running",
|m: &CgroupStats| { &m.nr_running },
|m: &mut CgroupStats| { &mut m.nr_running },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"nr_stopped",
|m: &CgroupStats| { &m.nr_stopped },
|m: &mut CgroupStats| { &mut m.nr_stopped },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"nr_uninterruptible",
|m: &CgroupStats| { &m.nr_uninterruptible },
|m: &mut CgroupStats| { &mut m.nr_uninterruptible },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"nr_io_wait",
|m: &CgroupStats| { &m.nr_io_wait },
|m: &mut CgroupStats| { &mut m.nr_io_wait },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CgroupStats>(
"CgroupStats",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static CgroupStats {
static instance: ::protobuf::rt::LazyV2<CgroupStats> = ::protobuf::rt::LazyV2::INIT;
instance.get(CgroupStats::new)
}
}
impl ::protobuf::Clear for CgroupStats {
fn clear(&mut self) {
self.nr_sleeping = 0;
self.nr_running = 0;
self.nr_stopped = 0;
self.nr_uninterruptible = 0;
self.nr_io_wait = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CgroupStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CgroupStats {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n4github.com/containerd/cgroups/stats/v1/metrics.proto\x12\x18io.contai\
nerd.cgroups.v1\x1a\x14gogoproto/gogo.proto\"\xe8\x04\n\x07Metrics\x12A\
\n\x07hugetlb\x18\x01\x20\x03(\x0b2%.io.containerd.cgroups.v1.HugetlbSta\
tR\x07hugetlbB\0\x128\n\x04pids\x18\x02\x20\x01(\x0b2\".io.containerd.cg\
roups.v1.PidsStatR\x04pidsB\0\x12<\n\x03cpu\x18\x03\x20\x01(\x0b2!.io.co\
ntainerd.cgroups.v1.CPUStatR\x03cpuB\x07\xe2\xde\x1f\x03CPU\x12>\n\x06me\
mory\x18\x04\x20\x01(\x0b2$.io.containerd.cgroups.v1.MemoryStatR\x06memo\
ryB\0\x12;\n\x05blkio\x18\x05\x20\x01(\x0b2#.io.containerd.cgroups.v1.Bl\
kIOStatR\x05blkioB\0\x128\n\x04rdma\x18\x06\x20\x01(\x0b2\".io.container\
d.cgroups.v1.RdmaStatR\x04rdmaB\0\x12A\n\x07network\x18\x07\x20\x03(\x0b\
2%.io.containerd.cgroups.v1.NetworkStatR\x07networkB\0\x12J\n\x0ccgroup_\
stats\x18\x08\x20\x01(\x0b2%.io.containerd.cgroups.v1.CgroupStatsR\x0bcg\
roupStatsB\0\x12Z\n\x12memory_oom_control\x18\t\x20\x01(\x0b2*.io.contai\
nerd.cgroups.v1.MemoryOomControlR\x10memoryOomControlB\0:\0\"u\n\x0bHuge\
tlbStat\x12\x16\n\x05usage\x18\x01\x20\x01(\x04R\x05usageB\0\x12\x12\n\
\x03max\x18\x02\x20\x01(\x04R\x03maxB\0\x12\x1a\n\x07failcnt\x18\x03\x20\
\x01(\x04R\x07failcntB\0\x12\x1c\n\x08pagesize\x18\x04\x20\x01(\tR\x08pa\
gesizeB\0:\0\"@\n\x08PidsStat\x12\x1a\n\x07current\x18\x01\x20\x01(\x04R\
\x07currentB\0\x12\x16\n\x05limit\x18\x02\x20\x01(\x04R\x05limitB\0:\0\"\
\x8d\x01\n\x07CPUStat\x12:\n\x05usage\x18\x01\x20\x01(\x0b2\".io.contain\
erd.cgroups.v1.CPUUsageR\x05usageB\0\x12D\n\nthrottling\x18\x02\x20\x01(\
\x0b2\".io.containerd.cgroups.v1.ThrottleR\nthrottlingB\0:\0\"y\n\x08CPU\
Usage\x12\x16\n\x05total\x18\x01\x20\x01(\x04R\x05totalB\0\x12\x18\n\x06\
kernel\x18\x02\x20\x01(\x04R\x06kernelB\0\x12\x14\n\x04user\x18\x03\x20\
\x01(\x04R\x04userB\0\x12#\n\x07per_cpu\x18\x04\x20\x03(\x04R\x06perCpuB\
\n\xe2\xde\x1f\x06PerCPU:\0\"\x80\x01\n\x08Throttle\x12\x1a\n\x07periods\
\x18\x01\x20\x01(\x04R\x07periodsB\0\x12-\n\x11throttled_periods\x18\x02\
\x20\x01(\x04R\x10throttledPeriodsB\0\x12'\n\x0ethrottled_time\x18\x03\
\x20\x01(\x04R\rthrottledTimeB\0:\0\"\x99\x0c\n\nMemoryStat\x12\x16\n\
\x05cache\x18\x01\x20\x01(\x04R\x05cacheB\0\x12\x19\n\x03rss\x18\x02\x20\
\x01(\x04R\x03rssB\x07\xe2\xde\x1f\x03RSS\x12&\n\x08rss_huge\x18\x03\x20\
\x01(\x04R\x07rssHugeB\x0b\xe2\xde\x1f\x07RSSHuge\x12!\n\x0bmapped_file\
\x18\x04\x20\x01(\x04R\nmappedFileB\0\x12\x16\n\x05dirty\x18\x05\x20\x01\
(\x04R\x05dirtyB\0\x12\x1e\n\twriteback\x18\x06\x20\x01(\x04R\twriteback\
B\0\x12\x1a\n\x08pg_pg_in\x18\x07\x20\x01(\x04R\x06pgPgInB\0\x12\x1c\n\t\
pg_pg_out\x18\x08\x20\x01(\x04R\x07pgPgOutB\0\x12\x1b\n\x08pg_fault\x18\
\t\x20\x01(\x04R\x07pgFaultB\0\x12\"\n\x0cpg_maj_fault\x18\n\x20\x01(\
\x04R\npgMajFaultB\0\x12%\n\rinactive_anon\x18\x0b\x20\x01(\x04R\x0cinac\
tiveAnonB\0\x12!\n\x0bactive_anon\x18\x0c\x20\x01(\x04R\nactiveAnonB\0\
\x12%\n\rinactive_file\x18\r\x20\x01(\x04R\x0cinactiveFileB\0\x12!\n\x0b\
active_file\x18\x0e\x20\x01(\x04R\nactiveFileB\0\x12\"\n\x0bunevictable\
\x18\x0f\x20\x01(\x04R\x0bunevictableB\0\x12<\n\x19hierarchical_memory_l\
imit\x18\x10\x20\x01(\x04R\x17hierarchicalMemoryLimitB\0\x128\n\x17hiera\
rchical_swap_limit\x18\x11\x20\x01(\x04R\x15hierarchicalSwapLimitB\0\x12\
!\n\x0btotal_cache\x18\x12\x20\x01(\x04R\ntotalCacheB\0\x12)\n\ttotal_rs\
s\x18\x13\x20\x01(\x04R\x08totalRssB\x0c\xe2\xde\x1f\x08TotalRSS\x126\n\
\x0etotal_rss_huge\x18\x14\x20\x01(\x04R\x0ctotalRssHugeB\x10\xe2\xde\
\x1f\x0cTotalRSSHuge\x12,\n\x11total_mapped_file\x18\x15\x20\x01(\x04R\
\x0ftotalMappedFileB\0\x12!\n\x0btotal_dirty\x18\x16\x20\x01(\x04R\ntota\
lDirtyB\0\x12)\n\x0ftotal_writeback\x18\x17\x20\x01(\x04R\x0etotalWriteb\
ackB\0\x12%\n\x0etotal_pg_pg_in\x18\x18\x20\x01(\x04R\x0btotalPgPgInB\0\
\x12'\n\x0ftotal_pg_pg_out\x18\x19\x20\x01(\x04R\x0ctotalPgPgOutB\0\x12&\
\n\x0etotal_pg_fault\x18\x1a\x20\x01(\x04R\x0ctotalPgFaultB\0\x12-\n\x12\
total_pg_maj_fault\x18\x1b\x20\x01(\x04R\x0ftotalPgMajFaultB\0\x120\n\
\x13total_inactive_anon\x18\x1c\x20\x01(\x04R\x11totalInactiveAnonB\0\
\x12,\n\x11total_active_anon\x18\x1d\x20\x01(\x04R\x0ftotalActiveAnonB\0\
\x120\n\x13total_inactive_file\x18\x1e\x20\x01(\x04R\x11totalInactiveFil\
eB\0\x12,\n\x11total_active_file\x18\x1f\x20\x01(\x04R\x0ftotalActiveFil\
eB\0\x12-\n\x11total_unevictable\x18\x20\x20\x01(\x04R\x10totalUnevictab\
leB\0\x12=\n\x05usage\x18!\x20\x01(\x0b2%.io.containerd.cgroups.v1.Memor\
yEntryR\x05usageB\0\x12;\n\x04swap\x18\"\x20\x01(\x0b2%.io.containerd.cg\
roups.v1.MemoryEntryR\x04swapB\0\x12?\n\x06kernel\x18#\x20\x01(\x0b2%.io\
.containerd.cgroups.v1.MemoryEntryR\x06kernelB\0\x12S\n\nkernel_tcp\x18$\
\x20\x01(\x0b2%.io.containerd.cgroups.v1.MemoryEntryR\tkernelTcpB\r\xe2\
\xde\x1f\tKernelTCP:\0\"o\n\x0bMemoryEntry\x12\x16\n\x05limit\x18\x01\
\x20\x01(\x04R\x05limitB\0\x12\x16\n\x05usage\x18\x02\x20\x01(\x04R\x05u\
sageB\0\x12\x12\n\x03max\x18\x03\x20\x01(\x04R\x03maxB\0\x12\x1a\n\x07fa\
ilcnt\x18\x04\x20\x01(\x04R\x07failcntB\0:\0\"|\n\x10MemoryOomControl\
\x12*\n\x10oom_kill_disable\x18\x01\x20\x01(\x04R\x0eoomKillDisableB\0\
\x12\x1d\n\tunder_oom\x18\x02\x20\x01(\x04R\x08underOomB\0\x12\x1b\n\x08\
oom_kill\x18\x03\x20\x01(\x04R\x07oomKillB\0:\0\"\xe7\x05\n\tBlkIOStat\
\x12c\n\x1aio_service_bytes_recursive\x18\x01\x20\x03(\x0b2$.io.containe\
rd.cgroups.v1.BlkIOEntryR\x17ioServiceBytesRecursiveB\0\x12Z\n\x15io_ser\
viced_recursive\x18\x02\x20\x03(\x0b2$.io.containerd.cgroups.v1.BlkIOEnt\
ryR\x13ioServicedRecursiveB\0\x12V\n\x13io_queued_recursive\x18\x03\x20\
\x03(\x0b2$.io.containerd.cgroups.v1.BlkIOEntryR\x11ioQueuedRecursiveB\0\
\x12a\n\x19io_service_time_recursive\x18\x04\x20\x03(\x0b2$.io.container\
d.cgroups.v1.BlkIOEntryR\x16ioServiceTimeRecursiveB\0\x12[\n\x16io_wait_\
time_recursive\x18\x05\x20\x03(\x0b2$.io.containerd.cgroups.v1.BlkIOEntr\
yR\x13ioWaitTimeRecursiveB\0\x12V\n\x13io_merged_recursive\x18\x06\x20\
\x03(\x0b2$.io.containerd.cgroups.v1.BlkIOEntryR\x11ioMergedRecursiveB\0\
\x12R\n\x11io_time_recursive\x18\x07\x20\x03(\x0b2$.io.containerd.cgroup\
s.v1.BlkIOEntryR\x0fioTimeRecursiveB\0\x12S\n\x11sectors_recursive\x18\
\x08\x20\x03(\x0b2$.io.containerd.cgroups.v1.BlkIOEntryR\x10sectorsRecur\
siveB\0:\0\"\x82\x01\n\nBlkIOEntry\x12\x10\n\x02op\x18\x01\x20\x01(\tR\
\x02opB\0\x12\x18\n\x06device\x18\x02\x20\x01(\tR\x06deviceB\0\x12\x16\n\
\x05major\x18\x03\x20\x01(\x04R\x05majorB\0\x12\x16\n\x05minor\x18\x04\
\x20\x01(\x04R\x05minorB\0\x12\x16\n\x05value\x18\x05\x20\x01(\x04R\x05v\
alueB\0:\0\"\x8a\x01\n\x08RdmaStat\x12?\n\x07current\x18\x01\x20\x03(\
\x0b2#.io.containerd.cgroups.v1.RdmaEntryR\x07currentB\0\x12;\n\x05limit\
\x18\x02\x20\x03(\x0b2#.io.containerd.cgroups.v1.RdmaEntryR\x05limitB\0:\
\0\"m\n\tRdmaEntry\x12\x18\n\x06device\x18\x01\x20\x01(\tR\x06deviceB\0\
\x12!\n\x0bhca_handles\x18\x02\x20\x01(\rR\nhcaHandlesB\0\x12!\n\x0bhca_\
objects\x18\x03\x20\x01(\rR\nhcaObjectsB\0:\0\"\xa1\x02\n\x0bNetworkStat\
\x12\x14\n\x04name\x18\x01\x20\x01(\tR\x04nameB\0\x12\x1b\n\x08rx_bytes\
\x18\x02\x20\x01(\x04R\x07rxBytesB\0\x12\x1f\n\nrx_packets\x18\x03\x20\
\x01(\x04R\trxPacketsB\0\x12\x1d\n\trx_errors\x18\x04\x20\x01(\x04R\x08r\
xErrorsB\0\x12\x1f\n\nrx_dropped\x18\x05\x20\x01(\x04R\trxDroppedB\0\x12\
\x1b\n\x08tx_bytes\x18\x06\x20\x01(\x04R\x07txBytesB\0\x12\x1f\n\ntx_pac\
kets\x18\x07\x20\x01(\x04R\ttxPacketsB\0\x12\x1d\n\ttx_errors\x18\x08\
\x20\x01(\x04R\x08txErrorsB\0\x12\x1f\n\ntx_dropped\x18\t\x20\x01(\x04R\
\ttxDroppedB\0:\0\"\xc5\x01\n\x0bCgroupStats\x12!\n\x0bnr_sleeping\x18\
\x01\x20\x01(\x04R\nnrSleepingB\0\x12\x1f\n\nnr_running\x18\x02\x20\x01(\
\x04R\tnrRunningB\0\x12\x1f\n\nnr_stopped\x18\x03\x20\x01(\x04R\tnrStopp\
edB\0\x12/\n\x12nr_uninterruptible\x18\x04\x20\x01(\x04R\x11nrUninterrup\
tibleB\0\x12\x1e\n\nnr_io_wait\x18\x05\x20\x01(\x04R\x08nrIoWaitB\0:\0B\
\0b\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}