shiny.autoreload in {golem}

[ColinFay]

As of right now, options(shiny.autoreload = TRUE) doesn't work with golem

[ColinFay]

Related SO question by @xari https://stackoverflow.com/questions/58648662/autoreload-in-golem-apps-shiny-option-doesnt-work

[ColinFay]

Ok so as far as I can tell it's because this behavior is triggered by shiny:::initAutoReloadMonitor, which is triggered when running a "standard app" in a directory with runApp, which is not triggered by the current implementation of golem.

For example, if I create a new golem, delete the R/ folder, create a shiny app in a folder called R and do :

> options(shiny.autoreload = TRUE)
> runApp(appDir = 'R')

The option works as expected.

And :

> trace("runApp", where = asNamespace("shiny"))
> trace("initAutoReloadMonitor", where = asNamespace("shiny"))
Tracing function "initAutoReloadMonitor" in package
"namespace:shiny"
[1] "initAutoReloadMonitor"

> runApp(appDir = 'R')
trace: runApp(appDir = "R")
Tracing initAutoReloadMonitor(appDir) on entry 

So runApp on directory works.

Then back in a golem app:

> options(shiny.autoreload = TRUE)
> trace("runApp", where = asNamespace("shiny"))
> trace("initAutoReloadMonitor", where = asNamespace("shiny"))

Then launch the run_dev,

> # Run the application
> lpppa::run_app()
Tracing runApp(x) on entry 
Loading required package: shiny

Listening on http://127.0.0.1:5164

I have the trace of runApp, but no initAutoReloadMonitor. So apparently the runApp called from golem (natively) doesn't launch the reloadMonitor.

Not sure how to handle that so far 🤔

[mik3y64]

I am having this issue and it's slowing down my development workflow. I did some test too (by intentionally not using golem to find out the root cause) and I suspect it's the issue with Shiny modules? Golem app uses modules and it gets affected too?

Filed similar issues at shiny but without any help. autoreload doesn't load with Shiny modules #2711

In my package (it's golem but doesn't matter because I am running the app without any golem configurations), R/ dir have three files

• R/app.R
• R/shiny_run.R
• R/my_module.R

autoreload works without module

# app.R
library(shiny)

ui <- fluidPage(
  selectInput("sample_input", "changeLabel", choices = letters[1:3])
)
server <- function(input, output, session) {
  NULL
}
shinyApp(ui = ui, server = server)

# shiny_run.R
options(shiny.autoreload = TRUE)
shiny::runApp()

Editing the "changeLabel" in selectInput() does the change the label.

autoreload doesn't work with module

# my_module.R
moduleUI <- function(id) { 
  ns <- NS(id)
  selectInput(ns("sample_input"), "changeLabel", choices = letters[1:3])
}
moduleServer <- function(input, output, session) {
  NULL
}

# app.R
library(shiny)
source("my_module.R")

ui <- fluidPage(
  moduleUI('test')
)
server <- function(input, output, session) {
  callModule(moduleServer, 'test')
}
shinyApp(ui = ui, server = server)

# shiny_run.R
options(shiny.autoreload = TRUE)
shiny::runApp()

Editing the "changeLabel" in selectInput() does refresh the Shiny application but "changeLabel" does not change at all.

[julistanley]

I'm just getting started with this, but I've been using a relatively hacky solution for this issue. Not sure if it's helpful to others, but I'll throw it here in case:

---

So, each time you change bits of your shiny application, you're supposed to run run_dev.R, right?

Instead of getting auto.reload to work, I just use bash to watch for changes in the R/ directory and call run_dev.R each time I see changes. Of course, it takes a bit to run run_dev.R, but I still find it handy.

Step 1: Set the port

I set that in run_dev.R:

# run_dev.R
[...]

# Run the application
options(shiny.port = 11616) # Added this line
run_app()

I just use port 11616 for fun, since it spells "app" (A=1, P=16).

Step 2: Create utils/watch_app.sh and utils/run_app.sh

Then I create a ./utils folder in my shiny directory and put two files there: watch_app.sh and run_app.sh.

watch_app.sh just checks for changes in the "R" directory. If it sees any changes, it: (1) kills all processes on port 11616, and (2) runs the run_dev.R script.

#!/bin/bash -eu
find ../R | entr sh -c 'lsof -i:11616 | awk '"'"'NR!=1 {print $2}'"'"' | xargs kill ; (cd .. && Rscript ./dev/run_dev.R &)'

run_app.sh (1) makes sure that all processes on port 11616 are killed when watch_app.sh is killed, and (2) runs watch_app.sh:

#!/usr/bin/env bash
trap watch_app.sh kill $( lsof -i:11616 -t)
bash watch_app.sh

Typical workflow

(1) Open up RStudio and my project
(2) Open up a terminal, navigate to [project-root]/utils, run run_app.sh, minimize terminal
(3) Open up a browser, navigate to localhost:11616
(4) Edit things in RStudio and refresh the browser when I want to see changes.

It's definitely a lot slower than Shiny's autorefresh, but it seems to work ok.

---

Sources: using entr | killing by port | nesting single quotes hack.

[gueyenono]

My solution to this issue makes use of a very small Javascript script, which automatically reloads the Shiny app (which is in fact a web page) after a desired length of time. I realize that many Shiny users are not comfortable with using Javascript and I, myself, am learning as of the time of writing this. So, I will write my solution in the form of a detailed step by step guide:

1- Create a Javascript file

The {golem} package makes the first step very trivial. Open the dev/02_dev.R file and look for the function golem::add_js_file(). Execute it by passing your desired file name to it as a character string (e.g. golem::add_js_file("script")). Note that you do not need to specify any extension to the file name. After running this code, the file script.js will be created in the inst/app/www/ folder. Look for it and open it (it does not matter whether you open it in RStudio or not).

2- Add the JavaScript code

Copy the code below, paste it in script.js and save it:

  // Function for reloading the page
  reloadPage = () => {
    window.location.reload()
  }
  setTimeout(reloadPage, 1000) // The page is reloaded every second (1000 milliseconds), adjust it to your needs

Do not forget to change the reload interval, which is 1000 milliseconds above (i.e. one second), if you want to.

3- Run your application

Run your application as usual by running the code in dev/run_dev.R.

Warning

Keep in mind that this hack is mostly useful for building your UI and that you will not be able to efficiently test your app while the script is running because it will automatically reload. For this reason options(shiny.autoreload = TRUE) would still be a more efficient way in your app development process.

In order to stop the script from running, you can just comment it out by using // at the beginning of each line of code:

  // Function for reloading the page
  // reloadPage = () => {
  //    window.location.reload()
  // }
  // setTimeout(reloadPage, 1000) // The page is reloaded every second (1000 milliseconds), adjust it to your needs

Source: this solution was adapted from this Stackoverflow thread.

[gorgitko]

Hello everyone!

I have also came to this problem and it's slowing down my productivity. The solution proposed by @julianstanley is quite similar to the Shiny's native autoreload, but I have actually realized that I like more something similar to the classic devtools shortcut Ctrl+Shift+L (calls load_all()). So I have made a simple reload Bash script and utilized the shrtcts package, which can assign any R command to keyboard shortcut (within RStudio). Now I can reload my Shiny app with Ctrl+Shift+R and watch its output in RStudio terminal. The steps are simple:

1. Put this script in <your golem package>/utils/reload_app.sh:

#!/usr/bin/env bash
cd "$(dirname "$0")"

echo "Running $0"

APP_NAME=$(basename $(realpath ../))

app_pid=${APP_NAME}.pid

if [[ -f $app_pid ]]; then
  printf "$APP_NAME is running, killing ... "
  pkill -F $app_pid
  printf "Done."
fi

printf "\nStarting $APP_NAME ... "
nohup Rscript ../dev/run_dev.R > $APP_NAME.log 2>&1 &
echo $! > $app_pid
printf "Done.\n"

I don't like killing processes through filtering their PID, so here, PID is saved to file and later used for killing.

2. Install shrtcts
3. Put this into ~/.Rprofile:

reload_shiny_app <- function() {
  system2("bash", paste0(golem::get_golem_wd(), "/utils/reload_app.sh"))

  cat("Waiting for Shiny app to start...\n")
  for (i in 1:1000) {
    is_app_running <- system2("curl", c("-IL", "http://localhost:8080"), stdout = NULL, stderr = NULL)

    ##-- exit code 0 means everything is fine :)
    if (!is_app_running) {
      rstudioapi::viewer("http://localhost:8080/")
      break
    }

    Sys.sleep(0.1)
  }
}

The app port is hardcoded here, so change it according to your settings. Make sure you have curl installed, as it is used to check whether the app is running.

3. Put this into ~/.shrtcts.R:

#' Reload current Shiny application.
#'
#' @description <app package>/utils/reload_app.sh must be present.
#'
#' @interactive
#' @shortcut Ctrl+Shift+R
globalenv()$reload_shiny_app

I don't understand how shrtcts is parsing the shortcut command, but if you directly use in shortcut definition what's in the reload_shiny_app(), then reload_app.sh is executed twice. But maybe just something weird is happening on my side, so feel free to try it without the intermediate reload_shiny_app() 😉

