buildizer 0.0.6 → 0.0.7

data/lib/buildizer/builder/native.rb

@@ -9,10 +9,9 @@ module Buildizer
         Target::Native
       end
 
-      def initial_target_params
-        super.tap do |params|
-          params[:package_version] = packager.package_version_tag
-        end
+      def check_params!(params)
+        super
+        _required_params! :package_version, params
       end
 
       def build_instructions(target)

data/lib/buildizer/builder/patch.rb

@@ -0,0 +1,40 @@
+module Buildizer
+  module Builder
+    class Patch < Base
+      def build_type
+        'patch'
+      end
+
+      def target_klass
+        Target::Patch
+      end
+
+      def initial_target_params
+        super.tap do |params|
+          params[:patch] = Array(packager.buildizer_conf['patch'])
+          params[:patch_version] = packager.buildizer_conf['patch_version']
+        end
+      end
+
+      def do_merge_params(into, params)
+        super.tap do |res|
+          res[:patch] = (into[:patch] + Array(params['patch'])).uniq
+          res[:patch_version] = into[:patch_version] || params['patch_version']
+        end
+      end
+
+      def check_params!(params)
+        super
+        _required_params! :patch_version, params
+      end
+
+      def build_instructions(target)
+        target.image.patch_build_instructions(self, target)
+      end
+
+      def build_dep(target)
+        target.image.patch_build_dep(self, target)
+      end
+    end # Patch
+  end # Builder
+end # Buildizer

data/lib/buildizer/cli.rb

@@ -54,5 +54,11 @@ module Buildizer
     def deploy
       self.class.construct_packager(options).deploy!
     end
+
+    desc "verify", "Verify targets params"
+    shared_options
+    def verify
+      self.class.construct_packager(options).verify!
+    end
   end # Cli
 end # Buildizer

data/lib/buildizer/docker.rb

@@ -1,17 +1,11 @@
 module Buildizer
   class Docker
     attr_reader :builder
-    attr_reader :username
-    attr_reader :password
-    attr_reader :email
-    attr_reader :server
+    attr_reader :cache
 
-    def initialize(builder, username:, password:, email:, server: nil)
+    def initialize(builder, cache: nil)
       @builder = builder
-      @username = username
-      @password = password
-      @email = email
-      @server = server
+      @cache = cache
     end
 
     def image_klass(os_name, os_version)
