bow 0.0.0 → 0.5.0

data/lib/bow/memorable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bow
+  module Memorable
+    def task_history
+      @task_history ||= Locker.load
+    end
+
+    # def update_history(step = {})
+    # task_history.add(name, step) unless step.empty?
+    # end
+
+    def flush_history
+      task_history.flush
+    end
+
+    def apply
+      task_history.apply(name)
+    end
+
+    def applied?
+      task_history.applied?(name)
+    end
+
+    def revert
+      task_history.revert(name)
+    end
+
+    def reverted?
+      task_history.reverted?(name)
+    end
+
+    def reset
+      task_history.reset(name)
+    end
+  end
+end

data/lib/bow/options.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Bow
+  class Options
+    OPTIONS = [
+      [
+        '-uUSER',
+        '--user=USER',
+        'Remote user (root used by default)',
+        :option_user
+      ],
+      [
+        '-gGROUP',
+        '--group=GROUP',
+        'Hosts group (defined in config)',
+        :option_group
+      ],
+      [
+        '-iINVENTORY',
+        '--inventory=INVENTORY',
+        'Path to inventory file',
+        :option_inventory
+      ],
+      [
+        '-c',
+        '--copy-tool',
+        'Utilit used for files transfer (scp or rsync)',
+        :option_copy_tool
+      ],
+      [
+        '-v',
+        '--version',
+        'Print version and exit',
+        :option_version
+      ]
+    ].freeze
+
+    def initialize(options)
+      @options = options
+    end
+
+    def parse(opts)
+      OPTIONS.each do |definition|
+        callable = definition.pop
+        opts.on(*definition, method(callable))
+      end
+      opts.on_tail('-h', '--help', 'Print this help and exit.') do
+        puts opts
+        exit
+      end
+    end
+
+    def option_user(user)
+      @options[:user] = user
+    end
+
+    def option_group(group)
+      @options[:group] = group
+    end
+
+    def option_inventory(inventory)
+      @options[:inventory] = inventory
+    end
+
+    def option_copy_tool(copy_tool)
+      @options[:copy_tool] = copy_tool
+    end
+
+    def option_version(_v)
+      puts VERSION
+      exit
+    end
+  end
+end

data/lib/bow/rake.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'bow'
+
+module Bow
+  class Rake; end
+end
+
+module Rake
+  module DSL
+    # Describe the flow of the next rake task.
+    #
+    # Example:
+    #   flow run: :once, enabled: true, revert: :world_down
+    #   task world: [:build] do
+    #     # ... build world
+    #   end
+    #
+    #   task :world_down do
+    #     # ... destroy world
+    #   end
+    def flow(*flow) # :doc:
+      Rake.application.last_flow = flow
+    end
+  end
+
+  module TaskManager
+    attr_accessor :last_flow
+
+    # Lookup a task.  Return an existing task if found, otherwise
+    # create a task of the current type.
+    def intern(task_class, task_name)
+      @tasks[task_name.to_s] ||= task_class.new(task_name, self)
+      task = @tasks[task_name.to_s]
+      task.unpack_flow(get_flow(task))
+      task
+    end
+
+    # Return current flow, clearing it in the process.
+    def get_flow(_task)
+      @last_flow ||= nil
+      flow = @last_flow&.first
+      @last_flow = nil
+      flow
+    end
+  end
+
+  class Task
+    include ::Bow::Memorable
+
+    ALLOWED_FLOW_RULES = %i[run enabled revert].freeze
+
+    alias orig__clear clear
+    alias orig__invoke_with_call_chain invoke_with_call_chain
+
+    def invoke_with_call_chain(task_args, invocation_chain) # :nodoc:
+      return apply_revert_task if disabled?
+      return if run_once? && applied?
+      result = orig__invoke_with_call_chain(task_args, invocation_chain)
+      apply if run_once?
+      flush_history
+      result
+    end
+
+    def apply_revert_task
+      revert_task = find_revert_task
+      return if reverted? || !revert_task || revert_task.applied?
+      result = revert_task.execute
+      revert_task.apply if revert_task.run_once?
+      revert
+      flush_history
+      result
+    end
+
+    def clear
+      clear_flow
+      orig__clear
+    end
+
+    def clear_flow
+      @flow = {}
+      self
+    end
+
+    def disabled?
+      !enabled?
+    end
+
+    def run_once?
+      flow[:run] == :once
+    end
+
+    def enabled?
+      !!flow[:enabled]
+    end
+
+    def flow
+      @flow ||= { enabled: true, run: :always, revert: nil }
+    end
+
+    def find_revert_task
+      return unless flow[:revert]
+      application.lookup(flow[:revert])
+    end
+
+    # Add flow to the task.
+    def unpack_flow(init_flow)
+      return unless init_flow
+      init_flow.each { |rule, val| add_flow_rule(rule, val) }
+    end
+
+    def add_flow_rule(rule, val)
+      return unless ALLOWED_FLOW_RULES.include? rule
+      flow[rule.to_sym] = val
+    end
+  end
+end

