hatecf 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9e89a8cfac1c0bf752d1c86a7b8637ca2191eecc55e53ff8f50ccf8b80acb5c
+  data.tar.gz: a3efe1d1aaeceb0c0566d88ad737d055e54181f5d7dece693a3129d4210e7525
+SHA512:
+  metadata.gz: 1e2770dafb8f77bf2f505aa0899c33d923ea32d785331323dadc30e26620261f3406d3f73e8a0495995613b4eb4180234071c805816a1c20bcfbf81f4781a4d7
+  data.tar.gz: 1c2ba2caa0a5c2319aa4dda79644d93e2a2f75bd9bff6963a3f5c8bc130270a766a772d324ea8afbdff6153a78ab223cb59ec5ccb4c1f114ac2c4a0e5201edbe

data/bootstrap_ruby

@@ -0,0 +1,2 @@
+#!/bin/sh
+dpkg -s ruby > /dev/null || (echo "machine has no ruby; installing..."; apt-get install --no-install-recommends -y ruby)

data/lib/hatecf.rb

@@ -0,0 +1,2 @@
+#require "./local_dsl.rb"
+require File.join(__dir__, "./local_dsl.rb")

data/lib/local.rb

@@ -0,0 +1,132 @@
+module Local
+  extend self
+
+  DEFAULT_TARGET = { user: "root", port: 22 }.freeze
+  attr_accessor :target
+  @target = {}
+
+  attr_accessor :as_user_block
+  @as_user_block = false
+
+  def print_location
+    exclude = [
+      "local.rb",
+      "local_dsl.rb",
+    ]
+    caller.each do |line|
+      $stderr.puts line unless exclude.find{|x| line.include? x}
+    end
+  end
+
+  def die(message)
+    $stderr.puts "Script error: #{message}"
+    print_location
+    exit 1
+  end
+
+  def type_check(name, value, *types)
+    unless types.find{|x| value.is_a? x}
+      case name
+      when 1
+        arg_dsc = "first argument"
+      when 2
+        arg_dsc = "second argument"
+      when 3
+        arg_dsc = "third argument"
+      when Symbol
+        arg_dsc = %{argument "#{name}:"}
+      else
+        arg_dsc = "argument"
+      end
+      if types.length > 1
+        types_dsc = "types #{types.map(&:to_s).join(" or ")}"
+      else
+        types_dsc = "type #{types.first}"
+      end
+      hints = types.map do |t|
+        case t.to_s
+        when "LocalFile"
+          %{LocalFile is a file on this very computer and could be defined as local_file("~/hello")}
+        when "Regexp"
+          "Regexp is a regular expression wrapped in /slashes/"
+        else
+          nil
+        end
+      end.compact.map{|x|"\nHint: #{x}"}.join
+      die "#{arg_dsc} should be of #{types_dsc}, but #{value.class.to_s} here#{hints}"
+    end
+  end
+
+  def check_mode(mode)
+    mode = mode.to_i(8) if mode.is_a? String
+    die "please supply up to 4 digits before the leading zero, example: 00644" if mode && mode >= 010000
+  end
+
+  attr_accessor :local_files
+  @local_files = []
+
+  require 'pathname'
+  def copy_local_files_to(dir)
+    @local_files.each do |local_file|
+      # dublicating the whole directory stucture
+      acc = []
+      Pathname.new(local_file).each_filename do |chunk|
+        source_path = File.join(*(['/'] + acc << chunk))
+        dst = File.join([dir] + acc << chunk)
+        if File.directory? source_path
+          unless File.directory? dst
+            debug "mkdir #{dst}"
+            FileUtils.mkdir_p(dst)
+          end
+        else
+          debug "cp #{source_path} #{dst}"
+          FileUtils.cp(source_path, dst)
+        end
+        acc << chunk
+      end
+    end
+  end
+
+  require 'tmpdir'
+  def perform!
+    die "no target host specified!" if (@target[:host] || "").empty?
+    script_path = File.expand_path(ENV["_"])
+    script_dir = File.dirname(File.expand_path(ENV["_"]))
+    status = nil
+    Dir.mktmpdir "hatecf" do |tmp_dir|
+      debug "using temporary dir #{tmp_dir}"
+      FileUtils.cp(script_path, File.join(tmp_dir, "script.rb"))
+      File.chmod(00777, File.join(tmp_dir, "script.rb"))
+      FileUtils.cp(File.join(__dir__, "../remote/hatecf.rb"    ), tmp_dir)
+      FileUtils.cp(File.join(__dir__, "../remote/remote_dsl.rb"), tmp_dir)
+      FileUtils.cp(File.join(__dir__, "../remote/remote.rb"    ), tmp_dir)
+      FileUtils.cp(File.join(__dir__, "../bootstrap_ruby"      ), tmp_dir)
+      File.chmod(00777, File.join(tmp_dir, "bootstrap_ruby"))
+      unless @local_files.empty?
+        local_files_dir = File.join(tmp_dir, "local_files")
+        FileUtils.mkdir local_files_dir
+        copy_local_files_to(local_files_dir)
+      end
+      cmd = "tar -czP #{tmp_dir} | ssh #{@target[:user] || DEFAULT_TARGET[:user]}@#{@target[:host]} \"tar -xzP -C / && (cd #{tmp_dir} && ./bootstrap_ruby && RUBYLIB=. ./script.rb #{@dry_run ? "--dry " : " "}--local-home #{ENV["HOME"]} --local-script-dir #{script_dir}); rm -r #{tmp_dir}\""
+      debug "executing: #{cmd}"
+      pid, status = Process.wait2(Process.spawn(cmd))
+      debug "exit status: #{status.exitstatus}"
+    end
+    exit status.exitstatus
+  end
+
+  require 'optparse'
+  OptionParser.new do |opts|
+    opts.on "--dry", "don't change anything, just test everything" do |x|
+      @dry_run = true
+    end
+  end.parse!
+
+  def debug(s)
+  end
+
+  def info(s)
+    $stdout.puts s
+    $stdout.flush
+  end
+end

