Nothing
## ----echo=TRUE----------------------------------------------------------------
library(ipc)
library(future)
plan(multisession)
q <- queue()
value <- ""
f <- future({
# set value in the main process
q$producer$fireEval({
value <- "Hello world"
})
})
Sys.sleep(.5)
# Evaluate signals
cons <- q$consumer$consume()
print(value)
# Remove temporary files
q$destroy()
## ---- eval=FALSE--------------------------------------------------------------
# variable <- 2
# q$producer$fireEval(val <- j, env=list(j=variable))
## ----echo=TRUE----------------------------------------------------------------
library(future)
library(promises)
plan(multisession)
q <- queue()
fut <- future({
for(i in 1:1000){
Sys.sleep(.1)
q$consumer$consume()
}
})
q$producer$fireEval(stop("Stop that child"))
cat(try(value(fut)))
q$destroy()
## ----eval=FALSE---------------------------------------------------------------
# library(future)
# library(promises)
# plan(multisession)
#
# q <- queue()
#
# fut <- future({
# for(i in 1:100){
# Sys.sleep(.1)
# q$producer$fireEval(print(index), list(index=i))
# }
# })
#
# q$consumer$start()
#
# # ... Later, stop consumption and clean up
# # q$destroy()
## ---- eval=FALSE--------------------------------------------------------------
# q <- queue(RedisSource$new())
## ---- eval=FALSE--------------------------------------------------------------
# library(shiny)
# library(ipc)
# library(future)
# plan(multisession)
#
# ui <- fluidPage(
#
# titlePanel("Countdown"),
#
# sidebarLayout(
# sidebarPanel(
# actionButton('run', 'count down')
# ),
#
# mainPanel(
# tableOutput("result")
# )
# )
# )
#
# server <- function(input, output) {
#
# queue <- shinyQueue()
# queue$consumer$start(100) # Execute signals every 100 milliseconds
#
# # A reactive value to hold output
# result_val <- reactiveVal()
#
# # Handle button click
# observeEvent(input$run,{
# future({
# for(i in 10:0){
# Sys.sleep(1)
# result <- data.frame(count=i)
# # change value
# queue$producer$fireAssignReactive("result_val",result)
# }
# })
#
# #Return something other than the future so we don't block the UI
# NULL
# })
#
# # set output to reactive value
# output$result <- renderTable({
# req(result_val())
# })
# }
#
# # Run the application
# shinyApp(ui = ui, server = server)
## ---- eval=FALSE--------------------------------------------------------------
# library(shiny)
# library(ipc)
# library(future)
# library(promises)
# plan(multisession)
#
# ui <- fluidPage(
#
# titlePanel("Countdown"),
#
# sidebarLayout(
# sidebarPanel(
# actionButton('run', 'Run')
# ),
#
# mainPanel(
# tableOutput("result")
# )
# )
# )
#
# server <- function(input, output) {
#
# # A reactive value to hold output
# result_val <- reactiveVal()
#
# # Handle button click
# observeEvent(input$run,{
# result_val(NULL)
#
# # Create a progress bar
# progress <- AsyncProgress$new(message="Complex analysis")
# future({
# for(i in 1:10){
# Sys.sleep(1)
# progress$inc(1/10) # Increment progress bar
# }
# progress$close() # Close the progress bar
# data.frame(result="Insightful result")
# }) %...>% result_val # Assign result of future to result_val
#
# # Return something other than the future so we don't block the UI
# NULL
# })
#
# # Set output to reactive value
# output$result <- renderTable({
# req(result_val())
# })
# }
#
# # Run the application
# shinyApp(ui = ui, server = server)
## ----echo=TRUE----------------------------------------------------------------
library(future)
library(promises)
plan(multisession)
# A long running function. Having a callback (progressMonitor) is a way to
# allow for interrupts to be checked for without adding a dependency
# to the analysis function.
accessableAnalysisFunction <- function(progressMonitor=function(i) cat(".")){
for(i in 1:1000){
Sys.sleep(.1)
progressMonitor(i)
}
data.frame(result="Insightful analysis")
}
inter <- AsyncInterruptor$new()
fut <- future({
accessableAnalysisFunction(progressMonitor = function(i) inter$execInterrupts())
})
inter$interrupt("Stop that future")
cat(try(value(fut)))
inter$destroy()
## ----eval=FALSE---------------------------------------------------------------
# library(shiny)
# library(ipc)
# library(future)
# library(promises)
# plan(multicore) # This will only work with multicore, which is unavailable on Windows
#
# inaccessableAnalysisFunction <- function(){
# Sys.sleep(10)
# data.frame(result="Insightful analysis")
# }
#
# # Define UI for application that draws a histogram
# ui <- fluidPage(
#
# # Application title
# titlePanel("Cancelable Async Task"),
#
# # Sidebar with a slider input for number of bins
# sidebarLayout(
# sidebarPanel(
# actionButton('run', 'Run'),
# actionButton('cancel', 'Cancel')
# ),
#
# # Show a plot of the generated distribution
# mainPanel(
# tableOutput("result")
# )
# )
# )
#
# server <- function(input, output) {
#
# fut <- NULL
#
# result_val <- reactiveVal()
# running <- reactiveVal(FALSE)
# observeEvent(input$run,{
#
# #Don't do anything if in the middle of a run
# if(running())
# return(NULL)
# running(TRUE)
#
# print("Starting Run")
# result_val(NULL)
# fut <<- future({
# result <- inaccessableAnalysisFunction()
# })
# prom <- fut %...>% result_val
# prom <- catch(fut,
# function(e){
# result_val(NULL)
# print(e$message)
# showNotification("Task Stopped")
# })
# prom <- finally(prom, function(){
# print("Done")
# running(FALSE) #declare done with run
# })
#
#
# #Return something other than the future so we don't block the UI
# NULL
# })
#
#
# # Kill future
# observeEvent(input$cancel,{
# #
# # Use this method of stopping only if you don't have access to the
# # internals of the long running process. If you are able, it is
# # recommended to use AsyncInterruptor instead.
# #
# stopMulticoreFuture(fut)
# })
#
#
# output$result <- renderTable({
# req(result_val())
# })
# }
#
# # Run the application
# shinyApp(ui = ui, server = server)
## ----echo=FALSE---------------------------------------------------------------
plan(sequential)
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.