Get act running of GH Action locally running (#93)

* Change workflow name
* Switch how rust is installed
* Simplify printing of errors in doc test comment examples
* Add description of using "act" tool to README
* Fix warnings from doc comments and convert a couple to code references
* Try /dev/console if /dev/kmsg fails to allow running in containers that don't allow access to /dev/kmsg
* Get name test to pass
* Qualify doc comment code reference that doesn't exist in linux
* Fix use of std::process across mac and linux

Author: andrewdavidmackenzie

.github/workflows/rust.yml

@@ -1,4 +1,4 @@
-name: Rust
+name: Build and Test
 
 on:
   push:
@@ -35,11 +35,13 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
+
+    - name: Install latest nightly
+      uses: actions-rs/toolchain@v1
       with:
-        fetch-depth: 2
-    - uses: hecrj/[email protected]
-      with:
-        rust-version: ${{ matrix.rust }}
+        profile: minimal
+        toolchain: nightly
+        override: true
         components: clippy
 
     - name: Clippy

README.md

@@ -99,15 +99,26 @@ To build for versions prior to Mac OS 10.7 disable the default features by passi
 To build for Mac OS X 10.7 (or 10.8) you can enable that feature alone using
 --no-default-features --features "macosx_10_7"
 
-# Build and Test
+# Build and Test Locally
 `cargo test` should build and test as usual for rust projects.
 
-However, as some functions need to be run as `root` to work, I run travis-CI tests as `root`. So, when developing in local
-it's best if you use `sudo cargo test`. NOTE: This can get you into permissions problems when switching back and for
-between using `cargo test` and `sudo cargo test`. To fix that run `sudo cargo clean` and then build or test as you prefer.
+However, as some functions need to be run as `root` to work, CI tests are run as `root`. 
+So, when developing in local it's best if you use `sudo cargo test`. 
 
-In order to have tests pass when run as `root` or not, some tests need to check if they are `root` at run-time 
-(using our own `am_root()` function is handy) and avoid failing if *not* run as `root`. 
+NOTE: This can get you into permissions problems when switching back and for
+between using `cargo test` and `sudo cargo test`. 
+To fix that run `sudo cargo clean` and then build or test as you prefer.
+
+In order to have tests pass when run as `root` or not, some tests need to check if they are `root` 
+at run-time (using our own `am_root()` function is handy) and avoid failing if *not* run as `root`. 
+
+## Using "act" to run GH Actions CI workflows locally
+If you develop on macos but want to ensure code builds and tests pass on linux while making changes, 
+you can use the [act](https://github.com/nektos/act) tool to run the Github Actions Workflows on 
+the test matrix.
+
+Just install "act" (`brew install act`) (previously install docker if you don't have it already, 
+and make sure the daemon is running) then run `act` at the command line
 
 ## Macos: clang detection and header file finding
 Newer versions of `bindgen` have improved the detection of `clang` and hence macos header files. 

src/libproc/kmesg_buffer.rs

@@ -58,7 +58,11 @@ pub fn kmsgbuf() -> Result<String, String> {
 /// has blocked and can't send anymore. Returning will end the thread and the channel.
 #[cfg(target_os = "linux")]
 pub fn kmsgbuf() -> Result<String, String> {
-    let file = File::open("/dev/kmsg").map_err(|_| "Could not open /dev/kmsg file '{}'")?;
+    let mut file = File::open("/dev/kmsg");
+    if file.is_err() {
+        file = File::open("/dev/console");
+    }
+    let file = file.map_err(|_| "Could not open /dev/kmsg nor /dev/console file '{}'")?;
     let kmsg_channel = spawn_kmsg_channel(file);
     let duration = time::Duration::from_millis(1);
     let mut buf = String::new();
@@ -90,9 +94,6 @@ fn spawn_kmsg_channel(file: File) -> Receiver<String> {
 
 #[cfg(test)]
 mod test {
-    use std::io;
-    use std::io::Write;
-
     use crate::libproc::proc_pid::am_root;
 
     use super::kmsgbuf;
@@ -105,7 +106,7 @@ mod test {
                 Err(message) => panic!("{}", message)
             }
         } else {
-            writeln!(&mut io::stdout(), "test libproc::kmesg_buffer::kmessage_buffer_test ... skipped as it needs to be run as root").unwrap();
+            println!("test skipped as it needs to be run as root");
         }
     }
 }

src/libproc/proc_pid.rs

@@ -163,21 +163,7 @@ impl From<ProcType> for processes::ProcFilter {
 ///
 /// This function is deprecated in favor of
 /// [`libproc::processes::pids_by_type()`][crate::processes::pids_by_type],
-/// which lets you specify what PGRP / TTY / UID / RUID / PPID you want to
-/// filter by.
-///
-/// # Examples
-///
-/// Get the list of running process IDs using `listpids`
-///
-/// ```
-/// use std::io::Write;
-/// use libproc::libproc::proc_pid;
-///
-/// if let Ok(pids) = proc_pid::listpids(proc_pid::ProcType::ProcAllPIDS) {
-///     println!("Found {} processes using listpids()", pids.len());
-/// }
-/// ```
+/// which lets you specify what PGRP / TTY / UID / RUID / PPID you want to filter by
 #[deprecated(
     since = "0.13.0",
     note = "Please use `libproc::processes::pids_by_type()` instead."
@@ -233,7 +219,7 @@ pub fn listpidspath(proc_types: ProcType, path: &str) -> Result<Vec<u32>, String
 /// // Get the `BSDInfo` for Process of pid 0
 /// match pidinfo::<BSDInfo>(pid, 0) {
 ///     Ok(info) => assert_eq!(info.pbi_pid as i32, pid),
-///     Err(err) => assert!(false, "Error retrieving process info: {}", err)
+///     Err(err) => eprintln!("Error retrieving process info: {}", err)
 /// };
 /// ```
 #[cfg(target_os = "macos")]
@@ -274,7 +260,7 @@ pub fn pidinfo<T: PIDInfo>(_pid: i32, _arg: u64) -> Result<T, String> {
 /// if am_root() {
 ///     match regionfilename(1, 0) {
 ///         Ok(regionfilename) => println!("Region Filename (at address = 0) of init process PID = 1 is '{}'", regionfilename),
-///         Err(message) => panic!(message)
+///         Err(err) => eprintln!("Error: {}", err)
 ///     }
 /// }
 /// ```
@@ -305,7 +291,7 @@ pub fn regionfilename(pid: i32, address: u64) -> Result<String, String> {
 /// if am_root() {
 ///     match regionfilename(1, 0) {
 ///         Ok(regionfilename) => println!("Region Filename (at address = 0) of init process PID = 1 is '{}'", regionfilename),
-///         Err(message) => panic!(message)
+///         Err(err) => eprintln!("Error: {}", err)
 ///     }
 /// }
 /// ```
@@ -323,7 +309,7 @@ pub fn regionfilename(_pid: i32, _address: u64) -> Result<String, String> {
 ///
 /// match pidpath(1) {
 ///     Ok(path) => println!("Path of init process with PID = 1 is '{}'", path),
-///     Err(message) => assert!(false, "{}", message)
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 #[cfg(target_os = "macos")]
@@ -350,8 +336,8 @@ pub fn pidpath(pid: i32) -> Result<String, String> {
 /// match pidpath(1) {
 ///     Ok(path) => println!("Path of init process with PID = 1 is '{}'", path),
 ///     Err(_) if !am_root() => println!("pidpath() needs to be run as root"),
-///     Err(message) if am_root() => assert!(false, "{}", message),
-///     _ => assert!(false, "Unknown error")
+///     Err(err) if am_root() => eprintln!("Error: {}", err),
+///     _ => panic!("Unknown error")
 /// }
 /// ```
 #[cfg(target_os = "linux")]
@@ -373,12 +359,11 @@ pub fn pidpath(pid: i32) -> Result<String, String> {
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid;
 ///
 /// match proc_pid::libversion() {
 ///     Ok((major, minor)) => println!("Libversion: {}.{}", major, minor),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 #[cfg(target_os = "macos")]
@@ -404,30 +389,28 @@ pub fn libversion() -> Result<(i32, i32), String> {
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid;
 ///
 /// match proc_pid::libversion() {
 ///     Ok((major, minor)) => println!("Libversion: {}.{}", major, minor),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 #[cfg(not(target_os = "macos"))]
 pub fn libversion() -> Result<(i32, i32), String> {
     Err("Linux does not use a library, so no library version number".to_owned())
 }
 
-/// Get the name of a process
+/// Get the name of a process, using it's process id (pid)
 ///
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid;
 ///
 /// match proc_pid::name(1) {
 ///     Ok(name) => println!("Name: {}", name),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 #[cfg(target_os = "macos")]
@@ -456,7 +439,7 @@ pub fn name(pid: i32) -> Result<String, String> {
 }
 
 
-/// Get the name of a Process using it's Pid
+/// Get the name of a process, using it's process id (pid)
 #[cfg(target_os = "linux")]
 pub fn name(pid: i32) -> Result<String, String> {
     helpers::procfile_field(&format!("/proc/{pid}/status"), "Name")
@@ -470,7 +453,6 @@ pub fn name(pid: i32) -> Result<String, String> {
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid::{listpidinfo, pidinfo};
 /// use libproc::libproc::task_info::TaskAllInfo;
 /// use libproc::libproc::file_info::{ListFDs, ProcFDType};
@@ -524,12 +506,11 @@ pub fn listpidinfo<T: ListPIDInfo>(_pid: i32, _max_len: usize) -> Result<Vec<T::
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid::pidcwd;
 ///
 /// match pidcwd(1) {
 ///     Ok(cwd) => println!("The CWD of the process with pid=1 is '{}'", cwd.display()),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 pub fn pidcwd(_pid: pid_t) -> Result<PathBuf, String> {
@@ -542,12 +523,11 @@ pub fn pidcwd(_pid: pid_t) -> Result<PathBuf, String> {
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid::pidcwd;
 ///
 /// match pidcwd(1) {
 ///     Ok(cwd) => println!("The CWD of the process with pid=1 is '{}'", cwd.display()),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 pub fn pidcwd(pid: pid_t) -> Result<PathBuf, String> {
@@ -563,12 +543,11 @@ pub fn pidcwd(pid: pid_t) -> Result<PathBuf, String> {
 /// # Examples
 ///
 /// ```
-/// use std::io::Write;
 /// use libproc::libproc::proc_pid::cwdself;
 ///
 /// match cwdself() {
 ///     Ok(cwd) => println!("The CWD of the current process is '{}'", cwd.display()),
-///     Err(err) => writeln!(&mut std::io::stderr(), "Error: {}", err).unwrap()
+///     Err(err) => eprintln!("Error: {}", err)
 /// }
 /// ```
 pub fn cwdself() -> Result<PathBuf, String> {
@@ -603,7 +582,6 @@ pub fn am_root() -> bool {
 // run tests with 'cargo test -- --nocapture' to see the test output
 #[cfg(test)]
 mod test {
-    #[cfg(target_os = "linux")]
     use std::process;
     use std::env;
 
@@ -632,7 +610,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn pidinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         match pidinfo::<BSDInfo>(pid, 0) {
@@ -644,7 +621,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn taskinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         match pidinfo::<TaskInfo>(pid, 0) {
@@ -656,7 +632,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn taskallinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         match pidinfo::<TaskAllInfo>(pid, 0) {
@@ -669,7 +644,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn threadinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         match pidinfo::<ThreadInfo>(pid, 0) {
@@ -682,7 +656,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn workqueueinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         match pidinfo::<WorkQueueInfo>(pid, 0) {
@@ -694,7 +667,6 @@ mod test {
     #[cfg(target_os = "macos")]
     #[test]
     fn listpidinfo_test() {
-        use std::process;
         let pid = process::id() as i32;
 
         if let Ok(info) = pidinfo::<TaskAllInfo>(pid, 0) {
@@ -715,16 +687,9 @@ mod test {
 
     #[test]
     fn name_test() {
-        #[cfg(target_os = "linux")]
-            let expected_name = "systemd";
-        #[cfg(target_os = "macos")]
-            let expected_name = "launchd";
-
         if am_root() || cfg!(target_os = "linux") {
-            match name(1) {
-                Ok(name) => assert_eq!(expected_name, name),
-                Err(_) => panic!("Error retrieving process name")
-            }
+            assert!(&name(process::id() as i32).expect("Could not get the process name")
+                .starts_with("libproc"), "Incorrect process name");
         } else {
             println!("Cannot run 'name_test' on macos unless run as root");
         }

src/processes.rs

@@ -4,8 +4,8 @@ use std::path::Path;
 
 use crate::libproc::sys::*;
 
-/// `ProcFilter` is used to filter process ids. See [`pids_by_type`] and
-/// [`pids_by_type_and_path`] for details.
+/// `ProcFilter` is used to filter process ids.
+/// See [`pids_by_type`] and `pids_by_type_and_path` (macos only) for details.
 #[derive(Copy, Clone)]
 pub enum ProcFilter {
     /// All processes
@@ -41,7 +41,7 @@ pub enum ProcFilter {
 ///
 /// # Examples
 ///
-/// Get the list of all running process IDs using `pids_by_type` and `ProcFilter::All`:
+/// Get the list of all running process IDs using [`pids_by_type`] and [`ProcFilter::All`]:
 ///
 /// ```
 /// use std::io::Write;