data/lib/local_dsl.rb

@@ -0,0 +1,200 @@
+#require "./local.rb"
+require File.join(__dir__, "./local.rb")
+
+def target(host:, user: nil, port: nil)
+  Local.type_check(:host, host, String)
+  Local.type_check(:user, user, String) if user
+  Local.type_check(:port, port, Integer) if port
+  #Local.target = Local::DEFAULT_TARGET.dup
+  Local.target[:host] = host
+  Local.target[:user] = user if user
+  Local.target[:port] = port if port
+end
+
+class LocalFile
+  def initialize(path)
+  end
+end
+
+def local_file(path)
+  # File.expand_path("~/dir") -> "/home/user/dir"
+  # File.expand_path("~/dir", "/whatever") -> "/home/user/dir" anyway
+  # File.expand_path("./dir", "/specific") -> "/specific/dir"
+  # File.join('/specific', '/absolute') -> "/specific/absolute"
+  path = File.expand_path(path, File.dirname(ENV["_"]))
+  Local.die "#{path} doesn't exists" unless File.exist? path
+  Local.local_files = Local.local_files | [path]
+  return LocalFile.new(path)
+end
+
+class LocalEntity
+  def initialize(payload)
+    @payload = payload
+  end
+end
+
+def local(x)
+  LocalEntity.new(x)
+end
+
+class TaskResult
+  def afterwards
+    yield
+  end
+end
+
+class ConfigBlockHandler
+  attr_accessor :path
+
+  def replace_or_add_line(a, b)
+    Local.type_check(1, a, String, Regexp)
+    Local.type_check(2, b, String)
+    TaskResult.new
+  end
+
+  def add_line(s)
+    Local.type_check(nil, s, String)
+    TaskResult.new
+  end
+
+  def add_block(text)
+    Local.type_check(nil, text, String)
+    TaskResult.new
+  end
+end
+
+def edit_config(path)
+  Local.type_check(nil, path, String)
+  h = ConfigBlockHandler.new
+  h.path = path
+  yield h
+  TaskResult.new
+end
+
+def service_reload(name)
+  Local.type_check(nil, name, String, Symbol)
+end
+
+def service_restart(name)
+  Local.type_check(nil, name, String, Symbol)
+end
+
+def create_user(name, create_home:, shell:)
+  Local.type_check(nil, name, String, Symbol)
+  Local.type_check(:create_home, create_home, TrueClass, FalseClass)
+  Local.type_check(:shell, shell, String)
+  TaskResult.new
+end
+
+def authorize_ssh_key(user:, key:)
+  Local.type_check(:user, user, String, Symbol)
+  Local.type_check(:key, key, String, LocalFile)
+  TaskResult.new
+end
+
+def apt_update
+end
+
+def apt_install(names)
+  Local.type_check(nil, names, String, Symbol, Array)
+  TaskResult.new
+end
+
+def apt_remove(names)
+  Local.type_check(nil, names, String, Symbol, Array)
+  TaskResult.new
+end
+
+def command(cmd, expect_status: 0)
+  Local.type_check(nil, cmd, String, Symbol, Array)
+  Local.type_check(:expect_status, expect_status, Integer, Array, Range)
+  TaskResult.new
+end
+
+def create_config(path, text)
+  Local.type_check(1, path, String)
+  Local.type_check(2, text, String)
+  TaskResult.new
+end
+
+def mkdir_p(x)
+  Local.type_check(nil, x, String, Symbol, Array)
+  TaskResult.new
+end
+
+def cp(src, dst, mode: nil)
+  Local.type_check(1, src, String, LocalFile)
+  Local.type_check(1, dst, String)
+  if mode
+    Local.type_check(:mode, mode, String, Integer)
+    Local.check_mode mode
+  end
+  TaskResult.new
+end
+
+def chmod(mode, path)
+  Local.type_check(2, path, String)
+  if mode
+    Local.type_check(:mode, mode, String, Integer)
+    Local.check_mode mode
+  end
+  TaskResult.new
+end
+
+def ln_s(src, dst)
+  Local.type_check(1, src, String)
+  Local.type_check(2, dst, String)
+  TaskResult.new
+end
+
+def block
+  yield
+end
+
+def as(user, group: nil)
+  Local.die 'nested "as" blocks are not supported' if Local.as_user_block
+  Local.type_check(nil, user, String, Symbol)
+  Local.type_check(nil, group, String, Symbol) if group
+  Local.as_user_block = true
+  begin
+    yield
+  ensure
+    Local.as_user_block = false
+  end
+end
+
+def remote_file(path)
+  Local.type_check(nil, path, String)
+  UndefinedOnLocal.new
+end
+
+class UndefinedOnLocal
+  def to_s
+    "[undefined on local]"
+  end
+  def method_missing(*args)
+    self
+  end
+end
+
+class RemoteFile
+  attr_reader :path
+  def initialize(path)
+    @path = path
+  end
+  def read
+    UndefinedOnLocal.new
+  end
+end
+
+def perform!
+  Local.perform!
+end
+
+# Monkey-patching
+
+class Array
+  def afterwards
+    yield
+  end
+end

