balmora 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f7d56a33f3e8d7e5e35beeb227e3881023ad7ca
+  data.tar.gz: 0a4e21d622e6a0c78c0ad5956d0b07b15221525e
+SHA512:
+  metadata.gz: 766373a8b25c96fc88762099c517f6bbd8c66d1f404c95c4ed8dbdfe2286da69664c1b694d513fd55de58536d090d810a7ae4cd5e2996085af7c366866a8a8d8
+  data.tar.gz: ec88c1d20741eda666acf3083a63293d2b1730915cf0f3674b80bd624d80cb30e90ad3809cdb13287186d7ffb5e56cf1f0771b3df9c377cf82143cd562cdfbac

data/bin/balmora

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'balmora/cli'
+
+result = Balmora::Cli.new().run(ARGV.clone())
+exit(result)

data/lib/balmora.rb

@@ -0,0 +1,77 @@
+class Balmora
+
+  class Error < StandardError; end
+  class Restart < StandardError; end
+  class Stop < StandardError
+
+    attr_reader :status
+
+    def initialize(message, status)
+      super(message)
+      @status = status
+    end
+
+  end
+
+  def self.run(task, arguments = {}, options = {})
+    state = Balmora::State.create(options, arguments)
+    state.balmora.run(task, state)
+  end
+
+  # def self.create(options = {}, arguments = {})
+  #   state = Balmora::State.create(options, arguments)
+  #   return state.balmora
+  # end
+
+  def self.factory(state)
+    return self.new(state.logger, state.extension, state)
+  end
+
+  def initialize(logger, extension, state)
+    @logger = logger
+    @extension = extension
+    @state = state
+  end
+
+  def run(task, state)
+    restarts = state.config.get([:max_restarts], default: 3)
+
+    restarts.
+      times() { |index|
+      begin
+        dir = state.config.get(:chdir, default: Dir.pwd)
+        dir = state.variables.inject(dir)
+        Dir.chdir(dir) {
+          commands = state.config.get([:tasks, task.to_sym(), :commands])
+          run_commands(state, commands)
+        }
+        return 0
+      rescue Restart
+        @logger.debug("Restarting task (#{restarts - index} attempts left)")
+        state = Balmora::State.create(@state.options, @state.arguments)
+      end
+    }
+
+
+    raise Error.new("Maximal restart attempts count (#{restarts}) reached")
+  rescue Stop => stop
+    @logger.debug("Stop with status #{stop.status} catched")
+    return stop.status
+  end
+
+  def run_commands(state, commands)
+    commands.
+      each() { |command|
+        run_command(state, command)
+      }
+  end
+
+  def run_command(state, command)
+    @extension.
+      create_command(state, command).
+      execute()
+  end
+
+end
+
+require 'balmora/require.rb'

data/lib/balmora/arguments.rb

