¿Puedo almacenar en caché el resultado de un comando en Linux desde CLI?

Question

Estoy buscando una implementación de un comando 'cacheme', que 'memoizes' la salida de lo que tenga en ARGV. Si nunca lo ejecutó, lo ejecutará y memorizará la salida. Si se ejecutó, simplemente copiará la salida del archivo (o incluso mejor, tanto la salida como el error a & 1 y & 2 respectivamente).

Supongamos que alguien escribió este comando, funcionaría así.

$ time cacheme sleep 1 # first time it takes one sec 
real 0m1.228s 
user 0m0.140s 
sys 0m0.040s 

$ time cacheme sleep 1 # second time it looks for stdout in the cache (dflt expires in 1h) 
#DEBUG# Cache version found! (1 minute old) 

real 0m0.100s 
user 0m0.100s 
sys 0m0.040s 

Este ejemplo es un poco tonto porque no tiene salida. Idealmente se probaría en un script como sleep-1-and-echo-hello-world.sh.

Creé un pequeño script que crea un archivo en/tmp/con hash del nombre completo del comando y nombre de usuario, pero estoy bastante seguro de que algo ya existe.

¿Conoces algo de esto?

Answer 1

Solución mejorada anteriormente añadiendo un límite de caducidad como argumento opcional.

#!/bin/sh 
# save as e.g. $HOME/.local/bin/cacheme 
# and then chmod u+x $HOME/.local/bin/cacheme 
VERBOSE=false 
PROG="$(basename $0)" 
DIR="${HOME}/.cache/${PROG}" 
mkdir -p "${DIR}" 
EXPIRY=600 # default to 10 minutes 
# check if first argument is a number, if so use it as expiration (seconds) 
[ "$1" -eq "$1" ] 2>/dev/null && EXPIRY=$1 && shift 
[ "$VERBOSE" = true ] && echo "Using expiration $EXPIRY seconds" 
CMD="$@" 
HASH=$(echo "$CMD" | md5sum | awk '{print $1}') 
CACHE="$DIR/$HASH" 
test -f "${CACHE}" && [ $(expr $(date +%s) - $(date -r "$CACHE" +%s)) -le $EXPIRY ] || eval "$CMD" > "${CACHE}" 
cat "${CACHE}" 

Answer 2

La solución que encontré en ruby ​​es esta. ¿Alguien ve alguna optimización?

#!/usr/bin/env ruby 

VER = '1.2' 
$time_cache_secs = 3600 
$cache_dir = File.expand_path("~/.cacheme") 

require 'rubygems' 
begin 
    require 'filecache'   # gem install ruby-cache 
rescue Exception => e 
    puts 'gem filecache requires installation, sorry. trying to install myself' 
    system 'sudo gem install -r filecache' 
    puts 'Try re-running the program now.' 
    exit 1 
end 

=begin 
    # create a new cache called "my-cache", rooted in /home/simon/caches 
    # with an expiry time of 30 seconds, and a file hierarchy three 
    # directories deep 
=end 
def main 
    cache = FileCache.new("cache3", $cache_dir, $time_cache_secs, 3) 
    cmd = ARGV.join(' ').to_s # caching on full command, note that quotes are stripped 
    cmd = 'echo give me an argment' if cmd.length < 1 

    # caches the command and retrieves it 
    if cache.get('output' + cmd) 
    #deb "Cache found!(for '#{cmd}')" 
    else 
    #deb "Cache not found! Recalculating and setting for the future" 
    cache.set('output' + cmd, `#{cmd}`) 
    end 
    #deb 'anyway calling the cache now' 
    print(cache.get('output' + cmd)) 
end 

main 

Answer 3

¿Qué le parece este sencillo script de shell (no probado)?

#!/bin/sh 

mkdir -p cache 

cachefile=cache/cache 

for i in "$@" 
do 
    cachefile=${cachefile}_$(printf %s "$i" | sed 's/./\\&/g') 
done 

test -f "$cachefile" || "$@" > "$cachefile" 
cat "$cachefile" 

Answer 4

he implementado un script sencillo para el almacenamiento en caché fiesta, porque quería speed up plotting from piped shell command in gnuplot. Se puede usar para almacenar en caché la salida de cualquier comando. La memoria caché se utiliza siempre que los argumentos sean los mismos y los archivos que pasen en argumentos no hayan cambiado. El sistema es responsable de la limpieza.

#!/bin/bash 

# hash all arguments 
KEY="$@" 

# hash last modified dates of any files 
for arg in "$@" 
do 
    if [ -f $arg ] 
    then 
    KEY+=`date -r "$arg" +\ %s` 
    fi 
done 

# use the hash as a name for temporary file 
FILE="/tmp/command_cache.`echo -n "$KEY" | md5sum | cut -c -10`" 

# use cached file or execute the command and cache it 
if [ -f $FILE ] 
then 
    cat $FILE 
else 
    $@ | tee $FILE 
fi 

Usted puede nombrar el guión cache, establecer el indicador ejecutable y lo puso en su PATH. Luego simplemente prefija cualquier comando con cache para usarlo.

Answer 5

Existe una implementación aquí: https://bitbucket.org/sivann/runcached/src Caché de ruta ejecutable, salida, código de salida, recuerda argumentos. Expiración configurable Implementado en bash, C, python, elige lo que más te convenga.