containerd-shim-protos 0.2.0

// This file is generated by rust-protobuf 2.27.1. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![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)]
//! Generated file from `github.com/containerd/containerd/api/events/task.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1;

#[derive(PartialEq,Clone,Default)]
pub struct TaskCreate {
    // message fields
    pub container_id: ::std::string::String,
    pub bundle: ::std::string::String,
    pub rootfs: ::protobuf::RepeatedField<super::mount::Mount>,
    pub io: ::protobuf::SingularPtrField<TaskIO>,
    pub checkpoint: ::std::string::String,
    pub pid: u32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskCreate {
    fn default() -> &'a TaskCreate {
        <TaskCreate as ::protobuf::Message>::default_instance()
    }
}

impl TaskCreate {
    pub fn new() -> TaskCreate {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // string bundle = 2;


    pub fn get_bundle(&self) -> &str {
        &self.bundle
    }
    pub fn clear_bundle(&mut self) {
        self.bundle.clear();
    }

    // Param is passed by value, moved
    pub fn set_bundle(&mut self, v: ::std::string::String) {
        self.bundle = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_bundle(&mut self) -> &mut ::std::string::String {
        &mut self.bundle
    }

    // Take field
    pub fn take_bundle(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.bundle, ::std::string::String::new())
    }

    // repeated .containerd.types.Mount rootfs = 3;


    pub fn get_rootfs(&self) -> &[super::mount::Mount] {
        &self.rootfs
    }
    pub fn clear_rootfs(&mut self) {
        self.rootfs.clear();
    }

    // Param is passed by value, moved
    pub fn set_rootfs(&mut self, v: ::protobuf::RepeatedField<super::mount::Mount>) {
        self.rootfs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_rootfs(&mut self) -> &mut ::protobuf::RepeatedField<super::mount::Mount> {
        &mut self.rootfs
    }

    // Take field
    pub fn take_rootfs(&mut self) -> ::protobuf::RepeatedField<super::mount::Mount> {
        ::std::mem::replace(&mut self.rootfs, ::protobuf::RepeatedField::new())
    }

    // .containerd.events.TaskIO io = 4;


    pub fn get_io(&self) -> &TaskIO {
        self.io.as_ref().unwrap_or_else(|| <TaskIO as ::protobuf::Message>::default_instance())
    }
    pub fn clear_io(&mut self) {
        self.io.clear();
    }

    pub fn has_io(&self) -> bool {
        self.io.is_some()
    }

    // Param is passed by value, moved
    pub fn set_io(&mut self, v: TaskIO) {
        self.io = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_io(&mut self) -> &mut TaskIO {
        if self.io.is_none() {
            self.io.set_default();
        }
        self.io.as_mut().unwrap()
    }

    // Take field
    pub fn take_io(&mut self) -> TaskIO {
        self.io.take().unwrap_or_else(|| TaskIO::new())
    }

    // string checkpoint = 5;


    pub fn get_checkpoint(&self) -> &str {
        &self.checkpoint
    }
    pub fn clear_checkpoint(&mut self) {
        self.checkpoint.clear();
    }

    // Param is passed by value, moved
    pub fn set_checkpoint(&mut self, v: ::std::string::String) {
        self.checkpoint = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_checkpoint(&mut self) -> &mut ::std::string::String {
        &mut self.checkpoint
    }

    // Take field
    pub fn take_checkpoint(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.checkpoint, ::std::string::String::new())
    }

    // uint32 pid = 6;


    pub fn get_pid(&self) -> u32 {
        self.pid
    }
    pub fn clear_pid(&mut self) {
        self.pid = 0;
    }

    // Param is passed by value, moved
    pub fn set_pid(&mut self, v: u32) {
        self.pid = v;
    }
}

impl ::protobuf::Message for TaskCreate {
    fn is_initialized(&self) -> bool {
        for v in &self.rootfs {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.io {
            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_proto3_string_into(wire_type, is, &mut self.container_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.bundle)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rootfs)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.io)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.checkpoint)?;
                },
                6 => {
                    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.pid = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if !self.bundle.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.bundle);
        }
        for value in &self.rootfs {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.io.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.checkpoint.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.checkpoint);
        }
        if self.pid != 0 {
            my_size += ::protobuf::rt::value_size(6, self.pid, ::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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if !self.bundle.is_empty() {
            os.write_string(2, &self.bundle)?;
        }
        for v in &self.rootfs {
            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.io.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 !self.checkpoint.is_empty() {
            os.write_string(5, &self.checkpoint)?;
        }
        if self.pid != 0 {
            os.write_uint32(6, self.pid)?;
        }
        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() -> TaskCreate {
        TaskCreate::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>(
                "container_id",
                |m: &TaskCreate| { &m.container_id },
                |m: &mut TaskCreate| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "bundle",
                |m: &TaskCreate| { &m.bundle },
                |m: &mut TaskCreate| { &mut m.bundle },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::mount::Mount>>(
                "rootfs",
                |m: &TaskCreate| { &m.rootfs },
                |m: &mut TaskCreate| { &mut m.rootfs },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TaskIO>>(
                "io",
                |m: &TaskCreate| { &m.io },
                |m: &mut TaskCreate| { &mut m.io },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "checkpoint",
                |m: &TaskCreate| { &m.checkpoint },
                |m: &mut TaskCreate| { &mut m.checkpoint },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "pid",
                |m: &TaskCreate| { &m.pid },
                |m: &mut TaskCreate| { &mut m.pid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskCreate>(
                "TaskCreate",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskCreate {
        static instance: ::protobuf::rt::LazyV2<TaskCreate> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskCreate::new)
    }
}

impl ::protobuf::Clear for TaskCreate {
    fn clear(&mut self) {
        self.container_id.clear();
        self.bundle.clear();
        self.rootfs.clear();
        self.io.clear();
        self.checkpoint.clear();
        self.pid = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskCreate {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskCreate {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskStart {
    // message fields
    pub container_id: ::std::string::String,
    pub pid: u32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskStart {
    fn default() -> &'a TaskStart {
        <TaskStart as ::protobuf::Message>::default_instance()
    }
}

impl TaskStart {
    pub fn new() -> TaskStart {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // uint32 pid = 2;


    pub fn get_pid(&self) -> u32 {
        self.pid
    }
    pub fn clear_pid(&mut self) {
        self.pid = 0;
    }

    // Param is passed by value, moved
    pub fn set_pid(&mut self, v: u32) {
        self.pid = v;
    }
}

impl ::protobuf::Message for TaskStart {
    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.container_id)?;
                },
                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.pid = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if self.pid != 0 {
            my_size += ::protobuf::rt::value_size(2, self.pid, ::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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if self.pid != 0 {
            os.write_uint32(2, self.pid)?;
        }
        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() -> TaskStart {
        TaskStart::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>(
                "container_id",
                |m: &TaskStart| { &m.container_id },
                |m: &mut TaskStart| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "pid",
                |m: &TaskStart| { &m.pid },
                |m: &mut TaskStart| { &mut m.pid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskStart>(
                "TaskStart",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskStart {
        static instance: ::protobuf::rt::LazyV2<TaskStart> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskStart::new)
    }
}

impl ::protobuf::Clear for TaskStart {
    fn clear(&mut self) {
        self.container_id.clear();
        self.pid = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskStart {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskStart {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskDelete {
    // message fields
    pub container_id: ::std::string::String,
    pub pid: u32,
    pub exit_status: u32,
    pub exited_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskDelete {
    fn default() -> &'a TaskDelete {
        <TaskDelete as ::protobuf::Message>::default_instance()
    }
}

impl TaskDelete {
    pub fn new() -> TaskDelete {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // uint32 pid = 2;


    pub fn get_pid(&self) -> u32 {
        self.pid
    }
    pub fn clear_pid(&mut self) {
        self.pid = 0;
    }

    // Param is passed by value, moved
    pub fn set_pid(&mut self, v: u32) {
        self.pid = v;
    }

    // uint32 exit_status = 3;


    pub fn get_exit_status(&self) -> u32 {
        self.exit_status
    }
    pub fn clear_exit_status(&mut self) {
        self.exit_status = 0;
    }

    // Param is passed by value, moved
    pub fn set_exit_status(&mut self, v: u32) {
        self.exit_status = v;
    }

    // .google.protobuf.Timestamp exited_at = 4;


    pub fn get_exited_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.exited_at.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_exited_at(&mut self) {
        self.exited_at.clear();
    }

    pub fn has_exited_at(&self) -> bool {
        self.exited_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_exited_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.exited_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_exited_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.exited_at.is_none() {
            self.exited_at.set_default();
        }
        self.exited_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_exited_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.exited_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // string id = 5;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: ::std::string::String) {
        self.id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_id(&mut self) -> &mut ::std::string::String {
        &mut self.id
    }

    // Take field
    pub fn take_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskDelete {
    fn is_initialized(&self) -> bool {
        for v in &self.exited_at {
            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_proto3_string_into(wire_type, is, &mut self.container_id)?;
                },
                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.pid = 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.exit_status = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.exited_at)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if self.pid != 0 {
            my_size += ::protobuf::rt::value_size(2, self.pid, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.exit_status != 0 {
            my_size += ::protobuf::rt::value_size(3, self.exit_status, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.exited_at.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.id);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if self.pid != 0 {
            os.write_uint32(2, self.pid)?;
        }
        if self.exit_status != 0 {
            os.write_uint32(3, self.exit_status)?;
        }
        if let Some(ref v) = self.exited_at.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 !self.id.is_empty() {
            os.write_string(5, &self.id)?;
        }
        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() -> TaskDelete {
        TaskDelete::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>(
                "container_id",
                |m: &TaskDelete| { &m.container_id },
                |m: &mut TaskDelete| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "pid",
                |m: &TaskDelete| { &m.pid },
                |m: &mut TaskDelete| { &mut m.pid },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "exit_status",
                |m: &TaskDelete| { &m.exit_status },
                |m: &mut TaskDelete| { &mut m.exit_status },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "exited_at",
                |m: &TaskDelete| { &m.exited_at },
                |m: &mut TaskDelete| { &mut m.exited_at },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "id",
                |m: &TaskDelete| { &m.id },
                |m: &mut TaskDelete| { &mut m.id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskDelete>(
                "TaskDelete",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskDelete {
        static instance: ::protobuf::rt::LazyV2<TaskDelete> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskDelete::new)
    }
}

impl ::protobuf::Clear for TaskDelete {
    fn clear(&mut self) {
        self.container_id.clear();
        self.pid = 0;
        self.exit_status = 0;
        self.exited_at.clear();
        self.id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskDelete {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskDelete {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskIO {
    // message fields
    pub stdin: ::std::string::String,
    pub stdout: ::std::string::String,
    pub stderr: ::std::string::String,
    pub terminal: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskIO {
    fn default() -> &'a TaskIO {
        <TaskIO as ::protobuf::Message>::default_instance()
    }
}

impl TaskIO {
    pub fn new() -> TaskIO {
        ::std::default::Default::default()
    }

    // string stdin = 1;


    pub fn get_stdin(&self) -> &str {
        &self.stdin
    }
    pub fn clear_stdin(&mut self) {
        self.stdin.clear();
    }

    // Param is passed by value, moved
    pub fn set_stdin(&mut self, v: ::std::string::String) {
        self.stdin = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_stdin(&mut self) -> &mut ::std::string::String {
        &mut self.stdin
    }

    // Take field
    pub fn take_stdin(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.stdin, ::std::string::String::new())
    }

    // string stdout = 2;


    pub fn get_stdout(&self) -> &str {
        &self.stdout
    }
    pub fn clear_stdout(&mut self) {
        self.stdout.clear();
    }

    // Param is passed by value, moved
    pub fn set_stdout(&mut self, v: ::std::string::String) {
        self.stdout = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_stdout(&mut self) -> &mut ::std::string::String {
        &mut self.stdout
    }

    // Take field
    pub fn take_stdout(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.stdout, ::std::string::String::new())
    }

    // string stderr = 3;


    pub fn get_stderr(&self) -> &str {
        &self.stderr
    }
    pub fn clear_stderr(&mut self) {
        self.stderr.clear();
    }

    // Param is passed by value, moved
    pub fn set_stderr(&mut self, v: ::std::string::String) {
        self.stderr = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_stderr(&mut self) -> &mut ::std::string::String {
        &mut self.stderr
    }

    // Take field
    pub fn take_stderr(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.stderr, ::std::string::String::new())
    }

    // bool terminal = 4;


    pub fn get_terminal(&self) -> bool {
        self.terminal
    }
    pub fn clear_terminal(&mut self) {
        self.terminal = false;
    }

    // Param is passed by value, moved
    pub fn set_terminal(&mut self, v: bool) {
        self.terminal = v;
    }
}

impl ::protobuf::Message for TaskIO {
    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.stdin)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.stdout)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.stderr)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.terminal = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.stdin.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.stdin);
        }
        if !self.stdout.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.stdout);
        }
        if !self.stderr.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.stderr);
        }
        if self.terminal != false {
            my_size += 2;
        }
        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.stdin.is_empty() {
            os.write_string(1, &self.stdin)?;
        }
        if !self.stdout.is_empty() {
            os.write_string(2, &self.stdout)?;
        }
        if !self.stderr.is_empty() {
            os.write_string(3, &self.stderr)?;
        }
        if self.terminal != false {
            os.write_bool(4, self.terminal)?;
        }
        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() -> TaskIO {
        TaskIO::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>(
                "stdin",
                |m: &TaskIO| { &m.stdin },
                |m: &mut TaskIO| { &mut m.stdin },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "stdout",
                |m: &TaskIO| { &m.stdout },
                |m: &mut TaskIO| { &mut m.stdout },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "stderr",
                |m: &TaskIO| { &m.stderr },
                |m: &mut TaskIO| { &mut m.stderr },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "terminal",
                |m: &TaskIO| { &m.terminal },
                |m: &mut TaskIO| { &mut m.terminal },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskIO>(
                "TaskIO",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskIO {
        static instance: ::protobuf::rt::LazyV2<TaskIO> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskIO::new)
    }
}

impl ::protobuf::Clear for TaskIO {
    fn clear(&mut self) {
        self.stdin.clear();
        self.stdout.clear();
        self.stderr.clear();
        self.terminal = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskIO {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskIO {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskExit {
    // message fields
    pub container_id: ::std::string::String,
    pub id: ::std::string::String,
    pub pid: u32,
    pub exit_status: u32,
    pub exited_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskExit {
    fn default() -> &'a TaskExit {
        <TaskExit as ::protobuf::Message>::default_instance()
    }
}

impl TaskExit {
    pub fn new() -> TaskExit {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // string id = 2;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: ::std::string::String) {
        self.id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_id(&mut self) -> &mut ::std::string::String {
        &mut self.id
    }

    // Take field
    pub fn take_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.id, ::std::string::String::new())
    }

    // uint32 pid = 3;


    pub fn get_pid(&self) -> u32 {
        self.pid
    }
    pub fn clear_pid(&mut self) {
        self.pid = 0;
    }

    // Param is passed by value, moved
    pub fn set_pid(&mut self, v: u32) {
        self.pid = v;
    }

    // uint32 exit_status = 4;


    pub fn get_exit_status(&self) -> u32 {
        self.exit_status
    }
    pub fn clear_exit_status(&mut self) {
        self.exit_status = 0;
    }

    // Param is passed by value, moved
    pub fn set_exit_status(&mut self, v: u32) {
        self.exit_status = v;
    }

    // .google.protobuf.Timestamp exited_at = 5;


    pub fn get_exited_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.exited_at.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_exited_at(&mut self) {
        self.exited_at.clear();
    }

    pub fn has_exited_at(&self) -> bool {
        self.exited_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_exited_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.exited_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_exited_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.exited_at.is_none() {
            self.exited_at.set_default();
        }
        self.exited_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_exited_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.exited_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for TaskExit {
    fn is_initialized(&self) -> bool {
        for v in &self.exited_at {
            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_proto3_string_into(wire_type, is, &mut self.container_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?;
                },
                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.pid = 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_uint32()?;
                    self.exit_status = tmp;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.exited_at)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.id);
        }
        if self.pid != 0 {
            my_size += ::protobuf::rt::value_size(3, self.pid, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.exit_status != 0 {
            my_size += ::protobuf::rt::value_size(4, self.exit_status, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.exited_at.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 !self.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if !self.id.is_empty() {
            os.write_string(2, &self.id)?;
        }
        if self.pid != 0 {
            os.write_uint32(3, self.pid)?;
        }
        if self.exit_status != 0 {
            os.write_uint32(4, self.exit_status)?;
        }
        if let Some(ref v) = self.exited_at.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)?;
        }
        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() -> TaskExit {
        TaskExit::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>(
                "container_id",
                |m: &TaskExit| { &m.container_id },
                |m: &mut TaskExit| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "id",
                |m: &TaskExit| { &m.id },
                |m: &mut TaskExit| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "pid",
                |m: &TaskExit| { &m.pid },
                |m: &mut TaskExit| { &mut m.pid },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "exit_status",
                |m: &TaskExit| { &m.exit_status },
                |m: &mut TaskExit| { &mut m.exit_status },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "exited_at",
                |m: &TaskExit| { &m.exited_at },
                |m: &mut TaskExit| { &mut m.exited_at },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskExit>(
                "TaskExit",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskExit {
        static instance: ::protobuf::rt::LazyV2<TaskExit> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskExit::new)
    }
}

impl ::protobuf::Clear for TaskExit {
    fn clear(&mut self) {
        self.container_id.clear();
        self.id.clear();
        self.pid = 0;
        self.exit_status = 0;
        self.exited_at.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskExit {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskExit {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskOOM {
    // message fields
    pub container_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskOOM {
    fn default() -> &'a TaskOOM {
        <TaskOOM as ::protobuf::Message>::default_instance()
    }
}

impl TaskOOM {
    pub fn new() -> TaskOOM {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskOOM {
    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.container_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        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() -> TaskOOM {
        TaskOOM::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>(
                "container_id",
                |m: &TaskOOM| { &m.container_id },
                |m: &mut TaskOOM| { &mut m.container_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskOOM>(
                "TaskOOM",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskOOM {
        static instance: ::protobuf::rt::LazyV2<TaskOOM> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskOOM::new)
    }
}

impl ::protobuf::Clear for TaskOOM {
    fn clear(&mut self) {
        self.container_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskOOM {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskOOM {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskExecAdded {
    // message fields
    pub container_id: ::std::string::String,
    pub exec_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskExecAdded {
    fn default() -> &'a TaskExecAdded {
        <TaskExecAdded as ::protobuf::Message>::default_instance()
    }
}

impl TaskExecAdded {
    pub fn new() -> TaskExecAdded {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // string exec_id = 2;


    pub fn get_exec_id(&self) -> &str {
        &self.exec_id
    }
    pub fn clear_exec_id(&mut self) {
        self.exec_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_exec_id(&mut self, v: ::std::string::String) {
        self.exec_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_exec_id(&mut self) -> &mut ::std::string::String {
        &mut self.exec_id
    }

    // Take field
    pub fn take_exec_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.exec_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskExecAdded {
    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.container_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.exec_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if !self.exec_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.exec_id);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if !self.exec_id.is_empty() {
            os.write_string(2, &self.exec_id)?;
        }
        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() -> TaskExecAdded {
        TaskExecAdded::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>(
                "container_id",
                |m: &TaskExecAdded| { &m.container_id },
                |m: &mut TaskExecAdded| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "exec_id",
                |m: &TaskExecAdded| { &m.exec_id },
                |m: &mut TaskExecAdded| { &mut m.exec_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskExecAdded>(
                "TaskExecAdded",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskExecAdded {
        static instance: ::protobuf::rt::LazyV2<TaskExecAdded> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskExecAdded::new)
    }
}

impl ::protobuf::Clear for TaskExecAdded {
    fn clear(&mut self) {
        self.container_id.clear();
        self.exec_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskExecAdded {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskExecAdded {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskExecStarted {
    // message fields
    pub container_id: ::std::string::String,
    pub exec_id: ::std::string::String,
    pub pid: u32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskExecStarted {
    fn default() -> &'a TaskExecStarted {
        <TaskExecStarted as ::protobuf::Message>::default_instance()
    }
}

impl TaskExecStarted {
    pub fn new() -> TaskExecStarted {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // string exec_id = 2;


    pub fn get_exec_id(&self) -> &str {
        &self.exec_id
    }
    pub fn clear_exec_id(&mut self) {
        self.exec_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_exec_id(&mut self, v: ::std::string::String) {
        self.exec_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_exec_id(&mut self) -> &mut ::std::string::String {
        &mut self.exec_id
    }

    // Take field
    pub fn take_exec_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.exec_id, ::std::string::String::new())
    }

    // uint32 pid = 3;


    pub fn get_pid(&self) -> u32 {
        self.pid
    }
    pub fn clear_pid(&mut self) {
        self.pid = 0;
    }

    // Param is passed by value, moved
    pub fn set_pid(&mut self, v: u32) {
        self.pid = v;
    }
}

impl ::protobuf::Message for TaskExecStarted {
    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.container_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.exec_id)?;
                },
                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.pid = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if !self.exec_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.exec_id);
        }
        if self.pid != 0 {
            my_size += ::protobuf::rt::value_size(3, self.pid, ::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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if !self.exec_id.is_empty() {
            os.write_string(2, &self.exec_id)?;
        }
        if self.pid != 0 {
            os.write_uint32(3, self.pid)?;
        }
        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() -> TaskExecStarted {
        TaskExecStarted::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>(
                "container_id",
                |m: &TaskExecStarted| { &m.container_id },
                |m: &mut TaskExecStarted| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "exec_id",
                |m: &TaskExecStarted| { &m.exec_id },
                |m: &mut TaskExecStarted| { &mut m.exec_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                "pid",
                |m: &TaskExecStarted| { &m.pid },
                |m: &mut TaskExecStarted| { &mut m.pid },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskExecStarted>(
                "TaskExecStarted",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskExecStarted {
        static instance: ::protobuf::rt::LazyV2<TaskExecStarted> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskExecStarted::new)
    }
}

impl ::protobuf::Clear for TaskExecStarted {
    fn clear(&mut self) {
        self.container_id.clear();
        self.exec_id.clear();
        self.pid = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskExecStarted {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskExecStarted {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskPaused {
    // message fields
    pub container_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskPaused {
    fn default() -> &'a TaskPaused {
        <TaskPaused as ::protobuf::Message>::default_instance()
    }
}

impl TaskPaused {
    pub fn new() -> TaskPaused {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskPaused {
    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.container_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        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() -> TaskPaused {
        TaskPaused::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>(
                "container_id",
                |m: &TaskPaused| { &m.container_id },
                |m: &mut TaskPaused| { &mut m.container_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskPaused>(
                "TaskPaused",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskPaused {
        static instance: ::protobuf::rt::LazyV2<TaskPaused> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskPaused::new)
    }
}

impl ::protobuf::Clear for TaskPaused {
    fn clear(&mut self) {
        self.container_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskPaused {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskPaused {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskResumed {
    // message fields
    pub container_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskResumed {
    fn default() -> &'a TaskResumed {
        <TaskResumed as ::protobuf::Message>::default_instance()
    }
}

impl TaskResumed {
    pub fn new() -> TaskResumed {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskResumed {
    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.container_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        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() -> TaskResumed {
        TaskResumed::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>(
                "container_id",
                |m: &TaskResumed| { &m.container_id },
                |m: &mut TaskResumed| { &mut m.container_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskResumed>(
                "TaskResumed",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskResumed {
        static instance: ::protobuf::rt::LazyV2<TaskResumed> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskResumed::new)
    }
}

impl ::protobuf::Clear for TaskResumed {
    fn clear(&mut self) {
        self.container_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskResumed {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskResumed {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct TaskCheckpointed {
    // message fields
    pub container_id: ::std::string::String,
    pub checkpoint: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a TaskCheckpointed {
    fn default() -> &'a TaskCheckpointed {
        <TaskCheckpointed as ::protobuf::Message>::default_instance()
    }
}

impl TaskCheckpointed {
    pub fn new() -> TaskCheckpointed {
        ::std::default::Default::default()
    }

    // string container_id = 1;


    pub fn get_container_id(&self) -> &str {
        &self.container_id
    }
    pub fn clear_container_id(&mut self) {
        self.container_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_container_id(&mut self, v: ::std::string::String) {
        self.container_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_container_id(&mut self) -> &mut ::std::string::String {
        &mut self.container_id
    }

    // Take field
    pub fn take_container_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.container_id, ::std::string::String::new())
    }

    // string checkpoint = 2;


    pub fn get_checkpoint(&self) -> &str {
        &self.checkpoint
    }
    pub fn clear_checkpoint(&mut self) {
        self.checkpoint.clear();
    }

    // Param is passed by value, moved
    pub fn set_checkpoint(&mut self, v: ::std::string::String) {
        self.checkpoint = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_checkpoint(&mut self) -> &mut ::std::string::String {
        &mut self.checkpoint
    }

    // Take field
    pub fn take_checkpoint(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.checkpoint, ::std::string::String::new())
    }
}

impl ::protobuf::Message for TaskCheckpointed {
    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.container_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.checkpoint)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.container_id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.container_id);
        }
        if !self.checkpoint.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.checkpoint);
        }
        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.container_id.is_empty() {
            os.write_string(1, &self.container_id)?;
        }
        if !self.checkpoint.is_empty() {
            os.write_string(2, &self.checkpoint)?;
        }
        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() -> TaskCheckpointed {
        TaskCheckpointed::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>(
                "container_id",
                |m: &TaskCheckpointed| { &m.container_id },
                |m: &mut TaskCheckpointed| { &mut m.container_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "checkpoint",
                |m: &TaskCheckpointed| { &m.checkpoint },
                |m: &mut TaskCheckpointed| { &mut m.checkpoint },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TaskCheckpointed>(
                "TaskCheckpointed",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static TaskCheckpointed {
        static instance: ::protobuf::rt::LazyV2<TaskCheckpointed> = ::protobuf::rt::LazyV2::INIT;
        instance.get(TaskCheckpointed::new)
    }
}

impl ::protobuf::Clear for TaskCheckpointed {
    fn clear(&mut self) {
        self.container_id.clear();
        self.checkpoint.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for TaskCheckpointed {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TaskCheckpointed {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n6github.com/containerd/containerd/api/events/task.proto\x12\x11contain\
    erd.events\x1a\x14gogoproto/gogo.proto\x1a\x1fgoogle/protobuf/timestamp.\
    proto\x1a6github.com/containerd/containerd/api/types/mount.proto\x1a@git\
    hub.com/containerd/containerd/protobuf/plugin/fieldpath.protoX\0X\x03\"\
    \xe9\x01\n\nTaskCreate\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcon\
    tainerIdB\0\x12\x18\n\x06bundle\x18\x02\x20\x01(\tR\x06bundleB\0\x121\n\
    \x06rootfs\x18\x03\x20\x03(\x0b2\x17.containerd.types.MountR\x06rootfsB\
    \0\x121\n\x02io\x18\x04\x20\x01(\x0b2\x19.containerd.events.TaskIOR\x02i\
    oB\x06\xe2\xde\x1f\x02IO\x12\x20\n\ncheckpoint\x18\x05\x20\x01(\tR\nchec\
    kpointB\0\x12\x12\n\x03pid\x18\x06\x20\x01(\rR\x03pidB\0:\0\"F\n\tTaskSt\
    art\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0\x12\x12\
    \n\x03pid\x18\x02\x20\x01(\rR\x03pidB\0:\0\"\xbf\x01\n\nTaskDelete\x12#\
    \n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0\x12\x12\n\x03pi\
    d\x18\x02\x20\x01(\rR\x03pidB\0\x12!\n\x0bexit_status\x18\x03\x20\x01(\r\
    R\nexitStatusB\0\x12A\n\texited_at\x18\x04\x20\x01(\x0b2\x1a.google.prot\
    obuf.TimestampR\x08exitedAtB\x08\x90\xdf\x1f\x01\xc8\xde\x1f\0\x12\x10\n\
    \x02id\x18\x05\x20\x01(\tR\x02idB\0:\0\"t\n\x06TaskIO\x12\x16\n\x05stdin\
    \x18\x01\x20\x01(\tR\x05stdinB\0\x12\x18\n\x06stdout\x18\x02\x20\x01(\tR\
    \x06stdoutB\0\x12\x18\n\x06stderr\x18\x03\x20\x01(\tR\x06stderrB\0\x12\
    \x1c\n\x08terminal\x18\x04\x20\x01(\x08R\x08terminalB\0:\0\"\xbd\x01\n\
    \x08TaskExit\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\
    \0\x12\x10\n\x02id\x18\x02\x20\x01(\tR\x02idB\0\x12\x12\n\x03pid\x18\x03\
    \x20\x01(\rR\x03pidB\0\x12!\n\x0bexit_status\x18\x04\x20\x01(\rR\nexitSt\
    atusB\0\x12A\n\texited_at\x18\x05\x20\x01(\x0b2\x1a.google.protobuf.Time\
    stampR\x08exitedAtB\x08\x90\xdf\x1f\x01\xc8\xde\x1f\0:\0\"0\n\x07TaskOOM\
    \x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0:\0\"Q\n\rT\
    askExecAdded\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\
    \0\x12\x19\n\x07exec_id\x18\x02\x20\x01(\tR\x06execIdB\0:\0\"g\n\x0fTask\
    ExecStarted\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0\
    \x12\x19\n\x07exec_id\x18\x02\x20\x01(\tR\x06execIdB\0\x12\x12\n\x03pid\
    \x18\x03\x20\x01(\rR\x03pidB\0:\0\"3\n\nTaskPaused\x12#\n\x0ccontainer_i\
    d\x18\x01\x20\x01(\tR\x0bcontainerIdB\0:\0\"4\n\x0bTaskResumed\x12#\n\
    \x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0:\0\"[\n\x10TaskCh\
    eckpointed\x12#\n\x0ccontainer_id\x18\x01\x20\x01(\tR\x0bcontainerIdB\0\
    \x12\x20\n\ncheckpoint\x18\x02\x20\x01(\tR\ncheckpointB\0:\0B\x04\xa0\
    \xf4\x1e\x01b\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()
    })
}