bow 0.0.0 → 0.5.0

data/lib/bow/commands/apply.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bow
+  module Commands
+    class Apply < Command
+      def description
+        'Apply provision on remote hosts.'
+      end
+
+      def run
+        ThreadPool.new do |t|
+          t.from_enumerable targets do |host|
+            result = app.ssh_helper(host).prepare_provision(PROVISION_PATH)
+            ResponseFormatter.pretty_print(host, result)
+
+            cmd = "'cd #{PROVISION_PATH} && rake #{host.group}:provision'"
+            result = app.ssh_helper(host).execute(cmd)
+            ResponseFormatter.pretty_print(host, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bow/commands/exec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'pp'
+
+module Bow
+  module Commands
+    class Exec < Command
+      def description
+        'Exec command on remote hosts.'
+      end
+
+      def usage
+        "bow #{command_name} command [args] [options]"
+      end
+
+      def run
+        raise ArgumentError, 'Command required!' unless @argv && !@argv&.empty?
+        cmd = @argv.shift
+        ThreadPool.new do |t|
+          t.from_enumerable targets do |host|
+            result = app.ssh_helper(host).execute(cmd)
+            ResponseFormatter.pretty_print(host, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bow/commands/init.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bow
+  module Commands
+    class Init < Command
+      def description
+        'Initialize minimal bow scaffold.'
+      end
+
+      def run
+        InventoryExample.new.init
+      end
+    end
+  end
+end

data/lib/bow/commands/ping.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Bow
+  module Commands
+    class Ping < Command
+      def description
+        'Check connectivity to all given hosts.'
+      end
+
+      def run
+        @argv << 'echo pong'
+        Exec.new(@app, @argv).run
+      end
+    end
+  end
+end

data/lib/bow/commands/prepare.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bow
+  module Commands
+    class Prepare < Command
+      def description
+        'Install RVM, Ruby and Rake on provisioned hosts'
+      end
+
+      def run
+        ThreadPool.new do |t|
+          t.from_enumerable targets do |host|
+            result = app.ssh_helper(host).prepare_provision(PROVISION_PATH)
+            ResponseFormatter.pretty_print(host, result)
+
+            provision_cmd = "bash #{PROVISION_PATH}/preprovision.sh"
+            result = app.ssh_helper(host).execute(provision_cmd)
+            ResponseFormatter.pretty_print(host, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bow/config.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bow
+  class Config
+    class << self
+      def host
+        @host ||= Config.new(:host, HOST_BASE_DIR)
+      end
+
+      def guest
+        @guest ||= Config.new(:guest, GUEST_BASE_DIR)
+      end
+
+      def guest_from_host
+        @guest_from_host ||= Config.new(:guest, '~')
+      end
+    end
+
+    HOST_BASE_DIR = File.dirname(File.dirname(File.dirname(__FILE__)))
+
+    GUEST_BASE_DIR = "#{Dir.home}/.bow"
+
+    GUEST_FROM_HOST_BASE_DIR = '~/.bow'
+
+    PATHS = {
+      guest: {
+        base_dir: '%s',
+        rake_dir: '%s/rake',
+        history: '%s/.history',
+        pre_script: '%s/provision.sh'
+      },
+      host: {
+        base_dir: '%s',
+        pre_script: '%s/src/provision.sh'
+      }
+    }.freeze
+
+    def initialize(type, base_dir)
+      @type = type
+      @base_dir = base_dir
+    end
+
+    def get(name)
+      name.to_sym
+      value = PATHS[@type][name]
+      substitude_dir(value)
+    end
+
+    def substitude_dir(orig)
+      format(orig, @base_dir) if orig
+    end
+
+    def [](name)
+      get(name)
+    end
+  end
+end

data/lib/bow/inventory.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'rake/file_list'
+
+module Bow
+  class Inventory
+    DEFAULT_RAKEFILES = [
+      'Rakefile',
+      'rakefile',
+      'Rakefile.rb',
+      'rakefile.rb'
+    ].freeze
+
+    DEFAULT_TARGETFILES = [
+      # 'bow.yaml',
+      # 'bow.rb',
+      'targets.json'
+    ].freeze
+
+    attr_reader :rakefile, :targetfile, :location
+
+    def initialize
+      @rakefiles = DEFAULT_RAKEFILES.dup
+      @targetfiles = DEFAULT_TARGETFILES.dup
+      @original_dir = Dir.pwd
+    end
+
+    def parse
+      return if @inventory_loaded
+      rakefile, targetfile, @location = inventory_location
+      @rakefile = File.join(@location, rakefile) if rakefile
+      @targetfile = File.join(@location, targetfile) if targetfile
+      @inventory_loaded = true
+    end
+
+    def valid?
+      parse
+      !!(rakefile && targetfile && location)
+    end
+
+    def ensure!
+      parse
+      [
+        ['Rakefile', @rakefile, @rakefiles],
+        ['Target file', @targetfile, @targetfiles]
+      ].each do |name, file, variants|
+        unless file
+          raise "No #{name} found (looking for: #{variants.join(', ')})"
+        end
+      end
+      self
+    end
+
+    private
+
+    def inventory_location
+      reset_path do
+        here = @original_dir
+        until (files = inspect_dir)
+          break if here == '/'
+          Dir.chdir('..')
+          here = Dir.pwd
+        end
+        [files, here].flatten
+      end
+    end
+
+    def reset_path
+      yield
+    ensure
+      Dir.chdir(@original_dir)
+    end
+
+    def inspect_dir
+      rakefile = detect_files(@rakefiles)
+      targetfile = detect_files(@targetfiles)
+      [rakefile, targetfile]
+    end
+
+    def detect_files(variants)
+      variants.detect { |fn| File.exist?(fn) }
+    end
+  end
+end

data/lib/bow/inventory_example.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+module Bow
+  class InventoryExample
+    TARGETING_EXAMPLE = {
+      'example_group1' => [
+        '192.168.50.27',
+        '192.168.50.37'
+      ],
+      'example_group2' => [
+        '192.168.50.47',
+        '192.168.50.57'
+      ]
+    }.freeze
+
+    RAKEFILE_EXAMPLE = <<-RAKEFILE.gsub(/^ {6}/, '').freeze
+      require 'bow/rake'
+
+      Rake.application.options.trace_rules = true
+
+      PROVISION_DIR = '/tmp/rake_provision'
+
+      namespace :example_group1 do
+        task provision: :print_hello do
+        end
+
+        flow run: :once
+        task :print_hello do
+          sh 'echo "Hello from example group #1 server!"'
+        end
+      end
+
+      namespace :example_group2 do
+        task provision: :print_hello do
+        end
+
+        flow enabled: false, revert_task: :print_goodbye
+        task :print_hello do
+          sh 'echo "Hello from example group #2 server!"'
+        end
+
+        task :print_goodbye do
+          sh 'echo "Goodbye! The task at example group #2 is disabled!"'
+        end
+      end
+    RAKEFILE
+
+    def init
+      raise 'Can not init. Directory not empty!' unless Dir.empty?(Dir.pwd)
+      {
+        'Rakefile'     => RAKEFILE_EXAMPLE,
+        'targets.json' => JSON.pretty_generate(TARGETING_EXAMPLE)
+      }.each do |targ, code|
+        f = File.open(targ, 'w')
+        f.write(code)
+        f.close
+      end
+    end
+  end
+end

data/lib/bow/locker.rb

@@ -0,0 +1,180 @@
+require 'fileutils'
+require 'objspace'
+
+# Locker is a task state manager.
+# It tracks the task status and saves it to the history file.
+module Bow
+  class Locker
+    class << self
+      attr_accessor :file_path
+
+      def load
+        @instance ||= new
+      end
+
+      def load!
+        @instance = new
+      end
+    end
+
+    SEPARATOR = ";\t".freeze
+    LINE_SEP = "\n".freeze
+    NOT_FOUND = :not_found
+
+    attr_accessor :runtime_cache
+
+    def initialize
+      @file_path = self.class.file_path || Config.guest[:history]
+      @modified = false
+      @file_opened = false
+      @runtime_cache = {}
+    end
+
+    def applied?(task)
+      record = parse(find(task))
+      !!(record && record[1])
+    end
+
+    def reverted?(task)
+      record = parse(find(task))
+      !!(record && record[2])
+    end
+
+    def apply(task)
+      return if applied?(task)
+      add(task, true, reverted?(task))
+    end
+
+    def revert(task)
+      return if reverted?(task)
+      add(task, applied?(task), true)
+    end
+
+    def parse(meta)
+      return false if meta[:record] == NOT_FOUND
+      record = meta[:record].split(SEPARATOR)
+      record.map do |v|
+        v.strip!
+        case v
+        when 'true' then true
+        when 'false' then false
+        else v
+        end
+      end
+    end
+
+    def reset(task)
+      meta = find(task)
+      reset_cache(task)
+      return if meta[:record] == NOT_FOUND
+      file.seek(meta[:first_c], IO::SEEK_SET)
+      str_len = meta[:last_c] - meta[:first_c] + 1
+      file.write ' ' * str_len
+    end
+
+    def find(task)
+      cached = from_cache(task)
+      return cached if cached
+      result = pure_find(task)
+      result
+    end
+
+    def from_cache(task)
+      @runtime_cache[task]
+    end
+
+    def to_cache(task, result)
+      @runtime_cache[task] = result
+    end
+
+    def reset_cache(task)
+      @runtime_cache[task] = nil
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Style/PerlBackrefs
+    def pure_find(task)
+      file.rewind
+      current_line = ''
+      first_c = 0
+      last_c = 0
+      file.each_char.with_index do |c, idx|
+        if c == LINE_SEP
+          current_line =~ /^([^\s]+)#{SEPARATOR}/
+          to_cache(task, record: $1, first_c: first_c, last_c: last_c)
+          if task == $1
+            return { record: current_line, first_c: first_c, last_c: last_c }
+          end
+          current_line = ''
+          first_c = idx + 1
+          last_c = first_c
+        else
+          current_line << c
+          last_c = idx
+        end
+      end
+      { record: NOT_FOUND, first_c: nil, last_c: nil }
+    end
+    # rubocop:enable Style/PerlBackrefs
+    # rubocop:enable Metrics/MethodLength
+
+    def add(task, applied = false, reverted = false)
+      reset(task)
+      file.seek(0, IO::SEEK_END)
+      write(task, applied, reverted)
+      self
+    end
+
+    def write(task, applied = false, reverted = false)
+      reset_cache(task)
+      record = [task, applied, reverted].join(SEPARATOR)
+      first_c = file.tell
+      file.puts(record)
+      last_c = first_c + record.size - 1
+      to_cache(task, record: record, first_c: first_c, last_c: last_c)
+      @modified = true
+      self
+    end
+
+    def flush
+      return unless @modified && @file_opened
+      file.close
+      @file_opened = false
+      @modified = false
+      self
+    end
+
+    def compact
+      compressed = ''
+      file.each do |l|
+        compressed << l unless l[0] == ' '
+      end
+      file.rewind
+      file.write(compressed)
+      file.truncate(compressed.size)
+      @runtime_cache = {}
+      @modified = true
+      self
+    end
+
+    def empty!
+      file.rewind
+      file.truncate(0)
+      @runtime_cache = {}
+    end
+
+    def file
+      return @file if @file && @file_opened
+      ensure_file(@file_path)
+      @file = File.open(@file_path, 'r+')
+      @file_opened = true
+      file
+    end
+
+    def ensure_file(name)
+      return if File.exist?(name)
+      FileUtils.mkdir_p(File.dirname(name))
+      FileUtils.touch(name)
+    end
+  end
+end