akabei 0.1.0

data/lib/akabei/chroot_tree.rb

@@ -0,0 +1,81 @@
+require 'akabei/attr_path'
+require 'akabei/error'
+require 'pathname'
+require 'tmpdir'
+
+module Akabei
+  class ChrootTree
+    class CommandFailed < Error
+      attr_reader :args
+      def initialize(args)
+        super("command failed: #{args.join(' ')}")
+        @args = args
+      end
+    end
+
+    extend AttrPath
+    attr_path_accessor :makepkg_config, :pacman_config
+
+    def initialize(root, arch)
+      @root = root && Pathname.new(root)
+      @arch = arch
+    end
+
+    BASE_PACKAGES = %w[base base-devel sudo]
+
+    def with_chroot(&block)
+      if @root
+        mkarchroot(*BASE_PACKAGES)
+        block.call
+      else
+        @root = Pathname.new(Dir.mktmpdir)
+        begin
+          mkarchroot(*BASE_PACKAGES)
+          block.call
+        ensure
+          execute('rm', '-rf', @root.to_s)
+          @root = nil
+        end
+      end
+    end
+
+    def makechrootpkg(dir, env)
+      execute('makechrootpkg', '-cur', @root.to_s, chdir: dir, env: env)
+    end
+
+    def mkarchroot(*args)
+      cmd = ['mkarchroot']
+      [['-M', makepkg_config], ['-C', pacman_config]].each do |flag, path|
+        if path
+          cmd << flag << path.to_s
+        end
+      end
+      cmd << @root.join('root').to_s
+      execute(*(cmd + args))
+    end
+
+    def arch_nspawn(*args)
+      execute('arch-nspawn', @root.join('root').to_s, *args)
+    end
+
+    def execute(*args)
+      if args.last.is_a?(Hash)
+        opts = args.last
+        if opts.has_key?(:env)
+          opts = opts.dup
+          env = opts.delete(:env)
+          env.each do |k, v|
+            args.unshift("#{k}=#{v}")
+          end
+          args.unshift('env')
+          args[-1] = opts
+        end
+      end
+
+      puts "Execute: #{args.join(' ')}"
+      unless system('sudo', 'setarch', @arch, *args)
+        raise CommandFailed.new(args)
+      end
+    end
+  end
+end

data/lib/akabei/cli.rb

