balmora 0.0.1

data/lib/balmora/extension/file_secret.rb

@@ -0,0 +1,45 @@
+module Balmora::Extension::FileSecret
+
+  def options()
+    return super() + [:password]
+  end
+
+  def _copy_file()
+    if @action == 'pull'
+      @shell.run!(_source_contents() + [_expr('|'), *@shell.sudo(), 'tee',
+        _target_path()])
+    else
+      @shell.run!(['cat', _source_path(), _expr('|'), *_encrypt(), _expr('|'),
+        *@shell.sudo(), 'tee', _target_path()])
+    end
+  end
+
+  def _source_contents()
+    command = super()
+
+    if @action == 'pull'
+      command += [_expr('|')] + _decrypt()
+    end
+
+    return command
+  end
+
+  def _target_contents()
+    command = super()
+
+    if @action == 'push'
+      command += [_expr('|')] + _decrypt()
+    end
+
+    return command
+  end
+
+  def _decrypt()
+    return ['openssl', 'enc', '-aes-256-cbc', '-d', '-pass', option(:password)]
+  end
+
+  def _encrypt()
+    return ['openssl', 'enc', '-aes-256-cbc', '-e', '-pass', option(:password)]
+  end
+
+end

data/lib/balmora/logger.rb

@@ -0,0 +1,25 @@
+require 'logger'
+
+class Balmora::Logger < Logger
+
+  def self.factory(state)
+    logger = self.new(STDOUT)
+
+    if state.options[:debug] == true && state.options[:quite] == true
+      raise Error.new("Options --quite and --verbose can not be set " +
+        "simulataneously")
+    end
+
+
+    if state.options[:verbose] == true
+      logger.level = ::Logger::DEBUG
+    elsif state.options[:quiet] != true
+      logger.level = ::Logger::INFO
+    else
+      logger.level = ::Logger::ERROR
+    end
+
+    return logger
+  end
+
+end

data/lib/balmora/require.rb

@@ -0,0 +1,25 @@
+require 'balmora/logger'
+require 'balmora/extension'
+require 'balmora/config'
+require 'balmora/shell'
+require 'balmora/variables'
+require 'balmora/command'
+require 'balmora/contexts'
+require 'balmora/context'
+
+require 'balmora/state'
+
+globs = [
+  'extension/**/*.rb',
+  'command/**/*.rb',
+  'variables/**/*.rb',
+  'context/**/*.rb'
+]
+
+Dir.chdir(File.dirname(__FILE__)) {
+  globs.each() { |glob|
+    Dir.glob(glob).each() { |file|
+      require ::File.join('balmora', file)
+    }
+  }
+}

data/lib/balmora/shell.rb

@@ -0,0 +1,118 @@
+require 'shellwords'
+
+class Balmora::Shell
+
+  class Error < StandardError
+
+    attr_reader :status
+
+    def initialize(message, status)
+      super(message)
+      @status = status
+    end
+
+  end
+
+  class Expression
+
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+
+  end
+
+  attr_accessor :exec, :status
+  attr_reader :home, :user_id
+
+  def self.factory(state)
+    return self.new(state.logger)
+  end
+
+  def initialize(logger, home = nil)
+    @logger = logger
+    @run = ::Object.method(:'`')
+    @system = ::Object.method(:system)
+    @status = Proc.new() { $?.exitstatus }
+    @home = Dir.home()
+    @user_id ||= `id -un; id -gn`.strip().split("\n").join(':')
+    @sudo_stack = []
+  end
+
+  def expression(command)
+    Expression.new(command)
+  end
+
+  def sudo()
+    if @sudo_stack.length == 0
+      return []
+    end
+
+    if @sudo_stack[-1] == true
+      return ['sudo']
+    else
+      return ['sudo', '--user', @sudo_stack[-1]]
+    end
+  end
+
+  def run(command, options = {})
+    command = sudo() + command
+
+    shell_command =
+      command.
+      collect() { |part|
+        if part.instance_of?(Expression)
+          next part.command
+        end
+
+        next Shellwords.escape(part)
+      }.
+      join(' ')
+
+    if options[:verbose] != false
+      @logger.info(shell_command)
+    else
+      @logger.debug(shell_command)
+    end
+
+    method = @run
+    if options[:system] == true
+      method = @system
+    end
+
+    result = method.call(shell_command)
+    status = @status.call()
+
+    if options[:raise] == true && status != 0
+      raise Error.new("Failed to execute command: #{shell_command}",
+        status)
+    end
+
+    return status, result
+  end
+
+  def run!(command, options = {})
+    return run(command, options.merge(raise: true))[1]
+  end
+
+  def system(command, options = {})
+    return run(command, options.merge(raise: true, system: true))[1]
+  end
+
+  def expand(path)
+    if path.start_with?('~') || path.start_with?('/')
+      return ::File.expand_path(path)
+    end
+
+    return path
+  end
+
+  def sudo!(sudo)
+    @sudo_stack.push(sudo)
+    yield
+  ensure
+    @sudo_stack.pop()
+  end
+
+end