data/remote/hatecf.rb

@@ -0,0 +1 @@
+require File.join(__dir__, "./remote_dsl.rb")

data/remote/remote.rb

@@ -0,0 +1,498 @@
+module Remote
+  extend self
+
+  # $HOME variable should be imported from local machine
+  # in order to access ~/ paths
+  # and directory of scrip should be imported
+  # in order to access relative ./ paths
+  attr_accessor :local_home, :local_script_dir
+
+  class LocalFile
+    attr_reader :local_path
+    def initialize(local_path)
+      @local_path = local_path
+    end
+
+    def remote_path
+      raise "local home wasn't set!" if Remote.local_home.nil?
+      # Temporary swapping $HOME for File.expand_path
+      t_home = ENV["HOME"]
+      begin
+        $stdout.flush
+        ENV["HOME"] = Remote.local_home
+        # File.expand_path("~/dir") -> "/home/user/dir"
+        # File.expand_path("~/dir", "/whatever") -> "/home/user/dir" anyway
+        # File.expand_path("./dir", "/specific") -> "/specific/dir"
+        # File.join('/specific', '/absolute') -> "/specific/absolute"
+        r = File.join(__dir__, "local_files", File.expand_path(local_path, Remote.local_script_dir))
+      ensure
+        ENV["HOME"] = t_home
+      end
+      return r
+    end
+  end
+
+  attr_accessor :block_contexts
+  @block_contexts = []
+
+  class TaskResult
+    attr_reader :changed
+    def initialize(changed)
+      @changed = changed
+      # propagating change to the block above
+      Remote.block_contexts[-1] = Remote.block_contexts[-1] || changed unless Remote.block_contexts[-1].nil?
+    end
+    def afterwards(&block)
+      if @changed
+        yield
+      end
+    end
+  end
+
+  class ConfigBlockHandler
+    attr_reader :changed
+    def initialize(path, handler)
+      @path = path
+      @handler = handler
+      @changed = false
+    end
+
+    def replace_or_add_line(a, b)
+      task_result = Remote.task do
+        b = b.strip
+        content = File.read(@handler)
+        case a # force to one line
+        when String
+          a_regexp = /^#{Regexp.quote(a)}$/
+        when Regexp
+          a_regexp = /^#{a}$/
+        end
+        if content.match /^#{Regexp.quote(b)}$/
+          Remote.ok "#{@path} config includes #{b.inspect}"
+        else
+          a_match = content.match(a_regexp)
+          if a_match
+            Remote.destructive "replacing in config #{@path} line #{a_match[0].inspect} with #{b.inspect}" do
+              @handler.truncate(0)
+              @handler.write(content.gsub(a_regexp, b))
+            end
+          else # appending
+            Remote.destructive "appending config #{@path} with #{b.inspect}" do
+              @handler.seek(-1, IO::SEEK_END) if @handler.size > 0
+              @handler.write("\n")
+              @handler.write(b)
+              @handler.write("\n")
+            end
+          end
+        end
+        @handler.seek(0, IO::SEEK_SET) # rewind handler back
+      end
+      @changed = @changed || task_result.changed # propagate to block
+    end
+
+    def add_line(line)
+      task_result = Remote.task do
+        line = line.strip
+        content = File.read(@handler)
+        if content.include? line
+          Remote.ok "#{@path} config includes #{line}"
+        else
+            Remote.destructive "appending config #{@path} with #{b.inspect}" do
+              @handler.seek(-1, IO::SEEK_END) if @handler.size > 0
+              @handler.write("\n")
+              @handler.write(b)
+              @handler.write("\n")
+            end
+        end
+        @handler.seek(0, IO::SEEK_SET) # rewind handler back
+      end
+      @changed = @changed || task_result.changed # propagate to block
+
+    end
+
+    def add_block(text)
+      task_result = Remote.task do
+        content = File.read(@handler)
+        if content.include? text.strip
+          Remote.ok "config #{@path} includes the block of text"
+        else
+          Remote.destructive "appending config #{@path} with the block of text" do
+            @handler.seek(-1, IO::SEEK_END) if @handler.size > 0
+            @handler.write("\n")
+            @handler.write(text)
+          end
+        end
+        @handler.seek(0, IO::SEEK_SET) # rewind handler back
+      end
+      @changed = @changed || task_result.changed # propagate to block
+    end
+  end
+
+  def service_reload(name)
+    destructive "reloading service #{name}" do
+      cmd = ["systemctl", "reload", name]
+      spawn(cmd, expect_status: 0)
+    end
+  end
+
+  def service_restart(name)
+    destructive "restarting service #{name}" do
+      cmd = ["systemctl", "restart", name]
+      spawn(cmd, expect_status: 0)
+    end
+  end
+
+  require 'etc'
+  def user_exists?(name)
+    begin
+      Etc.getpwnam(name)
+      true
+    rescue
+      false
+    end
+  end
+
+  def get_user_home_dir(name)
+    Etc.getpwnam(name).dir
+  end
+
+  def get_uid_and_gid_of_user(name)
+    r = Etc.getpwnam(name).dir
+    [r.uid, r.gid]
+  end
+
+  def create_user(name, create_home, shell)
+    if user_exists?(name)
+      ok "#{name} user exists"
+    else
+      destructive "creating user #{name}" do
+        cmd = ["useradd", name]
+        cmd << "--create-home" if create_home
+        cmd << "--shell" << shell if shell
+        spawn cmd, expect_status: 0
+      end
+    end
+  end
+
+  def authorize_ssh_key(user, key)
+    case key
+    when LocalFile
+      key_text = File.read(key.remote_path).strip
+    when String
+      key_text = key
+    else
+      raise "type #{key.class} is not supported for a SSH public key"
+    end
+    require 'fileutils'
+    home_dir = get_user_home_dir(user)
+    ssh_dir = File.join(home_dir, ".ssh")
+    authorized_keys_path = File.join(ssh_dir, "authorized_keys")
+    if File.exist? authorized_keys_path
+      file_mode = @dry_run ? File::RDONLY : File::RDWR | File::APPEND
+      File.open(authorized_keys_path, file_mode, 0600) do |f|
+        f.flock(File::LOCK_EX)
+        content = File.read(f)
+        if content.include? key_text
+          ok "#{authorized_keys_path} has the key"
+        else
+          destructive "appending key to #{authorized_keys_path}" do
+            f.seek(-1, IO::SEEK_END) if f.size > 0
+            f.write(key_text)
+            f.write("\n")
+          end
+        end
+      end
+    else
+      unless File.exist? ssh_dir
+        destructive "creating #{ssh_dir}" do
+          FileUtils.mkdir ssh_dir, mode: 0700
+          File.chown(*(get_uid_and_gid_of_user(user) << ssh_dir))
+        end
+      end
+      destructive "creating #{authorized_keys_path} with the key" do
+        File.open(authorized_keys_path, File::CREAT | File::WRONLY, 0600) do |f|
+          f.flock(File::LOCK_EX)
+          f.write(key_text)
+          f.write("\n")
+        end
+        File.chown(*(get_uid_and_gid_of_user(user) << authorized_keys_path))
+      end
+    end
+  end
+
+  attr_accessor :apt_updated
+  def dpkg_installed?(names)
+    #            | virtual | virtual | removed
+    #            | package | package | but
+    #            | present | absent  | dependency
+    #     method |         |         | left
+    # ----------------------------------------
+    #    dpkg -s | exit 1  | exit 1  | exit 1
+    # ----------------------------------------
+    # dpkg-qeury | exit 0  | exit 1  | exit 0
+    #         -W |         |         |
+    case names
+    when Array
+      cmd = ["dpkg-query", "-W"] + names
+    when String
+      cmd = ["dpkg-query", "-W", names]
+    end
+    spawn(cmd, expect_status: [0,1]) == 0
+  end
+
+  def apt_update
+    task do
+      destructive "apt-get update" do
+        spawn ["apt-get", "update", "-q"], expect_status: 0
+      end
+    end
+  end
+
+  def apt_install(names)
+    names = names.to_s if names.is_a? Symbol
+    names = names.split(/\s+/).map(&:strip).select{|x|not x.empty?} if names.is_a? String
+    if dpkg_installed?(names)
+      ok "installed: #{names.join(', ')}"
+    else
+      destructive "apt-get install #{names.is_a?(Array) ? names.join(' ') : names}" do
+        unless apt_updated
+          cmd = ["apt-get", "update", "-q"]
+          spawn(cmd, expect_status: 0)
+          apt_updated = true
+        end
+
+        cmd = ["apt-get", "install", "--no-install-recommends", "-y"]
+        cmd += names
+        spawn(cmd, expect_status: 0)
+      end
+    end
+  end
+
+  def apt_remove(names)
+    names = names.to_s if names.is_a? Symbol
+    names = names.split(/\s+/).map(&:strip).select{|x|not x.empty?} if names.is_a? String
+    installed = names.each.select do |x|
+      dpkg_installed? x
+    end
+    if installed.empty?
+      ok "removed: #{names.join(", ")}"
+    else
+      installed.each do |name|
+        destructive "apt-get remove #{name}" do
+          cmd = ["apt-get", "remove", "-y"]
+          cmd += names
+          spawn cmd, expect_status: 0
+        end
+      end
+      # We need to run autoremove because dpkg treat
+      # removed packages with installed dependencies
+      # as still installed. See the note in "dpkg_installed?"
+      # method
+      destructive "apt-get autoremove" do
+        spawn ["apt-get", "autoremove", "-y"], expect_status: 0
+      end
+    end
+  end
+
+  def create_config(path, text)
+    path = File.expand_path path
+    unless File.exist?(path) && File.read(path).rstrip == text
+      destructive "writing config #{path}" do
+        File.open(path, File::CREAT | File::TRUNC | File::WRONLY) do |f|
+          f.flock(File::LOCK_EX)
+          f.write(text)
+          f.write("\n")
+        end
+      end
+    else
+      ok "#{path} already there"
+    end
+  end
+
+  class RemoteFile
+    attr_reader :path
+    def initialize(path)
+      @path = path
+    end
+    def read
+      File.read(@path)
+    end
+  end
+
+  def mkdir_p(x)
+    x = File.expand_path x
+    if File.directory? x
+      ok "#{x} directory exists"
+    else
+      destructive "mkdir -p #{x}" do
+        FileUtils.mkdir_p x
+      end
+    end
+  end
+
+  # TODO: the dst is a dir case
+  def cp(src, dst, mode)
+    src = src.remote_path if src.is_a? LocalFile
+    dst = File.expand_path dst
+    if (not File.exist?(dst)) || (not FileUtils.cmp(src, dst))
+      destructive "copying to #{dst.inspect}" do
+        FileUtils.cp src, dst
+      end
+    else
+      ok "#{dst} already there"
+    end
+    if mode
+      mode = mode.to_i(8) if mode.is_a? String
+      if File.stat(dst).mode % 010000 == mode
+        ok "#{dst} already in #{sprintf "%04o", mode}"
+      else
+        destructive "chmod #{sprintf "%04o", mode} #{dst}" do
+          File.chmod(mode, dst)
+        end
+      end
+    end
+  end
+
+  def chmod(mode, path)
+    mode = mode.to_i(8) if mode.is_a? String
+    path = File.expand_path path
+    if File.stat(path).mode % 010000 == mode
+      ok "#{path} already in #{sprintf "%04o", mode}"
+    else
+      destructive "chmod #{sprintf "%04o", mode} #{path}" do
+        File.chmod(mode, path)
+      end
+    end
+  end
+
+  def ln_s(src, dst)
+    src = File.expand_path src
+    dst = File.expand_path dst
+    if File.lstat(dst).symlink? && File.readlink(dst) == src
+      ok "#{dst} leads to #{src}"
+    else
+      destructive "ln -s #{src} #{dst}" do
+        FileUtils.ln_s src dst
+      end
+    end
+  end
+
+  #attr_accessor :impressionating_user
+
+  def spawn(cmd, expect_status: nil)
+    expect_status = [expect_status] unless expect_status.nil? || expect_status.respond_to?(:include?)
+    stdout_r, stdout_w = IO.pipe
+    debug "executing #{cmd.inspect}"
+    pid, status = Process.wait2(Process.spawn(*cmd, in: File::NULL, out: stdout_w, err: stdout_w))
+    if expect_status && (not expect_status.include?(status.exitstatus))
+      stdout_w.close
+      text = stdout_r.read
+      raise CommandError.new("A process #{cmd.inspect} returned unexpected exit status #{status.exitstatus}", text)
+    end
+    stdout_w.close
+    stdout_r.close
+    return status.exitstatus
+  end
+
+  class CommandError < StandardError
+    attr_reader :output
+    def initialize(msg, output)
+      @output = output
+      super(msg)
+    end
+  end
+
+  def ok(s)
+    info "[ ] #{s}"
+  end
+
+  attr_reader :dry_run
+  @dry_run = false
+  def destructive(desc = nil)
+    if desc
+      if @dry_run
+        info "[-] NOT #{desc} [dry run]"
+      else
+        info "[x] #{desc}"
+      end
+    end
+    @task_changed_something = true
+    yield unless @dry_run
+  end
+
+  attr_reader :ok_counter, :changed_counter
+  @ok_counter = @changed_counter = 0
+  def task
+    @task_changed_something = false
+    begin
+      yield
+    rescue => e
+      handle_error e
+    end
+    if @task_changed_something
+      @changed_counter += 1
+    else
+      @ok_counter += 1
+    end
+    TaskResult.new @task_changed_something
+  end
+
+  def handle_error(exc)
+    $stderr.puts
+    #exclude = [
+    #  "hatecf.rb",
+    #  "remote.rb",
+    #]
+    #line = caller.select do |line|
+    #  not exclude.find{|x| line.include? x}
+    #  #$stderr.puts line unless exclude.find{|x| line.include? x}
+    #end.first
+
+    exc.backtrace.each do |line|
+      $stderr.puts line
+    end
+    $stderr.puts
+    $stderr.puts exc.message
+    $stderr.puts
+    if exc.respond_to? :output
+      $stderr.puts exc.output
+      $stderr.puts
+    end
+    exit 1
+  end
+
+  def debug(s)
+  end
+
+  def info(s)
+    $stdout.puts s
+    $stdout.flush
+  end
+
+  require 'json'
+  def save_state
+    JSON.dump({
+      ok_counter: @ok_counter,
+      changed_counter: @changed_counter,
+    })
+  end
+
+  def load_state(json)
+    h = JSON.parse(json, symbolize_names: true)
+    @ok_counter      = h[:ok_counter]
+    @changed_counter = h[:changed_counter]
+  end
+
+  require 'optparse'
+  OptionParser.new do |opts|
+    opts.on "--local-home HOME" do |x|
+      @local_home = x
+    end
+    opts.on "--local-script-dir DIR" do |x|
+      @local_script_dir = x
+    end
+    opts.on "--dry" do |x|
+      @dry_run = true
+    end
+  end.parse!
+end

