fasten 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a27dfb2f022703bc4565d85e3d013c64c0405c46fff2024b22226e98dd8fc6f
-  data.tar.gz: 19a023dbae6572e318a408057e292e685b8fd060bae0caa0cab108e00b044c70
+  metadata.gz: 1ca1b131f4ee26ffb7f5dcaa5408e314988c3568d155b9cb804daba84c588f90
+  data.tar.gz: 6bd08febfd39b5e0ab11c95e6e687acdb6778c67f493469033e49364f47b6012
 SHA512:
-  metadata.gz: 3eac77c5b0cb9e2eec8482d5b526c4314a1600af7cd70574eca81b43899b068e806db57aa3c730b4e251c73e6f16116ac329c16d3dfb827f9f3a1b084a6f0514
-  data.tar.gz: 98e60f25cbc70056d714904c6c73440ca5dc3eb60aaa7241800095a5f34df6cdc8147217f4e6b013ea7bc2af5c3e9cb3d7a2e8fb5f8a89a259ac39b2ddc15411
+  metadata.gz: 5fa5a15d9c430cbbe53fee25917c9dcaba4dfb40e70b6b5323d1a46036d0e2a53fdc1d4960226bddf14a76946499fcc8e777b9431596c7c92bfd261093476ed3
+  data.tar.gz: 4d0596481e975f9c4406f1c46ce707cde8f1f9d11b4089e94a825fe5281b3139e6a9fdf82ac3e905b606ef16a6157019aa04ee3bdd7a3687ebe5310d2303ede3

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+.fasten

data/.rubocop.yml

@@ -10,3 +10,7 @@ Metrics/BlockLength:
     - 'Rakefile'
     - '**/*.rake'
     - 'spec/**/*.rb'
+Metrics/AbcSize:
+  Max: 17
+Metrics/MethodLength:
+  Max: 15

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    fasten (0.1.0)
+    fasten (0.2.0)
       binding_of_caller
+      curses
 
 GEM
   remote: https://rubygems.org/
@@ -11,6 +12,7 @@ GEM
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
     coderay (1.1.2)
+    curses (1.2.4)
     debug_inspector (0.0.3)
     diff-lcs (1.3)
     jaro_winkler (1.5.1)
@@ -30,7 +32,7 @@ GEM
       rspec-mocks (~> 3.8.0)
     rspec-core (3.8.0)
       rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.1)
+    rspec-expectations (3.8.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-mocks (3.8.0)

data/README.md

@@ -4,18 +4,21 @@ FIXME: Add intro here
 
 ## Roadmap
 
-- [✔︎] define task to be run to reach a goal, with dependencies (similar to rake, make, and others)
-- [✔︎] run task in parallel by default
-- [ ] dynamicly change the number of worker processes
-- [✔︎] allow to programatically define new tasks
+- [x] define task to be run to reach a goal, with dependencies (similar to rake, make, and others)
+- [x] run task in parallel by default
+- [x] dynamicly change the number of worker processes
+- [x] allow to programatically define new tasks
 - [ ] allow to programatically redefine existing tasks
-- [ ] keep each task log in a separate file, to easily debug errors
-- [ ] early stop in case of a failure
-- [✔︎] for non-tty execution, report with a simple progress log in STDOUT
+- [x] keep each task log in a separate file, to easily debug errors
+- [x] early stop in case of failure
+- [x] for non-tty execution, report with a simple progress log in STDOUT
 - [ ] calculate ETA of script, based on previos executions of the same script
+- [ ] calculate ETA without previous information
 - [ ] for tty execution: start in background and provide a curses interface. When quit, the background process will keep running
 - [ ] provide a cli for running simple tasks
-- [ ] the cli can control (pause/stop/resume) other running executions
+- [x] provide a curses mode that displays number of workers, running tasks, remaining tasks, etc. Curses mode is the default.
+- [ ] display ETA in curses mode
+- [ ] curses mode can control (pause/stop/resume) other running executions
 
 
 ## Installation
@@ -46,7 +49,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fasten. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/a0/fasten. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -54,4 +57,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Fasten project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/fasten/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Fasten project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/a0/fasten/blob/master/CODE_OF_CONDUCT.md).

data/bin/console