4. In RStudio you can now press Ctrl+Shift+R (or whatever you define in ~/.shrtcts.R) and your app will be started. Then open terminal, navigate to utils directory and run tail -f <your app name>.log to watch app's output. Anytime you press Ctrl+Shift+R, your app will be reloaded and shown in RStudio viewer pane.

---

I think this sort of shortcut could be added to golem's RStudio addin.

[ColinFay]

Ok folks, so to sum up the issue is that the autoreload only works when calling runApp() on a directory, and by default {golem} apps don't do this runApp().

Here is the workaround to make this work:

• Step 1: create an app.R deployment file with golem::add_rstudioconnect_file().

• Step 2: change your dev/run_dev.R script as such :

# Set options here
options(golem.app.prod = FALSE) # TRUE = production mode, FALSE = development mode

# Detach all loaded packages and clean your environment
golem::detach_all_attached()
# rm(list=ls(all.names = TRUE))

# Document and reload your package
golem::document_and_reload()

options(shiny.autoreload = TRUE)
# Run the application
shiny::runApp(appDir = here::here())

Enjoy 🎉

[xari]

Ok folks, so to sum up the issue is that the autoreload only works when calling runApp() on a directory, and by default {golem} apps don't do this runApp().

Here is the workaround to make this work:

* Step 1: create an app.R deployment file with `golem::add_rstudioconnect_file()`.

* Step 2: change your dev/run_dev.R script as such :

# Set options here
options(golem.app.prod = FALSE) # TRUE = production mode, FALSE = development mode

# Detach all loaded packages and clean your environment
golem::detach_all_attached()
# rm(list=ls(all.names = TRUE))

# Document and reload your package
golem::document_and_reload()

options(shiny.autoreload = TRUE)
# Run the application
shiny::runApp()

Enjoy 🎉

Thanks for the follow-up, @ColinFay .

When my colleague and I originally encountered this issue, we came to the conclusion that our development workflow must have been fundamentally different from yours. At the time, we would make amendments to our business logic code, and then re-start our app to confirm that everything worked as intended. This involved a lot of waiting for the app to re-load, etc.

The conclusion that we came to is that you probably follow more of a test-driven-development workflow, where you run smaller pieces of your business logic without the need to start-up the entire app. Working this way means that the auto-reload feature is generally less necessary, as you only really need to start -up the app in development when testing UI features.

Chapter 10 of your book gets into TDD somewhat, but it could also be interesting to see a screencast that addresses this topic of "efficient development workflow".

[dwhdai]

Ok folks, so to sum up the issue is that the autoreload only works when calling runApp() on a directory, and by default {golem} apps don't do this runApp().

Here is the workaround to make this work:

• Step 1: create an app.R deployment file with golem::add_rstudioconnect_file().
• Step 2: change your dev/run_dev.R script as such :

# Set options here
options(golem.app.prod = FALSE) # TRUE = production mode, FALSE = development mode

# Detach all loaded packages and clean your environment
golem::detach_all_attached()
# rm(list=ls(all.names = TRUE))

# Document and reload your package
golem::document_and_reload()

options(shiny.autoreload = TRUE)
# Run the application
shiny::runApp()

Enjoy 🎉

Hmm, I just tried this and it didn't work for me. My workflow was:

1. Create app.R and make changes to dev/run_dev.R as Colin suggested
2. Click "Run App" in dev/run_dev.R.
3. Make changes in either app_ui.R or a UI module; neither change registered after refreshing the browser.

Attaching my session info below

[nvelden]

I followed the same steps and it also doesn't work for me.

[ColinFay]

@dwhdai this refreshes only if you save the file inside R (not the browser), and also, there is an issue with {shiny} itself rstudio/shiny#2711 :)

I feel like this should be implemented at {golem} level so that we have this under control.

For example in golem::run_dev() 🤔

[rsimonmd]

EDIT: Unintentionally wrote this in French at first ...

Hi @ColinFay,

The aformentionned solution works (I merely added appDir = here::here() in order to make it work with rstudio jobs while leaving run_dev.R inside the /dev folder, but its not what matters), but by "works" I mean "the page refreshes"

However, while the page refreshes, the UI changes do not appear. Unless I make a change to app.R, in which case the app in correctly refreshed and changes to modules taken into account. Of course, right after I wrote this I found the same kind of comment in the {shiny} repo ...

In any case, while I do not have a solution to contribute, knowing how to do this is good enough to make it work, I just add/remove a character in app.R and I can dev the app while watching my changes

So, thank you for writing a solution, and for what you guys do with {golem} :-)