@@ -19,6 +13,7 @@ module Buildizer
         'ubuntu' => {
           '12.04' => Image::Ubuntu1204,
           '14.04' => Image::Ubuntu1404,
+          '16.04' => Image::Ubuntu1604,
           nil => Image::Ubuntu1404,
         },
         'centos' => {
@@ -35,61 +30,127 @@ module Buildizer
       klass.new(self, **kwargs)
     end
 
-    def login!
-      docker_login = ["docker login --email=#{email} --username=#{username} --password=#{password}"]
-      docker_login << "--server=#{server}" if server
-      builder.packager.command! docker_login.join(' '), desc: "Docker login"
+    def with_cache(&blk)
+      warn("No docker cache account settings " +
+           "(BUILDIZER_DOCKER_CACHE, BUILDIZER_DOCKER_CACHE_USERNAME, " +
+           "BUILDIZER_DOCKER_CACHE_PASSWORD, BUILDIZER_DOCKER_CACHE_EMAIL, " +
+           "BUILDIZER_DOCKER_CACHE_SERVER) [WARN]") unless cache
+
+      cache_login! if cache
+      begin
+        yield if block_given?
+      ensure
+        cache_logout! if cache
+      end
     end
 
-    def logout!
-      builder.packager.command! 'docker logout', desc: "Docker logout"
-    end
+    def cache_login!
+      raise Error, error: :logical_error, message: "no docker cache account info" unless cache
 
-    def pull_image!(image)
-      builder.packager.command "docker pull #{image.base_image}", desc: "Docker pull #{image.base_image}"
-      builder.packager.command "docker pull #{image.name}", desc: "Docker pull #{image.name}"
+      cmd = ["docker login"]
+      cmd << "--email=#{cache[:email]}" if cache[:email]
+      cmd << "--username=#{cache[:username]}" if cache[:username]
+      cmd << "--password=#{cache[:password]}" if cache[:password]
+      cmd << "--server=#{cache[:server]}" if cache[:server]
+      builder.packager.command! cmd.join(' '), desc: "Docker cache account login"
     end
 
-    def push_image!(image)
-      builder.packager.command! "docker push #{image.name}", desc: "Docker push #{image.name}"
+    def cache_logout!
+      raise Error, error: :logical_error, message: "no docker cache account info" unless cache
+      builder.packager.command! 'docker logout', desc: "Docker cache account logout"
     end
 
-    def build_image!(image)
-      pull_image! image
-
-      image_build_path(image).join('Dockerfile').write [*image.instructions, nil].join("\n")
-      builder.packager.command! "docker build -t #{image.name} #{image_build_path(image)}", desc: "Docker build image #{image.name}"
+    def pull_image(image)
+      builder.packager.command!("docker pull #{image.base_image}",
+                                desc: "Docker pull #{image.base_image}")
 
-      push_image! image
+      builder.packager.command("docker pull #{image.name}",
+                               desc: "Docker pull #{image.name}") if cache
     end
 
-    def image_build_path(image)
-      builder.build_path.join(image.os_name).join(image.os_version)
+    def push_image(image)
+      builder.packager.command("docker push #{image.name}",
+                               desc: "Docker push #{image.name}") if cache
     end
 
-    def image_runtime_build_path(image)
-      image_build_path(image).join('build')
+    def build_image!(target)
+      pull_image target.image
+
+      target.image_work_path.join('Dockerfile').write [*target.image.instructions, nil].join("\n")
+      builder.packager.command! "docker build -t #{target.image.name} #{target.image_work_path}",
+                                desc: "Docker build image #{target.image.name}"
+
+      push_image target.image
     end
 
     def container_package_path
       Pathname.new('/package')
     end
 
+    def container_package_archive_path
+      Pathname.new('/package.tar.gz')
+    end
+
+    def container_package_mount_path
+      Pathname.new('/.package')
+    end
+
     def container_build_path
-      container_package_path.join('build')
+      Pathname.new('/build')
     end
 
-    def run!(image, cmd:, env: {})
-      cmd = Array(cmd)
+    def container_extra_path
+      Pathname.new('/extra')
+    end
 
+    def run_target_container!(target:, env: {})
+      container = SecureRandom.uuid
+      builder.packager.command! [
+        "docker run --detach --name #{container}",
+        *Array(_common_docker_params(target, env)),
+        _wrap_docker_run("while true ; do sleep 1 ; done"),
+      ].join(' '), desc: "Run container '#{container}' from docker image '#{target.image.name}'"
+      container
+    end
+
+    def shutdown_container!(container:)
+      builder.packager.command! "docker kill #{container}", desc: "Kill container '#{container}'"
+      builder.packager.command! "docker rm #{container}", desc: "Remove container '#{container}'"
+    end
+
+    def run_in_container!(container:, cmd:, desc: nil)
+      builder.packager.command! [
+        "docker exec #{container}",
+        _wrap_docker_exec(cmd),
+      ].join(' '), timeout: 24*60*60, desc: desc
+    end
+
+    def run_in_image!(target:, cmd:, env: {}, desc: nil)
       builder.packager.command! [
         "docker run --rm",
-        *env.map {|k,v| "-e #{k}=#{v}"},
-        "-v #{builder.packager.package_path}:#{container_package_path}",
-        "-v #{image_runtime_build_path(image)}:#{container_build_path}",
-        image.name,
-        "'#{cmd.join('; ')}'"
-      ].join(' '), desc: "Run build in docker image #{image.name}"
+        *Array(_common_docker_params(target, env)),
+        _wrap_docker_run(cmd),
+      ].join(' '), timeout: 24*60*60, desc: desc
+    end
+
+    def _common_docker_params(target, env)
+      [*env.map {|k,v| "-e #{k}=#{v}"},
+       "-v #{builder.packager.package_path}:#{container_package_mount_path}:ro",
+       "-v #{target.image_extra_path}:#{container_extra_path}:ro",
+       "-v #{target.image_build_path}:#{container_build_path}",
+       target.image.name]
+    end
+
+    def _wrap_docker_exec(cmd)
+      "/bin/bash -lec '#{_make_cmd(cmd)}'"
+    end
+
+    def _wrap_docker_run(cmd)
+      "'#{['set -e', _make_cmd(cmd)].join('; ')}'"
+    end
+
+    def _make_cmd(cmd)
+      Array(cmd).join('; ')
     end
   end # Docker
 end # Buildizer