@@ -6,6 +6,14 @@ require 'fasten'
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
+# call reload! for reloading clases in development
+def reload!(base = 'fasten')
+  $LOADED_FEATURES.select { |feature| feature =~ %r{/#{base}/lib/} }.each do |feature|
+    puts "Updating #{feature.gsub(/.*#{base}/, base)}: #{load feature}"
+  end
+  nil
+end
+
 # (If you use this, don't forget to add pry to your Gemfile!)
 require 'pry'
 Pry.start

data/fasten.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop'
 
   spec.add_runtime_dependency 'binding_of_caller'
+  spec.add_runtime_dependency 'curses'
 
   raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
 

data/lib/fasten/dag.rb

@@ -1,83 +1,115 @@
 module Fasten
-  class DAG
-    include Fasten::LogSupport
-    attr_reader :tasks, :pending, :done
-
-    def initialize
-      @tasks = {}
-      @done = []
+  module DAG
+    attr_reader :task_list, :task_done_list, :task_error_list, :task_pending_list, :task_running_list
+
+    def initialize_dag
+      @task_map = {}
+      @task_list = []
+      @task_done_list = []
+      @task_error_list = []
+      @task_pending_list = []
+      @task_running_list = []
     end
 
     def add(task)
-      raise "Task '#{task.name}' already defined" if tasks[task.name]
+      raise "Task '#{task.name}' already defined" if @task_map[task.name]
 
-      @waiting = nil
-      tasks[task.name] = task
+      @task_map[task.name] = task
+      @task_list << task
+      @task_waiting_list = nil
     end
 
-    def update_task(task, **opts)
-      opts.each { |key, val| task[key] = val }
-
-      return unless task.done
+    def update_task(task)
+      if task.error
+        update_error_task task
+      else
+        update_done_task task
+      end
+    end
 
-      @done << task
-      @pending.delete task
+    def update_done_task(task)
+      @task_done_list << task
+      @task_pending_list.delete task
       task.dependants.each do |dependant_task|
-        dependant_task.depends -= 1
+        dependant_task.depends.delete task
       end
 
-      update_waiting
+      move_pending_to_waiting
+    end
+
+    def update_error_task(task)
+      @task_error_list << task
+      @task_pending_list.delete task
     end
 
     def next_task
-      waiting.pop
+      task_waiting_list.pop
     end
 
-    def waiting
-      return @waiting if @waiting
+    def task_waiting_list
+      return @task_waiting_list if @task_waiting_list
 
       reset_tasks
       setup_tasks_dependencies
-      @waiting = []
-      update_waiting
-
-      @waiting
+      move_pending_to_waiting
     end
 
     protected
 
-    def update_waiting
-      move_list = @pending.select do |task|
-        task.depends.zero?
+    def move_pending_to_waiting
+      move_list = task_pending_list.select do |task|
+        task.depends.count.zero?
       end
 
-      @pending -= move_list
-      @waiting += move_list
+      @task_waiting_list ||= []
+      @task_pending_list -= move_list
+      @task_waiting_list += move_list
     end
 
     def reset_tasks
-      @pending = []
-      @done = []
-      tasks.each do |_key, task|
+      @task_pending_list.clear
+      @task_done_list.clear
+      @task_list.each do |task|
         task.dependants = []
-        task.depends = 0
-        @pending << task unless task.done
-        @done << task if task.done
+        task.depends = []
+        task.level = 0
+        task.done ? @task_done_list << task : @task_pending_list << task
       end
     end
 
     def setup_tasks_dependencies
-      @pending.each do |task|
+      @task_pending_list.each do |task|
         next unless task.after
 
         [task.after].flatten.each do |after|
-          after_task = after.is_a?(Task) ? after : tasks[after]
+          after_task = after.is_a?(Task) ? after : @task_map[after]
           raise "Dependency task '#{after}' not found on task '#{task.name}'." unless after_task
 
-          task.depends += 1
+          task.depends << after_task
+          task.level += 1
           after_task.dependants << task
         end
       end
     end
+
+    def no_waiting_tasks?
+      task_waiting_list.empty?
+    end
+
+    def no_running_tasks?
+      task_running_list.empty?
+    end
+
+    def tasks_waiting?
+      !task_waiting_list.empty?
+    end
+
+    def tasks_running?
+      !task_running_list.empty?
+    end
+
+    def tasks_failed?
+      !task_error_list.empty?
+    end
   end
 end

data/lib/fasten/executor.rb

@@ -1,87 +1,125 @@
 module Fasten
   class Executor < Task
     include Fasten::LogSupport
+    include Fasten::DAG
+    include Fasten::UI
+
+    def initialize(name: nil, workers: 8, worker_class: Fasten::Worker, fasten_dir: '.fasten')
+      super name: name || "#{self.class} #{$PID}", workers: workers, pid: $PID, state: :IDLE, worker_class: worker_class, fasten_dir: fasten_dir
+      initialize_dag
+
+      self.worker_list = []
+      log_path = "#{fasten_dir}/log/executor/#{self.name}.log"
+      FileUtils.mkdir_p File.dirname(log_path)
+      self.log_file = File.new(log_path, 'a')
+      Fasten.logger.reopen log_file
+    end
+
+    def perform
+      log_ini self, running_stats
+      self.state = :RUNNING
 
-    def initialize(name: nil, max_child: 8)
-      super name: name || $PROGRAM_NAME
-      self.max_childs = max_child
+      run_ui do
+        perform_loop
+      end
 
-      self.pid = $PID
-      self.tasks = {}
-      self.dag = Fasten::DAG.new
-      self.running = false
-      self.child_jobs = {}
-      self.running_tasks = []
+      self.state = :IDLE
+      log_fin self, running_stats
     end
 
-    def add(task)
-      dag.add task
+    def done_stats
+      "#{task_done_list.count}/#{task_list.count}"
     end
 
-    def perform
-      log_ini self
-      self.ini = Time.new
-      self.running = true
+    def running_stats
+      "#{task_done_list.count + task_running_list.count}/#{task_list.count}"
+    end
 
-      perform_loop
+    def perform_loop
+      loop do
+        wait_for_running_tasks
+        raise_error_in_failure
+        remove_workers_as_needed
+        dispatch_pending_tasks
+
+        break if no_running_tasks? && no_waiting_tasks?
+      end
 
-      self.fin = Time.new
-      log_fin self
+      remove_all_workers
     end
 
-    protected
+    def wait_for_running_tasks
+      while (no_waiting_tasks? && tasks_running?) || task_running_list.count >= workers || (tasks_running? && tasks_failed?)
+        ui_update
+        reads = worker_list.map(&:parent_read)
+        reads, _writes, _errors = IO.select(reads, [], [], 0.2)
 
-    def log_ini(object)
-      log_info "Init #{dag.done.count + running_tasks.count}/#{dag.tasks.count} #{object.class} #{object} "
+        receive_workers_tasks(reads)
+      end
+      ui_update
     end
 
-    def log_fin(object)
-      log_info "Done #{dag.done.count}/#{dag.tasks.count} #{object.class} #{object} in #{object.fin - object.ini}"
-    end
+    def receive_workers_tasks(reads)
+      reads&.each do |read|
+        worker = worker_list.find { |item| item.parent_read == read }
+        task = worker.receive
 
-    def perform_loop
-      while running
-        next_task = dag.next_task
+        task_running_list.delete task
 
-        wait_children next_task
-        run_next_task next_task
+        update_task task
 
-        self.running = !(next_task.nil? && child_jobs.empty? && dag.waiting.empty?)
+        log_fin task, done_stats
       end
-
-      wait_remaining
     end
 
-    def wait_children(next_task)
-      return unless (next_task.nil? && !child_jobs.empty?) || child_jobs.count >= max_childs
+    def raise_error_in_failure
+      return unless tasks_failed?
+
+      remove_all_workers
 
-      pid = Process.wait(0)
-      done_task = child_jobs.delete pid
-      return unless done_task
+      count = task_error_list.count
 
-      dag.update_task done_task, done: true, fin: Time.new
-      running_tasks.delete done_task
+      raise "Stopping because the following #{count} #{count == 1 ? 'task' : 'tasks'} failed: #{task_error_list.map(&:to_s).join(', ')}"
+    end
+
+    def remove_workers_as_needed
+      while worker_list.count > workers
+        return unless (worker = worker_list.find { |item| item.running_task.nil? })
 
-      log_fin done_task
+        worker.kill
+        worker_list.delete worker
+      end
     end
 
-    def run_next_task(next_task)
-      return unless next_task
+    def find_or_create_worker
+      worker = worker_list.find { |item| item.running_task.nil? }
+
+      unless worker
+        @worker_id = (@worker_id || 0) + 1
+        worker = worker_class.new executor: self, name: "#{worker_class} #{format '%02X', @worker_id}"
+        worker.fork
+        worker_list << worker
+
+        log_info "Worker created: #{worker}"
+      end
+
+      worker
+    end
 
-      running_tasks << next_task
-      log_ini next_task
+    def dispatch_pending_tasks
+      while tasks_waiting? && task_running_list.count < workers
+        worker = find_or_create_worker
 
-      next_task.ini = Time.new
-      pid = fork do
-        next_task.perform
+        task = next_task
+        log_ini task, "on worker #{worker}"
+        worker.dispatch(task)
+        task_running_list << task
       end
-      child_jobs[pid] = next_task
     end
 
-    def wait_remaining
-      child_jobs.each do |child_pid, child_task|
-        Process.wait child_pid
-        dag.update_task child_task, done: true
+    def remove_all_workers
+      while (worker = worker_list.pop)
+        worker.kill
       end
     end
   end

data/lib/fasten/log_support.rb

@@ -8,10 +8,39 @@ module Fasten
       define_method "log_#{method}" do |msg|
         return unless Fasten.logger.respond_to?(method)
 
-        caller = Kernel.binding.of_caller(1).eval('self')
-        Fasten.logger.send(method, caller.class) { msg }
+        caller_name = name if respond_to? :name
+        caller_name ||= Kernel.binding.of_caller(1).eval('self').class
+        Fasten.logger.send(method, caller_name) { msg }
       end
     end
+
+    def log_ini(object, message = nil)
+      object.ini ||= Time.new
+      log_info "Init #{object.class} #{object} #{message}"
+    end
+
+    def log_fin(object, message = nil)
+      object.fin ||= Time.new
+      diff = object.fin - object.ini
+
+      log_info "Done #{object.class} #{object} #{message} in #{diff}"
+    end
+
+    def redirect_std(path)
+      @saved_stdout = $stdout.clone
+      @saved_stderr = $stderr.clone
+
+      FileUtils.mkdir_p File.dirname(path)
+      log = File.new path, 'a'
+
+      $stdout.reopen log
+      $stderr.reopen log
+    end
+
+    def restore_std
+      $stdout.reopen(@saved_stdout)
+      $stderr.reopen(@saved_stderr)
+    end
   end
 end
 

data/lib/fasten/task.rb

@@ -1,14 +1,6 @@
 module Fasten
   class Task < OpenStruct
     include Fasten::LogSupport
-    def initialize(*)
-      super
-    end
-
-    def perform
-      log_debug "Performing #{self}"
-      system shell if shell
-    end
 
     def to_s
       name

data/lib/fasten/ui.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Fasten
+  module UI
+    include Curses
+
+    SPINNER_STR = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
+    SPINNER_LEN = SPINNER_STR.length
+    PROGRESSBAR_STR = ' ▏▎▍▌▋▊▉'
+    PROGRESSBAR_LEN = PROGRESSBAR_STR.length
+
+    def run_ui
+      ui_setup
+      ui_title
+      ui_workers
+
+      yield
+    ensure
+      close_screen
+    end
+
+    def ui_setup
+      init_screen
+      self.ui_rows = lines
+      self.ui_cols = cols
+      ui_setup_color
+      noecho
+      cbreak
+      nonl
+      curs_set 0
+    end
+
+    def ui_setup_color
+      start_color
+      use_default_colors
+      init_pair 1, Curses::COLOR_YELLOW, -1
+      init_pair 2, Curses::COLOR_GREEN, -1
+      init_pair 3, Curses::COLOR_RED, -1
+      init_pair 4, Curses::COLOR_WHITE, -1
+    end
+
+    def ui_text_aligned(row, align, str, attrs = nil)
+      if align == :center
+        setpos row, (ui_cols - str.length) / 2
+      elsif align == :right
+        setpos row, ui_cols - str.length
+      else
+        setpos row, 0
+      end
+
+      attrset attrs if attrs
+      addstr str
+      attroff attrs if attrs
+
+      str.length
+    end
+
+    def ui_title
+      ui_text_aligned(0, :left, 'Fasten your seatbelts!')
+      ui_text_aligned(0, :center, name.to_s)
+      ui_text_aligned(0, :right, Time.new.to_s)
+    end
+
+    def ui_update
+      clear
+      ui_title
+      ui_workers
+      ui_tasks
+
+      refresh
+    end
+
+    def ui_workers_summary
+      "Procs: #{task_running_list.count} run #{worker_list.count - task_running_list.count} idle #{workers} max"
+    end
+
+    def ui_workers
+      l = ui_text_aligned(1, :left, ui_workers_summary) + 1
+
+      worker_list.each_with_index do |worker, index|
+        setpos 1, l + index
+        attrs = worker.running? ? A_STANDOUT : color_pair(4) | A_DIM
+        attrset attrs
+        addstr worker.running? ? 'R' : '_'
+        attroff attrs
+      end
+    end
+
+    def ui_progressbar(row, col_ini, col_fin, count, total)
+      slice = total.to_f / (col_fin - col_ini + 1)
+      col_ini.upto col_fin do |col|
+        setpos row, col
+        count -= slice
+        if count.positive?
+          addstr PROGRESSBAR_STR[-1]
+        elsif count > -slice
+          addstr PROGRESSBAR_STR[(count * PROGRESSBAR_LEN / slice) % PROGRESSBAR_LEN]
+        else
+          addstr '.'
+        end
+      end
+    end
+
+    def ui_task_string(task, y, x, icon: nil)
+      setpos y, x
+
+      case task.state
+      when :RUNNING
+        attrs = color_pair(1) | A_TOP
+        icon = SPINNER_STR[task.worker&.spinner] if icon
+      when :ERROR
+        attrs = color_pair(3)
+        icon = '✘︎' if icon
+      when :DONE
+        attrs = color_pair(2)
+        icon = '✔︎' if icon
+      else
+        attrs = color_pair(4) | A_DIM
+        icon = '…' if icon
+      end
+
+      str = icon ? "#{icon} #{task}" : task.to_s
+
+      attrset attrs if attrs
+      addstr str
+      attroff attrs if attrs
+
+      x + str.length
+    end
+
+    def ui_tasks
+      worker_list.each do |worker|
+        worker.spinner = (worker.spinner + 1) % SPINNER_LEN if worker.running?
+      end
+
+      count_done = task_done_list.count
+      count_total = task_list.count
+      tl = count_total.to_s.length
+      col_ini = ui_text_aligned(2, :left, format("Tasks: %#{tl}d/%s", count_done, count_total)) + 1
+      col_fin = ui_cols - 5
+      ui_text_aligned(2, :right, "#{(count_done * 100/count_total).to_i}%") if count_total.positive?
+
+      ui_progressbar(2, col_ini, col_fin, count_done, count_total)
+
+      max = 2
+      task_list.each_with_index do |task, index|
+        next if 3 + index >= ui_rows
+
+        x = ui_task_string(task, 3 + index, 2, icon: true)
+        max = x if x > max
+      end
+
+      task_list.each_with_index do |task, index|
+        next if 3 + index >= ui_rows || task.depends.nil? || task.depends.empty?
+
+        setpos 3 + index, max
+        x = max + 2
+        addstr ':'
+        task.depends.each do |dependant_task|
+          x = ui_task_string(dependant_task, 3 + index, x) + 1
+        end
+      end
+    end
+  end
+end

data/lib/fasten/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fasten
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/fasten/worker.rb

@@ -0,0 +1,113 @@
+module Fasten
+  class Worker < Task
+    include Fasten::LogSupport
+
+    def initialize(executor:, name: nil)
+      super executor: executor, name: name, spinner: 0
+    end
+
+    def perform(task)
+      system task.shell if task.shell
+    end
+
+    def fork
+      create_pipes
+
+      self.pid = Process.fork do
+        close_parent_pipes
+
+        process_incoming_tasks
+      end
+
+      close_child_pipes
+    end
+
+    def dispatch(task)
+      Marshal.dump(Task.new(task.to_h.merge(depends: nil, dependants: nil)), parent_write)
+      self.running_task = task
+      task.worker = self
+      task.state = :RUNNING
+    end
+
+    def receive
+      updated_task = Marshal.load(parent_read) # rubocop:disable Security/MarshalLoad
+
+      %i[ini fin response error].each { |key| running_task[key] = updated_task[key] }
+
+      task = running_task
+      self.running_task = nil
+      task.state = task.error ? :ERROR : :DONE
+
+      task
+    end
+
+    def kill
+      log_info 'Removing worker'
+      Process.kill(:KILL, pid)
+      close_parent_pipes
+    rescue StandardError => error
+      log_warn "Ignoring error killing worker #{self}, error: #{error}"
+    end
+
+    def idle?
+      running_task.nil?
+    end
+
+    def running?
+      !idle?
+    end
+
+    protected
+
+    def create_pipes
+      self.child_read, self.parent_write = IO.pipe
+      self.parent_read, self.child_write = IO.pipe
+    end
+
+    def close_parent_pipes
+      parent_read.close unless parent_read.closed?
+      parent_write.close unless parent_write.closed?
+    end
+
+    def close_child_pipes
+      child_read.close unless child_read.closed?
+      child_write.close unless child_write.closed?
+    end
+
+    def process_incoming_tasks
+      log_ini self, 'process_incoming_tasks'
+
+      while (object = Marshal.load(child_read)) # rubocop:disable Security/MarshalLoad
+        run_task(object) if object.is_a? Fasten::Task
+      end
+
+      log_fin self, 'process_incoming_tasks'
+    rescue EOFError
+      log_info 'Terminating on EOF'
+    end
+
+    def run_task(task)
+      log_ini task, 'perform'
+      Fasten.logger.reopen(STDOUT)
+      redirect_std "#{executor.fasten_dir}/log/task/#{task.name}.log"
+
+      perform_task task
+
+      restore_std
+      Fasten.logger.reopen(executor.log_file)
+      log_fin task, 'perform'
+    end
+
+    def perform_task(task)
+      log_ini task, 'perform'
+
+      perform(task)
+
+      log_fin task, 'perform'
+      Marshal.dump(task, child_write)
+    rescue StandardError => error
+      task.error = error
+      Marshal.dump(task, child_write)
+    end
+  end
+end

data/lib/fasten.rb

@@ -5,31 +5,41 @@ require 'yaml'
 require 'binding_of_caller'
 require 'logger'
 require 'ostruct'
+require 'curses'
 
 require 'fasten/log_support'
 require 'fasten/task'
+require 'fasten/ui'
 require 'fasten/dag'
 require 'fasten/executor'
+require 'fasten/worker'
 require 'fasten/version'
 
 module Fasten
   class << self
     include Fasten::LogSupport
 
-    def load(path)
-      executor = Fasten::Executor.new
+    def load(path, **options)
+      executor = Fasten::Executor.new(**options)
+      executor.load(path)
+
+      executor
+    end
+  end
 
-      YAML.safe_load(File.read(path)).each do |name, params|
+  class Executor
+    def load(path)
+      items = YAML.safe_load(File.read(path)).each do |name, params|
         params.each do |key, val|
           next unless val.is_a?(String) && (match = %r{^/(.+)/$}.match(val))
 
           params[key] = Regexp.new(match[1])
         end
-        executor.add Fasten::Task.new({ name: name }.merge(params))
+
+        add Fasten::Task.new({ name: name }.merge(params))
       end
 
-      log_info "Loaded #{executor.dag.tasks.count} tasks from #{path}"
-      executor
+      log_info "Loaded #{items.count} tasks from #{path}"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fasten
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aldrin Martoq
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-09 00:00:00.000000000 Z
+date: 2018-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Fasten your seatbelts! Run jobs in parallel, intelligently.
 email:
 - contacto@a0.cl
@@ -121,7 +135,9 @@ files:
 - lib/fasten/executor.rb
 - lib/fasten/log_support.rb
 - lib/fasten/task.rb
+- lib/fasten/ui.rb
 - lib/fasten/version.rb
+- lib/fasten/worker.rb
 homepage: https://github.com/a0/fasten/
 licenses:
 - MIT