data/lib/bow/response_formatter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bow
+  class ResponseFormatter
+    ERROR = "\033[31m%s\033[0m"
+    INFO = "\033[33m%s\033[0m"
+    SUCCESS = "\033[32m%s\033[0m"
+    HEADER = "\033[1;35m%s\033[0m"
+
+    class << self
+      def pretty_print(*args)
+        puts "#{wrap(*args)}\n"
+      end
+
+      def wrap(host, result)
+        host_group = colorize("[#{host.group}]", HEADER)
+        host_addr = colorize(host.host, HEADER)
+        host_header = "\n#{host_group} #{host_addr}:\n\n"
+        response = colorize_result(result).compact.first
+        "#{host_header}#{response}"
+      end
+
+      def colorize_result(result)
+        out, err = result.map { |m| m.to_s.strip }
+        err = err.empty? ? nil : colorize(err, ERROR)
+        out = if !out.empty?
+                colorize(out, SUCCESS)
+              elsif err.nil?
+                colorize('DONE', INFO)
+              end
+        [out, err]
+      end
+
+      def colorize(msg, color_pattern)
+        color_pattern % msg
+      end
+    end
+  end
+end

data/lib/bow/ssh/rsync.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+module Bow
+  module Ssh
+    class Rsync
+      def initialize(ssh_helper)
+        @ssh_helper = ssh_helper
+      end
+
+      def call(source, target)
+        @ssh_helper.run(cmd_rsync(source, conn, target))
+      end
+
+      def cmd_rsync(source, conn, target)
+        format(
+          'rsync --contimeout=10 --force -r %s %s:%s',
+          source,
+          conn,
+          target
+        )
+      end
+    end
+  end
+end

data/lib/bow/ssh/scp.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+module Bow
+  module Ssh
+    class Scp
+      def initialize(ssh_helper)
+        @ssh_helper = ssh_helper
+      end
+
+      def call(source, target)
+        @ssh_helper.execute(cmd_rm(target)) if cleanup_needed?
+        @ssh_helper.run(cmd_scp(source, conn, target))
+        @ssh_helper.run(cmd)
+      end
+
+      def cmd_scp(source, conn, target)
+        format('scp -o ConnectTimeout -r %s %s:%s', source, conn, target)
+      end
+
+      def cmd_rm(target)
+        format('rm -rf %s', target)
+      end
+
+      def cleanup_needed?(source, target)
+        File.basename(source) == File.basename(target)
+      end
+    end
+  end
+end

data/lib/bow/ssh_helper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Bow
+  class SshHelper
+    class << self
+      def method_missing(m, *args, &block)
+        new(args.shift).send m, *args, &block
+      end
+    end
+
+    COPY_TOOLS = { rsync: Ssh::Rsync, scp: Ssh::Scp }.freeze
+
+    attr_reader :conn
+
+    def initialize(conn, app)
+      @app = app
+      @conn = conn
+    end
+
+    def execute(cmd, timeout = 10)
+      cmd = "ssh -o ConnectTimeout=#{timeout} #{conn} #{cmd}"
+      run(cmd)
+    end
+
+    def copy(source, target)
+      source = source.match?(%r{^\/}) ? source : File.join(Dir.pwd, source)
+      copy_tool.call(source, target)
+    end
+
+    def prepare_provision
+      @app.inventory.ensure!
+      results = []
+      results << ensure_base_dir
+      results << copy_preprovision_script
+      results << copy_rake_tasks
+      merge_results(*results)
+    end
+
+    def ensure_base_dir
+      execute("mkdir -p #{@app.config.guest_from_host[:base_dir]}")
+    end
+
+    def copy_preprovision_script
+      copy(
+        @app.config.host[:pre_script],
+        @app.config.guest_from_host[:pre_script]
+      )
+    end
+
+    def copy_rake_tasks
+      copy(@app.inventory.location, @app.config.guest_from_host[:rake_dir])
+    end
+
+    def copy_tool
+      return @copy_tool if @copy_tool
+      unless (key = @app.options[:copy_tool]&.to_sym)
+        key = COPY_TOOLS.keys.detect { |t| system("which #{t} &>/dev/null") }
+        error = "Either #{COPY_TOOLS.keys.join(' or ')} should be installed!"
+        raise error unless key
+      end
+      @copy_tool = COPY_TOOLS[key].new(self)
+    end
+
+    def merge_results(result1, *results)
+      merged = result1.map { |v| [v] }
+      results.each_with_object(merged) do |result, acc|
+        result.each_with_index do |val, i|
+          if val.is_a? Array
+            acc[i] += val
+          else
+            acc[i] << val
+          end
+        end
+      end
+    end
+
+    def run(cmd)
+      return cmd if @app.debug?
+      Open3.capture3(cmd).first(2)
+    end
+  end
+end

data/lib/bow/targets.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'set'
+
+module Bow
+  Host = Struct.new(:host, :group, :conn)
+
+  class Targets
+    attr_reader :groups
+    attr_accessor :file, :group, :user
+
+    def initialize(file, user = 'root')
+      @file = file
+      @hosts = { all: Set.new }
+      @user = user
+      @groups = []
+    end
+
+    def hosts(group = :all)
+      parse
+      group = group.to_sym
+      return @hosts[group] unless block_given?
+      @hosts[group.to_sym].each { |h| yield(h) }
+    end
+
+    def parse
+      return if @parsed
+      raw_data.each do |group, hosts|
+        parse_group(group, hosts)
+      end
+      @hosts[:all] = @hosts[:all].uniq
+      @parsed = true
+    end
+
+    private
+
+    def parse_group(group, hosts)
+      group = group.to_sym
+      hosts = hosts.uniq.map { |h| build_host(group, h) }
+      @hosts[group] = Set.new hosts
+      @hosts[:all] += hosts
+      groups << group
+    end
+
+    def build_host(group, host)
+      Host.new(host, group, "#{@user}@#{host}")
+    end
+
+    def raw_data
+      @raw_data ||= JSON.parse(File.read(@file))
+    end
+  end
+end