Make EML -> segmentation fault maybe due to big data file and/or big taxcov EAL template file

[yvanlebras]

Here is the logs:

[fill_module.R] save & template
[fill_module.R] set EAL variables
[fill_module.R] set local rv
[fill-module-setup.R] set variable
[fill-module-setup.R] post-modification
[fill-module-setup] passed
[fill_module.R] change pane
[fill_module.R] update history
[fill_module.R] save variables change
[fill_module.R] display UI
[fill_module.R] ended

*** caught segfault ***
address (nil), cause 'memory not mapped'

Traceback:
1: data.table::fread(file = f, fill = TRUE, blank.lines.skip = TRUE, sep = "\t", colClasses = list(character = 1:utils::count.fields(f, sep = "\t")[1]))
2: as.data.frame(data.table::fread(file = f, fill = TRUE, blank.lines.skip = TRUE, sep = "\t", colClasses = list(character = 1:utils::count.fields(f, sep = "\t")[1])))
3: read_tbl(paste0(path, "/", tfound[i]))
4: EMLassemblyline::template_arguments(path = .$SelectDP$dp.metadata.path, data.path = .$SelectDP$dp.data.path, data.table = dir(.$SelectDP$dp.data.path))
5: doTryCatch(return(expr), name, parentenv, handler)
6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
7: tryCatchList(expr, classes, parentenv, handlers)
8: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call)[1L] prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
9: try(EMLassemblyline::template_arguments(path = .$SelectDP$dp.metadata.path, data.path = .$SelectDP$dp.data.path, data.table = dir(.$SelectDP$dp.data.path)))
10: eval(expr, env)
11: eval(expr, env)
12: withProgress({ . <- main.env$save.variable fileName <- .$SelectDP$dp.title x <- try(EMLassemblyline::template_arguments(path = .$SelectDP$dp.metadata.path, data.path = .$SelectDP$dp.data.path, data.table = dir(.$SelectDP$dp.data.path))) if (class(x) == "try-error") { out <- x out[1] <- paste("Upon templating arguments: ", x) incProgress(0.9) } else { incProgress(0.3) x$path <- .$SelectDP$dp.metadata.path x$data.path <- .$SelectDP$dp.data.path x$eml.path <- .$SelectDP$dp.eml.path x$dataset.title <- .$SelectDP$dp.title x$temporal.coverage <- .$Misc$temporal.coverage x$maintenance.description <- "ongoing" x$data.table.name <- optional(.$DataFiles$table.name) x$data.table.description <- optional(.$DataFiles$description) x$data.table.url <- optional(.$DataFiles$url) x$user.id <- optional(if (main.env$SETTINGS$user != "public") main.env$SETTINGS$user) x$package.id = x$dataset.title x$write.file <- TRUE x$return.obj <- TRUE incProgress(0.2) file.remove(dir(main.env$save.variable$SelectDP$dp.eml.path, full.names = TRUE)) do.call(EMLassemblyline::make_eml, x[names(x) %in% names(formals(EMLassemblyline::make_eml))]) incProgress(0.4) }}, message = "Writing EML ...", value = 0.1)
13: <observer>(...)
14: valueFunc()
15: ..stacktraceon..(expr)
16: contextFunc()
17: env$runWith(self, func)
18: force(expr)
19: domain$wrapSync(expr)
20: promises::with_promise_domain(createVarPromiseDomain(.globals, "domain", domain), expr)
21: withReactiveDomain(.domain, { env <- .getReactiveEnvironment() rLog$enter(.reactId, id, .reactType, .domain) on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE) env$runWith(self, func)})
22: domain$wrapSync(expr)
23: promises::with_promise_domain(reactivePromiseDomain(), { withReactiveDomain(.domain, { env <- .getReactiveEnvironment() rLog$enter(.reactId, id, .reactType, .domain) on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE) env$runWith(self, func) })})
24: ctx$run(function() { ..stacktraceon..(expr)})
25: ..stacktraceoff..(ctx$run(function() { ..stacktraceon..(expr)}))
26: isolate(valueFunc())
27: func(v$value)
28: withVisible(func(v$value))
29: f(init, x[[i]])
30: Reduce(function(v, func) { if (v$visible) { withVisible(func(v$value)) } else { withVisible(func(invisible(v$value))) }}, list(...), result)
31: withCallingHandlers(expr, error = doCaptureStack)
32: domain$wrapSync(expr)
33: promises::with_promise_domain(createStackTracePromiseDomain(), expr)
34: captureStackTraces({ result <- withVisible(force(expr)) if (promises::is.promising(result$value)) { p <- promise_chain(valueWithVisible(result), ..., catch = catch, finally = finally) runFinally <- FALSE p } else { result <- Reduce(function(v, func) { if (v$visible) { withVisible(func(v$value)) } else { withVisible(func(invisible(v$value))) } }, list(...), result) valueWithVisible(result) }})
35: doTryCatch(return(expr), name, parentenv, handler)
36: tryCatchOne(expr, names, parentenv, handlers[[1L]])
37: tryCatchList(expr, classes, parentenv, handlers)
38: tryCatch({ captureStackTraces({ result <- withVisible(force(expr)) if (promises::is.promising(result$value)) { p <- promise_chain(valueWithVisible(result), ..., catch = catch, finally = finally) runFinally <- FALSE p } else { result <- Reduce(function(v, func) { if (v$visible) { withVisible(func(v$value)) } else { withVisible(func(invisible(v$value))) } }, list(...), result) valueWithVisible(result) } })}, error = function(e) { if (!is.null(catch)) catch(e) else stop(e)}, finally = if (runFinally && !is.null(finally)) finally())
39: do()
40: hybrid_chain(eventFunc(), function(value) { if (ignoreInit && !initialized) { initialized <<- TRUE return() } if (ignoreNULL && isNullEvent(value)) { return() } if (once) { on.exit(x$destroy()) } req(!ignoreNULL || !isNullEvent(value)) isolate(valueFunc())})
41: EAL9: make eml(...)
42: contextFunc()
43: env$runWith(self, func)
44: force(expr)
45: domain$wrapSync(expr)
46: promises::with_promise_domain(createVarPromiseDomain(.globals, "domain", domain), expr)
47: withReactiveDomain(.domain, { env <- .getReactiveEnvironment() rLog$enter(.reactId, id, .reactType, .domain) on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE) env$runWith(self, func)})
48: domain$wrapSync(expr)
49: promises::with_promise_domain(reactivePromiseDomain(), { withReactiveDomain(.domain, { env <- .getReactiveEnvironment() rLog$enter(.reactId, id, .reactType, .domain) on.exit(rLog$exit(.reactId, id, .reactType, .domain), add = TRUE) env$runWith(self, func) })})
50: ctx$run(.func)
51: run()
52: withCallingHandlers(expr, error = doCaptureStack)
53: domain$wrapSync(expr)
54: promises::with_promise_domain(createStackTracePromiseDomain(), expr)
55: captureStackTraces(expr)
56: withCallingHandlers(captureStackTraces(expr), error = function(e) { if (inherits(e, "shiny.silent.error")) return() handle <- getOption("shiny.error") if (is.function(handle)) handle()})
57: shinyCallingHandlers(run())
58: force(expr)
59: withVisible(force(expr))
60: withCallingHandlers(expr, error = doCaptureStack)
61: domain$wrapSync(expr)
62: promises::with_promise_domain(createStackTracePromiseDomain(), expr)
63: captureStackTraces({ result <- withVisible(force(expr)) if (promises::is.promising(result$value)) { p <- promise_chain(valueWithVisible(result), ..., catch = catch, finally = finally) runFinally <- FALSE p } else { result <- Reduce(function(v, func) { if (v$visible) { withVisible(func(v$value)) } else { withVisible(func(invisible(v$value))) } }, list(...), result) valueWithVisible(result) }})
64: doTryCatch(return(expr), name, parentenv, handler)
66: tryCatchList(expr, classes, parentenv, handlers)
67: tryCatch({ captureStackTraces({ result <- withVisible(force(expr)) if (promises::is.promising(result$value)) { p <- promise_chain(valueWithVisible(result), ..., catch = catch, finally = finally) runFinally <- FALSE p } else { result <- Reduce(function(v, func) { if (v$visible) { withVisible(func(v$value)) } else { withVisible(func(invisible(v$value))) } }, list(...), result) valueWithVisible(result) } })}, error = function(e) { if (!is.null(catch)) catch(e) else stop(e)}, finally = if (runFinally && !is.null(finally)) finally())
68: do()
69: hybrid_chain({ if (!.destroyed) { shinyCallingHandlers(run()) }}, catch = function(e) { if (inherits(e, "shiny.silent.error")) { return() } printError(e) if (!is.null(.domain)) { .domain$unhandledError(e) }}, finally = .domain$decrementBusyCount)
70: flushCallback()
71: FUN(X[[i]], ...)
72: lapply(.flushCallbacks, function(flushCallback) { flushCallback()})
73: ctx$executeFlushCallbacks()
74: .getReactiveEnvironment()$flush()
75: flushReact()
76: serviceApp()
77: ..stacktracefloor..(serviceApp())
78: withCallingHandlers(expr, error = doCaptureStack)
79: domain$wrapSync(expr)
80: promises::with_promise_domain(createStackTracePromiseDomain(), expr)
81: captureStackTraces({ while (!.globals$stopped) { ..stacktracefloor..(serviceApp()) }})
82: ..stacktraceoff..(captureStackTraces({ while (!.globals$stopped) { ..stacktracefloor..(serviceApp()) }}))
83: runApp(shinyApp(ui = ui, server = server), launch.browser = args$launch.browser)
84: MetaShARK::runMetashark(dev = FALSE)
An irrecoverable exception occurred. R is aborting now ...
Segmentation faul

[earnaud]

What files were you using?