fix(core): performance issue with certain dependency structures

This change reduces the number of times module configs are resolved,
which especially helps for deeply nested dependency graphs. Should
dramatically reduce CPU usage in certain cases (although most users
won't feel much of a difference).

core/src/actions.ts

@@ -717,12 +717,13 @@ export class ActionRouter implements TypeGuard {
 
   async getServiceStatuses({
     log,
+    graph,
     serviceNames,
   }: {
     log: LogEntry
+    graph: ConfigGraph
     serviceNames?: string[]
   }): Promise<ServiceStatusMap> {
-    const graph = await this.garden.getConfigGraph(log)
     const services = graph.getServices({ names: serviceNames })
 
     const tasks = services.map(
@@ -942,7 +943,7 @@ export class ActionRouter implements TypeGuard {
     actionType: T
     defaultHandler?: ModuleActionHandlers[T]
   }): Promise<ModuleActionOutputs[T]> {
-    const { module, pluginName, log } = params
+    const { module, pluginName, log, graph } = params
 
     log.silly(`Getting '${actionType}' handler for module '${module.name}' (type '${module.type}')`)
 
@@ -954,7 +955,6 @@ export class ActionRouter implements TypeGuard {
     })
 
     const providers = await this.garden.resolveProviders(log)
-    const graph = await this.garden.getConfigGraph(log)
     const templateContext = ModuleConfigContext.fromModule({
       garden: this.garden,
       resolvedProviders: providers,
@@ -983,7 +983,7 @@ export class ActionRouter implements TypeGuard {
     actionType: T
     defaultHandler?: ServiceActionHandlers[T]
   }) {
-    let { log, service, runtimeContext } = params
+    let { log, service, runtimeContext, graph } = params
     let module = service.module
 
     log.silly(`Getting ${actionType} handler for service ${service.name}`)
@@ -996,7 +996,6 @@ export class ActionRouter implements TypeGuard {
     })
 
     const providers = await this.garden.resolveProviders(log)
-    const graph = await this.garden.getConfigGraph(log, runtimeContext)
 
     const modules = graph.getModules()
     const templateContext = ModuleConfigContext.fromModule({
@@ -1016,6 +1015,9 @@ export class ActionRouter implements TypeGuard {
     if (!runtimeContextIsEmpty && getRuntimeTemplateReferences(module).length > 0) {
       log.silly(`Resolving runtime template strings for service '${service.name}'`)
 
+      // Resolve the graph again (TODO: avoid this somehow!)
+      graph = await this.garden.getConfigGraph(log, runtimeContext)
+
       // Resolve the service again
       service = graph.getService(service.name)
       module = service.module
@@ -1049,7 +1051,7 @@ export class ActionRouter implements TypeGuard {
     actionType: T
     defaultHandler?: TaskActionHandlers[T]
   }) {
-    let { task, log } = params
+    let { task, log, graph } = params
     const runtimeContext = params["runtimeContext"] as RuntimeContext | undefined
     let module = task.module
 
@@ -1063,7 +1065,6 @@ export class ActionRouter implements TypeGuard {
     })
 
     const providers = await this.garden.resolveProviders(log)
-    const graph = await this.garden.getConfigGraph(log, runtimeContext)
 
     const modules = graph.getModules()
     const templateContext = ModuleConfigContext.fromModule({
@@ -1083,6 +1084,9 @@ export class ActionRouter implements TypeGuard {
     if (!runtimeContextIsEmpty && getRuntimeTemplateReferences(module).length > 0) {
       log.silly(`Resolving runtime template strings for task '${task.name}'`)
 
+      // Resolve the graph again (TODO: avoid this somehow!)
+      graph = await this.garden.getConfigGraph(log, runtimeContext)
+
       // Resolve the task again
       task = graph.getTask(task.name)
       module = task.module
@@ -1441,14 +1445,18 @@ type WrappedModuleActionMap = {
 // avoid having to specify common params on each action helper call
 type ActionRouterParams<T extends PluginActionParamsBase> = Omit<T, CommonParams> & { pluginName?: string }
 
-type ModuleActionRouterParams<T extends PluginModuleActionParamsBase> = Omit<T, CommonParams> & { pluginName?: string }
-// additionally make runtimeContext param optional
+type ModuleActionRouterParams<T extends PluginModuleActionParamsBase> = Omit<T, CommonParams> & {
+  graph: ConfigGraph
+  pluginName?: string
+}
 
 type ServiceActionRouterParams<T extends PluginServiceActionParamsBase> = Omit<T, "module" | CommonParams> & {
+  graph: ConfigGraph
   pluginName?: string
 }
 
 type TaskActionRouterParams<T extends PluginTaskActionParamsBase> = Omit<T, "module" | CommonParams> & {
+  graph: ConfigGraph
   pluginName?: string
 }
 

core/src/commands/call.ts

@@ -75,7 +75,14 @@ export class CallCommand extends Command<Args> {
     // No need for full context, since we're just checking if the service is running.
     const runtimeContext = emptyRuntimeContext
     const actions = await garden.getActionRouter()
-    const status = await actions.getServiceStatus({ service, log, devMode: false, hotReload: false, runtimeContext })
+    const status = await actions.getServiceStatus({
+      service,
+      log,
+      graph,
+      devMode: false,
+      hotReload: false,
+      runtimeContext,
+    })
 
     if (!includes(["ready", "outdated"], status.state)) {
       throw new RuntimeError(`Service ${service.name} is not running`, {

core/src/commands/exec.ts

@@ -83,6 +83,7 @@ export class ExecCommand extends Command<Args> {
     const actions = await garden.getActionRouter()
     const result = await actions.execInService({
       log,
+      graph,
       service,
       command,
       interactive: opts.interactive,

core/src/commands/get/get-status.ts

@@ -68,9 +68,10 @@ export class GetStatusCommand extends Command {
 
   async action({ garden, log, opts }: CommandParams): Promise<CommandResult<StatusCommandResult>> {
     const actions = await garden.getActionRouter()
+    const graph = await garden.getConfigGraph(log)
 
     const envStatus = await garden.getEnvironmentStatus(log)
-    const serviceStatuses = await actions.getServiceStatuses({ log })
+    const serviceStatuses = await actions.getServiceStatuses({ log, graph })
 
     let result: StatusCommandResult = {
       providers: envStatus,
@@ -80,7 +81,6 @@ export class GetStatusCommand extends Command {
     }
 
     if (opts.output) {
-      const graph = await garden.getConfigGraph(log)
       result = {
         ...result,
         ...(await Bluebird.props({
@@ -125,6 +125,7 @@ async function getTestStatuses(garden: Garden, configGraph: ConfigGraph, log: Lo
           const result = await actions.getTestResult({
             module,
             log,
+            graph: configGraph,
             test: testFromConfig(module, testConfig, configGraph),
           })
           return [`${module.name}.${testConfig.name}`, runStatus(result)]
@@ -140,7 +141,7 @@ async function getTaskStatuses(garden: Garden, configGraph: ConfigGraph, log: Lo
 
   return fromPairs(
     await Bluebird.map(tasks, async (task) => {
-      const result = await actions.getTaskResult({ task, log })
+      const result = await actions.getTaskResult({ task, log, graph: configGraph })
       return [task.name, runStatus(result)]
     })
   )

core/src/commands/get/get-task-result.ts

@@ -63,6 +63,7 @@ export class GetTaskResultCommand extends Command<Args> {
     const taskResult = await actions.getTaskResult({
       log,
       task,
+      graph,
     })
 
     let result: GetTaskResultCommandResult = null

core/src/commands/get/get-test-result.ts

@@ -73,6 +73,7 @@ export class GetTestResultCommand extends Command<Args> {
 
     const testResult = await actions.getTestResult({
       log,
+      graph,
       test,
       module,
     })

core/src/commands/logs.ts

@@ -223,7 +223,7 @@ export class LogsCommand extends Command<Args, Opts> {
     const actions = await garden.getActionRouter()
 
     await Bluebird.map(services, async (service: GardenService<any>) => {
-      await actions.getServiceLogs({ log, service, stream, follow, tail, since })
+      await actions.getServiceLogs({ log, graph, service, stream, follow, tail, since })
     })
 
     const sorted = sortBy(result, "timestamp")

core/src/commands/run/module.ts

@@ -127,6 +127,7 @@ export class RunModuleCommand extends Command<Args, Opts> {
 
     const result = await actions.runModule({
       log,
+      graph,
       module,
       command: opts.command?.split(" "),
       args: args.arguments || [],

core/src/commands/run/service.ts

@@ -122,6 +122,7 @@ export class RunServiceCommand extends Command<Args, Opts> {
 
     const result = await actions.runService({
       log,
+      graph,
       service,
       runtimeContext,
       interactive,

core/src/commands/run/test.ts

@@ -166,6 +166,7 @@ export class RunTestCommand extends Command<Args, Opts> {
 
     const result = await actions.testModule({
       log,
+      graph,
       module,
       silent: false,
       interactive,

core/src/config-graph.ts

@@ -75,7 +75,7 @@ export type DependencyGraph = { [key: string]: DependencyGraphNode }
  * A graph data structure that facilitates querying (recursive or non-recursive) of the project's dependency and
  * dependant relationships.
  *
- * This should be initialized with fully resolved and validated ModuleConfigs.
+ * This should be initialized with resolved and validated GardenModules.
  */
 export class ConfigGraph {
   private dependencyGraph: DependencyGraph

core/src/plugins/kubernetes/run.ts

@@ -857,7 +857,7 @@ export class PodRunner extends PodRunnerParams {
           })
         }
 
-        await sleep(200)
+        await sleep(800)
       }
 
       // Retrieve logs after run

core/src/plugins/kubernetes/system.ts

@@ -95,9 +95,11 @@ interface GetSystemServicesStatusParams {
 
 export async function getSystemServiceStatus({ sysGarden, log, serviceNames }: GetSystemServicesStatusParams) {
   const actions = await sysGarden.getActionRouter()
+  const graph = await sysGarden.getConfigGraph(log)
 
   const serviceStatuses = await actions.getServiceStatuses({
     log: log.placeholder({ level: LogLevel.verbose, childEntriesInheritLevel: true }),
+    graph,
     serviceNames,
   })
   const state = combineStates(Object.values(serviceStatuses).map((s) => (s && s.state) || "unknown"))

core/src/proxy.ts

@@ -18,6 +18,7 @@ import { registerCleanupFunction, sleep } from "./util/util"
 import { LogEntry } from "./logger/log-entry"
 import { GetPortForwardResult } from "./types/plugin/service/getPortForward"
 import { LocalAddress } from "./db/entities/local-address"
+import { ConfigGraph } from "./config-graph"
 
 interface PortProxy {
   key: string
@@ -42,39 +43,55 @@ registerCleanupFunction("kill-service-port-proxies", () => {
 
 const portLock = new AsyncLock()
 
-export async function startPortProxies(garden: Garden, log: LogEntry, service: GardenService, status: ServiceStatus) {
+// tslint:disable-next-line: max-line-length
+export async function startPortProxies({
+  garden,
+  graph,
+  log,
+  service,
+  status,
+}: {
+  garden: Garden
+  graph: ConfigGraph
+  log: LogEntry
+  service: GardenService
+  status: ServiceStatus
+}) {
   if (garden.disablePortForwards) {
     log.info({ msg: chalk.gray("Port forwards disabled") })
     return []
   }
 
   return Bluebird.map(status.forwardablePorts || [], (spec) => {
-    return startPortProxy(garden, log, service, spec)
+    return startPortProxy({ garden, graph, log, service, spec })
   })
 }
 
-async function startPortProxy(garden: Garden, log: LogEntry, service: GardenService, spec: ForwardablePort) {
+interface StartPortProxyParams {
+  garden: Garden
+  graph: ConfigGraph
+  log: LogEntry
+  service: GardenService
+  spec: ForwardablePort
+}
+
+async function startPortProxy({ garden, graph, log, service, spec }: StartPortProxyParams) {
   const key = getPortKey(service, spec)
   let proxy = activeProxies[key]
 
   if (!proxy) {
     // Start new proxy
-    proxy = activeProxies[key] = await createProxy(garden, log, service, spec)
+    proxy = activeProxies[key] = await createProxy({ garden, graph, log, service, spec })
   } else if (!isEqual(proxy.spec, spec)) {
     // Stop existing proxy and create new one
     stopPortProxy(proxy, log)
-    proxy = activeProxies[key] = await createProxy(garden, log, service, spec)
+    proxy = activeProxies[key] = await createProxy({ garden, graph, log, service, spec })
   }
 
   return proxy
 }
 
-async function createProxy(
-  garden: Garden,
-  log: LogEntry,
-  service: GardenService,
-  spec: ForwardablePort
-): Promise<PortProxy> {
+async function createProxy({ garden, graph, log, service, spec }: StartPortProxyParams): Promise<PortProxy> {
   const actions = await garden.getActionRouter()
   const key = getPortKey(service, spec)
   let fwd: GetPortForwardResult | null = null
@@ -91,7 +108,7 @@ async function createProxy(
       log.debug(`Starting port forward to ${key}`)
 
       try {
-        fwd = await actions.getPortForward({ service, log, ...spec })
+        fwd = await actions.getPortForward({ service, log, graph, ...spec })
       } catch (err) {
         log.error(`Error starting port forward to ${key}: ${err.message}`)
       }

core/src/task-graph.ts

@@ -126,7 +126,7 @@ export class TaskGraph extends EventEmitter2 {
         throw new TaskGraphError(
           dedent`
             ${failed.length} task(s) failed:
-            ${failed.map(([key, result]) => `- ${key}: ${result?.error?.toString()}`).join("\n")}
+            ${failed.map(([key, result]) => `- ${key}: ${result?.error?.stack || result?.error?.message}`).join("\n")}
           `,
           { results }
         )

core/src/tasks/build.ts

@@ -130,7 +130,7 @@ export class BuildTask extends BaseTask {
         status: "active",
       })
 
-      const status = await actions.getBuildStatus({ log: this.log, module })
+      const status = await actions.getBuildStatus({ log: this.log, graph: this.graph, module })
 
       if (status.ready) {
         log.setSuccess({
@@ -148,6 +148,7 @@ export class BuildTask extends BaseTask {
     let result: BuildResult
     try {
       result = await actions.build({
+        graph: this.graph,
         module,
         log,
       })

core/src/tasks/delete-service.ts

@@ -79,7 +79,7 @@ export class DeleteServiceTask extends BaseTask {
     let status: ServiceStatus
 
     try {
-      status = await actions.deleteService({ log: this.log, service: this.service })
+      status = await actions.deleteService({ log: this.log, service: this.service, graph: this.graph })
     } catch (err) {
       this.log.setError()
       throw err

core/src/tasks/deploy.ts

@@ -107,6 +107,7 @@ export class DeployTask extends BaseTask {
       const taskResultTasks = await Bluebird.map(deps.run, async (task) => {
         return new GetTaskResultTask({
           garden: this.garden,
+          graph: this.graph,
           log: this.log,
           task,
           force: false,
@@ -207,6 +208,7 @@ export class DeployTask extends BaseTask {
     } else {
       try {
         status = await actions.deployService({
+          graph: this.graph,
           service: this.service,
           runtimeContext,
           log,
@@ -230,7 +232,13 @@ export class DeployTask extends BaseTask {
     }
 
     if (this.garden.persistent) {
-      const proxies = await startPortProxies(this.garden, log, this.service, status)
+      const proxies = await startPortProxies({
+        garden: this.garden,
+        graph: this.graph,
+        log,
+        service: this.service,
+        status,
+      })
 
       for (const proxy of proxies) {
         const targetHost = proxy.spec.targetName || this.service.name