data/lib/buildizer/image/base.rb

@@ -52,9 +52,21 @@ module Buildizer
         instructions << [instruction.to_s.upcase, cmd].join(' ')
       end
 
+      def patch_build_dep(builder, target)
+        target_package_spec(target)
+      end
+
       def native_build_instructions(builder, target)
         raise
       end
+
+      def patch_build_instructions(builder, target)
+        raise
+      end
+
+      def target_package_spec(target)
+        raise
+      end
     end # Base
   end # Image
 end # Buildizer

data/lib/buildizer/image/centos.rb

@@ -48,23 +48,55 @@ module Buildizer
         instruction :RUN, "bash -lec \"echo -e '#{repo}' >> /etc/yum.repos.d/CentOS-Extra-Buildizer.repo\""
       end
 
+      def target_spec_name(target)
+        "#{target.base_package_name}.spec"
+      end
+
+      def rpmdev_setuptree_instructions(builder, target)
+        "rpmdev-setuptree"
+      end
+
+      def build_rpm_instructions(builder, target)
+        ["cd ~/rpmbuild/SPECS/",
+         "rpmbuild -bb #{target_spec_name(target)}",
+         ["find ~/rpmbuild/RPMS -name '*.rpm' ",
+          "-exec mv {} #{builder.docker.container_build_path} \\;"].join]
+      end
+
       def native_build_instructions(builder, target)
-        version, release = target.package_version.split('-')
-        source_name = "#{target.package_name}-#{version}"
-        source_archive_path = Pathname.new('/package.tar.gz')
-        target_spec_name = "#{target.package_name}.spec"
-
-        ["cp -r #{builder.docker.container_package_path} /tmp/#{source_name}",
-         "cd /tmp",
-         "tar -zcvf #{source_archive_path} #{source_name}",
-         "ln -fs #{builder.docker.container_build_path} ~/rpmbuild",
-         "rpmdev-setuptree",
-         "cp #{source_archive_path} ~/rpmbuild/SOURCES",
-         "cp #{builder.docker.container_package_path.join(target_spec_name)} ~/rpmbuild/SPECS",
-         "cd ~/rpmbuild/SPECS",
-         "rpmbuild -ba #{target_spec_name}",
-         "cp $(find #{builder.docker.container_build_path.join('RPMS')} -name '*.rpm') #{builder.docker.container_build_path}",
-        ]
+        [*Array(rpmdev_setuptree_instructions(builder, target)),
+         "cp #{builder.docker.container_package_archive_path} ~/rpmbuild/SOURCES/",
+         "cp #{builder.docker.container_package_path.join(target_spec_name(target))} ~/rpmbuild/SPECS/",
+         *Array(build_rpm_instructions(builder, target))]
+      end
+
+      def patch_build_instructions(builder, target)
+        rpmchange_cmd = "rpmchange %{cmd} --specfile ~/rpmbuild/SPECS/#{target_spec_name(target)} %{args}"
+        get_release_cmd = rpmchange_cmd % {cmd: :tag, args: "--name release"}
+        set_release_cmd = rpmchange_cmd % {cmd: :tag, args: "--name release --value %{value}"}
+        changelog_cmd = rpmchange_cmd % {
+          cmd: :changelog,
+          args: "--append --name \"%{name}\" --email \"%{email}\" --message \"%{message}\""
+        }
+
+        [*Array(rpmdev_setuptree_instructions(builder, target)),
+         "yumdownloader --source #{target_package_spec(target)}",
+         "rpm -i *.rpm",
+         "gem install rpmchange",
+         set_release_cmd % {value: "$(#{get_release_cmd})buildizer#{target.package_version}"},
+         *target.patch.map {|patch| "cp #{patch} ~/rpmbuild/SOURCES/"},
+         *target.patch.map {|patch|
+           rpmchange_cmd % {cmd: :append,
+                            args: "--section prep --value \"patch -p1 < %{_sourcedir}/#{patch}\""}
+         },
+         changelog_cmd % {name: target.maintainer,
+                          email: target.maintainer_email,
+                          message: 'Patch by buildizer'},
+         *Array(build_rpm_instructions(builder, target))]
+      end
+
+      def target_package_spec(target)
+        [target.package_name, target.package_version].compact.join('-')
       end
     end # Centos
   end # Image

