Feature request: Cache identifier

[sluga]

Hi Neal,

would the following addition make sense for the package? If so, would you be open to a PR or interested in implementing this yourself?

Problem

We have Shiny apps that use the crunch package, which in turns uses httpcache, as you might know. :)
Because of how Shiny Server works, different users share an R session, therefore they also share the httpcache's cache.
Instead of this, we'd like to have each user have their own cache.

Possible solution

We create a pair of functions that register/identify the cache environment:

cache_identifier_key <- '__CACHE_IDENTIFIER_FUNCTION__'
registerCacheIdentifier <- function(fn){
    stopifnot(
        'fn must be a function' = is.function(fn)
    )
    assign(cache_identifier_key, fn, envir = cache)
}
identifyCache <- function(){
    idfun <- get(cache_identifier_key, envir = cache)
    idfun()
}

We register the default environment in R/load-cache.R:

registerCacheIdentifier(function() cache)

We then modify the functions that check/modify the cache environment:

hitCache <- function (key) {
    exists(key, envir = identifyCache())
}

cacheKeys <- function (){
    setdiff(ls(all.names=TRUE, envir = identifyCache()), cache_identifier_key)
}

# etc.

Usage

Basic example

pkgload::load_all('.')

getCache('foo') # NULL
setCache('foo', 'bar')
getCache('foo') # bar

cache_env <- new.env()
registerCacheIdentifier(function() cache_env)
getCache('foo') # NULL
setCache('foo', 'bar!')
getCache('foo') # bar!

Shiny

For our Shiny applications, we could then do something like this:

registerCacheIdentifier(function() shiny::getShinyOption('cache_environment'))

Inside the server function:

shiny::shinyOptions(cache_environment = new.env(parent = emptyenv()))

[nealrichardson]

I put up #3, which I think will let you do what you need without adding much complexity to httpcache. Let me know what you think.

[sluga]

Thanks for considering this.

However, the current implementation doesn't seem to be super ergonomic in the context of a Shiny app. A toy example is featured below. In this example, the goal is to render a value we've stored in a specific cache environment.

• Approach 1 --- in which we call withCache from within the renderText function --- works, i.e. it displays 'bar', the value of 'foo'. But it requires that we pepper the Shiny code with withCache calls if we extend the app.
• In Approach 2 we try to get around that by including a larger block of code in the withCache function. This approach doesn't work, however, due to how Shiny uses environments.

For comparison, I've opened a PR with the suggested implementation. This alternative implementation passes all existing httpcache tests, and only requires the addition of 3 lines of code per Shiny app:

registerCache(function() getShinyOption('cache'))
# ...
session_cache <- new.env(parent = emptyenv())
shinyOptions(cache = session_cache)

Fortunately, it seems easy to adapt your implementation to enable this kind of approach: If your cache function checked if getOption("httpcache.env") is a function and, if it is, evaluated it, that should work.

We could then do:

options(httpcache.env = function() getShinyOption("cache"))
# ...
session_cache <- new.env(parent = emptyenv())
shinyOptions(cache = session_cache)

What do you think?

Toy example for the httpcache/custom-cache implementation

library(shiny)
library(httpcache) # branch custom-cache

ui <- fluidPage(
    tags$h2("Approach 1: Wrap *inside* render function"),
    verbatimTextOutput("data_wrapped_inside_render"),
    tags$h2("Approach 2: Wrap `withCache()` outside render function"),
    verbatimTextOutput("data_wrapped_outside_render")
)

server <- function(input, output, session) {
    
    session_cache <- new.env(parent = emptyenv())
    shinyOptions(cache = session_cache)
    
    withCache(getShinyOption("cache"), setCache('foo', 'bar'))
    
    # Approach 1 - OK
    output$data_wrapped_inside_render <- renderText({
        paste0(
            "Cached value of foo is: ",
            withCache(getShinyOption("cache"), getCache('foo'))
        )
    })
    # Approach 2 - not OK
    withCache(
        getShinyOption("cache"),
        {
            output$data_wrapped_outside_render <- renderText({
                paste0(
                    "Cached value of foo is: ", getCache('foo')
                )
            })
        }
    )
}

shinyApp(ui = ui, server = server)