Merge pull request #23 from Tim-Zhang/add-trait-bound-for-hierarchy

Add trait bound for hierarchy

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "cgroups"
+name = "cgroups-rs"
 description = "Native Rust crate for managing control groups on Linux"
-repository = "https://github.com/levex/cgroups-rs"
+repository = "https://github.com/kata-containers/cgroups-rs"
 keywords = ["linux", "cgroup", "containers", "isolation"]
 categories = ["os", "api-bindings", "os::unix-apis"]
 license = "MIT OR Apache-2.0"
-version = "0.2.0"
-authors = ["Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
+version = "0.2.1"
+authors = ["The Kata Containers community <kata-dev@lists.katacontainers.io>", "Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
 edition = "2018"
 
 [dependencies]

README.md

@@ -1,8 +1,7 @@
-# cgroups-rs ![Build](https://travis-ci.org/levex/cgroups-rs.svg?branch=master)
+# cgroups-rs ![Build](https://travis-ci.org/kata-containers/cgroups-rs.svg?branch=master)
 Native Rust library for managing control groups under Linux
 
-Right now the crate only support the original, V1 hierarchy, however support
-is planned for the Unified hierarchy.
+Both v1 and v2 of cgroups are supported.
 
 # Examples
 
@@ -11,11 +10,11 @@ is planned for the Unified hierarchy.
 ``` rust
 
 
-use cgroups::*;
-use cgroups::cgroup_builder::*;
+use cgroups_rs::*;
+use cgroups_rs::cgroup_builder::*;
 
 // Acquire a handle for the cgroup hierarchy.
-let hier = cgroups::hierarchies::auto();
+let hier = cgroups_rs::hierarchies::auto();
 
 // Use the builder pattern (see the documentation to create the control group)
 //
@@ -30,7 +29,7 @@ let hier = cgroups::hierarchies::auto();
 // other control groups.
 
 // Get a handle to the CPU controller.
-let cpus: &cgroups::cpu::CpuController = cg.controller_of().unwrap();
+let cpus: &cgroups_rs::cpu::CpuController = cg.controller_of().unwrap();
 cpus.add_task(&CgroupPid::from(1234u64));
 
 // [...]

src/blkio.rs

@@ -8,13 +8,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/blkio-controller.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/blkio-controller.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{
     BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem,
 };
@@ -401,25 +401,6 @@ impl<'a> From<&'a Subsystem> for &'a BlkIoController {
     }
 }
 
-fn read_string_from(mut file: File) -> Result<String> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl BlkIoController {
     /// Constructs a new `BlkIoController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf, v2: bool) -> Self {

src/cgroup_builder.rs

@@ -16,10 +16,10 @@
 //! by a call to `build()`.
 //!
 //! ```rust,no_run
-//! # use cgroups::*;
-//! # use cgroups::devices::*;
-//! # use cgroups::cgroup_builder::*;
-//! let h = cgroups::hierarchies::auto();
+//! # use cgroups_rs::*;
+//! # use cgroups_rs::devices::*;
+//! # use cgroups_rs::cgroup_builder::*;
+//! let h = cgroups_rs::hierarchies::auto();
 //! let cgroup: Cgroup = CgroupBuilder::new("hello")
 //!      .memory()
 //!          .kernel_memory_limit(1024 * 1024)

src/cpu.rs

@@ -15,7 +15,7 @@ use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
-use crate::{parse_max_value, read_i64_from};
+use crate::{parse_max_value, read_i64_from, read_u64_from};
 
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, CpuResources, CustomizedAttribute,
@@ -110,17 +110,6 @@ impl<'a> From<&'a Subsystem> for &'a CpuController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl CpuController {
     /// Contructs a new `CpuController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf, v2: bool) -> Self {

src/cpuacct.rs

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/cpuacct.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/cpuacct.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem};
 
 /// A controller that allows controlling the `cpuacct` subsystem of a Cgroup.
@@ -97,26 +97,6 @@ impl<'a> From<&'a Subsystem> for &'a CpuAcctController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    let res = file.read_to_string(&mut string);
-    match res {
-        Ok(_) => match string.trim().parse() {
-            Ok(e) => Ok(e),
-            Err(e) => Err(Error::with_cause(ParseError, e)),
-        },
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-fn read_string_from(mut file: File) -> Result<String> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl CpuAcctController {
     /// Contructs a new `CpuAcctController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {

src/cpuset.rs

@@ -10,13 +10,13 @@
 //!  [Documentation/cgroup-v1/cpusets.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt)
 
 use log::*;
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, CpuResources, Resources, Subsystem,
 };
@@ -204,25 +204,6 @@ impl<'a> From<&'a Subsystem> for &'a CpuSetController {
     }
 }
 
