class Croupier::TaskManagerType

• Croupier::TaskManagerType
• Reference
• Object

Overview

TaskManager is a singleton that keeps track of all tasks

Defined in:

croupier.cr

Instance Method Summary

• #_dependencies(outputs : Array(String))

  Helper function for dependencies Uses memoization to avoid exponential blowup when many tasks share dependencies

• #_run_tasks(task_names, run_all : Bool = false, dry_run : Bool = false, keep_going : Bool = false, early_cutoff : Bool = true)

  Internal helper to run tasks serially

• #_run_tasks_parallel(task_names : Array(String) = [] of String, run_all : Bool = false, dry_run : Bool = false, keep_going : Bool = false, early_cutoff : Bool = true)

  Internal helper to run tasks concurrently.

• #add_mutex(name : String)
• #all_inputs
• #auto_mode=(auto_mode : Bool)

  If true, it's running in auto mode

• #auto_mode? : Bool

  If true, it's running in auto mode

• #auto_run(targets : Array(String) = [] of String)
• #auto_stop
• #before_run_hook : Proc(Set(String), Nil)

  If set, it's called in auto mode after changes are detected but before tasks run Receives the list of changed files as an argument

• #before_run_hook=(before_run_hook : Proc(Set(String), Nil))

  If set, it's called in auto mode after changes are detected but before tasks run Receives the list of changed files as an argument

• #check_dependencies

  Check if all inputs are correct: They should all be either task outputs or existing files

• #cleanup

  Remove all tasks and everything else (good for tests)

• #dependencies(outputs : Array(String))

  Get a task list of what tasks need to be done to produce outputs The list is sorted so it can be executed in order

• #dependencies(output : String)

  Get a task list of what tasks need to be done to produce output The list is sorted so it can be executed in order Overloaded to accept a single string for convenience

• #depends_on(input : String)
• #depends_on(inputs : Array(String))
• #early_cutoff=(early_cutoff : Bool)

  If true, enable early cutoff optimization (skip tasks when upstream outputs unchanged)

• #early_cutoff? : Bool

  If true, enable early cutoff optimization (skip tasks when upstream outputs unchanged)

• #fast_dirs=(fast_dirs : Bool)

  If true, directories depend on a list of files, not its contents

• #fast_dirs? : Bool

  If true, directories depend on a list of files, not its contents

• #fast_mode=(fast_mode : Bool)

  If true, only compare file dates

• #fast_mode? : Bool

  If true, only compare file dates

• #get(key)
• #inputs(targets : Array(String))

  The set of all inputs for the given tasks

• #invalidate_graph_cache

  Invalidate the cached task graph

• #invalidate_graph_cache_no_store

  Invalidate the graph cache without setting k/v (for internal use from Task.initialize)

• #last_run : Hash(String, String)

  SHA1 of files from last run

• #last_run=(last_run : Hash(String, String))

  SHA1 of files from last run

• #lock_mutex(name : String)
• #mark_stale_inputs

  Read state of last run, then scan inputs and compare

• #modified : Set(String)

  Registry of modified files, which will make tasks stale

• #modified=(modified : Set(String))

  Registry of modified files, which will make tasks stale

• #modified?(key : String) : Bool

  Whether key (a file or kv:// key) was modified since the last run.

• #mutexes

  A hash of mutexes required by tasks

• #mutexes=(mutexes)

  A hash of mutexes required by tasks

• #next_run : Hash(String, String)

  SHA1 of input files as of ending this run

• #next_run=(next_run : Hash(String, String))

  SHA1 of input files as of ending this run

• #previous_output_hash(output : String) : String | Nil

  The hash recorded for output by the last completed run, if any.

• #progress_callback : Proc(String, Nil)

  If set, it's called after every task finishes

• #progress_callback=(progress_callback : Proc(String, Nil))

  If set, it's called after every task finishes

• #propagate_staleness

  Propagate staleness through the task graph in a single forward pass.

• #record_output_hash(output : String, new_hash : String) : Nil

  Record the hash of a task output for the next run's state file.

• #register_subtask(master_id : String, subtask : Task)

  Register a subtask with the task manager

• #remove_subtasks(master_id : String)

  Remove all subtasks belonging to a master task

• #run_tasks(run_all : Bool = false, dry_run : Bool = false, parallel : Bool = false, keep_going : Bool = false, early_cutoff : Bool | Nil = nil)

  Run all stale tasks in dependency order

• #run_tasks(targets : Array(String), run_all : Bool = false, dry_run : Bool = false, parallel : Bool = false, keep_going : Bool = false, early_cutoff : Bool | Nil = nil)

  Run the tasks needed to create or update the requested targets

• #save_run

  We ran all tasks, store the current state

• #scan_inputs

  Scan all inputs and return a hash with their sha1.

• #set(key, value)
• #sorted_task_graph
• #state_file : String

  Path to the state file that stores hashes between runs

• #state_file=(state_file : String)

  Path to the state file that stores hashes between runs

• #tasks : Hash(String, Croupier::Task)

  Registry of all tasks

• #tasks=(tasks : Hash(String, Croupier::Task))

  Registry of all tasks

• #this_run : Hash(String, String)

  SHA1 of files as of starting this run

• #this_run=(this_run : Hash(String, String))

  SHA1 of files as of starting this run

• #unlock_mutex(name : String)
• #use_persistent_store(path : String)

  Use a persistent k/v store in this path instead of the default memory store

• #watch(targets : Array(String) = [] of String)

Instance Method Detail