SYMBOL INDEX (912 symbols across 71 files)

FILE: crates/client/build.rs
  constant PROTO_FILES (line 19) | const PROTO_FILES: &[&str] = &[
  constant FIXUP_MODULES (line 56) | const FIXUP_MODULES: &[&str] = &[
  function main (line 68) | fn main() {
  function fixup_imports (line 98) | fn fixup_imports(path: &str) -> Result<(), io::Error> {

FILE: crates/client/examples/container.rs
  constant CID (line 31) | const CID: &str = "abc123";
  constant NAMESPACE (line 32) | const NAMESPACE: &str = "default";
  function main (line 37) | async fn main() {

FILE: crates/client/examples/container_events.rs
  function main (line 25) | async fn main() {

FILE: crates/client/examples/container_pull.rs
  constant IMAGE (line 31) | const IMAGE: &str = "docker.io/library/alpine:latest";
  constant NAMESPACE (line 32) | const NAMESPACE: &str = "default";
  function main (line 37) | async fn main() {

FILE: crates/client/examples/version.rs
  function main (line 21) | async fn main() {

FILE: crates/client/src/lib.rs
  function connect (line 86) | pub async fn connect(
  function to_any (line 130) | pub fn to_any<T: Message + Name>(m: &T) -> Any {
  type Client (line 169) | pub struct Client {
    method from (line 174) | fn from(value: Channel) -> Self {
    method from_path (line 182) | pub async fn from_path(path: impl AsRef<std::path::Path>) -> Result<Se...
    method channel (line 189) | pub fn channel(&self) -> Channel {
    method version (line 195) | pub fn version(&self) -> VersionClient<Channel> {
    method tasks (line 201) | pub fn tasks(&self) -> TasksClient<Channel> {
    method transfer (line 207) | pub fn transfer(&self) -> TransferClient<Channel> {
    method sandbox_store (line 213) | pub fn sandbox_store(&self) -> StoreClient<Channel> {
    method streaming (line 219) | pub fn streaming(&self) -> StreamingClient<Channel> {
    method sandbox_controller (line 225) | pub fn sandbox_controller(&self) -> ControllerClient<Channel> {
    method snapshots (line 231) | pub fn snapshots(&self) -> SnapshotsClient<Channel> {
    method namespaces (line 237) | pub fn namespaces(&self) -> NamespacesClient<Channel> {
    method leases (line 243) | pub fn leases(&self) -> LeasesClient<Channel> {
    method introspection (line 249) | pub fn introspection(&self) -> IntrospectionClient<Channel> {
    method images (line 255) | pub fn images(&self) -> ImagesClient<Channel> {
    method events (line 261) | pub fn events(&self) -> EventsClient<Channel> {
    method diff (line 267) | pub fn diff(&self) -> DiffClient<Channel> {
    method content (line 273) | pub fn content(&self) -> ContentClient<Channel> {
    method containers (line 279) | pub fn containers(&self) -> ContainersClient<Channel> {
  function any_roundtrip (line 291) | fn any_roundtrip() {

FILE: crates/logging/examples/journal.rs
  function pump (line 22) | fn pump(reader: fs::File) {
  type Journal (line 33) | struct Journal {
  type Error (line 39) | type Error = String;
  method new (line 41) | fn new(config: Config) -> Result<Self, Self::Error> {
  method wait (line 51) | fn wait(self) -> Result<(), Self::Error> {
  function main (line 62) | fn main() {

FILE: crates/logging/src/lib.rs
  type Config (line 23) | pub struct Config {
    method new (line 43) | fn new() -> Config {
  type Ready (line 73) | struct Ready(fs::File);
    method new (line 76) | fn new() -> Ready {
    method signal (line 81) | fn signal(self) {
  type Driver (line 112) | pub trait Driver: Sized {
    method new (line 120) | fn new(config: Config) -> Result<Self, Self::Error>;
    method wait (line 125) | fn wait(self) -> Result<(), Self::Error>;
  function run (line 131) | pub fn run<D: Driver>() {
  function handle_err (line 153) | fn handle_err(err: impl fmt::Debug) -> ! {

FILE: crates/runc-shim/build.rs
  function main (line 19) | fn main() {

FILE: crates/runc-shim/src/cgroup_memory.rs
  function get_path_from_cgorup (line 32) | pub async fn get_path_from_cgorup(pid: u32) -> Result<String> {
  function get_existing_cgroup_mem_path (line 48) | pub async fn get_existing_cgroup_mem_path(pid_path: String) -> Result<(S...
  function get_path_from_mountinfo (line 57) | async fn get_path_from_mountinfo() -> Result<(String, String)> {
  function parse_memory_mountroot (line 74) | fn parse_memory_mountroot(line: &str) -> Result<(String, String)> {
  function register_memory_event (line 85) | pub async fn register_memory_event(
  function test_cgroupv1_oom_monitor (line 140) | async fn test_cgroupv1_oom_monitor() {

FILE: crates/runc-shim/src/common.rs
  constant GROUP_LABELS (line 55) | pub const GROUP_LABELS: [&str; 2] = [
  constant INIT_PID_FILE (line 59) | pub const INIT_PID_FILE: &str = "init.pid";
  constant LOG_JSON_FILE (line 60) | pub const LOG_JSON_FILE: &str = "log.json";
  constant FIFO_SCHEME (line 61) | pub const FIFO_SCHEME: &str = "fifo";
  constant TIMEOUT_DURATION (line 63) | const TIMEOUT_DURATION: std::time::Duration = Duration::from_secs(3);
  type Log (line 66) | pub struct Log {
  type ProcessIO (line 72) | pub struct ProcessIO {
  function create_io (line 78) | pub fn create_io(
  type ShimExecutor (line 122) | pub struct ShimExecutor {}
  function get_spec_from_request (line 124) | pub fn get_spec_from_request(
  function check_kill_error (line 136) | pub fn check_kill_error(emsg: String) -> Error {
  constant DEFAULT_RUNC_ROOT (line 150) | const DEFAULT_RUNC_ROOT: &str = "/run/containerd/runc";
  constant DEFAULT_COMMAND (line 151) | const DEFAULT_COMMAND: &str = "runc";
  function create_runc (line 153) | pub fn create_runc(
  type CreateConfig (line 189) | pub(crate) struct CreateConfig {}
  function receive_socket (line 191) | pub fn receive_socket(stream_fd: RawFd) -> containerd_shim::Result<Owned...
  function has_shared_pid_namespace (line 229) | pub fn has_shared_pid_namespace(spec: &Spec) -> bool {
  function xdg_runtime_dir (line 248) | pub(crate) fn xdg_runtime_dir() -> String {
  function handle_file_open (line 253) | pub async fn handle_file_open<F, Fut>(file_op: F) -> Result<tokio::fs::F...

FILE: crates/runc-shim/src/console.rs
  type ConsoleSocket (line 26) | pub struct ConsoleSocket {
    method new (line 33) | pub async fn new() -> Result<ConsoleSocket> {
    method accept (line 49) | pub async fn accept(&self) -> Result<UnixStream> {
    method clean (line 59) | pub async fn clean(self) {

FILE: crates/runc-shim/src/container.rs
  type Container (line 39) | pub trait Container {
    method start (line 40) | async fn start(&mut self, exec_id: Option<&str>) -> Result<i32>;
    method state (line 41) | async fn state(&self, exec_id: Option<&str>) -> Result<StateResponse>;
    method kill (line 42) | async fn kill(&mut self, exec_id: Option<&str>, signal: u32, all: bool...
    method wait_channel (line 43) | async fn wait_channel(&mut self, exec_id: Option<&str>) -> Result<Rece...
    method get_exit_info (line 44) | async fn get_exit_info(
    method delete (line 48) | async fn delete(
    method exec (line 52) | async fn exec(&mut self, req: ExecProcessRequest) -> Result<()>;
    method resize_pty (line 53) | async fn resize_pty(&mut self, exec_id: Option<&str>, height: u32, wid...
    method pid (line 54) | async fn pid(&self) -> i32;
    method id (line 55) | async fn id(&self) -> String;
    method update (line 56) | async fn update(&mut self, resources: &LinuxResources) -> Result<()>;
    method stats (line 57) | async fn stats(&self) -> Result<Metrics>;
    method all_processes (line 58) | async fn all_processes(&self) -> Result<Vec<ProcessInfo>>;
    method close_io (line 59) | async fn close_io(&mut self, exec_id: Option<&str>) -> Result<()>;
    method pause (line 60) | async fn pause(&mut self) -> Result<()>;
    method resume (line 61) | async fn resume(&mut self) -> Result<()>;
    method init_state (line 62) | async fn init_state(&self) -> EnumOrUnknown<Status>;
    method init_state (line 100) | async fn init_state(&self) -> EnumOrUnknown<Status> {
    method start (line 105) | async fn start(&mut self, exec_id: Option<&str>) -> Result<i32> {
    method state (line 111) | async fn state(&self, exec_id: Option<&str>) -> Result<StateResponse> {
    method kill (line 125) | async fn kill(&mut self, exec_id: Option<&str>, signal: u32, all: bool...
    method wait_channel (line 130) | async fn wait_channel(&mut self, exec_id: Option<&str>) -> Result<Rece...
    method get_exit_info (line 135) | async fn get_exit_info(
    method delete (line 147) | async fn delete(
    method exec (line 163) | async fn exec(&mut self, req: ExecProcessRequest) -> Result<()> {
    method resize_pty (line 170) | async fn resize_pty(&mut self, exec_id: Option<&str>, height: u32, wid...
    method pid (line 175) | async fn pid(&self) -> i32 {
    method id (line 179) | async fn id(&self) -> String {
    method update (line 184) | async fn update(&mut self, resources: &LinuxResources) -> Result<()> {
    method update (line 189) | async fn update(&mut self, _resources: &LinuxResources) -> Result<()> {
    method stats (line 194) | async fn stats(&self) -> Result<Metrics> {
    method stats (line 199) | async fn stats(&self) -> Result<Metrics> {
    method all_processes (line 203) | async fn all_processes(&self) -> Result<Vec<ProcessInfo>> {
    method close_io (line 225) | async fn close_io(&mut self, exec_id: Option<&str>) -> Result<()> {
    method pause (line 230) | async fn pause(&mut self) -> Result<()> {
    method resume (line 234) | async fn resume(&mut self) -> Result<()> {
  type ContainerFactory (line 66) | pub trait ContainerFactory<C> {
    method create (line 67) | async fn create(&self, ns: &str, req: &CreateTaskRequest) -> Result<C>;
    method cleanup (line 68) | async fn cleanup(&self, ns: &str, c: &C) -> Result<()>;
  type ProcessFactory (line 72) | pub trait ProcessFactory<E> {
    method create (line 73) | async fn create(&self, req: &ExecProcessRequest) -> Result<E>;
  type ContainerTemplate (line 80) | pub struct ContainerTemplate<T, E, P> {
  function get_process (line 244) | pub fn get_process(&self, exec_id: Option<&str>) -> Result<&(dyn Process...
  function get_mut_process (line 256) | pub fn get_mut_process(

FILE: crates/runc-shim/src/io.rs
  type Stdio (line 18) | pub struct Stdio {
    method new (line 26) | pub fn new(stdin: &str, stdout: &str, stderr: &str, terminal: bool) ->...
    method is_null (line 35) | pub fn is_null(&self) -> bool {

FILE: crates/runc-shim/src/main.rs
  function parse_version (line 38) | fn parse_version() {
  function main (line 82) | async fn main() {

FILE: crates/runc-shim/src/processes.rs
  type Process (line 40) | pub trait Process {
    method start (line 41) | async fn start(&mut self) -> Result<()>;
    method set_exited (line 42) | async fn set_exited(&mut self, exit_code: i32);
    method pid (line 43) | async fn pid(&self) -> i32;
    method state (line 44) | async fn state(&self) -> Result<StateResponse>;
    method kill (line 45) | async fn kill(&mut self, signal: u32, all: bool) -> Result<()>;
    method delete (line 46) | async fn delete(&mut self) -> Result<()>;
    method wait_channel (line 47) | async fn wait_channel(&mut self) -> Result<Receiver<()>>;
    method exit_code (line 48) | async fn exit_code(&self) -> i32;
    method exited_at (line 49) | async fn exited_at(&self) -> Option<OffsetDateTime>;
    method resize_pty (line 50) | async fn resize_pty(&mut self, height: u32, width: u32) -> Result<()>;
    method update (line 51) | async fn update(&mut self, resources: &LinuxResources) -> Result<()>;
    method stats (line 52) | async fn stats(&self) -> Result<Metrics>;
    method ps (line 53) | async fn ps(&self) -> Result<Vec<ProcessInfo>>;
    method close_io (line 54) | async fn close_io(&mut self) -> Result<()>;
    method pause (line 55) | async fn pause(&mut self) -> Result<()>;
    method resume (line 56) | async fn resume(&mut self) -> Result<()>;
    method id (line 57) | async fn id(&self) -> &str;
    method start (line 107) | async fn start(&mut self) -> Result<()> {
    method set_exited (line 112) | async fn set_exited(&mut self, exit_code: i32) {
    method pid (line 120) | async fn pid(&self) -> i32 {
    method id (line 124) | async fn id(&self) -> &str {
    method state (line 128) | async fn state(&self) -> Result<StateResponse> {
    method kill (line 147) | async fn kill(&mut self, signal: u32, all: bool) -> Result<()> {
    method delete (line 151) | async fn delete(&mut self) -> Result<()> {
    method wait_channel (line 155) | async fn wait_channel(&mut self) -> Result<Receiver<()>> {
    method exit_code (line 163) | async fn exit_code(&self) -> i32 {
    method exited_at (line 167) | async fn exited_at(&self) -> Option<OffsetDateTime> {
    method resize_pty (line 171) | async fn resize_pty(&mut self, height: u32, width: u32) -> Result<()> {
    method update (line 185) | async fn update(&mut self, resources: &LinuxResources) -> Result<()> {
    method stats (line 189) | async fn stats(&self) -> Result<Metrics> {
    method ps (line 193) | async fn ps(&self) -> Result<Vec<ProcessInfo>> {
    method close_io (line 197) | async fn close_io(&mut self) -> Result<()> {
    method pause (line 205) | async fn pause(&mut self) -> Result<()> {
    method resume (line 209) | async fn resume(&mut self) -> Result<()> {
  type ProcessLifecycle (line 61) | pub trait ProcessLifecycle<P: Process> {
    method start (line 62) | async fn start(&self, p: &mut P) -> Result<()>;
    method kill (line 63) | async fn kill(&self, p: &mut P, signal: u32, all: bool) -> Result<()>;
    method delete (line 64) | async fn delete(&self, p: &mut P) -> Result<()>;
    method update (line 65) | async fn update(&self, p: &mut P, resources: &LinuxResources) -> Resul...
    method stats (line 66) | async fn stats(&self, p: &P) -> Result<Metrics>;
    method ps (line 67) | async fn ps(&self, p: &P) -> Result<Vec<ProcessInfo>>;
    method pause (line 68) | async fn pause(&self, p: &mut P) -> Result<()>;
    method resume (line 69) | async fn resume(&self, p: &mut P) -> Result<()>;
  type ProcessTemplate (line 72) | pub struct ProcessTemplate<S> {
  function new (line 86) | pub fn new(id: &str, stdio: Stdio, lifecycle: S) -> Self {

FILE: crates/runc-shim/src/runc.rs
  type ExecProcess (line 73) | pub type ExecProcess = ProcessTemplate<RuncExecLifecycle>;
  type InitProcess (line 74) | pub type InitProcess = ProcessTemplate<RuncInitLifecycle>;
  type RuncContainer (line 76) | pub type RuncContainer = ContainerTemplate<InitProcess, ExecProcess, Run...
  type RuncFactory (line 79) | pub(crate) struct RuncFactory {}
    method create (line 83) | async fn create(
    method cleanup (line 155) | async fn cleanup(&self, _ns: &str, _c: &RuncContainer) -> containerd_s...
    method do_create (line 161) | async fn do_create(&self, init: &mut InitProcess, _config: CreateConfi...
  function runtime_error (line 201) | pub async fn runtime_error(bundle: &str, e: runc::error::Error, msg: &st...
  type RuncExecFactory (line 227) | pub struct RuncExecFactory {
    method create (line 236) | async fn create(&self, req: &ExecProcessRequest) -> Result<ExecProcess> {
  type RuncInitLifecycle (line 266) | pub struct RuncInitLifecycle {
    method start (line 278) | async fn start(&self, p: &mut InitProcess) -> containerd_shim::Result<...
    method kill (line 286) | async fn kill(
    method delete (line 302) | async fn delete(&self, p: &mut InitProcess) -> containerd_shim::Result...
    method update (line 323) | async fn update(&self, p: &mut InitProcess, resources: &LinuxResources...
    method update (line 346) | async fn update(&self, _p: &mut InitProcess, _resources: &LinuxResourc...
    method stats (line 351) | async fn stats(&self, p: &InitProcess) -> Result<Metrics> {
    method stats (line 374) | async fn stats(&self, _p: &InitProcess) -> Result<Metrics> {
    method ps (line 378) | async fn ps(&self, p: &InitProcess) -> Result<Vec<ProcessInfo>> {
    method pause (line 394) | async fn pause(&self, p: &mut InitProcess) -> Result<()> {
    method pause (line 410) | async fn pause(&self, _p: &mut InitProcess) -> Result<()> {
    method resume (line 415) | async fn resume(&self, p: &mut InitProcess) -> Result<()> {
    method resume (line 429) | async fn resume(&self, _p: &mut InitProcess) -> Result<()> {
    method new (line 435) | pub fn new(runtime: Runc, opts: Options, bundle: &str) -> Self {
    method ensure_init_cgroup_exists (line 449) | async fn ensure_init_cgroup_exists(&self) -> bool {
  type RuncExecLifecycle (line 459) | pub struct RuncExecLifecycle {
    method start (line 471) | async fn start(&self, p: &mut ExecProcess) -> containerd_shim::Result<...
    method kill (line 525) | async fn kill(
    method delete (line 568) | async fn delete(&self, p: &mut ExecProcess) -> Result<()> {
    method update (line 575) | async fn update(&self, _p: &mut ExecProcess, _resources: &LinuxResourc...
    method stats (line 579) | async fn stats(&self, _p: &ExecProcess) -> Result<Metrics> {
    method ps (line 583) | async fn ps(&self, _p: &ExecProcess) -> Result<Vec<ProcessInfo>> {
    method pause (line 587) | async fn pause(&self, _p: &mut ExecProcess) -> Result<()> {
    method resume (line 591) | async fn resume(&self, _p: &mut ExecProcess) -> Result<()> {
  function copy_console (line 596) | async fn copy_console(
  function copy_io (line 649) | pub async fn copy_io(pio: &ProcessIO, stdio: &Stdio, exit_signal: Arc<Ex...
  function spawn_copy (line 737) | fn spawn_copy<R, W, F>(from: R, to: W, exit_signal: Arc<ExitSignal>, on_...
  function copy_io_or_console (line 762) | async fn copy_io_or_console<P>(
  method execute (line 789) | async fn execute(&self, cmd: Command) -> runc::Result<(ExitStatus, u32, ...
  function read_std (line 814) | async fn read_std<T>(std: Option<T>) -> String
  function wait_pid (line 830) | async fn wait_pid(pid: i32, s: Subscription) -> i32 {
  function test_runtime_error (line 857) | async fn test_runtime_error() {

FILE: crates/runc-shim/src/service.rs
  type Service (line 49) | pub(crate) struct Service {
  type T (line 57) | type T = TaskService<RuncFactory, RuncContainer>;
  method new (line 59) | async fn new(_runtime_id: &str, args: &Flags, _config: &mut Config) -> S...
  method start_shim (line 69) | async fn start_shim(&mut self, opts: StartOpts) -> containerd_shim::Resu...
  method delete_shim (line 105) | async fn delete_shim(&mut self) -> containerd_shim::Result<DeleteRespons...
  method wait (line 135) | async fn wait(&mut self) {
  method create_task_service (line 139) | async fn create_task_service(&self, publisher: RemotePublisher) -> Self:...
  function process_exits (line 152) | async fn process_exits(
  function forward (line 220) | async fn forward(
  function should_kill_all_on_exit (line 238) | async fn should_kill_all_on_exit(bundle_path: &str) -> bool {

FILE: crates/runc-shim/src/task.rs
  type EventSender (line 47) | type EventSender = Sender<(String, Box<dyn MessageDyn>)>;
  type TaskService (line 75) | pub struct TaskService<F, C> {
  function new (line 90) | pub fn new(ns: &str, exit: Arc<ExitSignal>, tx: EventSender) -> Self {
  function container_mut (line 102) | pub async fn container_mut(&self, id: &str) -> TtrpcResult<RwLockMappedW...
  function container (line 114) | pub async fn container(&self, id: &str) -> TtrpcResult<RwLockReadGuard<'...
  function send_event (line 126) | pub async fn send_event(&self, event: impl Event) {
  function run_oom_monitor (line 136) | fn run_oom_monitor(mut rx: Receiver<String>, id: String, tx: EventSender) {
  function monitor_oom (line 153) | async fn monitor_oom(id: &String, pid: u32, tx: EventSender) -> Result<(...
  method state (line 179) | async fn state(&self, _ctx: &TtrpcContext, req: StateRequest) -> TtrpcRe...
  method create (line 186) | async fn create(
  method start (line 227) | async fn start(&self, _ctx: &TtrpcContext, req: StartRequest) -> TtrpcRe...
  method delete (line 271) | async fn delete(&self, _ctx: &TtrpcContext, req: DeleteRequest) -> Ttrpc...
  method pids (line 309) | async fn pids(&self, _ctx: &TtrpcContext, req: PidsRequest) -> TtrpcResu...
  method pause (line 319) | async fn pause(&self, _ctx: &TtrpcContext, req: PauseRequest) -> TtrpcRe...
  method resume (line 331) | async fn resume(&self, _ctx: &TtrpcContext, req: ResumeRequest) -> Ttrpc...
  method kill (line 343) | async fn kill(&self, _ctx: &TtrpcContext, req: KillRequest) -> TtrpcResu...
  method exec (line 353) | async fn exec(&self, _ctx: &TtrpcContext, req: ExecProcessRequest) -> Tt...
  method resize_pty (line 373) | async fn resize_pty(&self, _ctx: &TtrpcContext, req: ResizePtyRequest) -...
  method close_io (line 385) | async fn close_io(&self, _ctx: &TtrpcContext, req: CloseIORequest) -> Tt...
  method update (line 393) | async fn update(&self, _ctx: &TtrpcContext, mut req: UpdateTaskRequest) ...
  method wait (line 415) | async fn wait(&self, _ctx: &TtrpcContext, req: WaitRequest) -> TtrpcResu...
  method stats (line 446) | async fn stats(&self, _ctx: &TtrpcContext, req: StatsRequest) -> TtrpcRe...
  method connect (line 454) | async fn connect(
  method shutdown (line 474) | async fn shutdown(&self, _ctx: &TtrpcContext, _req: ShutdownRequest) -> ...

FILE: crates/runc/src/asynchronous/io.rs
  type IOOption (line 27) | pub struct IOOption {
  method default (line 34) | fn default() -> Self {
  method new (line 44) | pub fn new(uid: u32, gid: u32, opts: &IOOption) -> std::io::Result<Self> {
  method create_pipe (line 64) | fn create_pipe(uid: u32, gid: u32, stdin: bool) -> std::io::Result<Optio...
  type NullIo (line 85) | pub struct NullIo {
    method new (line 90) | pub fn new() -> std::io::Result<Self> {
  method set (line 99) | async fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 107) | async fn close_after_start(&self) {
  type InheritedStdIo (line 117) | pub struct InheritedStdIo {}
    method new (line 120) | pub fn new() -> std::io::Result<Self> {
  method set (line 127) | async fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 134) | async fn close_after_start(&self) {}
  type PipedStdIo (line 141) | pub struct PipedStdIo {}
    method new (line 144) | pub fn new() -> std::io::Result<Self> {
  method set (line 150) | async fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 157) | async fn close_after_start(&self) {}
  type FIFO (line 162) | pub struct FIFO {
  method set (line 169) | async fn set(&self, cmd: &mut Command) -> Result<()> {
  method close_after_start (line 192) | async fn close_after_start(&self) {}
  function test_io_option (line 201) | fn test_io_option() {
  function test_null_io (line 215) | async fn test_null_io() {

FILE: crates/runc/src/asynchronous/mod.rs
  type Io (line 28) | pub trait Io: Debug + Send + Sync {
    method stdin (line 29) | fn stdin(&self) -> Option<Box<dyn AsyncWrite + Send + Sync + Unpin>> {
    method stdout (line 33) | fn stdout(&self) -> Option<Box<dyn AsyncRead + Send + Sync + Unpin>> {
    method stderr (line 37) | fn stderr(&self) -> Option<Box<dyn AsyncRead + Send + Sync + Unpin>> {
    method set (line 43) | async fn set(&self, cmd: &mut Command) -> Result<()>;
    method close_after_start (line 46) | async fn close_after_start(&self);
    method stdin (line 57) | fn stdin(&self) -> Option<Box<dyn AsyncWrite + Send + Sync + Unpin>> {
    method stdout (line 67) | fn stdout(&self) -> Option<Box<dyn AsyncRead + Send + Sync + Unpin>> {
    method stderr (line 76) | fn stderr(&self) -> Option<Box<dyn AsyncRead + Send + Sync + Unpin>> {
    method set (line 87) | async fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
    method close_after_start (line 110) | async fn close_after_start(&self) {
  type PipedIo (line 50) | pub struct PipedIo {

FILE: crates/runc/src/asynchronous/pipe.rs
  type Pipe (line 27) | pub struct Pipe {
    method new (line 33) | pub fn new() -> std::io::Result<Self> {
    method wr_as_raw_fd (line 42) | pub fn wr_as_raw_fd(&self) -> Option<RawFd> {
    method try_clone_wr (line 47) | pub fn try_clone_wr(&self) -> Option<OwnedFd> {
    method close_wr (line 56) | pub fn close_wr(&self) {
    method take_wr (line 61) | pub fn take_wr(&self) -> Option<OwnedFd> {
  function test_pipe_creation (line 78) | async fn test_pipe_creation() {
  function test_pipe_write_read (line 89) | async fn test_pipe_write_read() {
  function test_pipe_async_write_read (line 113) | async fn test_pipe_async_write_read() {

FILE: crates/runc/src/asynchronous/runc.rs
  method launch (line 53) | pub(crate) async fn launch(&self, mut cmd: Command, combined_output: boo...
  method create (line 98) | pub async fn create<P>(
  method delete (line 129) | pub async fn delete(&self, id: &str, opts: Option<&DeleteOpts>) -> Resul...
  method events (line 140) | pub async fn events(&self, _id: &str, _interval: &std::time::Duration) -...
  method exec (line 145) | pub async fn exec(&self, id: &str, spec: &Process, opts: Option<&ExecOpt...
  method kill (line 173) | pub async fn kill(&self, id: &str, sig: u32, opts: Option<&KillOpts>) ->...
  method list (line 185) | pub async fn list(&self) -> Result<Vec<Container>> {
  method pause (line 199) | pub async fn pause(&self, id: &str) -> Result<()> {
  method resume (line 206) | pub async fn resume(&self, id: &str) -> Result<()> {
  method checkpoint (line 212) | pub async fn checkpoint(&self) -> Result<()> {
  method restore (line 216) | pub async fn restore(&self) -> Result<()> {
  method ps (line 221) | pub async fn ps(&self, id: &str) -> Result<Vec<usize>> {
  method run (line 239) | pub async fn run<P>(&self, id: &str, bundle: P, opts: Option<&CreateOpts...
  method start (line 263) | pub async fn start(&self, id: &str) -> Result<()> {
  method state (line 270) | pub async fn state(&self, id: &str) -> Result<Container> {
  method stats (line 277) | pub async fn stats(&self, id: &str) -> Result<events::Stats> {
  method update (line 290) | pub async fn update(&self, id: &str, resources: &LinuxResources) -> Resu...
  type Spawner (line 305) | pub trait Spawner: Debug {
    method execute (line 306) | async fn execute(&self, cmd: Command) -> Result<(ExitStatus, u32, Stri...
    method execute (line 314) | async fn execute(&self, cmd: Command) -> Result<(ExitStatus, u32, Stri...
  type DefaultExecutor (line 310) | pub struct DefaultExecutor {}
  function ok_client (line 341) | fn ok_client() -> Runc {
  function fail_client (line 348) | fn fail_client() -> Runc {
  function echo_client (line 355) | fn echo_client() -> Runc {
  function test_async_create (line 363) | async fn test_async_create() {
  function test_async_start (line 404) | async fn test_async_start() {
  function test_async_run (line 435) | async fn test_async_run() {
  function test_async_delete (line 473) | async fn test_async_delete() {
  function test_async_output (line 508) | async fn test_async_output() {

FILE: crates/runc/src/container.rs
  type Container (line 43) | pub struct Container {
  function serde_test (line 59) | fn serde_test() {

FILE: crates/runc/src/error.rs
  type Error (line 41) | pub enum Error {

FILE: crates/runc/src/events.rs
  type EventType (line 43) | pub enum EventType {
  type Event (line 51) | pub struct Event {
  type Stats (line 60) | pub struct Stats {
  type HugeTLB (line 71) | pub struct HugeTLB {
  type BlkIOEntry (line 79) | pub struct BlkIOEntry {
  type BlkIO (line 87) | pub struct BlkIO {
  type Pids (line 115) | pub struct Pids {
  type Throttling (line 123) | pub struct Throttling {
  type CpuUsage (line 136) | pub struct CpuUsage {
  type Cpu (line 148) | pub struct Cpu {
  type MemoryEntry (line 154) | pub struct MemoryEntry {
  type Memory (line 167) | pub struct Memory {

FILE: crates/runc/src/lib.rs
  constant JSON (line 65) | const JSON: &str = "json";
  constant TEXT (line 66) | const TEXT: &str = "text";
  type Result (line 68) | pub type Result<T> = std::result::Result<T, crate::error::Error>;
  type Response (line 72) | pub struct Response {
  type Version (line 79) | pub struct Version {
  type LogFormat (line 86) | pub enum LogFormat {
  method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Command (line 102) | pub type Command = std::process::Command;
  type Command (line 105) | pub type Command = tokio::process::Command;
  type Runc (line 108) | pub struct Runc {
    method command (line 115) | fn command(&self, args: &[String]) -> Result<Command> {

FILE: crates/runc/src/monitor.rs
  type ProcessMonitor (line 36) | pub trait ProcessMonitor {
    method start (line 44) | async fn start(&self, mut cmd: Command, tx: Sender<Exit>) -> std::io::...
    method wait (line 66) | async fn wait(&self, rx: Receiver<Exit>) -> std::io::Result<Exit> {
  type DefaultMonitor (line 76) | pub struct DefaultMonitor {}
    method new (line 81) | pub const fn new() -> Self {
  type Exit (line 88) | pub struct Exit {
  type ExecuteResult (line 95) | pub struct ExecuteResult {
  function execute (line 107) | pub async fn execute<T: ProcessMonitor + Send + Sync>(
  function test_start_wait_without_output (line 142) | async fn test_start_wait_without_output() {
  function test_start_wait_with_output (line 155) | async fn test_start_wait_with_output() {
  function test_execute (line 169) | async fn test_execute() {

FILE: crates/runc/src/options.rs
  constant JSON (line 45) | pub const JSON: &str = "json";
  constant TEXT (line 46) | pub const TEXT: &str = "text";
  constant DEBUG (line 49) | const DEBUG: &str = "--debug";
  constant LOG (line 50) | const LOG: &str = "--log";
  constant LOG_FORMAT (line 51) | const LOG_FORMAT: &str = "--log-format";
  constant ROOT (line 52) | const ROOT: &str = "--root";
  constant ROOTLESS (line 53) | const ROOTLESS: &str = "--rootless";
  constant SYSTEMD_CGROUP (line 54) | const SYSTEMD_CGROUP: &str = "--systemd-cgroup";
  constant CONSOLE_SOCKET (line 57) | const CONSOLE_SOCKET: &str = "--console-socket";
  constant DETACH (line 58) | const DETACH: &str = "--detach";
  constant NO_NEW_KEYRING (line 59) | const NO_NEW_KEYRING: &str = "--no-new-keyring";
  constant NO_PIVOT (line 60) | const NO_PIVOT: &str = "--no-pivot";
  constant PID_FILE (line 61) | const PID_FILE: &str = "--pid-file";
  constant ALL (line 64) | const ALL: &str = "--all";
  constant FORCE (line 67) | const FORCE: &str = "--force";
  constant DEFAULT_COMMAND (line 70) | pub const DEFAULT_COMMAND: &str = "runc";
  type Args (line 72) | pub trait Args {
    method args (line 75) | fn args(&self) -> Self::Output;
    type Output (line 252) | type Output = Result<Runc, Error>;
    method args (line 254) | fn args(&self) -> Self::Output {
    type Output (line 285) | type Output = Result<Vec<String>, Error>;
    method args (line 287) | fn args(&self) -> Self::Output {
    type Output (line 365) | type Output = Result<Vec<String>, Error>;
    method args (line 367) | fn args(&self) -> Self::Output {
    type Output (line 424) | type Output = Vec<String>;
    method args (line 426) | fn args(&self) -> Self::Output {
    type Output (line 454) | type Output = Vec<String>;
    method args (line 456) | fn args(&self) -> Self::Output {
  type GlobalOpts (line 83) | pub struct GlobalOpts {
    method new (line 116) | pub fn new() -> Self {
    method command (line 120) | pub fn command(mut self, command: impl AsRef<Path>) -> Self {
    method root (line 129) | pub fn root(mut self, root: impl AsRef<Path>) -> Self {
    method debug (line 135) | pub fn debug(mut self, debug: bool) -> Self {
    method log (line 143) | pub fn log(mut self, log: impl AsRef<Path>) -> Self {
    method log_format (line 149) | pub fn log_format(mut self, log_format: LogFormat) -> Self {
    method log_json (line 155) | pub fn log_json(self) -> Self {
    method log_text (line 160) | pub fn log_text(self) -> Self {
    method systemd_cgroup (line 168) | pub fn systemd_cgroup(mut self, systemd_cgroup: bool) -> Self {
    method rootless (line 176) | pub fn rootless(mut self, rootless: bool) -> Self {
    method rootless_auto (line 182) | pub fn rootless_auto(mut self) -> Self {
    method set_pgid (line 187) | pub fn set_pgid(mut self, set_pgid: bool) -> Self {
    method timeout (line 192) | pub fn timeout(&mut self, millis: u64) -> &mut Self {
    method custom_spawner (line 197) | pub fn custom_spawner(&mut self, executor: Arc<dyn Spawner + Send + Sy...
    method build (line 202) | pub fn build(self) -> Result<Runc, Error> {
    method output (line 206) | fn output(&self) -> Result<(PathBuf, Vec<String>), Error> {
  type CreateOpts (line 270) | pub struct CreateOpts {
    method new (line 311) | pub fn new() -> Self {
    method io (line 315) | pub fn io(mut self, io: Arc<dyn Io>) -> Self {
    method pid_file (line 320) | pub fn pid_file<P>(mut self, pid_file: P) -> Self
    method console_socket (line 328) | pub fn console_socket<P>(mut self, console_socket: P) -> Self
    method detach (line 336) | pub fn detach(mut self, detach: bool) -> Self {
    method no_pivot (line 341) | pub fn no_pivot(mut self, no_pivot: bool) -> Self {
    method no_new_keyring (line 346) | pub fn no_new_keyring(mut self, no_new_keyring: bool) -> Self {
  type ExecOpts (line 354) | pub struct ExecOpts {
    method new (line 385) | pub fn new() -> Self {
    method io (line 389) | pub fn io(mut self, io: Arc<dyn Io>) -> Self {
    method pid_file (line 394) | pub fn pid_file<P>(mut self, pid_file: P) -> Self
    method console_socket (line 402) | pub fn console_socket<P>(mut self, console_socket: P) -> Self
    method detach (line 410) | pub fn detach(mut self, detach: bool) -> Self {
  type DeleteOpts (line 418) | pub struct DeleteOpts {
    method new (line 436) | pub fn new() -> Self {
    method force (line 440) | pub fn force(mut self, force: bool) -> Self {
  type KillOpts (line 448) | pub struct KillOpts {
    method new (line 466) | pub fn new() -> Self {
    method all (line 470) | pub fn all(mut self, all: bool) -> Self {
  constant ARGS_FAIL_MSG (line 482) | const ARGS_FAIL_MSG: &str = "Args.args() failed.";
  function create_opts_test (line 485) | fn create_opts_test() {
  function exec_opts_test (line 536) | fn exec_opts_test() {
  function delete_opts_test (line 578) | fn delete_opts_test() {
  function kill_opts_test (line 588) | fn kill_opts_test() {
  function global_opts_test (line 596) | fn global_opts_test() {

FILE: crates/runc/src/synchronous/io.rs
  type IOOption (line 32) | pub struct IOOption {
  method default (line 39) | fn default() -> Self {
  method new (line 49) | pub fn new(uid: u32, gid: u32, opts: &IOOption) -> std::io::Result<Self> {
  method create_pipe (line 69) | fn create_pipe(uid: u32, gid: u32, stdin: bool) -> std::io::Result<Optio...
  type NullIo (line 90) | pub struct NullIo {
    method new (line 95) | pub fn new() -> std::io::Result<Self> {
  method set (line 103) | fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 111) | fn close_after_start(&self) {
  type InheritedStdIo (line 121) | pub struct InheritedStdIo {}
    method new (line 124) | pub fn new() -> std::io::Result<Self> {
  method set (line 130) | fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 137) | fn close_after_start(&self) {}
  type PipedStdIo (line 144) | pub struct PipedStdIo {}
    method new (line 147) | pub fn new() -> std::io::Result<Self> {
  method set (line 153) | fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
  method close_after_start (line 160) | fn close_after_start(&self) {}
  type FIFO (line 165) | pub struct FIFO {
  method set (line 172) | fn set(&self, cmd: &mut Command) -> Result<()> {
  method close_after_start (line 194) | fn close_after_start(&self) {}
  function test_io_option (line 203) | fn test_io_option() {
  function test_create_piped_io (line 218) | fn test_create_piped_io() {
  function test_null_io (line 260) | fn test_null_io() {

FILE: crates/runc/src/synchronous/mod.rs
  type Io (line 29) | pub trait Io: Debug + Send + Sync {
    method stdin (line 31) | fn stdin(&self) -> Option<Box<dyn Write + Send + Sync>> {
    method stdout (line 36) | fn stdout(&self) -> Option<Box<dyn Read + Send>> {
    method stderr (line 41) | fn stderr(&self) -> Option<Box<dyn Read + Send>> {
    method set (line 47) | fn set(&self, cmd: &mut Command) -> Result<()>;
    method close_after_start (line 50) | fn close_after_start(&self);
    method stdin (line 61) | fn stdin(&self) -> Option<Box<dyn Write + Send + Sync>> {
    method stdout (line 68) | fn stdout(&self) -> Option<Box<dyn Read + Send>> {
    method stderr (line 77) | fn stderr(&self) -> Option<Box<dyn Read + Send>> {
    method set (line 87) | fn set(&self, cmd: &mut Command) -> std::io::Result<()> {
    method close_after_start (line 110) | fn close_after_start(&self) {
  type PipedIo (line 54) | pub struct PipedIo {

FILE: crates/runc/src/synchronous/pipe.rs
  type Pipe (line 23) | pub struct Pipe {
    method new (line 29) | pub fn new() -> std::io::Result<Self> {
    method try_clone_wr (line 38) | pub fn try_clone_wr(&self) -> Option<PipeWriter> {
    method close_wr (line 47) | pub fn close_wr(&self) {

FILE: crates/runc/src/synchronous/runc.rs
  method launch (line 31) | pub(crate) fn launch(&self, cmd: Command, combined_output: bool) -> Resu...
  method create (line 54) | pub fn create<P>(&self, id: &str, bundle: P, opts: Option<&CreateOpts>) ...
  method delete (line 80) | pub fn delete(&self, id: &str, opts: Option<&DeleteOpts>) -> Result<()> {
  method exec (line 91) | pub fn exec(&self, id: &str, spec: &Process, opts: Option<&ExecOpts>) ->...
  method kill (line 113) | pub fn kill(&self, id: &str, sig: u32, opts: Option<&KillOpts>) -> Resul...
  method list (line 125) | pub fn list(&self) -> Result<Vec<Container>> {
  method pause (line 139) | pub fn pause(&self, id: &str) -> Result<()> {
  method resume (line 146) | pub fn resume(&self, id: &str) -> Result<()> {
  method checkpoint (line 152) | pub fn checkpoint(&self) -> Result<()> {
  method restore (line 156) | pub fn restore(&self) -> Result<()> {
  method ps (line 161) | pub fn ps(&self, id: &str) -> Result<Vec<usize>> {
  method run (line 179) | pub fn run<P>(&self, id: &str, bundle: P, opts: Option<&CreateOpts>) -> ...
  method start (line 200) | pub fn start(&self, id: &str) -> Result<Response> {
  method state (line 206) | pub fn state(&self, id: &str) -> Result<Container> {
  method stats (line 213) | pub fn stats(&self, id: &str) -> Result<events::Stats> {
  method update (line 226) | pub fn update(&self, id: &str, resources: &LinuxResources) -> Result<()> {
  type Spawner (line 239) | pub trait Spawner: Debug {
    method execute (line 240) | fn execute(&self, cmd: Command) -> Result<(ExitStatus, u32, String, St...
    method execute (line 247) | fn execute(&self, cmd: Command) -> Result<(ExitStatus, u32, String, St...
  type DefaultExecutor (line 244) | pub struct DefaultExecutor {}
  function ok_client (line 273) | fn ok_client() -> Runc {
  function fail_client (line 280) | fn fail_client() -> Runc {
  function echo_client (line 287) | fn echo_client() -> Runc {
  function dummy_process (line 294) | fn dummy_process() -> Process {
  function test_create (line 309) | fn test_create() {
  function test_run (line 338) | fn test_run() {
  function test_exec (line 367) | fn test_exec() {
  function test_delete (line 395) | fn test_delete() {
  function test_output (line 422) | fn test_output() {

FILE: crates/runc/src/utils.rs
  function abs_path_buf (line 34) | pub fn abs_path_buf<P>(path: P) -> Result<PathBuf, Error>
  function path_to_string (line 52) | fn path_to_string(path: impl AsRef<Path>) -> Result<String, Error> {
  function abs_string (line 64) | pub fn abs_string<P>(path: P) -> Result<String, Error>
  function xdg_runtime_dir (line 73) | fn xdg_runtime_dir() -> String {
  function write_value_to_temp_file (line 80) | pub fn write_value_to_temp_file<T: Serialize>(value: &T) -> Result<(Name...
  function write_value_to_temp_file (line 102) | pub async fn write_value_to_temp_file<T: Serialize>(value: &T) -> Result...
  function binary_path (line 124) | pub fn binary_path<P>(path: P) -> Option<PathBuf>

FILE: crates/shim-protos/build.rs
  function main (line 26) | fn main() {
  function genmodule (line 122) | fn genmodule(name: &str, inputs: &[&str], async_all: bool) {

FILE: crates/shim-protos/examples/connect-async.rs
  function main (line 24) | async fn main() {

FILE: crates/shim-protos/examples/connect.rs
  function main (line 23) | fn main() {

FILE: crates/shim-protos/examples/ttrpc-client-async.rs
  function default_ctx (line 22) | fn default_ctx() -> Context {
  function main (line 32) | async fn main() {

FILE: crates/shim-protos/examples/ttrpc-client.rs
  function main (line 22) | fn main() {
  function default_ctx (line 44) | fn default_ctx() -> Context {

FILE: crates/shim-protos/examples/ttrpc-server-async.rs
  type FakeServer (line 26) | struct FakeServer {
    method new (line 31) | fn new() -> Self {
  method create (line 38) | async fn create(
  function main (line 60) | async fn main() {

FILE: crates/shim-protos/examples/ttrpc-server.rs
  type FakeServer (line 25) | struct FakeServer {
    method new (line 30) | fn new() -> Self {
  method create (line 36) | fn create(
  function main (line 57) | fn main() {

FILE: crates/shim-protos/src/topics.rs
  constant TASK_CREATE_EVENT_TOPIC (line 19) | pub const TASK_CREATE_EVENT_TOPIC: &str = "/tasks/create";
  constant TASK_START_EVENT_TOPIC (line 20) | pub const TASK_START_EVENT_TOPIC: &str = "/tasks/start";
  constant TASK_OOM_EVENT_TOPIC (line 21) | pub const TASK_OOM_EVENT_TOPIC: &str = "/tasks/oom";
  constant TASK_EXIT_EVENT_TOPIC (line 22) | pub const TASK_EXIT_EVENT_TOPIC: &str = "/tasks/exit";
  constant TASK_DELETE_EVENT_TOPIC (line 23) | pub const TASK_DELETE_EVENT_TOPIC: &str = "/tasks/delete";
  constant TASK_EXEC_ADDED_EVENT_TOPIC (line 24) | pub const TASK_EXEC_ADDED_EVENT_TOPIC: &str = "/tasks/exec-added";
  constant TASK_EXEC_STARTED_EVENT_TOPIC (line 25) | pub const TASK_EXEC_STARTED_EVENT_TOPIC: &str = "/tasks/exec-started";
  constant TASK_PAUSED_EVENT_TOPIC (line 26) | pub const TASK_PAUSED_EVENT_TOPIC: &str = "/tasks/paused";
  constant TASK_RESUMED_EVENT_TOPIC (line 27) | pub const TASK_RESUMED_EVENT_TOPIC: &str = "/tasks/resumed";
  constant TASK_CHECKPOINTED_EVENT_TOPIC (line 28) | pub const TASK_CHECKPOINTED_EVENT_TOPIC: &str = "/tasks/checkpointed";
  constant TASK_UNKNOWN_TOPIC (line 29) | pub const TASK_UNKNOWN_TOPIC: &str = "/tasks/?";

FILE: crates/shim-protos/tests/ttrpc.rs
  constant MESSAGE_TYPE_REQUEST (line 19) | const MESSAGE_TYPE_REQUEST: u8 = 0x1;
  constant MESSAGE_TYPE_RESPONSE (line 20) | const MESSAGE_TYPE_RESPONSE: u8 = 0x2;
  type FakeServer (line 23) | struct FakeServer {
    method new (line 28) | fn new() -> Self {
  method create (line 34) | fn create(
  function create_ttrpc_context (line 49) | fn create_ttrpc_context() -> (
  function test_task_method_num (line 74) | fn test_task_method_num() {
  function test_create_task (line 80) | fn test_create_task() {
  function test_delete_task (line 121) | fn test_delete_task() {

FILE: crates/shim/examples/publish.rs
  function main (line 22) | fn main() {
  function main (line 51) | async fn main() {

FILE: crates/shim/examples/skeleton.rs
  type Service (line 31) | pub(crate) struct Service {
    type T (line 36) | type T = Service;
    method new (line 38) | fn new(_runtime_id: &str, _args: &Flags, _config: &mut Config) -> Self {
    method start_shim (line 44) | fn start_shim(&mut self, opts: shim::StartOpts) -> Result<String, shim...
    method delete_shim (line 50) | fn delete_shim(&mut self) -> Result<DeleteResponse, shim::Error> {
    method wait (line 54) | fn wait(&mut self) {
    method create_task_service (line 58) | fn create_task_service(&self, _publisher: RemotePublisher) -> Self::T {
    method connect (line 64) | fn connect(
    method shutdown (line 76) | fn shutdown(
  function main (line 88) | fn main() {

FILE: crates/shim/examples/skeleton_async.rs
  type Service (line 31) | struct Service {
  type T (line 37) | type T = Service;
  method new (line 39) | async fn new(_runtime_id: &str, _args: &Flags, _config: &mut Config) -> ...
  method start_shim (line 45) | async fn start_shim(&mut self, opts: StartOpts) -> Result<String, Error> {
  method delete_shim (line 51) | async fn delete_shim(&mut self) -> Result<DeleteResponse, Error> {
  method wait (line 55) | async fn wait(&mut self) {
  method create_task_service (line 59) | async fn create_task_service(&self, _publisher: RemotePublisher) -> Self...
  method connect (line 66) | async fn connect(
  method shutdown (line 78) | async fn shutdown(
  function main (line 90) | async fn main() {

FILE: crates/shim/examples/windows_log_reader.rs
  function main (line 20) | fn main() -> Result<(), Box<dyn Error>> {
  function main (line 69) | fn main() {

FILE: crates/shim/src/args.rs
  type Flags (line 24) | pub struct Flags {
  function parse (line 50) | pub fn parse<S: AsRef<OsStr>>(args: &[S]) -> Result<Flags> {
  function parse_all (line 83) | fn parse_all() {
  function parse_flags (line 115) | fn parse_flags() {
  function parse_action (line 127) | fn parse_action() {
  function parse_version_long_flag (line 136) | fn parse_version_long_flag() {
  function parse_version_short_flag (line 142) | fn parse_version_short_flag() {

FILE: crates/shim/src/asynchronous/mod.rs
  constant DEFAULT_BINARY_NAME (line 54) | const DEFAULT_BINARY_NAME: &str = "runc";
  type Shim (line 73) | pub trait Shim {
    method new (line 84) | async fn new(runtime_id: &str, args: &Flags, config: &mut Config) -> S...
    method start_shim (line 92) | async fn start_shim(&mut self, opts: StartOpts) -> Result<String>;
    method delete_shim (line 96) | async fn delete_shim(&mut self) -> Result<DeleteResponse>;
    method wait (line 99) | async fn wait(&mut self);
    method create_task_service (line 102) | async fn create_task_service(&self, publisher: RemotePublisher) -> Sel...
  function run (line 107) | pub async fn run<T>(runtime_id: &str, opts: Option<Config>)
  function run_info (line 117) | pub fn run_info() -> Result<RuntimeInfo> {
  function bootstrap (line 163) | async fn bootstrap<T>(runtime_id: &str, opts: Option<Config>) -> Result<()>
  type ExitSignal (line 269) | pub struct ExitSignal {
    method signal (line 285) | pub fn signal(&self) {
    method wait (line 291) | pub async fn wait(&self) {
  method default (line 275) | fn default() -> Self {
  function spawn (line 305) | pub async fn spawn(opts: StartOpts, grouping: &str, vars: Vec<(&str, &st...
  function create_server (line 351) | async fn create_server(flags: &args::Flags) -> Result<Server> {
  function create_server_with_retry (line 359) | async fn create_server_with_retry(flags: &args::Flags) -> Result<Option<...
  function signal_server_started (line 379) | fn signal_server_started() {
  function signal_stream (line 390) | fn signal_stream(kind: i32) -> std::io::Result<BoxStream<'static, i32>> {
  function signal_stream (line 407) | fn signal_stream(kind: i32) -> std::io::Result<BoxStream<'static, i32>> {
  type Signals (line 433) | type Signals = SelectAll<BoxStream<'static, i32>>;
  function setup_signals_tokio (line 436) | fn setup_signals_tokio(config: &Config) -> Signals {
  function handle_signals (line 462) | async fn handle_signals(signals: Signals) {
  function remove_socket_silently (line 509) | async fn remove_socket_silently(address: &str) {
  function remove_socket (line 516) | async fn remove_socket(address: &str) -> Result<()> {
  function start_listener (line 531) | async fn start_listener(address: &str) -> Result<UnixListener> {
  function wait_socket_working (line 543) | async fn wait_socket_working(address: &str, interval_in_ms: u64, count: ...
  function test_exit_signal (line 564) | async fn test_exit_signal() {
  function test_start_listener (line 580) | async fn test_start_listener() {

FILE: crates/shim/src/asynchronous/monitor.rs
  function monitor_subscribe (line 38) | pub async fn monitor_subscribe(topic: Topic) -> Result<Subscription> {
  function monitor_unsubscribe (line 44) | pub async fn monitor_unsubscribe(sub_id: i64) -> Result<()> {
  function monitor_notify_by_pid (line 49) | pub async fn monitor_notify_by_pid(pid: i32, exit_code: i32) -> Result<(...
  function monitor_notify_by_exec (line 54) | pub async fn monitor_notify_by_exec(id: &str, exec_id: &str, exit_code: ...
  type Monitor (line 59) | pub struct Monitor {
    method subscribe (line 76) | pub fn subscribe(&mut self, topic: Topic) -> Result<Subscription> {
    method notify_by_pid (line 90) | pub async fn notify_by_pid(&self, pid: i32, exit_code: i32) -> Result<...
    method notify_by_exec (line 97) | pub async fn notify_by_exec(&self, cid: &str, exec_id: &str, exit_code...
    method notify_topic (line 105) | async fn notify_topic(&self, topic: &Topic, subject: &Subject, exit_co...
    method unsubscribe (line 126) | pub fn unsubscribe(&mut self, id: i64) -> Result<()> {
  type Subscriber (line 65) | pub(crate) struct Subscriber {
  type Subscription (line 70) | pub struct Subscription {
  function test_monitor (line 149) | async fn test_monitor() {

FILE: crates/shim/src/asynchronous/publisher.rs
  constant QUEUE_SIZE (line 41) | const QUEUE_SIZE: i64 = 1024;
  constant MAX_REQUEUE (line 43) | const MAX_REQUEUE: i64 = 5;
  type RemotePublisher (line 46) | pub struct RemotePublisher {
    method new (line 62) | pub async fn new(address: impl AsRef<str>) -> Result<RemotePublisher> {
    method process_queue (line 77) | pub async fn process_queue(&self, ttrpc_client: Client, mut receiver: ...
    method connect (line 129) | async fn connect(address: impl AsRef<str>) -> Result<Client> {
    method publish (line 145) | pub async fn publish(
  type Item (line 52) | pub struct Item {
  method forward (line 176) | async fn forward(
  type FakeServer (line 216) | struct FakeServer {
  method forward (line 222) | async fn forward(&self, _ctx: &TtrpcContext, req: ForwardRequest) -> ttr...
  function test_connect (line 234) | async fn test_connect() {

FILE: crates/shim/src/asynchronous/util.rs
  function asyncify (line 34) | pub async fn asyncify<F, T>(f: F) -> Result<T>
  function read_file_to_str (line 44) | pub async fn read_file_to_str(path: impl AsRef<Path>) -> Result<String> {
  function write_str_to_file (line 60) | pub async fn write_str_to_file(filename: impl AsRef<Path>, s: impl AsRef...
  function read_pid_from_file (line 90) | pub async fn read_pid_from_file(pid_path: &Path) -> Result<i32> {
  function read_spec (line 96) | pub async fn read_spec(bundle: impl AsRef<Path>) -> Result<Spec> {
  function read_options (line 104) | pub async fn read_options(bundle: impl AsRef<Path>) -> Result<Options> {
  function read_runtime (line 115) | pub async fn read_runtime(bundle: impl AsRef<Path>) -> Result<String> {
  function write_options (line 119) | pub async fn write_options(bundle: impl AsRef<Path>, opt: &Options) -> R...
  function write_runtime (line 126) | pub async fn write_runtime(bundle: impl AsRef<Path>, binary_name: &str) ...
  function mount_rootfs (line 130) | pub async fn mount_rootfs(m: &Mount, target: impl AsRef<Path>) -> Result...
  function mkdir (line 143) | pub async fn mkdir(path: impl AsRef<Path>, mode: mode_t) -> Result<()> {
  function test_read_write_str (line 160) | async fn test_read_write_str() {

FILE: crates/shim/src/cgroup.rs
  constant OOM_SCORE_ADJ_MAX (line 43) | const OOM_SCORE_ADJ_MAX: i64 = 1000;
  function set_cgroup_and_oom_score (line 46) | pub fn set_cgroup_and_oom_score(pid: u32) -> Result<()> {
  function add_task_to_cgroup (line 72) | pub fn add_task_to_cgroup(path: &str, pid: u32) -> Result<()> {
  function adjust_oom_score (line 85) | pub fn adjust_oom_score(pid: u32) -> Result<()> {
  function read_process_oom_score (line 94) | fn read_process_oom_score(pid: u32) -> Result<i64> {
  function write_process_oom_score (line 105) | fn write_process_oom_score(pid: u32, score: i64) -> Result<()> {
  function collect_metrics (line 112) | pub fn collect_metrics(cgroup: &Cgroup) -> Result<Metrics> {
  function get_cgroup (line 205) | pub fn get_cgroup(pid: u32) -> Result<Cgroup> {
  function get_cgroups_v2_path_by_pid (line 221) | pub fn get_cgroups_v2_path_by_pid(pid: u32) -> Result<PathBuf> {
  function parse_cgroups_v2_path (line 235) | fn parse_cgroups_v2_path(content: &str) -> Result<PathBuf> {
  function update_resources (line 251) | pub fn update_resources(cgroup: &Cgroup, resources: &LinuxResources) -> ...
  function test_add_cgroup (line 366) | fn test_add_cgroup() {
  function test_adjust_oom_score (line 384) | fn test_adjust_oom_score() {
  function test_parse_cgroups_v2_path (line 398) | fn test_parse_cgroups_v2_path() {
  function test_parse_cgroups_v2_path_empty (line 407) | fn test_parse_cgroups_v2_path_empty() {
  function test_parse_cgroups_v2_path_kube (line 416) | fn test_parse_cgroups_v2_path_kube() {

FILE: crates/shim/src/error.rs
  type Result (line 24) | pub type Result<T> = std::result::Result<T, Error>;
  type Error (line 27) | pub enum Error {
  function from (line 93) | fn from(e: Error) -> Self {

FILE: crates/shim/src/event.rs
  type Event (line 3) | pub trait Event: MessageDyn {
    method topic (line 4) | fn topic(&self) -> String;
    method topic (line 8) | fn topic(&self) -> String {
    method topic (line 14) | fn topic(&self) -> String {
    method topic (line 20) | fn topic(&self) -> String {
    method topic (line 26) | fn topic(&self) -> String {
    method topic (line 32) | fn topic(&self) -> String {
    method topic (line 38) | fn topic(&self) -> String {
    method topic (line 44) | fn topic(&self) -> String {
    method topic (line 50) | fn topic(&self) -> String {
    method topic (line 56) | fn topic(&self) -> String {
    method topic (line 62) | fn topic(&self) -> String {

FILE: crates/shim/src/lib.rs
  constant TTRPC_ADDRESS (line 105) | const TTRPC_ADDRESS: &str = "TTRPC_ADDRESS";
  type Config (line 109) | pub struct Config {
  method default (line 121) | fn default() -> Self {
  type StartOpts (line 135) | pub struct StartOpts {
  constant SOCKET_ROOT (line 151) | pub const SOCKET_ROOT: &str = "/run/containerd";
  constant SOCKET_ROOT (line 154) | pub const SOCKET_ROOT: &str = "/var/run/containerd";
  constant SOCKET_ROOT (line 157) | pub const SOCKET_ROOT: &str = r"\\.\pipe\containerd-containerd";
  function socket_address (line 161) | pub fn socket_address(socket_path: &str, namespace: &str, id: &str) -> S...
  function parse_sockaddr (line 182) | fn parse_sockaddr(addr: &str) -> &str {
  function start_listener (line 195) | fn start_listener(address: &str) -> std::io::Result<()> {
  function start_listener (line 214) | fn start_listener(address: &str) -> std::io::Result<UnixListener> {
  type Console (line 223) | pub struct Console {
  function test_start_listener (line 233) | fn test_start_listener() {
  function test_start_listener_windows (line 258) | fn test_start_listener_windows() {

FILE: crates/shim/src/logger.rs
  constant LOG_ENV (line 35) | pub const LOG_ENV: &str = "RUST_LOG";
  type FifoLogger (line 37) | pub struct FifoLogger {
    method new (line 42) | pub fn new(_namespace: &str, _id: &str) -> io::Result<FifoLogger> {
    method with_path (line 56) | pub fn with_path(path: impl AsRef<Path>) -> io::Result<FifoLogger> {
    method with_file (line 66) | pub fn with_file(file: File) -> FifoLogger {
    method with_named_pipe (line 72) | pub fn with_named_pipe(name: &str) -> io::Result<FifoLogger> {
    method enabled (line 155) | fn enabled(&self, metadata: &Metadata) -> bool {
    method log (line 159) | fn log(&self, record: &Record) {
    method flush (line 185) | fn flush(&self) {
  type SimpleWriteVistor (line 131) | pub(crate) struct SimpleWriteVistor {
    method visit_pair (line 136) | fn visit_pair(&mut self, k: kv::Key<'kvs>, v: kv::Value<'kvs>) -> Resu...
    method new (line 143) | pub(crate) fn new() -> SimpleWriteVistor {
    method as_str (line 149) | pub(crate) fn as_str(&self) -> &str {
  function init (line 191) | pub fn init(debug: bool, default_log_level: &str, namespace: &str, id: &...
  function configure_logging_level (line 198) | fn configure_logging_level(debug: bool, default_log_level: &str) {
  function rfc3339_formated (line 209) | pub(crate) fn rfc3339_formated() -> String {
  function test_init_log_level (line 225) | fn test_init_log_level() -> Result<(), Error> {
  function test_fifo_log (line 274) | fn test_fifo_log() {
  function test_supports_structured_logging (line 314) | fn test_supports_structured_logging() {
  function test_namedpipe_log_can_write_before_client_connected (line 368) | fn test_namedpipe_log_can_write_before_client_connected() {
  function test_namedpipe_log (line 386) | fn test_namedpipe_log() {
  function read_message (line 433) | fn read_message(client: &mut NamedPipe, length: usize) -> Vec<u8> {
  function create_client (line 462) | fn create_client(pipe_name: &str) -> mio::windows::NamedPipe {

FILE: crates/shim/src/monitor.rs
  type Topic (line 24) | pub enum Topic {
  type ExitEvent (line 31) | pub struct ExitEvent {
    method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Subject (line 55) | pub enum Subject {

FILE: crates/shim/src/mount_linux.rs
  type Flag (line 39) | struct Flag {
  type LoopParams (line 46) | pub struct LoopParams {
  type LoopInfo (line 54) | pub struct LoopInfo {
  method default (line 71) | fn default() -> Self {
  constant LOOP_CONTROL_PATH (line 90) | const LOOP_CONTROL_PATH: &str = "/dev/loop-control";
  constant LOOP_DEV_FORMAT (line 92) | const LOOP_DEV_FORMAT: &str = "/dev/loop";
  constant EBUSY_STRING (line 94) | const EBUSY_STRING: &str = "device or resource busy";
  constant OVERLAY_LOWERDIR_PREFIX (line 95) | const OVERLAY_LOWERDIR_PREFIX: &str = "lowerdir=";
  type MountInfo (line 99) | struct MountInfo {
  constant PROPAGATION_TYPES (line 312) | const PROPAGATION_TYPES: MsFlags = MsFlags::MS_SHARED
  constant MS_PROPAGATION (line 317) | const MS_PROPAGATION: MsFlags = PROPAGATION_TYPES
  constant MS_BIND_RO (line 321) | const MS_BIND_RO: MsFlags = MsFlags::MS_BIND.union(MsFlags::MS_RDONLY);
  function page_size (line 323) | fn page_size() -> usize {
  function options_size (line 329) | fn options_size(options: &[String]) -> usize {
  function longest_common_prefix (line 333) | fn longest_common_prefix(dirs: &[String]) -> &str {
  function trim_flawed_dir (line 360) | fn trim_flawed_dir(s: &str) -> String {
  type LowerdirCompactor (line 365) | struct LowerdirCompactor {
    method new (line 372) | fn new(options: &[String]) -> Self {
    method lowerdirs (line 379) | fn lowerdirs(&mut self) -> &mut Self {
    method lowerdir_prefix (line 392) | fn lowerdir_prefix(&mut self) -> &mut Self {
    method compact (line 403) | fn compact(&mut self) -> (Option<String>, Vec<String>) {
  type MountExitCode (line 434) | enum MountExitCode {
    method from (line 442) | fn from(code: i32) -> Self {
    method from (line 464) | fn from(err: nix::errno::Errno) -> Self {
  function from (line 453) | fn from(code: MountExitCode) -> Self {
  function from (line 473) | fn from(code: MountExitCode) -> Self {
  function from (line 482) | fn from(code: MountExitCode) -> Self {
  function mount_rootfs (line 499) | pub fn mount_rootfs(
  function mount_rootfs (line 613) | pub fn mount_rootfs(
  function setup_loop (line 712) | fn setup_loop(source: Option<&str>, params: LoopParams) -> Result<String> {
  function get_free_loop_dev (line 733) | pub fn get_free_loop_dev() -> Result<i32> {
  function setup_loop_dev (line 761) | pub fn setup_loop_dev(backing_file: &str, loop_dev: &str, params: &LoopP...
  function umount_recursive (line 886) | pub fn umount_recursive(target: Option<&str>, flags: i32) -> Result<()> {
  function umount_all (line 897) | fn umount_all(target: Option<String>, flags: i32) -> Result<()> {
  function prefix_filter (line 919) | fn prefix_filter(prefix: String) -> impl Fn(MountInfo) -> bool {
  function get_mounts (line 923) | fn get_mounts<F>(f: Option<F>) -> Result<Vec<MountInfo>>
  function test_trim_flawed_dir (line 1017) | fn test_trim_flawed_dir() {
  function test_longest_common_prefix (line 1032) | fn test_longest_common_prefix() {
  function test_compact_lowerdir_option (line 1056) | fn test_compact_lowerdir_option() {
  function test_mount_rootfs_umount_recursive (line 1122) | fn test_mount_rootfs_umount_recursive() {
  function test_setup_loop_dev (line 1170) | fn test_setup_loop_dev() {

FILE: crates/shim/src/mount_other.rs
  function mount_rootfs (line 22) | pub fn mount_rootfs(
  function umount_recursive (line 33) | pub fn umount_recursive(target: Option<&str>, flags: i32) -> Result<()> {

FILE: crates/shim/src/reap.rs
  function set_subreaper (line 28) | pub fn set_subreaper() -> Result<()> {
  function set_subreaper (line 41) | pub fn set_subreaper() -> Result<()> {
  function test_set_subreaper (line 51) | fn test_set_subreaper() {

FILE: crates/shim/src/synchronous/mod.rs
  type ExitSignal (line 122) | pub struct ExitSignal(Mutex<bool>, Condvar);
    method signal (line 133) | pub fn signal(&self) {
    method wait (line 141) | pub fn wait(&self) {
  type AppSignals (line 125) | struct AppSignals {
  type Shim (line 153) | pub trait Shim {
    method new (line 163) | fn new(runtime_id: &str, args: &Flags, config: &mut Config) -> Self;
    method start_shim (line 171) | fn start_shim(&mut self, opts: StartOpts) -> Result<String>;
    method delete_shim (line 174) | fn delete_shim(&mut self) -> Result<DeleteResponse>;
    method wait (line 177) | fn wait(&mut self);
    method create_task_service (line 180) | fn create_task_service(&self, publisher: RemotePublisher) -> Self::T;
    type T (line 615) | type T = NopTask;
    method new (line 617) | fn new(_runtime_id: &str, _args: &Flags, _config: &mut Config) -> Self {
    method start_shim (line 621) | fn start_shim(&mut self, _opts: StartOpts) -> Result<String> {
    method delete_shim (line 625) | fn delete_shim(&mut self) -> Result<DeleteResponse> {
    method wait (line 629) | fn wait(&mut self) {}
    method create_task_service (line 631) | fn create_task_service(&self, _publisher: RemotePublisher) -> Self::T {
  function run (line 185) | pub fn run<T>(runtime_id: &str, opts: Option<Config>)
  function bootstrap (line 196) | fn bootstrap<T>(runtime_id: &str, opts: Option<Config>) -> Result<()>
  function create_server (line 304) | fn create_server(flags: &args::Flags) -> Result<Server> {
  function create_server (line 313) | fn create_server(flags: &args::Flags) -> Result<Server> {
  function create_server_with_retry (line 322) | fn create_server_with_retry(flags: &args::Flags) -> Result<Option<Server...
  function setup_signals (line 343) | fn setup_signals(_config: &Config) -> Option<AppSignals> {
  function signal_handler (line 373) | unsafe extern "system" fn signal_handler(_: u32) -> i32 {
  function handle_signals (line 379) | fn handle_signals(mut _signals: Option<AppSignals>) {
  function wait_socket_working (line 441) | fn wait_socket_working(address: &str, interval_in_ms: u64, count: u32) -...
  function remove_socket_silently (line 456) | fn remove_socket_silently(address: &str) {
  function remove_socket (line 461) | fn remove_socket(address: &str) -> Result<()> {
  function spawn (line 490) | pub fn spawn(opts: StartOpts, grouping: &str, vars: Vec<(&str, &str)>) -...
  function disable_handle_inheritance (line 539) | fn disable_handle_inheritance() {
  function signal_server_started (line 561) | fn signal_server_started() {
  function signal_server_started (line 577) | fn signal_server_started() {
  function exit_signal (line 594) | fn exit_signal() {
  type Nop (line 609) | struct Nop {}
  type NopTask (line 611) | struct NopTask {}
  function no_namespace (line 637) | fn no_namespace() {

FILE: crates/shim/src/synchronous/monitor.rs
  function monitor_subscribe (line 40) | pub fn monitor_subscribe(topic: Topic) -> Result<Subscription> {
  function monitor_notify_by_pid (line 46) | pub fn monitor_notify_by_pid(pid: i32, exit_code: i32) -> Result<()> {
  function monitor_notify_by_exec (line 51) | pub fn monitor_notify_by_exec(id: &str, exec_id: &str, exit_code: i32) -...
  type Monitor (line 56) | pub struct Monitor {
    method subscribe (line 73) | pub fn subscribe(&mut self, topic: Topic) -> Result<Subscription> {
    method notify_by_pid (line 86) | pub fn notify_by_pid(&self, pid: i32, exit_code: i32) -> Result<()> {
    method notify_by_exec (line 93) | pub fn notify_by_exec(&self, cid: &str, exec_id: &str, exit_code: i32)...
    method notify_topic (line 100) | fn notify_topic(&self, topic: &Topic, subject: &Subject, exit_code: i3...
    method unsubscribe (line 116) | pub fn unsubscribe(&mut self, id: i64) -> Result<()> {
  type Subscriber (line 62) | pub(crate) struct Subscriber {
  type Subscription (line 67) | pub struct Subscription {
  method drop (line 130) | fn drop(&mut self) {
  function wait_pid (line 138) | pub fn wait_pid(pid: i32, s: Subscription) -> i32 {

FILE: crates/shim/src/synchronous/publisher.rs
  constant RETRY_COUNT (line 38) | const RETRY_COUNT: i32 = 3;
  type RemotePublisher (line 41) | pub struct RemotePublisher {
    method new (line 49) | pub fn new(address: impl AsRef<str>) -> Result<RemotePublisher> {
    method connect (line 57) | fn connect(address: impl AsRef<str>) -> Result<Client> {
    method publish (line 87) | pub fn publish(
  method forward (line 110) | fn forward(
  type FakeServer (line 133) | struct FakeServer {}
  method forward (line 136) | fn forward(&self, _ctx: &ttrpc::TtrpcContext, req: ForwardRequest) -> tt...
  function test_connect (line 144) | fn test_connect() {
  function create_server (line 185) | fn create_server(server_address: &str) -> Server {

FILE: crates/shim/src/synchronous/util.rs
  function read_file_to_str (line 36) | pub fn read_file_to_str<P: AsRef<Path>>(filename: P) -> crate::Result<St...
  function read_options (line 51) | pub fn read_options(bundle: impl AsRef<Path>) -> crate::Result<Options> {
  function read_runtime (line 58) | pub fn read_runtime(bundle: impl AsRef<Path>) -> crate::Result<String> {
  function read_address (line 63) | pub fn read_address() -> crate::Result<String> {
  function read_pid_from_file (line 68) | pub fn read_pid_from_file(pid_path: &Path) -> crate::Result<i32> {
  function write_str_to_path (line 74) | pub fn write_str_to_path(filename: &Path, s: &str) -> crate::Result<()> {
  function write_options (line 100) | pub fn write_options(bundle: &str, opt: &Options) -> crate::Result<()> {
  function write_runtime (line 107) | pub fn write_runtime(bundle: &str, binary_name: &str) -> crate::Result<(...
  function write_address (line 112) | pub fn write_address(address: &str) -> crate::Result<()> {
  function read_spec_from_file (line 117) | pub fn read_spec_from_file(bundle: &str) -> crate::Result<Spec> {
  function mkdir (line 123) | pub fn mkdir(path: impl AsRef<Path>, mode: mode_t) -> crate::Result<()> {
  type HelperRemoveFile (line 133) | pub struct HelperRemoveFile {
    method new (line 138) | pub fn new(path: String) -> Self {
  method drop (line 144) | fn drop(&mut self) {
  function setup_debugger_event (line 154) | pub(crate) fn setup_debugger_event() {
  function create_event (line 187) | fn create_event(name: String) -> crate::Result<isize> {

FILE: crates/shim/src/util.rs
  constant CONFIG_FILE_NAME (line 37) | pub const CONFIG_FILE_NAME: &str = "config.json";
  constant OPTIONS_FILE_NAME (line 38) | pub const OPTIONS_FILE_NAME: &str = "options.json";
  constant RUNTIME_FILE_NAME (line 39) | pub const RUNTIME_FILE_NAME: &str = "runtime";
  type JsonOptions (line 46) | pub struct JsonOptions {
    method from (line 69) | fn from(o: Options) -> Self {
  method from (line 88) | fn from(j: JsonOptions) -> Self {
  function connect (line 108) | pub fn connect(address: impl AsRef<str>) -> Result<RawFd> {
  function timestamp (line 145) | pub fn timestamp() -> Result<Timestamp> {
  function convert_to_timestamp (line 157) | pub fn convert_to_timestamp(exited_at: Option<OffsetDateTime>) -> Timest...
  function convert_to_any (line 166) | pub fn convert_to_any(obj: Box<dyn MessageDyn>) -> Result<Any> {
  type IntoOption (line 177) | pub trait IntoOption
    method none_if (line 181) | fn none_if<F>(self, callback: F) -> Option<Self>
  type AsOption (line 195) | pub trait AsOption {
    method as_option (line 196) | fn as_option(&self) -> Option<&Self>;
    method as_option (line 200) | fn as_option(&self) -> Option<&Self> {
  function test_timestamp (line 214) | fn test_timestamp() {

FILE: crates/snapshots/build.rs
  constant PROTO_FILES (line 19) | const PROTO_FILES: &[&str] = &["types/mount.proto", "services/snapshots/...
  constant FIXUP_MODULES (line 21) | const FIXUP_MODULES: &[&str] = &["containerd.services.snapshots.v1"];
  function main (line 23) | fn main() {
  function fixup_imports (line 48) | fn fixup_imports(path: &str) -> Result<(), io::Error> {

FILE: crates/snapshots/examples/snapshotter.rs
  type Example (line 34) | struct Example;
    type Error (line 38) | type Error = snapshots::tonic::Status;
    method stat (line 40) | async fn stat(&self, key: String) -> Result<Info, Self::Error> {
    method update (line 45) | async fn update(
    method usage (line 54) | async fn usage(&self, key: String) -> Result<Usage, Self::Error> {
    method mounts (line 59) | async fn mounts(&self, key: String) -> Result<Vec<api::types::Mount>, ...
    method prepare (line 64) | async fn prepare(
    method view (line 77) | async fn view(
    method commit (line 87) | async fn commit(
    method remove (line 97) | async fn remove(&self, key: String) -> Result<(), Self::Error> {
    type InfoStream (line 102) | type InfoStream = EmptyStream;
    method list (line 103) | async fn list(
  type EmptyStream (line 114) | struct EmptyStream;
  type Item (line 116) | type Item = Result<Info, snapshots::tonic::Status>;
  method poll_next (line 117) | fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option...
  function main (line 124) | async fn main() {
  type UnixStream (line 169) | pub struct UnixStream(pub tokio::net::UnixStream);
  type ConnectInfo (line 172) | type ConnectInfo = UdsConnectInfo;
  method connect_info (line 174) | fn connect_info(&self) -> Self::ConnectInfo {
  type UdsConnectInfo (line 184) | pub struct UdsConnectInfo {
  method poll_read (line 190) | fn poll_read(
  method poll_write (line 200) | fn poll_write(
  method poll_flush (line 208) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<st...
  method poll_shutdown (line 212) | fn poll_shutdown(
  function main (line 222) | fn main() {

FILE: crates/snapshots/src/convert.rs
  function from (line 27) | fn from(kind: Kind) -> i32 {
  type Error (line 38) | type Error = Error;
  method try_from (line 40) | fn try_from(value: i32) -> Result<Self, Self::Error> {
  type Error (line 52) | type Error = Error;
  method try_from (line 54) | fn try_from(info: grpc::Info) -> Result<Self, Self::Error> {
  function from (line 67) | fn from(info: Info) -> Self {
  type Error (line 80) | pub enum Error {
  function from (line 89) | fn from(err: Error) -> Self {

FILE: crates/snapshots/src/lib.rs
  type Kind (line 53) | pub enum Kind {
  type Info (line 63) | pub struct Info {
  method default (line 79) | fn default() -> Self {
  type Usage (line 96) | pub struct Usage {
  method add_assign (line 105) | fn add_assign(&mut self, rhs: Self) {
  type Snapshotter (line 119) | pub trait Snapshotter: Send + Sync + 'static {
    method stat (line 129) | async fn stat(&self, key: String) -> Result<Info, Self::Error>;
    method update (line 134) | async fn update(
    method usage (line 146) | async fn usage(&self, key: String) -> Result<Usage, Self::Error>;
    method mounts (line 155) | async fn mounts(&self, key: String) -> Result<Vec<api::types::Mount>, ...
    method prepare (line 169) | async fn prepare(
    method view (line 188) | async fn view(
    method commit (line 203) | async fn commit(
    method remove (line 216) | async fn remove(&self, key: String) -> Result<(), Self::Error>;
    method clear (line 226) | async fn clear(&self) -> Result<(), Self::Error> {
    method list (line 250) | async fn list(

FILE: crates/snapshots/src/wrap.rs
  type Wrapper (line 31) | pub struct Wrapper<S: Snapshotter> {
  function server (line 36) | pub fn server<S: Snapshotter>(snapshotter: Arc<S>) -> SnapshotsServer<Wr...
  method prepare (line 42) | async fn prepare(
  method view (line 57) | async fn view(
  method mounts (line 71) | async fn mounts(
  method commit (line 85) | async fn commit(
  method remove (line 97) | async fn remove(
  method stat (line 109) | async fn stat(
  method update (line 125) | async fn update(
  type ListStream (line 157) | type ListStream = BoxStream<Result<ListSnapshotsResponse, tonic::Status>...
  method list (line 159) | async fn list(
  method usage (line 183) | async fn usage(
  method cleanup (line 202) | async fn cleanup(