data/remote/remote_dsl.rb

@@ -0,0 +1,178 @@
+require './remote.rb'
+
+def target(*args)
+  # skip on remote
+end
+
+def local_file(path)
+  Remote::LocalFile.new(path)
+end
+
+def edit_config(path)
+  path = File.expand_path path
+  File.open(path, File::RDWR) do |f|
+    f.flock(File::LOCK_EX)
+    h = Remote::ConfigBlockHandler.new(path, f)
+    yield h
+    return Remote::TaskResult.new(h.changed)
+  end
+end
+
+def service_reload(name)
+  Remote.task do
+    Remote.service_reload(name)
+  end
+end
+
+def service_restart(name)
+  Remote.task do
+    Remote.service_restart(name)
+  end
+end
+
+def create_user(name, create_home: false, shell: nil)
+  Remote.task do
+    Remote.create_user(name, create_home, shell)
+  end
+end
+
+def authorize_ssh_key(user:, key:)
+  Remote.task do
+    Remote.authorize_ssh_key(user, key)
+  end
+end
+
+def apt_update
+  Remote.apt_update
+end
+
+def apt_install(names)
+  Remote.task do
+    Remote.apt_install names
+  end
+end
+
+def apt_remove(names)
+  Remote.task do
+    Remote.apt_remove(names)
+  end
+end
+
+def command(cmd, expect_status: 0)
+  Remote.task do
+    Remote.destructive "executing #{cmd.inspect}" do
+      Remote.spawn(cmd, expect_status: expect_status)
+    end
+  end
+end
+
+def create_config(path, text)
+  Remote.task do
+    Remote.create_config(path, text)
+  end
+end
+
+def mkdir_p(x)
+  Remote.task do
+    Remote.mkdir_p(x)
+  end
+end
+
+def cp(src, dst, mode: nil)
+  Remote.task do
+    Remote.cp(src, dst, mode)
+  end
+end
+
+def chmod(mode, path)
+  Remote.task do
+    Remote.chmod(mode, path)
+  end
+end
+
+def ln_s(src, dst)
+  Remote.task do
+    Remote.ln_s(src, dst)
+  end
+end
+
+def block
+  Remote.block_contexts << false
+  begin
+    yield
+  ensure
+    changed = Remote.block_contexts.pop
+  end
+  Remote::TaskResult.new(changed)
+end
+
+def as(user, group: nil)
+  require 'etc'
+  u = Etc.getpwnam(user)
+  if group
+    g = Etc.getgrnam(group)
+  else
+    begin
+      g = Etc.getgrnam(user)
+    rescue
+    end
+  end
+  rd, wr = IO.pipe # for state
+  child_pid = fork
+  if child_pid # parent
+    wr.close
+    pid, status = Process.wait2(child_pid)
+    if status.exitstatus > 0
+      exit status.exitstatus
+    else
+      Remote.load_state(rd.read)
+      rd.close
+    end
+  else # child
+    rd.close
+    wr.close_on_exec = true
+    #ENV["USER"] = user
+    #ENV["LOGNAME"] = user
+    ENV["HOME"] = u.dir # required at least for File.expand_path
+    Process.gid = Process.egid = g.gid if g
+    Process.uid = Process.euid = u.uid
+    yield
+    wr.write(Remote.save_state)
+    wr.flush
+    wr.close
+    $stdout.flush
+    $stderr.flush
+    exit 0
+  end
+end
+
+def remote_file(path)
+  Remote::RemoteFile.new(path)
+end
+
+def perform!
+  Remote.info "ok: #{Remote.ok_counter}, changed: #{Remote.changed_counter}"
+end
+
+# Monkey-patching
+
+module ArrayExtension
+  @task_result = nil
+  def afterwards(&block)
+    @task_result.afterwards(&block)
+  end
+  def each
+    Remote.block_contexts << false
+    begin
+      r = super
+    ensure
+      changed = Remote.block_contexts.pop
+    end
+    @task_result = Remote::TaskResult.new(changed)
+    return r
+  end
+end
+
+class Array
+  prepend ArrayExtension
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: hatecf
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexander Markov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-12 00:00:00.000000000 Z
+dependencies: []
+description: Configuration management engine like Ansible but without YAML and 30
+  times faster
+email: apshertonets@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bootstrap_ruby
+- lib/hatecf.rb
+- lib/local.rb
+- lib/local_dsl.rb
+- remote/hatecf.rb
+- remote/remote.rb
+- remote/remote_dsl.rb
+homepage: https://github.com/apsheronets/hatecf
+licenses:
+- LGPL-3.0
+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: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: Configuration management powered by hate
+test_files: []