go-jsoncache
The package provides an extremely simple JSON value caching package
for developers to build CLI apps with Go. JSON values are cached with
keys developers using this package will provide and in a named
subdirectory within the user's home directory of the developer's
choosing.
Primary Use-Case
The primary use-case for this package is to cache JSON API responses locally to improve performance.
Any app that depends on accessing JSON APIs and/or JSON files hosted
remotely on a webserver, such as JSON files found in GitHub
repositories, a.k.a. "a poor man's JSON API" can benefit from
go-jsoncache
if the app is not currently caching its HTTP requests.
Package Dependencies
go-jsoncache
has two (2) dependencies, one of which we developed too:
github.com/gearboxworks/go-status
— Our "error" package that allows
for returning success messages as well as error messages.
github.com/mitchellh/go-homedir
— Hashicorp's defacto-canonical package
for determining home directories
Concurrency/Go Routines
This package does not attempt to support concurrent use, although we are
not opposed to pull requests that would address those limitations.
Using go-jsoncache
First create an instance of a jsoncache
object:
New()
cache := jsoncache.New(".my-app")
Next identify a cache key — which must be globally unique with respect
to any and all cache keys for a given computer — and call the Set()
method with your key, a byte slice a.k.a. []byte
and finally a string
representing a duration that can be parsed with time.ParseDuration()
:
b,_ := json.Marshal(mydata)
key := "key-for-my-data"
sts := cache.Set(key, b, "600s") //
Get()
Later, to retrieve a cache value create a new cache object with the same
directory you used previous and call Get()
with the same cache key:
cache := jsoncache.New(".my-app")
b,ok,sts := cache.Get("key-for-my-data")
if is.Error(sts) {
panic(sts.Message())
}
if is.Success(sts) {
fmt.Printf("Hurray! %s", sts.Message())
}
Get()
's return values
If a cache value can be retrieved it will be in the first return value,
the second will be true
and the third will be a status value where
sts.IsSuccess()
will be true
.
If an error occurs the first return value will be a zero []byte
, the
second will be false
and sts.IsError()
will be true
with
sts.Message()
providing the error message. To learn more about
statuses vs. errors see
the go-status
package.
If the case of a cache expiration then the third return value will be
indicate a success with sts.IsSuccess()
but the 2nd parameter will be
false
indicating the cache expired, and of course the 1st return value
will be a zero []byte
.
Clear()
You can clear a key's cached value before it expires with Clear()
:
cache := jsoncache.New(".my-app")
cache.Clear("key-for-my-data")
Type Aliases
The go-jsoncache
package defines the following
types as aliases to
string
:
Filepath
— Intended to represent a full local file path
Path
— Intended to represent a relative file path
Dir
— Intended to represent a full local directory path
Key
— Intended to be used with cache keys
Other Cache Methods
There are several other methods provided, but we have not yet documented them:
VerifyCacheFile(Key) (Filepath, status.Status)
GetCacheFilepath(Key) Filepath
Cache File Location(s)
By default the cache location is a subdirectory name of your own
choosing either ~/
, or if go-homedir
fails then either in /tmp
or
whatever Window's temporary directory
is. If you specify an empty subdirectory name it will use
.go-jsoncache
instead.
JSON values are cached in JSON text files where the developer's JSON
value is wrapped in an outer JSON objects with both data
and expires
properties. The values for the expiration property are generated as
follows using RFC3339
:
duration := "600s"
dur, _ := time.ParseDuration(duration)
wrapper.expires := time.Now().Add(dur).Format(time.RFC3339)
License
The go-jsoncache
package is licensed via AGPL-3.0. Please contact us if you would like to use this package under a different license.