data/lib/balmora/state.rb

@@ -0,0 +1,82 @@
+class Balmora::State
+
+  attr_reader :options, :arguments, :logger, :balmora, :extension, :config
+  attr_reader :shell, :variables, :context
+
+  @@constants = [
+    Balmora::Logger,
+    Balmora::Extension,
+    Balmora::Shell,
+    Balmora::Variables,
+    Balmora::Config,
+    Balmora::Contexts,
+    Balmora,
+  ]
+
+  def self.create(options, arguments)
+    state = Balmora::State.new()
+    state.instance_variable_set(:@options, options)
+    state.instance_variable_set(:@arguments, arguments)
+
+    config = Balmora::Config.create(options[:config])
+    config.load()
+
+    state.instance_variable_set(:@config, config)
+
+    constants = @@constants.clone()
+    Balmora.constants.each() { |constant|
+      if !constants.include?(constant)
+        constants.push(constant)
+      end
+    }
+
+    constants.delete(Balmora::Config)
+
+    constants.each() { |constant|
+      if !constant.respond_to?(:factory)
+        next
+      end
+
+      name =
+        constant.
+        to_s().
+        split('::')[1..-1].
+        join('_').
+        split(/(?=[A-Z])/).
+        collect() { |word| word.downcase() }.
+        join('_').
+        to_sym()
+
+      if name == :''
+        name = :balmora
+      end
+
+      state.set(name, constant.factory(state))
+    }
+
+    config.variables = state.variables
+
+    return state
+  end
+
+  def set(name, instance)
+    if self.instance_variable_defined?(:"@#{name}")
+      raise Error.new("Can not set #{name.inspect()}: variable is already set")
+    end
+
+    self.instance_variable_set(:"@#{name}", instance)
+  end
+
+  def method_missing(method, *arguments)
+    if arguments.length > 1
+      super(method, *arguments)
+    end
+
+    if !self.instance_variable_defined?(:"@#{method}")
+      super(method, *arguments)
+    end
+
+    return self.instance_variable_get(:"@#{method}")
+  end
+
+end

data/lib/balmora/variables.rb

