शायद यह भी वास्तव में क्या आप देख रहे हैं नहीं है, लेकिन चाल कर सकता है (कम से कम एम पर ताकतवर लिनक्स)। मेरे लिए यह वैसे ही काम करता है जब मैं चाहता हूं क्योंकि मैं बैश स्क्रिप्ट का उपयोग करता हूं जो आर चमकदार द्वारा ट्रिगर किए जाते हैं और मैं उन्हें निरस्त करने में सक्षम होना चाहता हूं। तो अपने आर कोड को एक स्क्रिप्ट में डालने और सिस्टम कमांड द्वारा स्क्रिप्ट को ट्रिगर करने के बारे में कैसे?
नीचे दिए गए उदाहरण में मैं केवल एक साधारण डमी बैश स्क्रिप्ट का उपयोग करता हूं जो नींद कमांड चलाता है, जबकि पहला सीएल तर्क नींद की मात्रा है। 10 सेकंड से कम सब कुछ स्वीकार नहीं किया जाता है और बाहर निकलने की स्थिति को 1 तक रखता है। इसके अतिरिक्त, मुझे लॉगफाइल में कुछ आउटपुट मिलता है जिसे मैं मॉनीटर कर सकता हूं, और इस प्रकार रीयलटाइम में प्रगति करता हूं।
आशा है कि आपको यह सहायक लगेगा।
library(shiny)
ui <- fluidPage(
# we need this to send costumized messages
tags$head(tags$script(HTML('Shiny.addCustomMessageHandler("jsCode",function(message) {eval(message.value);});'))),
# Sidebar with a slider input for number of bins
sidebarLayout(
sidebarPanel(
textInput("duration", "How long you want to wait?"),hr(),
p("Are you experienced?"),
actionButton("processbtn", "Yes"),hr(),
p("Show me what's going on"),
actionButton("logbtn", "Show me by clicking here."),hr(),
p("Tired of being experienced?"),
actionButton("abortbtn", "Yes")
), # close sidebar panel
# Show a plot of the generated distribution
mainPanel(
textOutput("outText"),hr(),
verbatimTextOutput("outLog")
) # close mainpanel
) # close sidebar
) # close fluidpage
#------SERVER------------
# Define server logic required to draw a histogram
server <- function(input, output, session) {
# our reactive values that change on button click by the observe functions below
values <- reactiveValues(process = 0, abort = 0, log = 0)
observeEvent(input$processbtn, {
values$process = 1
values$abort = 0
values$log = 0
})
observeEvent(input$abortbtn, {
values$process = 0
values$abort = 1
})
observeEvent(input$logbtn, {
values$log = 1
})
current_state = function(exitfile) {
# get the pid
pid = as.integer(system2("ps", args = "-ef | grep \"bash ~/dummy_script.sh\" | grep -v grep | awk '{print $2}'", stdout = TRUE))
print(pid)
if (length(pid) > 0)
return("RUNNING")
if (file.exists(exitfile))
return("TERMINATED")
return("NOT_STARTED")
}
start_function = function(exitfile) {
if(input$duration == "") {
end_message="The text input field is empty!"
js_string <- 'alert("SUCCESS");'
js_string <- sub("SUCCESS",end_message,js_string)
session$sendCustomMessage(type='jsCode', list(value = js_string))
values$process = 0
return("NOT_STARTED")
} else { # all checks are fine. send a message and start processing
end_message="We start waiting, yeah!!!"
js_string <- 'alert("SUCCESS");'
js_string <- sub("SUCCESS",end_message,js_string)
session$sendCustomMessage(type='jsCode', list(value = js_string))
# here we execute the outsourced script and
# write the exit status to a file, so we can check for that and give an error message
system(paste("(bash ~/dummy_script.sh", input$duration,"; echo $? >", exitfile, ")"), wait = FALSE)
return("RUNNING")
}
}
on_terminated = function(exitfile) {
# get the exit state of the script
status = readLines(exitfile)
print(status)
# we want to remove the exit file for the next run
unlink(exitfile, force = TRUE)
# message when we finished
if (status != 0){
end_message="Duration is too short."
js_string <- 'alert("SUCCESS");'
js_string <- sub("SUCCESS",end_message,js_string)
session$sendCustomMessage(type='jsCode', list(value = js_string))
}
else {
end_message="Success"
js_string <- 'alert("SUCCESS");'
js_string <- sub("SUCCESS",end_message,js_string)
session$sendCustomMessage(type='jsCode', list(value = js_string))
}
values$process = 0
}
# our main processing fucntion
output$outText = renderText({
# trigger processing when action button clicked
if(values$process) {
# get the homefolder
homedir=Sys.getenv("HOME")
# create the path for an exit file (we'll need to evaluate the end of the script)
exitfile=file.path(homedir, "dummy_exit")
print(exitfile)
state = current_state(exitfile) # Can be NOT_STARTED, RUNNING, COMPLETED
print(state)
if (state == "NOT_STARTED")
state = start_function(exitfile)
if (state == "RUNNING")
invalidateLater(2000, session = getDefaultReactiveDomain())
if (state == "TERMINATED")
on_terminated(exitfile)
# Abort processing
} else
if(values$abort) {
pid = as.integer(system2("ps", args = "-ef | grep \"bash ~/dummy_script.sh\" | grep -v grep | awk '{print $2}'", stdout = TRUE))
print(pid)
system(paste("kill", pid), wait = FALSE)
}
}) # close renderText function
output$outLog = renderText({
if(values$log) {
homedir=Sys.getenv("HOME")
logfile=file.path(homedir, "/dummy_log")
if(file.exists(logfile)){
invalidateLater(2000)
paste(readLines(logfile), collapse = "\n")
}
else {
print("Nothing going on here")
}
}
})
} # close server
# Run the application
shinyApp(ui = ui, server = server)
मेरे पास "विश्लेषण" बटन है जिसमें कई मिनट लग सकते हैं। कभी-कभी मुझे एहसास होता है कि मैं कुछ विकल्प सेट करना भूल गया हूं और मैं इसे रद्द करना चाहता हूं ताकि मैं एक छोटा समायोजन कर सकूं। पुनरारंभ करने के लिए ऐप को मारना असुविधाजनक है, मुझे फिर से पूरी प्रक्रिया में जाना होगा। और ऐसा लगता है कि सत्र स्वयं ही मारा जाता है (अगर मैं उस विंडो को बंद करता हूं जहां "विश्लेषण" बटन क्लिक किया गया था, तो कोड कम से कम चलता है, कम से कम उस मामले में मैं अनुरोध को मारने में सक्षम होना चाहता हूं। –
I आश्चर्य कीजिए कि क्या आप 'विश्लेषण' के अंदर एक बूबी-जाल को एकीकृत कर सकते हैं जो एक निश्चित घटना (जैसे बटन प्रेस) के लिए सुनता है और कोड से तोड़ता है। –
मुझे लगता है कि उदाहरण के लिए आप कुछ वैश्विक बूलियन ध्वज प्राप्त कर सकते हैं, और 'विश्लेषण' के अंदर समय-समय पर ध्वज की जांच करेगा। तो हाँ आप एक हैकी समाधान कर सकते हैं मानते हैं कि आपके पास जो भी कोड है, वह लंबी गणना कर रहा है।यदि आप किसी ऐसे फ़ंक्शन पर कॉल कर रहे हैं जो आपके द्वारा नहीं लिखा गया है, तो मुझे नहीं लगता कि आप यह कैसे कर सकते हैं –