data/lib/buildizer/image/ubuntu.rb

@@ -34,6 +34,37 @@ module Buildizer
           res << '--deb-no-default-config-files'
         end
       end
+
+      def build_deb_instructions(builder, target)
+        ["DEB_BUILD_OPTIONS=nocheck dpkg-buildpackage -b -us -uc -j#{builder.build_jobs}",
+         "cp ../*.deb #{builder.docker.container_build_path}"]
+      end
+
+      def native_build_instructions(builder, target)
+        source_archive_name = "#{target.package_name}_#{target.package_upstream_version}.orig.tar.gz"
+
+        [["ln -fs #{target.container_package_archive_path} ",
+          "#{target.container_package_path.dirname.join(source_archive_name)}"].join,
+         "cd #{target.container_package_path}",
+         *Array(build_deb_instructions(builder, target))]
+      end
+
+      def patch_build_instructions(builder, target)
+        ["apt-get source #{target_package_spec(target)}",
+         'cd $(ls *.orig.tar* | ruby -ne "puts \$_.split(\\".orig.tar\\").first.gsub(\\"_\\", \\"-\\")")',
+         ["DEBFULLNAME=\"#{target.maintainer}\" DEBEMAIL=\"#{target.maintainer_email}\" ",
+          "debchange --newversion ",
+          "$(dpkg-parsechangelog | grep \"Version:\" | cut -d\" \" -f2-)buildizer#{target.patch_version} ",
+          "--distribution #{os_codename} \"Patch by buildizer\""].join,
+         *target.patch.map {|patch| "cp ../#{patch} debian/patches/"},
+         *target.patch.map {|patch| "sed -i \"/#{Regexp.escape(patch)}/d\" debian/patches/series"},
+         *target.patch.map {|patch| "echo #{patch} >> debian/patches/series"},
+         *Array(build_deb_instructions(builder, target))]
+      end
+
+      def target_package_spec(target)
+        [target.package_name, target.package_version].compact.join('=')
+      end
     end # Ubuntu
   end # Image
 end # Buildizer

data/lib/buildizer/image/ubuntu1604.rb

@@ -0,0 +1,13 @@
+module Buildizer
+  module Image
+    class Ubuntu1604 < Ubuntu
+      def initialize(docker, **kwargs)
+        super(docker, '16.04', **kwargs)
+      end
+
+      def os_codename
+        'xenial'
+      end
+    end # Ubuntu1604
+  end # Image
+end # Buildizer

data/lib/buildizer/packager.rb

@@ -1,9 +1,12 @@
 module Buildizer
   class Packager
+    using Refine
+
     attr_reader :package_path
     attr_reader :buildizer_conf_path
     attr_reader :options_path
     attr_reader :travis_path
+    attr_reader :work_path
     attr_reader :debug
 
     def initialize(options: {}, debug: false)
@@ -11,8 +14,9 @@ module Buildizer
       @buildizer_conf_path = package_path.join('Buildizer')
       @options_path = package_path.join('.buildizer.yml')
       @travis_path = package_path.join('.travis.yml')
+      @work_path = Pathname.new(ENV['BUILDIZER_WORK_PATH'] || '~/.buildizer').expand_path
       @_options = options
