balmora 0.0.1

data/lib/balmora/command/commands.rb

@@ -0,0 +1,21 @@
+class Balmora::Command::Commands < Balmora::Command
+
+  def options()
+    return super().concat([:commands])
+  end
+
+  def verify()
+    if @commands.nil?()
+      raise Error.new('"commands" should be set')
+    end
+  end
+
+  def run()
+    @balmora.run_commands(@state, @commands)
+  end
+
+  def _installed()
+    return @shell.run!(['pacman', '-Q'], verbose: false).split("\n")
+  end
+
+end

data/lib/balmora/command/exec.rb

@@ -0,0 +1,24 @@
+class Balmora::Command::Exec < Balmora::Command
+
+  class Error < StandardError; end
+
+  def options()
+    return super().concat([:exec])
+  end
+
+  def verify()
+    if @exec.nil?()
+      raise Error.new('"exec" should be defined')
+    end
+  end
+
+  def run()
+    exec = option(:exec)
+    if !exec.instance_of?(::Array)
+      exec = [@shell.expression(exec)]
+    end
+
+    @shell.system(exec)
+  end
+
+end

data/lib/balmora/command/file.rb

@@ -0,0 +1,168 @@
+class Balmora::Command::File < Balmora::Command
+
+  class Error < StandardError; end
+
+  OPTIONS = '-T'
+
+  def init()
+    super()
+
+    @action = @variables.inject(@action)
+    @file = @variables.inject(@file)
+    @source = @variables.inject(@source)
+    @storage = @variables.inject(@storage)
+  end
+
+  def options()
+    return super().concat([:file, :source, :storage, :action, :check_equal,
+      :options])
+  end
+
+  def run()
+    if !_run_required?()
+      return nil
+    end
+
+    _create_target_path()
+    _copy_file()
+    # _change_file_owner()
+  end
+
+  def verify()
+    if @file.nil?()
+      raise Error.new('"file" should be defined')
+    end
+
+    if !@storage.nil?() && !@source.nil?()
+      raise Error.new('"storage" and "source" could not be defined together')
+    end
+
+    if @storage.nil?() && @source.nil?()
+      raise Error.new('"storage" or "source" should be defined')
+    end
+
+    if @action.nil?()
+      raise Error.new('"action" should be set')
+    end
+
+    if !['pull', 'push'].include?(@action)
+      Error.new("Unknown action #{@action.inspect()}")
+    end
+  end
+
+  protected
+
+  def _create_target_path()
+    @shell.run!(['mkdir', '-p', ::File.dirname(_target_path())], verbose: false)
+  end
+
+  def _copy_file()
+    @shell.run!(['cp', option(:options) || OPTIONS, _source_path(),
+      _target_path()])
+  end
+
+  # def _change_file_owner()
+  #   new_owner = _get_target_required_owner()
+  #   if _get_target_actual_owner() == new_owner
+  #     return
+  #   end
+
+  #   @shell.run!(['chown', new_owner, '-R', _target_path()])
+  # end
+
+  # def _get_target_actual_owner()
+  #   owner =
+  #     @shell.run!(['stat', '-c', '%U:%G', _target_path()], verbose: false).
+  #     strip()
+
+  #   return owner
+  # end
+
+  # def _get_target_required_owner()
+  #   owner =
+  #     if @action == 'pull'
+  #       @owner
+  #     elsif @action == 'push'
+  #       @storage_owner
+  #     else
+  #       raise Error.new("Can not get owner for action #{@action}")
+  #     end
+
+  #   owner = owner || @shell.user_id()
+
+  #   return owner
+  # end
+
+  def _run_required?()
+    # if @check_equal == false
+    #   return true
+    # end
+
+    command = [
+      'test', '-e', _source_path(), _expr('&&'),
+      *@shell.sudo(), 'test', '-e', _target_path(), _expr('&&'),
+      _expr('[ "$('), *@shell.sudo(), *_source_contents(), _expr('| md5sum'),
+        _expr(')" = '),
+      _expr('"$('), *@shell.sudo(), *_target_contents(), _expr('| md5sum)" ]'),
+    ]
+
+    return @shell.run(command, verbose: false)[0] != 0
+  end
+
+  def _source_contents()
+    return ['cat', _source_path()]
+  end
+
+  def _target_contents()
+    return ['cat', _target_path()]
+  end
+
+  def _source_path()
+    return _files()[0]
+  end
+
+  def _target_path()
+    return _files()[1]
+  end
+
+  def _expr(expression)
+    return @shell.expression(expression)
+  end
+
+  def _owner()
+    return @owner || ENV['USER']
+  end
+
+  def _storage_owner()
+    return @storage_owner || ENV['USER']
+  end
+
+  private
+
+  def _files()
+    if @action == 'pull'
+      return _resolve_source_path(), @shell.expand(@file)
+    else
+      return @shell.expand(@file), _resolve_source_path()
+    end
+  end
+
+  def _resolve_source_path()
+    if !@source.nil?()
+      return @shell.expand(@source)
+    end
+
+    storage = @shell.expand(@storage)
+
+    if @file.start_with?('~/')
+      result = ::File.join(storage, @file[1..-1])
+    elsif @file.start_with?('/')
+      result = ::File.join(storage, @file[1..-1])
+    else
+      result = ::File.join(storage, @file)
+    end
+
+    return result
+  end
+
+end

