kmx git

require 'time'
load "#{File.dirname(__FILE__)}/rbpkg/log.rb"
load "#{File.dirname(__FILE__)}/rbpkg/repos.rb"

module Rbpkg
  def self.build(repos)
    repos.each do |name|
      Repos.repo(name).build()
    end
  end

  def self.cc
    if system("which cc >/dev/null 2>&1")
      "cc"
    elsif system("which gcc >/dev/null 2>&1")
      "gcc"
    elsif system("which egcc >/dev/null 2>&1")
      "egcc"
    end
  end

  def self.cc!
    r = cc()
    raise "C compiler not found" unless r
    r
  end

  def self.checkout(branch, repos)
    repos.each do |name|
      Repos.repo(name).checkout(branch)
    end
  end

  def self.ci_dir
    "#{dir}/ci"
  end

  def self.ci_build_dir
    "#{ci_dir}/build"
  end

  def self.ci_init
    [ci_dir,
     ci_build_dir,
     ci_log_dir,
     ci_status_dir
    ].each do |d|
      cmd! "mkdir -p #{sh_quote(d)}"
    end
  end

  def self.ci_log_dir
    "#{ci_dir}/log/#{os}/#{target}/#{date}_#{$$}"
  end

  def self.ci_remote(repo, branch, commit, host)
    verbose(3, "Rbpkg.ci_remote(#{repo.inspect}, #{branch.inspect}, #{commit.inspect}, #{host.inspect})")
    sh_host = sh_quote(host)
    cmd! "ssh #{sh_host} rbpkg/bin/rbpkg_ci #{sh_quote(repo)} #{sh_quote(branch)} #{sh_quote(commit)}"
    sh_ci_dir = sh_quote(ci_dir)
    cmd! "rsync -a #{sh_host}:#{sh_ci_dir}/. #{sh_ci_dir}"
  end

  def self.ci_status_dir
    "#{ci_dir}/status/#{os}/#{target}/#{date}_#{$$}"
  end

  def self.clean_all(repos)
    repos.each do |name|
      Repos.repo(name).clean_all()
    end
  end

  def self.clean_build(repos)
    repos.each do |name|
      Repos.repo(name).clean_build()
    end
  end

  def self.clean_configure(repos)
    repos.each do |name|
      Repos.repo(name).clean_configure()
    end
  end

  def self.clean_fake(repos)
    repos.each do |name|
      Repos.repo(name).clean_fake()
    end
  end

  def self.clean_package(repos)
    repos.each do |name|
      Repos.repo(name).clean_package()
    end
  end

  def self.clean_sources(repos)
    repos.each do |name|
      Repos.repo(name).clean_sources()
    end
  end

  def self.configure(repos)
    repos.each do |name|
      Repos.repo(name).configure()
    end
  end

  @@date = nil
  def self.date
    @@date || @@date = Time.now.utc.iso8601
  end

  @@dir = nil
  def self.dir
    @@dir || @@dir = (ENV["RBPKG_DIR"] || "#{ENV["HOME"]}/rbpkg")
  end

  def self.ensure_dir(path)
    if ! File.directory?(path)
      cmd! "mkdir -p #{sh_quote(path)}"
    end
  end

  def self.fake(repos)
    repos.each do |name|
      Repos.repo(name).fake()
    end
  end

  def self.fake_dir
    "#{target_dir}/fake"
  end

  def self.fetch(repos)
    repos.each do |name|
      Repos.repo(name).fetch()
    end
  end

  def self.git_clone(repos)
    repos.each do |name|
      Repos.repo(name).git_clone()
    end
  end

  def self.info(repos)
    global_info = inspect()
    $log.puts global_info
    puts global_info
    repos.each do |name|
      repo_info = Repos.repo(name).inspect()
      $log.puts repo_info
      puts repo_info
    end
  end

  def self.init(name, verbose_level, log_dir)
    @@verbose_level = verbose_level
    [dir,
     lock_dir,
     log_dir
    ].each do |d|
      FileUtils.mkdir_p(d)
    end
    $log = Rbpkg::Log
    Rbpkg::Log.init(log_dir, name)
    Rbpkg.lock(name)
  end

  def self.inspect
    """%Rbpkg{
 CC: #{cc.inspect},
 dir: #{dir.inspect},
 ncpu: #{ncpu.inspect},
 sha256: #{sha256.inspect},
 target: #{target.inspect}
}"""
  end

  def self.install(repos)
    repos.each do |name|
      Repos.repo(name).install()
    end
  end

  def self.installed_dir
    "#{dir}/var/db/installed"
  end

  def self.lib_dir
    "#{dir}/lib"
  end

  def self.lock(name)
    path = lock_path(name)
    verbose(3, "Locking #{path}")
    while File.file?(path)
      sleep 1000.ms
    end
    File.write(path, "")
    at_exit { FileUtils.rm(path) }
  end

  def self.lock_dir
    "#{dir}/var/lock"
  end

  def self.lock_path(name)
    "#{lock_dir}/#{name}.lock"
  end

  def self.log_dir
    "#{dir}/var/log/rbpkg/#{date}_#{$$}"
  end

  @@ncpu = nil
  def self.ncpu
    @@ncpu || @@ncpu = self.ncpu_fetch
  end

  def self.ncpu_fetch
    `which nproc >/dev/null 2>&1 && nproc || which sysctl >/dev/null 2>&1 && sysctl -n hw.ncpu || echo 1`.strip.to_i
  end

  def self.obj_dir
    "#{target_dir}/obj"
  end

  @@os = nil
  def self.os
    os_fetch unless @@os
    @@os
  end

  @@os_dir = nil
  def self.os_dir
    os_fetch unless @@os_dir
    @@os_dir
  end

  def self.os_fetch
    uname = `uname`.strip
    raise "uname failed" unless $?.success?
    if uname == "Linux"
      distrib = `uname -a | grep -io -e Debian -e gentoo -e Ubuntu | sed -e 's|gentoo|Gentoo|'`
      @@os_dir = "#{uname}/#{distrib}"
      @@os = "#{uname}_#{distrib}"
    else
      @@os = uname
      @@os_dir = uname
    end
  end

  def self.package(repos)
    repos.each do |name|
      Repos.repo(name).package()
    end
  end

  def self.package_dir
    "#{target_dir}/package"
  end

  def self.prefix
    dir
  end

  def self.pull(repos)
    repos.each do |name|
      Repos.repo(name).pull()
    end
  end

  @@sha256 = nil
  def self.sha256
    @@sha256 || @@sha256 = if system("which sha256 >/dev/null 2>&1")
                             "sha256"
                           elsif system("which sha256sum >/dev/null 2>&1")
                             "sha256sum"
                           else
                             raise "sha256 executable not found"
                           end
  end

  def self.sha256_file(path)
    c = "#{sh_quote(sha256)} #{sh_quote(path)}"
    r = `#{c}`
    raise "#{sha256} #{path.inspect} failed" unless $?.success?
    if r.match?(/^SHA256 \(/)
      r
    else
      part = r.split(' ')
      "SHA256 (#{part[1]}) = #{part[0]}"
    end
  end

  def self.src_dir
    "#{dir}/src"
  end

  def self.tag_dir
    "#{target_dir}/tag"
  end

  @@target = nil
  def self.target
    @@target || @@target = `LC_ALL=C.UTF-8 #{sh_quote(cc!)} -v 2>&1 | grep '^Target: ' | head -n 1 | cut -c 9-`.strip
  end

  def self.target_dir
    "#{dir}/target/#{target}"
  end

  def self.test(repos)
    repos.each do |name|
      Repos.repo(name).test()
    end
  end

  def self.uninstall(repos)
    repos.each do |name|
      Repos.repo(name).uninstall()
    end
  end

  def self.upgrade(repos)
    upgrade_self
    repos.each do |name|
      Repos.repo(name).upgrade()
    end
  end

  def self.upgrade_self
    verbose 3, "Rbpkg.upgrade_self"
    cmd! "cd #{sh_quote(dir)} && git pull"
    load "#{dir}/lib/rbpkg.rb"
  end

  def self.verbose_level
    @@verbose_level
  end
end

def cmd(string)
  verbose(1, string)
  IO.popen("#{string} 2>&1", "r") do |pipe|
    while line = pipe.gets()
      $log.puts line
      puts line if Rbpkg.verbose_level > 1
    end
    pipe.close
    $?.success?
  end
end

def cmd!(string)
  r = cmd(string)
  raise "command failed: #{string}" unless r
  true
end

def sh_quote(str)
  if str.scan("\n") == [] && str.match?(/^[-+\/=.,:^_0-9A-Za-z]*$/)
    str
  else
    "\"" + str.gsub(/([$`\\\"])/, "\\\1") + "\""
  end
end
      
def verbose(level, msg)
  colored = case level
            when -1
              "\33[0;31m#{msg}\33[0m\n"
            when 0
              msg
            when 1
              "\33[0;34m#{msg}\33[0m\n"
            when 3
              "\33[0;35m#{msg}\33[0m\n"
            else
              raise "unknown verbose level: #{level.inspect}"
            end
  $log.puts colored
  STDOUT.puts colored if level <= Rbpkg.verbose_level
end
kmx.io/rbpkg/lib/rbpkg.rb

Commit

lib/rbpkg.rb