-      @debug = debug
+      @debug = ENV['BUILDIZER_DEBUG'].nil? ? debug : ENV['BUILDIZER_DEBUG'].to_s.on?
     end
 
     def initialized?
@@ -53,6 +57,10 @@ module Buildizer
       builder.deploy
     end
 
+    def verify!
+      builder.verify
+    end
+
     def buildizer_conf
       @buildizer_conf ||= (YAML.load((buildizer_conf_path.read rescue "")) || {})
     end
@@ -155,12 +163,13 @@ git add -v .travis.yml
       buildizer_conf['package_version']
     end
 
-    def package_version_tag
-      ENV['TRAVIS_TAG'] || ENV['CI_BUILD_TAG']
+    def package_version_tag_required_for_deploy?
+      ENV['BUILDIZER_REQUIRE_TAG'].to_s.on?
     end
 
-    def os_params(os)
-      buildizer_conf['os'].to_h[os.to_s].to_h
+    def package_version_tag
+      res = ENV['TRAVIS_TAG'] || ENV['CI_BUILD_TAG']
+      if res.nil? then res elsif res.empty? then nil else res end
     end
 
     def before_prepare
@@ -199,40 +208,46 @@ git add -v .travis.yml
       buildizer_conf['image']
     end
 
-    def package_cloud
-      buildizer_conf['package_cloud']
+    def package_cloud_repo
+      ENV['PACKAGECLOUD'].to_s.split(',')
     end
 
-    def package_cloud_token
-      ENV['PACKAGECLOUD_TOKEN'] || begin
-        raise Error, error: :input_error, message: "PACKAGECLOUD_TOKEN env variable required"
-      end
+    def package_cloud_org
+      default_token = ENV['PACKAGECLOUD_TOKEN']
+      package_cloud_repo.map {|repo| repo.split('/').first}.uniq.map do |org|
+        [org, ENV["PACKAGECLOUD_TOKEN_#{org.upcase}"] || default_token]
+      end.to_h
     end
 
-    def docker_username
-      ENV['BUILDIZER_DOCKER_USERNAME'] || begin
-        raise Error, error: :input_error, message: "BUILDIZER_DOCKER_USERNAME env variable required"
+    def package_cloud
+      tokens = package_cloud_org
+      package_cloud_repo.map do |repo|
+        org = repo.split('/').first
+        token = tokens[org]
+        {org: org, repo: repo, token: token}
       end
     end
 
-    def docker_password
-      ENV['BUILDIZER_DOCKER_PASSWORD'] || begin
-        raise Error, error: :input_error, message: "BUILDIZER_DOCKER_PASSWORD env variable required"
-      end
+    def docker_cache
+      return unless org = ENV['BUILDIZER_DOCKER_CACHE']
+      {username: ENV['BUILDIZER_DOCKER_CACHE_USERNAME'],
+       password: ENV['BUILDIZER_DOCKER_CACHE_PASSWORD'],
+       email: ENV['BUILDIZER_DOCKER_CACHE_EMAIL'],
+       server: ENV['BUILDIZER_DOCKER_CACHE_SERVER'],
+       org: org}
     end
 
-    def docker_email
-      ENV['BUILDIZER_DOCKER_EMAIL'] || begin
-        raise Error, error: :input_error, message: "BUILDIZER_DOCKER_EMAIL env variable required"
-      end
+    def maintainer
+      buildizer_conf['maintainer']
     end
 
     def builder
       @builder ||= begin
         build_type = buildizer_conf['build_type']
-        raise Error, error: :input_error, message: "no build_type given" unless build_type
+        raise Error, error: :input_error, message: "build_type is not defined" unless build_type
         klass = {fpm: Builder::Fpm,
-                 native: Builder::Native}[build_type.to_s.to_sym]
+                 native: Builder::Native,
+                 patch: Builder::Patch}[build_type.to_s.to_sym]
         raise Error, error: :input_error, message: "unknown build_type '#{build_type}'" unless klass
         klass.new(self)
       end