@@ -0,0 +1,175 @@
+class Balmora::Arguments
+
+  class Error < StandardError; end
+
+  def self.parse(options, argv)
+    shortcuts = _shortcuts(options)
+
+    result = {}
+    index = 0
+    while index < argv.length
+      arg = argv[index]
+
+      if arg.start_with?('--')
+        new_index = _parse_key(result, options, argv, index, arg[2..-1])
+      elsif arg.start_with?('-')
+        new_index = _parse_flags(result, options, argv, index, shortcuts, arg)
+      else
+        new_index = nil
+      end
+
+      if new_index.nil?()
+        return result, argv[index..-1]
+      end
+
+      index = new_index + 1
+    end
+
+    return result, nil
+  end
+
+  protected
+
+  def self._shortcuts(options)
+    shortcuts = Hash[
+      options.
+        collect() { |key, option|
+          if !option.has_key?(:shortcut)
+            next nil
+          end
+
+          [option[:shortcut].to_sym(), key]
+        }.
+        compact()
+    ]
+
+    return shortcuts
+  end
+
+  def self._parse_flags(result, options, argv, index, shortcuts, arg)
+    new_index = nil
+
+    if arg.length > 2
+      arg[1..-1].split('').each() { |flag|
+        new_index = _parse_key(result, options, argv, index,
+          shortcuts[flag.to_sym()], true)
+
+        if new_index.nil?()
+          return nil
+        end
+      }
+    else
+      new_index = _parse_key(result, options, argv, index,
+        shortcuts[arg[1..-1].to_sym()])
+    end
+
+    return new_index
+  end
+
+  def self._parse_key(result, options, argv, index, key, flag_required = false)
+    if key.nil?()
+      return nil
+    end
+
+    key = key.to_sym()
+
+    if !options.has_key?(key)
+      return nil
+    end
+
+    option = options[key]
+    if option[:flag] == true
+      result[key] = true
+    else
+      if flag_required
+        return nil
+      end
+
+      value = argv[index + 1]
+      result[key] = value
+      index += 1
+    end
+
+    return index
+  end
+
+  public
+
+  def self.help(options)
+    lines = []
+    options.each() { |long, option|
+      if option.instance_of?(::String)
+        lines.push(option)
+        next
+      end
+
+      arg =
+        if option[:shortcut].nil?()
+          (' ' * 7) + '--' + long.to_s()
+        else
+          (' ' * 4) + '-' + option[:shortcut] + ', ' + '--' + long.to_s()
+        end
+
+      lines.push([arg, option[:description]])
+    }
+
+    return format(lines)
+  end
+
+  def self.format(lines)
+    indent =
+      lines.
+      inject(0) { |current, line|
+        if line.instance_of?(::String)
+          next current
+        end
+
+        if current < line[0].length
+          current = line[0].length
+        end
+
+        current
+      } +
+      4
+
+    result = []
+    lines.each() { |line|
+      if line.instance_of?(::String)
+        result.push(line)
+        next
+      end
+
+      summary = _wrap(line[1] || '', 60)
+      result.push(line[0] + (' ' * (indent - line[0].length)) +
+        (summary[0] || ''))
+
+      (summary[1..-1] || []).each() { |ln| result.push(' ' * indent + ln) }
+
+      result.push('')
+    }
+
+    return result.join("\n").rstrip()
+  end
+
+  def self._wrap(text, length)
+    line = ''
+    result = []
+
+    text.split("\n").each() { |text_line|
+      text_line.split(' ').each() { |word|
+        if (line + word + ' ').length > length
+          result.push(line.rstrip())
+          line = ''
+        end
+
+        line += word + ' '
+      }
+
+      result.push(line.rstrip())
+      line = ''
+    }
+
+    return result
+  end
+
+end

data/lib/balmora/cli.rb

@@ -0,0 +1,150 @@
+require 'balmora'
+require 'balmora/arguments'
+require 'optparse'
+
+class Balmora::Cli
+
+  class Error < StandardError; end
+
+  attr_accessor :out, :err, :rescue
+
+  def initialize()
+    _create_options()
+
+    @out = STDOUT
+    @err = STDERR
+    @rescue = true
+
+    @arguments = Balmora::Arguments
+  end
+
+  def _create_options()
+    @options = {
+      config: {
+        shortcut: 'c',
+        description: 'Configuration file; if not specified, balmora will ' +
+          'look configuration file at ~/.config/balmora/balmora.conf and ' +
+          '/etc/balmora/balmora.conf in order',
+      },
+
+      quite: {
+        shortcut: 'q',
+        flag: true,
+        description: 'Quite mode; reports only errors',
+      },
+
+      verbose: {
+        shortcut: 'v',
+        flag: true,
+        description: 'Verbose mode; reports all executed commands',
+      },
+
+      help: {
+        shortcut: 'h',
+        flag: true,
+        description: 'Show help; if --config specified in arguments, shows ' +
+          'config help; if TASK specified, shows task help',
+      },
+    }
+  end
+
+  def run(argv)
+    args, tail = @arguments.parse(@options, argv)
+    state = Balmora::State.create(args, {})
+    if tail.nil?()
+      if args[:help] == true
+        @out.puts(help(state))
+        return 1
+      end
+
+      @err.puts('No task specified; use --help to see help')
+      return 1
+    end
+
+    if tail[0].start_with?('-')
+      raise Error.new("Unknown option #{tail.first()}; use --help to see " +
+        "options")
+    end
+
+
+    task_name, *task_argv = tail
+    task = state.config.get([:tasks, task_name.to_sym()], default: nil,
+      variables: false)
+
+    if task.nil?()
+      raise Error.new("Unknown task #{task_name.to_s().inspect()}; use " +
+        "--help to see task list")
+    end
+
+    if args[:help] == true
+      @out.puts(task_help(state, task_name, task))
+      return 1
+    end
+
+    if task.has_key?(:arguments)
+      task_args, task_args_tail = @arguments.parse(task[:arguments], task_argv)
+      if !task_args_tail.nil?()
+        raise Error.new("Unknown task option #{task_args_tail.first().
+          inspect()}; use --help #{task_name} to see task options")
+      end
+    else
+      task_args = {}
+    end
+
+    state.arguments.merge!(task_args)
+
+    STDIN.reopen("/dev/tty") # make sure that input to tty will
+
+    return state.balmora.run(task_name, state)
+  rescue => error
+    if !@rescue || true
+      raise error
+    end
+
+    @err.puts('Error: ' + error.to_s())
+    if args[:debug]
+      @err.puts(error.backtrace)
+    end
+
+    return 1
+  end
+
+  def help(state)
+    tasks =
+      state.
+      config.
+      get([:tasks], variables: false, default: []).
+      collect() { |key, task|
+        [' ' * 4 + key.to_s(), task[:description] || '']
+      }
+
+    help =
+      "Usage: balmora [common-options] task [task-options]\n\n" +
+      "Options\n\n" +
+      @arguments.help(@options) + "\n\n" +
+      "Tasks:\n\n" +
+      @arguments.format(tasks)
+
+    return help
+  end
+
+  def task_help(statetask_name, task)
+    help =
+      "Usage: balmora [common-optinos] #{task_name} [task-options]\n\n" +
+      "Description:\n\n" +
+      (
+        task[:description] &&
+        @arguments.format([['   ', task[:description]]]) ||
+        ((' ' * 4) + 'No description provided')
+      ) + "\n\n" +
+      "Arguments:\n\n" +
+      (
+        task[:arguments] &&
+        @arguments.help(statetask[:arguments]) ||
+        ((' ' * 4) + 'Task has no arguments')
+      )
+
+    return help
+  end
+
+end