data/lib/balmora/command/files.rb

@@ -0,0 +1,122 @@
+class Balmora::Command::Files < Balmora::Command
+
+  class Error < StandardError; end
+
+  def init()
+    super()
+
+    @files = @variables.inject(@files)
+    @storage = @variables.inject(@storage)
+    @exclude = @variables.inject(@exclude)
+  end
+
+  def options()
+    return super().concat([:action, :options, :files, :storage, :exclude])
+  end
+
+  def verify()
+    if @files.nil?() && @storage.nil?()
+      raise Error.new('"files" or "storage" should be defined')
+    end
+
+    if @files.nil?() || @files.empty?()
+      raise Error.new('"files" should be defined')
+    end
+
+    if !@options.nil?() && @options.has_key?(:storage) && !@storage.nil?()
+      raise Error.new('"file.storage" and "storage" could not be defined ' +
+        'together')
+    end
+
+    if @action.nil?()
+      raise Error.new('"action" should be defined')
+    end
+  end
+
+  def run()
+    _files().each() { |file|
+      command = _get_command(file)
+      @balmora.run_command(@state, command)
+    }
+  end
+
+  def _files()
+    files = _find_files()
+    files = _filter_files(files)
+    return files
+  end
+
+  def _find_files()
+    storage = @shell.expand(@storage)
+
+    files = []
+    @files.each() { |file|
+      path = file
+      if path.instance_of?(::Hash)
+        path = path[:file]
+      end
+
+      if @action == 'pull'
+        path = ::File.join(storage, path.gsub(/^(\~\/|\~$|\/)/, ''))
+      else
+        path = @shell.expand(path)
+      end
+
+      command = ['test', '-d', path, @shell.expression('&&'), 'find', path,
+        '-type', 'f']
+
+      dir_status, dir_files = @shell.run(command, verbose: false)
+      if dir_status != 0
+        files.push(file)
+        next
+      end
+
+      dir_files.
+        strip().
+        split("\n").
+        each() { |found|
+          found = found[(path.length + 1)..-1]
+          if file.instance_of?(::Hash)
+            files.push(file.merge(file: ::File.join(file[:file], found)))
+          else
+            files.push(::File.join(file, found))
+          end
+        }
+    }
+
+    return files
+  end
+
+  def _filter_files(files)
+    if !@exclude.nil?()
+      exclude = Regexp.new('(' + @exclude.collect() { |part| "(#{part})" }.
+        join('|') + ')')
+
+      files = files.select() { |file|
+        result =
+          if file.instance_of?(::Hash)
+            !file[:file].match(exclude)
+          else
+            !file.match(exclude)
+          end
+
+        next result
+      }
+    end
+
+    return files
+  end
+
+  def _get_command(file)
+    command = (@options || {}).merge(command: 'file', file: file)
+
+    if file.instance_of?(::Hash)
+      command.merge!(file)
+    end
+
+    command.merge!(action: @action, storage: @storage)
+
+    return command
+  end
+
+end