@@ -0,0 +1,110 @@
+class Balmora::Variables
+
+  class Error < StandardError; end
+
+  def self.factory(state)
+    return self.new(state.extension, state.shell, state)
+  end
+
+  def initialize(extension, shell, state)
+    @extension = extension
+    @shell = shell
+    @state = state
+  end
+
+  def get(name)
+    if !name.instance_of?(::Array)
+      name = name.split('.').collect() { |part| part.to_sym() }
+    else
+      name = name.clone()
+    end
+
+    parts = []
+    provider = @extension.get(Balmora::Variables, name.shift()).factory(@state)
+
+    result =
+      name.
+      inject(provider) { |current, part|
+        parts.push(part)
+
+        if current.instance_of?(::Hash)
+          if !current.has_key?(part)
+            raise Error.new("Unknown variable #{parts.join('.')}")
+          end
+
+          next current[part]
+        end
+
+        if !current.respond_to?(part)
+          raise Error.new("Unknown variable #{parts.join('.')}")
+        end
+
+        next current.public_send(part)
+      }
+
+    return result
+  end
+
+  def inject(value, string = true)
+    result =
+      if value.instance_of?(::Array)
+        _inject_array(value, string)
+      elsif value.instance_of?(::Hash)
+        _inject_hash(value, string)
+      elsif value.instance_of?(::String) && string
+        _inject_string(value)
+      else
+        value
+      end
+
+    return result
+  end
+
+  def _inject_array(value, string)
+    result = []
+
+    value.each_with_index() { |item, index|
+      if item.instance_of?(::Hash) && item.keys() == [:'extend-variable']
+        result += get(item[:'extend-variable'])
+      else
+        result.push(inject(item, string))
+      end
+    }
+
+    return result
+  end
+
+  def _inject_hash(value, string)
+    result = {}
+    value.each() { |key, item|
+      if key == :'include-variable'
+        result.merge!(get(item))
+      else
+        result[key] = inject(item, string)
+      end
+    }
+
+    return result
+  end
+
+  def _inject_string(value)
+    value = value.gsub('\\\\', '{{__ESCAPED_SLASH__}}')
+
+    if value.match(/(?<!\\)\#\{/)
+      value = value.gsub('\\#', '#')
+      value = eval('"' + value + '"')
+    end
+
+    value = value.gsub(/(?<!\\)\${(.*?)}/) { |string | get(string[2...-1]) }
+    value = value.gsub(/(?<!\\)\%{(.*?)}/) { |string |
+      command = @shell.expression(string[2...-1])
+      @shell.run!([command], verbose: false, message: 'Executing embedded ' +
+        'command: ').rstrip()
+    }
+
+    value = value.gsub('\\$', '$')
+    value = value.gsub('\\%', '%')
+    value = value.gsub('{{__ESCAPED_SLASH__}}', '\\')
+  end
+
+end

data/lib/balmora/variables/config.rb

@@ -0,0 +1,7 @@
+class Balmora::Variables::Config
+
+  def self.factory(state)
+    return state.config.get([], variables: false)
+  end
+
+end

data/lib/balmora/variables/variables.rb

@@ -0,0 +1,7 @@
+class Balmora::Variables::Variables
+
+  def self.factory(state)
+    return state.config.get([:variables], variables: false)
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: balmora
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Leonid Shagabutdinov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-20 00:00:00.000000000 Z
+dependencies: []
+description: Balmora - linux task runner
+email: leonid@shagabutdinov.com
+executables:
+- balmora
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/balmora
+- lib/balmora.rb
+- lib/balmora/arguments.rb
+- lib/balmora/cli.rb
+- lib/balmora/command.rb
+- lib/balmora/command/commands.rb
+- lib/balmora/command/exec.rb
+- lib/balmora/command/file.rb
+- lib/balmora/command/files.rb
+- lib/balmora/command/pacman.rb
+- lib/balmora/command/reload_config.rb
+- lib/balmora/command/restart.rb
+- lib/balmora/command/set_variable.rb
+- lib/balmora/command/stop.rb
+- lib/balmora/command/yaourt.rb
+- lib/balmora/config.rb
+- lib/balmora/context.rb
+- lib/balmora/context/config_changed.rb
+- lib/balmora/context/exec.rb
+- lib/balmora/context/exec_result.rb
+- lib/balmora/contexts.rb
+- lib/balmora/extension.rb
+- lib/balmora/extension/file_secret.rb
+- lib/balmora/logger.rb
+- lib/balmora/require.rb
+- lib/balmora/shell.rb
+- lib/balmora/state.rb
+- lib/balmora/variables.rb
+- lib/balmora/variables/config.rb
+- lib/balmora/variables/variables.rb
+homepage: http://github.com/shagabutdinov/balmora
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Balmora
+test_files: []