data/lib/balmora/command.rb

@@ -0,0 +1,106 @@
+class Balmora::Command
+
+  class Error < StandardError; end
+
+  def initialize(state, command)
+    @state = state
+
+    @logger = state.logger
+    @shell = state.shell
+    @config = state.config
+    @contexts = state.contexts
+    @variables = state.variables
+    @balmora = state.balmora
+
+    @command = command
+  end
+
+  def init()
+    if (@command.keys() - [:command] - options()).length != 0
+      raise Error.new("Unknown options #{(@command.keys() - [:command] -
+        options()).inspect()}")
+    end
+
+    options().each() { |key|
+      if self.instance_variable_defined?(:"@#{key}")
+        raise Error.new("Can not use #{key} as option")
+      end
+
+      option = @command.fetch(key, nil)
+      self.instance_variable_set(:"@#{key}", option)
+    }
+
+    verify()
+  end
+
+  def options()
+    return [:ignore_error, :fallback, :extensions, :sudo, :context, :chdir,
+      :require]
+  end
+
+  def execute()
+    if @command.has_key?(:chdir)
+      dir = @command[:chdir]
+      dir = @variables.inject(dir)
+      dir = @shell.expand(dir)
+      Dir.chdir(dir) {
+        _execute()
+      }
+    else
+      _execute()
+    end
+  end
+
+  def _execute()
+    if @command.instance_of?(::Hash) && !@contexts.check(@command[:context])
+      @logger.debug("Skip: #{@command.inspect()}")
+      return
+    end
+
+    init()
+
+    if !@require.nil?()
+      option(:require).each() { |file|
+        require file
+      }
+    end
+
+    @logger.debug("Run: #{@command.inspect()}")
+
+    execute = self.method(:run)
+
+    if !@sudo.nil?()
+      execute_sudo = execute
+      execute = Proc.new() {
+        @shell.sudo!(option(:sudo)) {
+          execute_sudo.call()
+        }
+      }
+    end
+
+    execute.call()
+  rescue => error
+    @logger.error("#{error.inspect()}; failed to run " +
+      "command: #{@command.inspect()}")
+
+    if @fallback
+      @logger.debug("Executing fallback for command #{@command.inspect()}")
+      @balmora.execute(@fallback)
+    end
+
+    if option(:ignore_error) == true
+      return
+    end
+
+    raise error
+  end
+
+  def run()
+    raise Error.new("Run should be implemented in subclass")
+  end
+
+  def option(option)
+    return @variables.inject(self.instance_variable_get(:"@#{option}"))
+  end
+
+end