How to slow down the scrolling of multipage standard output on terminal?

Question

On a cluster where I am part of the management team, I often have to go through the multipage standard output of various commands such as sudo find / to look for any troubles such as broken links or to check the directory trees. At other times, I need to review long text files with lists of items on them to see if there are any unusual names.

Normally, piping the output through less, I can scroll pagewise but I figure it would be sufficient if the standard output scrolled a little slowly just like the credit roll at the end of a movie.

Is there a way to accomplish this in bash or any other terminal environment?

Answer 1

pv, the pipe viewer, will let you print one line every second, use it like:

cat foo | pv --quiet --line-mode --rate-limit 1 

(or, shorter, pv -qlL1). In --line-mode, the --rate-limit (-L) flag defines the number of lines per second that will be printed; the higher the number, the faster the output.

It should be available in your distro's repositories (e.g. aptitude install pv to get it).

Answer 2

Answer from thrig's comment on OP. Works very well. Change the decimal after sleep to modify the time between lines.

sudo find / | awk '{system("sleep .5");print}'

Quit with ctrl+z and then kill the job (when using bash); ctrl+c only exits that line.

Edit:

Did some research based on a comment below. The suggestion awk '{system(sleep.5)||exit;print}' wasn't working on my system, but the following does seem to allow a ctrl+c exit.

awk '{if (system("sleep .5 && exit 2") != 2) exit; print}'

Putting it in a script or giving it an alias will save you from carpal tunnel.

Answer 3

As promised in a previous answer, a simple C program. Why not? Boring day.

slower.c

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main(int argc, char** argv) {
    int delay;
    char* rem;
    if (argc > 1) {
        delay = strtol(argv[1], &rem, 10);
    } else {
        delay = 500;
    }

    char* line;
    size_t bufsize = 0;

    struct timespec ts;
    ts.tv_sec = delay / 1000;
    ts.tv_nsec = (delay % 1000) * 1000000;

    while (getline(&line, &bufsize, stdin) != -1) {
        printf("%s", line);
        nanosleep(&ts, NULL);
    }
    free(line);
}

Compile with a nice gcc slower.c -o slower. If used with no arguments, the milliseconds per line defaults to 500.

Usage: sudo find / | ./slower [MILLISECONDS PER LINE]

Edit: Fixed up some of the code thanks to input in the comments. Apparently, getline doesn't even need your filthy malloc, or any default values. Let getline allocate the crap out of itself.

Edit 2: Removed the improper while (!feof(stdin)) usage and added back in the bufsize initialization for compatibility.

Answer 4

If its just the output of find you need to rate-limit in this manner, then you can just use find's -exec parameter to perform the sleep for each line:

sudo find / -exec sleep 0.2 \; -print

Answer 5

A simple Go program, to moderate output.

// moderare will slow down printing.
//
// $ find ~ | moderare
package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "log"
    "os"
    "time"
)

var (
    sleep = flag.Duration("s", 1*time.Second, "sleep after each line")
    br    = bufio.NewReader(os.Stdin)
)

func main() {
    flag.Parse()
    for {
        line, err := br.ReadString('\n')
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatal(err)
        }
        time.Sleep(*sleep)
        fmt.Printf(line)
    }
}