@@ -0,0 +1,172 @@
+require 'akabei/abs'
+require 'akabei/builder'
+require 'akabei/chroot_tree'
+require 'akabei/package'
+require 'akabei/repository'
+require 'akabei/signer'
+require 'pathname'
+require 'thor'
+require 'tmpdir'
+
+module Akabei
+  class CLI < Thor
+    module CommonOptions
+      COMMON_OPTIONS = {
+        repo_key: {
+          desc: 'GPG key to sign repository database',
+          banner: 'GPGKEY',
+          type: :string
+        },
+        repo_name: {
+          desc: 'Name of the repository',
+          banner: 'NAME',
+          type: :string,
+          required: true,
+        },
+        srcdest: {
+          desc: 'Path to the directory to store sources',
+          banner: 'FILE',
+          type: :string,
+        },
+      }.freeze
+
+      def common_options(*opts)
+        opts.each do |opt|
+          unless COMMON_OPTIONS.has_key?(opt)
+            raise "No such common option: #{opt}"
+          end
+          option(opt, COMMON_OPTIONS[opt])
+        end
+      end
+    end
+    extend CommonOptions
+
+    desc 'build DIR', 'Build package in chroot environment'
+    option :chroot_dir,
+      desc: 'Path to chroot top',
+      banner: 'DIR',
+      type: :string
+    option :makepkg_config,
+      desc: 'Path to makepkg.conf used in chroot',
+      banner: 'FILE',
+      type: :string
+    option :pacman_config,
+      desc: 'Path to pacman.conf used in chroot',
+      banner: 'FILE',
+      type: :string
+    option :package_key,
+      desc: 'GPG key to sign packages',
+      banner: 'GPGKEY',
+      type: :string
+    option :logdest,
+      desc: 'Path to the directory to store logs',
+      banner: 'FILE',
+      type: :string
+    option :repo_dir,
+      desc: 'Path to the repository',
+      banner: 'DIR',
+      type: :string,
+      required: true
+    option :arch,
+      desc: 'Archtecture',
+      banner: 'ARCH',
+      enum: %w[i686 x86_64],
+      required: true
+    common_options :repo_name, :repo_key, :srcdest
+    def build(package_dir)
+      chroot = ChrootTree.new(options[:chroot_dir], options[:arch])
+      if options[:makepkg_config]
+        chroot.makepkg_config = options[:makepkg_config]
+      end
+      if options[:pacman_config]
+        chroot.pacman_config = options[:pacman_config]
+      end
+
+      repo_db = Repository.new
+      repo_db.signer = options[:repo_key] && Signer.new(options[:repo_key])
+      repo_files = Repository.new
+      repo_files.include_files = true
+
+      builder = Builder.new
+      builder.signer = options[:package_key] && Signer.new(options[:package_key])
+      builder.srcdest = options[:srcdest]
+      builder.logdest = options[:logdest]
+
+      repo_path = Pathname.new(options[:repo_dir])
+      repo_name = options[:repo_name]
+      builder.pkgdest = repo_path
+
+      db_path = repo_path.join("#{repo_name}.db")
+      files_path = repo_path.join("#{repo_name}.files")
+      repo_db.load(db_path)
+      repo_files.load(files_path)
+
+      abs = Abs.new(repo_path.join("#{repo_name}.abs.tar.gz"), repo_name)
+
+      chroot.with_chroot do
+        packages = builder.build_package(package_dir, chroot)
+        packages.each do |package|
+          repo_db.add(package)
+          repo_files.add(package)
+        end
+        abs.add(package_dir, builder)
+        repo_db.save(db_path)
+        repo_files.save(files_path)
+      end
+    end
+
+    desc 'abs-add DIR ABS_TARBALL', 'Add the package inside DIR to ABS_TARBALL'
+    common_options :repo_name, :srcdest
+    def abs_add(package_dir, abs_path)
+      builder = Builder.new
+      builder.srcdest = options[:srcdest]
+      abs = Abs.new(abs_path, options[:repo_name])
+      abs.add(package_dir, builder)
+    end
+
+    desc 'abs-remove PKG_NAME ABS_TARBALL', 'Remove PKG_NAME from ABS_TARBALL'
+    common_options :repo_name
+    def abs_remove(package_name, abs_path)
+      abs = Abs.new(abs_path, options[:repo_name])
+      abs.remove(package_name)
+    end
+
+    desc 'repo-add PACKAGE_PATH REPOSITORY_DB', 'Add PACKAGE_PATH to REPOSITORY_DB'
+    common_options :repo_key
+    def repo_add(package_path, db_path)
+      repo = Repository.new
+      repo.signer = options[:repo_key] && Signer.new(options[:repo_key])
+      repo.load(db_path)
+      repo.add(Package.new(package_path))
+      repo.save(db_path)
+    end
+
+    desc 'repo-remove PACKAGE_NAME REPOSITORY_DB', 'Remove PACKAGE_NAME from REPOSITORY_DB'
+    common_options :repo_key
+    def repo_remove(package_name, db_path)
+      repo = Repository.new
+      repo.signer = options[:repo_key] && Signer.new(options[:repo_key])
+      repo.load(db_path)
+      repo.remove(package_name)
+      repo.save(db_path)
+    end
+
+    desc 'files-add PACKAGE_PATH FILES_DB', 'Add PACKAGE_PATH to FILES_DB'
+    def files_add(package_path, db_path)
+      repo = Repository.new
+      repo.include_files = true
+      repo.load(db_path)
+      repo.add(Package.new(package_path))
+      repo.save(db_path)
+    end
+
+    desc 'files-remove PACKAGE_NAME FILES_DB', 'Remove PACKAGE_NAME from FILES_DB'
+    def files_remove(package_name, db_path)
+      repo = Repository.new
+      repo.include_files = true
+      repo.load(db_path)
+      repo.remove(package_name)
+      repo.save(db_path)
+    end
+  end
+end

data/lib/akabei/error.rb

@@ -0,0 +1,4 @@
+module Akabei
+  class Error < StandardError
+  end
+end

data/lib/akabei/package.rb