data/lib/balmora/command/pacman.rb

@@ -0,0 +1,71 @@
+class Balmora::Command::Pacman < Balmora::Command
+
+  def initialize(state, command)
+    super(state, command)
+    @bin = ['sudo', 'pacman']
+  end
+
+  def init()
+    super()
+    @action = @variables.inject(@action)
+    @packages = @variables.inject(@packages)
+    @synchronize = @variables.inject(@synchronize)
+  end
+
+  def options()
+    return super().concat([:action, :packages, :synchronize])
+  end
+
+  def verify()
+    if @action.nil?()
+      raise Error.new('"action" should be set')
+    end
+
+    if !['install', 'update', 'remove'].include?(@action)
+      raise Error.new('wrong "action" value; allowed values: install, ' +
+        'update, remove')
+    end
+
+    if @packages.nil?() || @packages.empty?()
+      raise Error.new('"packages" should be set')
+    end
+  end
+
+  def run()
+    command = '-S'
+
+    if @synchronize != false
+      command += 'y'
+    end
+
+    if @action == 'install'
+      packages = @packages - _installed()
+    elsif @action == 'update'
+      packages = @packages
+    elsif @action == 'remove'
+      packages = @packages & _installed()
+      command = '-R'
+    else
+      raise Error.new("Wrong action #{@action.inspect()}")
+    end
+
+    if packages.length == 0
+      return
+    end
+
+    @shell.system([*@bin, command, *packages, '--noconfirm'])
+  end
+
+  def _installed()
+    packages =
+      @shell.
+      run!(['pacman', '-Q'], verbose: false).
+      split("\n").
+      collect() { |package|
+        package.split(' ')[0]
+      }
+
+    return packages
+  end
+
+end

data/lib/balmora/command/reload_config.rb

@@ -0,0 +1,13 @@
+class Balmora::Command::ReloadConfig < Balmora::Command
+
+  class Error < StandardError; end
+
+  def verify()
+    return true
+  end
+
+  def run()
+    @config.load()
+  end
+
+end

data/lib/balmora/command/restart.rb

@@ -0,0 +1,13 @@
+class Balmora::Command::Restart < Balmora::Command
+
+  class Error < StandardError; end
+
+  def verify()
+    return true
+  end
+
+  def run()
+    raise Balmora::Restart.new()
+  end
+
+end

data/lib/balmora/command/set_variable.rb

@@ -0,0 +1,41 @@
+class Balmora::Command::SetVariable < Balmora::Command
+
+  class Error < StandardError; end
+
+  def init()
+    super()
+
+    @variable = option(:variable)
+    @value = option(:value)
+  end
+
+  def options()
+    return super().concat([:variable, :value])
+  end
+
+  def verify()
+    if @variable.nil?()
+      raise Error.new('"variable" should be defined')
+    end
+
+    if @value.nil?()
+      raise Error.new('"value" should be defined')
+    end
+  end
+
+  def run()
+    parts = @variable.split('.').collect() { |part| part.to_sym() }
+    @config.config[:variables] ||= {}
+    parent = parts[0...-1].inject(@config.config[:variables]) { |current, variable|
+      if !current.instance_of?(::Hash)
+        raise Error.new("wrong variable name #{@variable}: target is not hash")
+      end
+
+      current[variable] ||= {}
+      next current[variable]
+    }
+
+    parent[parts[-1]] = @value
+  end
+
+end