Cfrtjryk

Hope this is the right place to ask.

Is there a unix tool that works similarly to this?

# invokes echo, saves to cache (using command with arguments as key), returns "hi"

cache 10 echo hi 



# wait 2 seconds

sleep 2



# doesn't invoke echo, from cache returns "hi"

cache 10 echo hi 



# wait 10 seconds

sleep 10



# with cache expired, invokes echo, returns "hi"

cache 10 echo hi 

Obviously echo wouldn't be the real use-case.

Basically cache STDOUT, STDERR and status for a given command+arguments, so the next call to the same process doesn't have to re-run it.

I could write a script that does it but I wondered if there was one in the unix toolset that I don't know about.

You could put the result in a file and then read it back from that file...

tmpDir=/tmp/$$

rm -rf "$tmpDir"

mkdir "$tmpDir"



echo cmd1 > "$tmpDir"/cmd1_stdout 2> "$tmpDir"/cmd1_stderr

echo $? > "$tmpDir"/cmd1_exitcode



# Retrieving output of cmd1:

( cat "$tmpDir"/cmd1_stdout ; cat "$tmpDir"/cmd1_stderr 1>&2; exit $(cat "$tmpDir"/cmd1_exitcode) )

From this we could define a "cache" function. This version need a character that we will never use as argument. For example the comma ",". You can change it at the line "IFS=,"

tmpDir=/tmp/$$

rm -rf "$tmpDir"

mkdir "$tmpDir"



cache() {



 IFS=, cmd="$*"

 if [ -f "$tmpDir/$cmd"_exitcode ]; then 

   cat "$tmpDir/$cmd"_stdout

   cat "$tmpDir/$cmd"_stderr 1>&2

   return $(cat "$tmpDir"/cmd1_exitcode)

 fi



   # This line is bash-only:

 "$@" 2> >(tee "$tmpDir/$cmd"_stderr 1>&2) > >(tee "$tmpDir/$cmd"_stdout)

 local e=$?

 echo $e > "$tmpDir/$cmd"_exitcode



 return $e

}

The timeout could be implemented with "date +%s" and "stat -c %Y" :

tmpDir=/tmp/$$

rm -rf "$tmpDir"

mkdir "$tmpDir"



cache() {



 local timeout=$1

 shift



 IFS=, cmd="$*"

 if [ -f "$tmpDir/$cmd"_exitcode ]; then 



   local now=$(date +%s)

   local fdate=$(stat -c %Y "$tmpDir/$cmd"_exitcode)



   if [ $((now-fdate)) -le $timeout ]; then 

     cat "$tmpDir/$cmd"_stdout

     cat "$tmpDir/$cmd"_stderr 1>&2

     return $(cat "$tmpDir/$cmd"_exitcode)

   fi



 fi



   # This line is bash-only:

 "$@" 2> >(tee "$tmpDir/$cmd"_stderr 1>&2) > >(tee "$tmpDir/$cmd"_stdout)

 local e=$?

 echo $e > "$tmpDir/$cmd"_exitcode



 return $e

}

The "bash only" line could be replaced by :

  "$@" 2> "$tmpDir/$cmd"_stderr > "$tmpDir/$cmd"_stdout

  local e=$?

  cat "$tmpDir/$cmd"_stdout

  cat "$tmpDir/$cmd"_stderr 1>&2

To my knowledge, there is no standard or traditional tool which works this way. However, searching for "cache stdout" brought me to https://github.com/Valiev/cache, which appears to be a tool which does what you want.

I'm not aware of a generic tool for doing this sort of caching, but I'm aware of a specific tool for caching the result of compiling C or C++ files, the ccache compiler cache.

This stores the preprocessed sources and compiled object code files, and uses hashes based on both the source code and the compiler signature to figure out whether to use the cache or to recompile a file.

A generic cache for the shell would have to similarly hash the script, the signature of each external utility used, etc., and also take into account that the output of a shell script may depend on the time of day (if it uses date) and many many other factors.

Creating a cache for a single command would not be beneficial, especially not for echo since this is built into most shells and the extra processing of it for caching would only slow it down (unless what was echoed also called heavy external utilities through command substitutions etc.)

I don't think it would be worthwhile in the end, but possibly only useful in a very specific context, such as the ccache utility for caching compilations, which is a problem slightly more limited in its scope.

The most common mechanism for caching command output in shell scripts is to assign it to a variable. This is easily done with a subshell. It doesn't expire in the way a traditional cache does, but those who write shell scripts most often find it acceptable. Here's your above script using a subshell and variable

HI=$(echo hi)

echo $HI

sleep 2

echo $HI

sleep 10

echo $HI

Another alternative is to create a cache function in shell script. Something like ...

cache() {

expiry=$1

cmd=$2-

cache=/tmp/{$2-}_cache



if test "`find -not -newermt '-30 seconds' -delete ${cache}`"; then

$cmd |tee "$cache"

else

cat "$cache"

fi

}

use this cmd https://github.com/jingminglang/cmd_cache

git clone https://github.com/jingminglang/cmd_cache

go build main.go

./main -c [your command] -t [cache time]