@@ -0,0 +1,174 @@
+require 'akabei/archive_utils'
+require 'akabei/error'
+require 'akabei/package_entry'
+require 'akabei/package_info'
+require 'base64'
+require 'digest'
+
+module Akabei
+  class Package
+    class NotFound < Akabei::Error
+      attr_reader :path, :archive
+
+      def initialize(archive, path)
+        super("#{path} is not found in #{archive}")
+        @path = path
+        @archive = archive
+      end
+    end
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = Pathname.new(path)
+    end
+
+    def pkginfo
+      @pkginfo ||= extract_pkginfo
+    end
+
+    def extract_pkginfo
+      ArchiveUtils.each_entry(@path.to_s) do |entry, archive|
+        if entry.pathname == '.PKGINFO'
+          return PackageInfo.parse(archive.read_data)
+        end
+      end
+      raise NotFound.new(@path, '.PKGINFO')
+    end
+
+    def db_name
+      "#{pkgname}-#{pkgver}"
+    end
+
+    def csize
+      @path.size
+    end
+
+    def isize
+      pkginfo.size
+    end
+
+    def md5sum
+      @md5sum ||= compute_checksum('MD5')
+    end
+
+    def sha256sum
+      @sha256sum ||= compute_checksum('SHA256')
+    end
+
+    def compute_checksum(algo)
+      Digest(algo).file(@path).hexdigest
+    end
+
+    %w[
+      pkgname
+      pkgver
+      pkgbase
+      pkgdesc
+      url
+      license
+      arch
+      builddate
+      packager
+      replaces
+
+      provides
+    ].each do |attr|
+      define_method(attr) do
+        pkginfo.public_send(attr)
+      end
+    end
+
+    %w[
+      group
+      depend
+      conflict
+      optdepend
+      makedepend
+      checkdepend
+    ].each do |attr|
+      define_method("#{attr}s") do
+        pkginfo.public_send(attr)
+      end
+    end
+
+    def filename
+      @path.basename.to_s
+    end
+
+    def name
+      pkginfo.pkgname
+    end
+
+    def base
+      pkginfo.pkgbase
+    end
+
+    def version
+      pkginfo.pkgver
+    end
+
+    def desc
+      pkginfo.pkgdesc
+    end
+
+    def pgpsig
+      sig_file = @path.parent.join("#{filename}.sig")
+      if sig_file.readable?
+        Base64.strict_encode64(sig_file.binread)
+      end
+    end
+
+    def files
+      xs = []
+      ArchiveUtils.each_entry(@path) do |entry|
+        unless entry.pathname.start_with?('.')
+          xs << entry.pathname
+        end
+      end
+      xs.sort
+    end
+
+    def to_entry
+      entry = PackageEntry.new
+      %w[
+        filename
+        name
+        base
+        version
+        desc
+        groups
+        csize
+        isize
+
+        md5sum
+        sha256sum
+
+        pgpsig
+
+        url
+        license
+        builddate
+        packager
+        replaces
+
+        provides
+        optdepends
+        makedepends
+        checkdepends
+
+        files
+      ].each do |attr|
+        val = send(attr)
+        if val.is_a?(Array)
+          val.each do |v|
+            entry.add(attr, v)
+          end
+        else
+          entry.add(attr, val)
+        end
+      end
+      entry
+    end
+  end
+end

data/lib/akabei/package_entry.rb

@@ -0,0 +1,110 @@
+require 'akabei/error'
+
+module Akabei
+  class PackageEntry
+    ARRAY_DESC_ATTRIBUTES = %w[
+      groups
+      license
+      replaces
+    ].freeze
+    DESC_ATTRIBUTES = %w[
+      filename
+      name
+      base
+      version
+      desc
+      csize
+      isize
+      md5sum
+      sha256sum
+      pgpsig
+      url
+      arch
+      builddate
+      packager
+    ].freeze
+    ARRAY_DEPENDS_ATTRIBUTES = %w[
+      depends
+      conflicts
+      provides
+      optdepends
+      makedepends
+      checkdepends
+    ].freeze
+    ARRAY_FILES_ATTRIBUTES = %w[files].freeze
+
+    ARRAY_ATTRIBUTES = (ARRAY_DESC_ATTRIBUTES + ARRAY_DEPENDS_ATTRIBUTES + ARRAY_FILES_ATTRIBUTES).freeze
+
+    attr_reader *ARRAY_ATTRIBUTES
+    attr_reader *DESC_ATTRIBUTES
+
+    def initialize
+      ARRAY_ATTRIBUTES.each do |key|
+        instance_variable_set("@#{key}", [])
+      end
+    end
+
+    def add(key, val)
+      ivar = "@#{key}".intern
+      if ARRAY_ATTRIBUTES.include?(key)
+        instance_variable_get(ivar) << val
+      elsif DESC_ATTRIBUTES.include?(key)
+        if v = instance_variable_get(ivar)
+          raise Error.new("Multiple entry found: #{v} and #{val}")
+        else
+          instance_variable_set(ivar, val)
+        end
+      else
+        raise Error.new("Unknown entry key: #{key}")
+      end
+    end
+
+    def ==(other)
+      (ARRAY_ATTRIBUTES + DESC_ATTRIBUTES).all? do |attr|
+        public_send(attr) == other.public_send(attr)
+      end
+    end
+
+    def write_desc(io)
+      ARRAY_DESC_ATTRIBUTES.each do |attr|
+        write_array(io, attr)
+      end
+
+      DESC_ATTRIBUTES.each do |attr|
+        write_string(io, attr)
+      end
+    end
+
+    def write_depends(io)
+      ARRAY_DEPENDS_ATTRIBUTES.each do |attr|
+        write_array(io, attr)
+      end
+    end
+
+    def write_files(io)
+      unless write_array(io, 'files')
+        warn 'WARNING: files attribute is empty.'
+      end
+    end
+
+    def write_array(io, attr)
+      arr = instance_variable_get("@#{attr}")
+      unless arr.empty?
+        write_entry(io, attr, arr)
+      end
+    end
+
+    def write_string(io, attr)
+      if v = instance_variable_get("@#{attr}")
+        write_entry(io, attr, v)
+      end
+    end
+
+    def write_entry(io, attr, val)
+      io.puts "%#{attr.upcase}%"
+      io.puts val
+      io.puts
+      true
+    end
+  end
+end