Crate ogle

ogle is a program that runs the given command-line periodically, showing the output only when it is different than the last.

The simplest way to show most of the features of ogle is by asking it to run date; sleep in a shell, with a waiting period of 3s:

Lines that were written by ogle all start with =>. On the first execution, ogle shows a spinner while the command is running. On the next executions, ogle shows a progress bar, where the total corresponds to the duration of the previous execution. The sleep time is also shown, as a countdown. If the command returns an error to the shell, the error value is displayed.

ogle also supports limited interactive control with one-character commands followed by ENTER:

• q: quit after when the process is no longer running.

Installation

If you’re a Rust programmer, ogle can be installed with cargo:

$ cargo install ogle

If you’re a Debian user, ogle is available in packagecloud. Follow these instruction to use the package repository.

Internals

To make it fully testable, it uses a layered architecture based on tokio streams which ends up being similar to how we use pipes in a shell. We can divide it in the following layers:

• wrappers: we have 3 wrapper modules that abtract external libraries to provide us simpler types or types that provide that impl traits we need. They also make it easier to replate the underlying implementation in the future, if necessary. Namely:
  • process_wrapper: wraps process instantiation and I/O, and provides an Item that implements Eq so that we can use it in tests.
  • term_wrapper: implements terminal functions, mostly for output. As we are currently wrapping console and its functions require a console::Term object, we end up using a mutex here to abstract the singleton.
  • user_wrapper: abstract user interaction. At the moment, we just monitor stdin in line mode, and ogle exits gracefully when that’s detected.
  • time_wrapper: home of the Instant and Duration types, which use types from chrono at the moment.
• sys: most of the ogle code doesn’t really call functions that interact with the host system - we have the sys module for that. The module does that by providing a sys::SysApi trait that is then implemented by both the sys::SysReal type, which calls the system functions; and by the sys::SysVirtual type, which can be used to mock these calls in various ways.

sys -> engine -> view -> output

Modules

cli 🔒

ogle’s CLI using clap

differ 🔒

engine 🔒

Main lower-level module that takes care of running the command and yielding all possible events into a coherent stream of timestamped events.

misc 🔒

Misc utility functions

orchestrator 🔒

output 🔒

Wrapper for “low-level” system function used for the output

process_wrapper 🔒

Wrapper for process functions.

progbar 🔒

sys 🔒

Module that wraps system functions used as inputs.

term_wrapper 🔒

Wrapper for low-level terminal manipulation.

time_wrapper 🔒

Wrapper for time Instant and Duration abstractions.

user_wrapper 🔒

Wrapper for user interaction.

view 🔒

Functions

main

Ogle main function, the single pub function in this lib.