-fn read_string_from(mut file: File) -> Result<String> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 /// Parse a string like "1,2,4-5,8" into a list of (start, end) tuples.
 fn parse_range(s: String) -> Result<Vec<(u64, u64)>> {
     let mut fin = Vec::new();

src/hugetlb.rs

@@ -8,13 +8,12 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/hugetlb.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/hugetlb.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
-use crate::flat_keyed_to_vec;
+use crate::{flat_keyed_to_vec, read_u64_from};
 
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, HugePageResources, Resources, Subsystem,
@@ -86,17 +85,6 @@ impl<'a> From<&'a Subsystem> for &'a HugeTlbController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl HugeTlbController {
     /// Constructs a new `HugeTlbController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf, v2: bool) -> Self {

src/lib.rs

@@ -10,6 +10,7 @@ use std::collections::HashMap;
 use std::fs::{self, File};
 use std::io::{BufRead, BufReader, Read, Write};
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 
 macro_rules! update_and_test {
     ($self: ident, $set_func:ident, $value:expr, $get_func:ident) => {
@@ -385,7 +386,7 @@ pub trait ControllIdentifier {
 
 /// Control group hierarchy (right now, only V1 is supported, but in the future Unified will be
 /// implemented as well).
-pub trait Hierarchy: std::fmt::Debug + Send {
+pub trait Hierarchy: std::fmt::Debug + Send + Sync {
     /// Returns what subsystems are supported by the hierarchy.
     fn subsystems(&self) -> Vec<Subsystem>;
 
@@ -422,7 +423,7 @@ pub struct MemoryResources {
     ///
     /// # Usage:
     /// ```
-    /// let resource = &mut cgroups::Resources::default();
+    /// let resource = &mut cgroups_rs::Resources::default();
     /// resource.memory.attrs.insert("memory.numa_balancing", "true".to_string());
     /// // apply here
     pub attrs: std::collections::HashMap<&'static str, String>,
@@ -464,7 +465,7 @@ pub struct CpuResources {
     /// Customized key-value attributes
     /// # Usage:
     /// ```
-    /// let resource = &mut cgroups::Resources::default();
+    /// let resource = &mut cgroups_rs::Resources::default();
     /// resource.cpu.attrs.insert("cpu.cfs_init_buffer_us", "10".to_string());
     /// // apply here
     /// ```
@@ -832,14 +833,35 @@ pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap
     Ok(h)
 }
 
-/// read and parse an i64 data
-fn read_i64_from(mut file: File) -> Result<i64> {
+fn read_from<T>(mut file: File) -> Result<T>
+where
+    T: FromStr,
+    <T as FromStr>::Err: 'static + Send + Sync + std::error::Error,
+{
     let mut string = String::new();
     match file.read_to_string(&mut string) {
         Ok(_) => string
             .trim()
-            .parse()
+            .parse::<T>()
             .map_err(|e| Error::with_cause(ParseError, e)),
         Err(e) => Err(Error::with_cause(ReadFailed, e)),
     }
 }
+
+fn read_string_from(mut file: File) -> Result<String> {
+    let mut string = String::new();
+    match file.read_to_string(&mut string) {
+        Ok(_) => Ok(string.trim().to_string()),
+        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+    }
+}
+
+/// read and parse an u64 data
+fn read_u64_from(file: File) -> Result<u64> {
+    read_from::<u64>(file)
+}
+
+/// read and parse an i64 data
+fn read_i64_from(file: File) -> Result<i64> {
+    read_from::<i64>(file)
+}

src/memory.rs

@@ -9,15 +9,14 @@
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/memory.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt)
 use std::collections::HashMap;
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 use std::sync::mpsc::Receiver;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 use crate::events;
-use crate::read_i64_from;
+use crate::{read_i64_from, read_string_from, read_u64_from};
 
 use crate::flat_keyed_to_hashmap;
 
@@ -870,25 +869,6 @@ impl<'a> From<&'a Subsystem> for &'a MemController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-fn read_string_from(mut file: File) -> Result<String> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::memory::{

src/net_cls.rs

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/net_cls.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/net_cls.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, NetworkResources, Resources, Subsystem,
 };
@@ -74,17 +74,6 @@ impl<'a> From<&'a Subsystem> for &'a NetClsController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl NetClsController {
     /// Constructs a new `NetClsController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {

src/net_prio.rs

@@ -8,13 +8,13 @@
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/net_prio.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/net_prio.txt)
 use std::collections::HashMap;
-use std::fs::File;
-use std::io::{BufRead, BufReader, Read, Write};
+use std::io::{BufRead, BufReader, Write};
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, NetworkResources, Resources, Subsystem,
 };
@@ -77,17 +77,6 @@ impl<'a> From<&'a Subsystem> for &'a NetPrioController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl NetPrioController {
     /// Constructs a new `NetPrioController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {

src/pid.rs

@@ -8,13 +8,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroups-v1/pids.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/pids.txt)
-use std::fs::File;
 use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     parse_max_value, ControllIdentifier, ControllerInternal, Controllers, MaxValue, PidResources,
     Resources, Subsystem,
@@ -89,17 +89,6 @@ impl<'a> From<&'a Subsystem> for &'a PidController {
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl PidController {
     /// Constructors a new `PidController` instance, with `root` serving as the controller's root
     /// directory.

src/rdma.rs

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/rdma.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/rdma.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_string_from;
 use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem};
 
 /// A controller that allows controlling the `rdma` subsystem of a Cgroup.
@@ -66,14 +66,6 @@ impl<'a> From<&'a Subsystem> for &'a RdmaController {
     }
 }
 
-fn read_string_from(mut file: File) -> Result<String> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl RdmaController {
     /// Constructs a new `RdmaController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {

tests/builder.rs

@@ -5,19 +5,19 @@
 //
 
 //! Some simple tests covering the builder pattern for control groups.
-use cgroups::blkio::*;
-use cgroups::cgroup_builder::*;
-use cgroups::cpu::*;
-use cgroups::devices::*;
-use cgroups::hugetlb::*;
-use cgroups::memory::*;
-use cgroups::net_cls::*;
-use cgroups::pid::*;
-use cgroups::*;
+use cgroups_rs::blkio::*;
+use cgroups_rs::cgroup_builder::*;
+use cgroups_rs::cpu::*;
+use cgroups_rs::devices::*;
+use cgroups_rs::hugetlb::*;
+use cgroups_rs::memory::*;
+use cgroups_rs::net_cls::*;
+use cgroups_rs::pid::*;
+use cgroups_rs::*;
 
 #[test]
 pub fn test_cpu_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build")
         .cpu()
         .shares(85)
@@ -35,7 +35,7 @@ pub fn test_cpu_res_build() {
 
 #[test]
 pub fn test_memory_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_memory_res_build")
         .memory()
         .kernel_memory_limit(128 * 1024 * 1024)
@@ -58,7 +58,7 @@ pub fn test_memory_res_build() {
 
 #[test]
 pub fn test_pid_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_pid_res_build")
         .pid()
         .maximum_number_of_processes(MaxValue::Value(123))
@@ -77,7 +77,7 @@ pub fn test_pid_res_build() {
 #[test]
 #[ignore] // ignore this test for now, not sure why my kernel doesn't like it
 pub fn test_devices_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_devices_res_build")
         .devices()
         .device(1, 6, DeviceType::Char, true, vec![DevicePermissions::Read])
@@ -103,7 +103,7 @@ pub fn test_devices_res_build() {
 
 #[test]
 pub fn test_network_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if h.v2() {
         // FIXME add cases for v2
         return;
@@ -124,7 +124,7 @@ pub fn test_network_res_build() {
 
 #[test]
 pub fn test_hugepages_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if h.v2() {
         // FIXME add cases for v2
         return;
@@ -149,7 +149,7 @@ pub fn test_hugepages_res_build() {
 #[test]
 #[ignore] // high version kernel not support `blkio.weight`
 pub fn test_blkio_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build")
         .blkio()
         .weight(100)

tests/cgroup.rs

@@ -5,13 +5,13 @@
 //
 
 //! Simple unit tests about the control groups system.
-use cgroups::memory::MemController;
-use cgroups::Controller;
-use cgroups::{Cgroup, CgroupPid, Subsystem};
+use cgroups_rs::memory::MemController;
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, CgroupPid, Subsystem};
 
 #[test]
 fn test_tasks_iterator() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
     let cg = Cgroup::new(h, String::from("test_tasks_iterator"));
     {
@@ -38,10 +38,10 @@ fn test_tasks_iterator() {
 
 #[test]
 fn test_cgroup_with_relative_paths() {
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cgroup_root = h.root();
     let cgroup_name = "test_cgroup_with_relative_paths";
 
@@ -79,10 +79,10 @@ fn test_cgroup_with_relative_paths() {
 
 #[test]
 fn test_cgroup_v2() {
-    if !cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_v2"));
 
     let mem_controller: &MemController = cg.controller_of().unwrap();

tests/cpu.rs

@@ -4,12 +4,12 @@
 //
 
 //! Simple unit tests about the CPU control groups system.
-use cgroups::cpu::CpuController;
-use cgroups::Cgroup;
+use cgroups_rs::cpu::CpuController;
+use cgroups_rs::Cgroup;
 
 #[test]
 fn test_cfs_quota_and_periods() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods"));
 
     let cpu_controller: &CpuController = cg.controller_of().unwrap();

tests/cpuset.rs

@@ -4,15 +4,15 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 //
 
-use cgroups::cpuset::CpuSetController;
-use cgroups::error::ErrorKind;
-use cgroups::{Cgroup, CgroupPid};
+use cgroups_rs::cpuset::CpuSetController;
+use cgroups_rs::error::ErrorKind;
+use cgroups_rs::{Cgroup, CgroupPid};
 
 use std::fs;
 
 #[test]
 fn test_cpuset_memory_pressure_root_cg() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_memory_pressure_root_cg"));
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
@@ -26,7 +26,7 @@ fn test_cpuset_memory_pressure_root_cg() {
 
 #[test]
 fn test_cpuset_set_cpus() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus"));
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
@@ -64,7 +64,7 @@ fn test_cpuset_set_cpus() {
 
 #[test]
 fn test_cpuset_set_cpus_add_task() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus_add_task/sub-dir"));
 
     let cpuset: &CpuSetController = cg.controller_of().unwrap();

tests/devices.rs

@@ -6,17 +6,17 @@
 
 //! Integration tests about the devices subsystem
 
-use cgroups::devices::{DevicePermissions, DeviceType, DevicesController};
-use cgroups::{Cgroup, DeviceResource};
+use cgroups_rs::devices::{DevicePermissions, DeviceType, DevicesController};
+use cgroups_rs::{Cgroup, DeviceResource};
 
 #[test]
 fn test_devices_parsing() {
     // now only v2
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
 
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_devices_parsing"));
     {
         let devices: &DevicesController = cg.controller_of().unwrap();

tests/hugetlb.rs

@@ -4,19 +4,19 @@
 //
 
 //! Integration tests about the hugetlb subsystem
-use cgroups::error::*;
-use cgroups::hugetlb::{self, HugeTlbController};
-use cgroups::Cgroup;
+use cgroups_rs::error::*;
+use cgroups_rs::hugetlb::{self, HugeTlbController};
+use cgroups_rs::Cgroup;
 use std::fs;
 
 #[test]
 fn test_hugetlb_sizes() {
     // now only v2
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
 
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_hugetlb_sizes"));
     {
         let hugetlb_controller: &HugeTlbController = cg.controller_of().unwrap();

tests/memory.rs

@@ -4,13 +4,13 @@
 //
 
 //! Integration tests about the hugetlb subsystem
-use cgroups::memory::{MemController, SetMemory};
-use cgroups::Controller;
-use cgroups::{Cgroup, MaxValue};
+use cgroups_rs::memory::{MemController, SetMemory};
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, MaxValue};
 
 #[test]
 fn test_disable_oom_killer() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_disable_oom_killer"));
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
@@ -35,7 +35,7 @@ fn test_disable_oom_killer() {
 
 #[test]
 fn set_mem_v2() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if !h.v2() {
         return;
     }

tests/pids.rs

@@ -5,9 +5,9 @@
 //
 
 //! Integration tests about the pids subsystem
-use cgroups::pid::PidController;
-use cgroups::Controller;
-use cgroups::{Cgroup, MaxValue};
+use cgroups_rs::pid::PidController;
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, MaxValue};
 
 use nix::sys::wait::{waitpid, WaitStatus};
 use nix::unistd::{fork, ForkResult};
@@ -16,7 +16,7 @@ use libc::pid_t;
 
 #[test]
 fn create_and_delete_cgroup() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("create_and_delete_cgroup"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -30,7 +30,7 @@ fn create_and_delete_cgroup() {
 
 #[test]
 fn test_pids_current_is_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pids_current_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -42,7 +42,7 @@ fn test_pids_current_is_zero() {
 
 #[test]
 fn test_pids_events_is_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pids_events_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -55,7 +55,7 @@ fn test_pids_events_is_zero() {
 
 #[test]
 fn test_pid_events_is_not_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pid_events_is_not_zero"));
     {
         let pids: &PidController = cg.controller_of().unwrap();

tests/resources.rs

@@ -5,12 +5,12 @@
 //
 
 //! Integration test about setting resources using `apply()`
-use cgroups::pid::PidController;
-use cgroups::{Cgroup, MaxValue, PidResources, Resources};
+use cgroups_rs::pid::PidController;
+use cgroups_rs::{Cgroup, MaxValue, PidResources, Resources};
 
 #[test]
 fn pid_resources() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("pid_resources"));
     {
         let res = Resources {