buildizer 0.1.0 → 0.1.1

data/lib/buildizer/buildizer/buildizer_conf_mod.rb

@@ -16,46 +16,6 @@ module Buildizer
       def buildizer_conf_setup!
         write_yaml(buildizer_conf_path, buildizer_conf)
       end
-
-      def package_name
-        buildizer_conf['package_name']
-      end
-
-      def package_version
-        buildizer_conf['package_version']
-      end
-
-      def before_prepare
-        Array(buildizer_conf['before_prepare'])
-      end
-
-      def after_prepare
-        Array(buildizer_conf['after_prepare'])
-      end
-
-      def targets
-        targets = Array(buildizer_conf['target'])
-        restrict_targets = ENV['BUILDIZER_TARGET']
-        restrict_targets = restrict_targets.split(',').map(&:strip) if restrict_targets
-        targets = targets & restrict_targets if restrict_targets
-        targets
-      end
-
-      def prepare
-        Array(buildizer_conf['prepare'])
-      end
-
-      def build_dep
-        Array(buildizer_conf['build_dep']).to_set
-      end
-
-      def before_build
-        Array(buildizer_conf['before_build'])
-      end
-
-      def maintainer
-        buildizer_conf['maintainer']
-      end
     end # BuildizerConfMod
   end # Buildizer
 end # Buildizer

data/lib/buildizer/buildizer/overcommit_mod.rb

@@ -45,7 +45,7 @@ module Overcommit::Hook::PreCommit
     def run
 #{overcommit_buildizer_require}
 
-      ::Buildizer::Buildizer.new.verify!
+      ::Buildizer::Buildizer.new.verify
       :pass
     rescue ::Buildizer::Error => e
       $stderr.puts e.net_status.net_status_message

data/lib/buildizer/ci/travis.rb

@@ -51,24 +51,31 @@ module Buildizer
           'sudo apt-get update',
 
           # FIXME [https://github.com/docker/docker/issues/20316]:
-          'sudo apt-get -o dpkg::options::="--force-confnew" install -y docker-engine=1.9.1-0~trusty',
+          'sudo apt-get -o dpkg::options::="--force-confnew" install -y --force-yes docker-engine=1.9.1-0~trusty',
 
           'echo "docker-engine hold" | sudo dpkg --set-selections',
         ]
         install.push(*Array(buildizer_install_instructions(master: buildizer.project_settings['master'])))
 
-        env = buildizer.targets.map {|t| "BUILDIZER_TARGET=#{t}"}
-        conf.merge(
+        if buildizer.project_settings['master']
+          buildizer_bin = 'bundle exec buildizer'
+        else
+          buildizer_bin = 'buildizer'
+        end
+
+        env = buildizer.builder.target_names.map {|t| "BUILDIZER_TARGET=#{t}"}
+
+        conf.merge!(
           'dist' => 'trusty',
           'sudo' => 'required',
           'cache' => 'apt',
           'language' => 'ruby',
           'rvm' => '2.2.1',
           'install' => install,
-          'before_script' => 'buildizer prepare',
-          'script' => 'buildizer build',
+          'before_script' => "#{buildizer_bin} prepare",
+          'script' => "#{buildizer_bin} build && #{buildizer_bin} test",
           'env' => env,
-          'after_success' => 'buildizer deploy',
+          'after_success' => "#{buildizer_bin} deploy",
         )
       end
 

data/lib/buildizer/cli/main.rb

@@ -51,34 +51,36 @@ module Buildizer
         end
       end
 
-      desc "deinit", "Deinitialize settings (.buildizer.yml, git pre-commit hook)"
-      shared_options
-      def deinit
-        buildizer.deinit!
-      end
-
       desc "prepare", "Prepare images for building packages"
       shared_options
       def prepare
-        buildizer.prepare!
+        buildizer.prepare
       end
 
       desc "build", "Build packages"
       shared_options
       def build
-        buildizer.build!
+        buildizer.build
+      end
+
+      desc "test", "Run integration tests for packages"
+      shared_options
+      method_option :shell, type: :boolean, default: false,
+                            desc: "drop into test shell for each target + env"
+      def test
+        buildizer.test
       end
 
       desc "deploy", "Deploy packages"
       shared_options
       def deploy
-        buildizer.deploy!
+        buildizer.deploy
       end
 
       desc "verify", "Verify targets params"
       shared_options
       def verify
-        buildizer.verify!
+        buildizer.verify
       end
     end # Main
   end # Cli

data/lib/buildizer/core_ext/hash.rb

@@ -1,20 +1,20 @@
 class Hash
   def zymbolize_keys
     map do |key, value|
-      [_symbolize(key), value]
+      [_zymbolize(key), value]
     end.to_h
   end
 
   def zymbolize_keys!
     keys.each do |key|
-      self[_symbolize(key)] = delete(key)
+      self[_zymbolize(key)] = delete(key)
     end
     self
   end
 
   def zymbolize_keys_deep
     map do |key, value|
-      [_symbolize(key), if value.is_a? Hash
+      [_zymbolize(key), if value.is_a? Hash
         value.zymbolize_keys_deep
       else
         value
@@ -29,7 +29,7 @@ class Hash
       visited.add hash
       hash.keys.each do |key|
         value = hash.delete(key)
-        hash[_symbolize(key)] = value
+        hash[_zymbolize(key)] = value
         queue << value if value.is_a? Hash and not visited.include? hash
       end
     end
@@ -42,7 +42,7 @@ class Hash
 
   private
 
-  def _symbolize(value)
+  def _zymbolize(value)
     value.respond_to?(:to_sym) ? value.to_sym : value
   end
 end # Hash

data/lib/buildizer/core_ext/pathname.rb

@@ -1,9 +1,9 @@
 class Pathname
   def load_yaml
-    exist? ? YAML.load(read) : {}
+    exist? ? YAML.load(read) || {} : {}
   rescue Psych::Exception => err
-    raise Error, error: :input_error,
-                 message: "bad yaml config file #{self}: #{err.message}"
+    raise Buildizer::Error, error: :input_error,
+                            message: "bad yaml config file #{self}: #{err.message}"
   end
 
   def dump_yaml(cfg)

data/lib/buildizer/docker.rb

@@ -8,25 +8,25 @@ module Buildizer
       @cache = cache
     end
 
-    def image_klass(os_name, os_version)
+    def os_klass(name, version)
       ({
         'ubuntu' => {
-          '12.04' => Image::Ubuntu1204,
-          '14.04' => Image::Ubuntu1404,
-          '16.04' => Image::Ubuntu1604,
-          nil => Image::Ubuntu1404,
+          '12.04' => Os::Ubuntu1204,
+          '14.04' => Os::Ubuntu1404,
+          '16.04' => Os::Ubuntu1604,
+          nil => Os::Ubuntu1404,
         },
         'centos' => {
-          'centos6' => Image::Centos6,
-          'centos7' => Image::Centos7,
-          nil => Image::Centos7,
+          'centos6' => Os::Centos6,
+          'centos7' => Os::Centos7,
+          nil => Os::Centos7,
         },
-      }[os_name] || {})[os_version]
+      }[name] || {})[version]
     end
 
-    def new_image(os_name, os_version, **kwargs)
-      klass = image_klass(os_name, os_version)
-      raise Error, message: "unknown os '#{[os_name, os_version].compact.join('-')}'" unless klass
+    def new_os(name, version, **kwargs)
+      klass = os_klass(name, version)
+      raise Error, message: "unknown os '#{[name, version].compact.join('-')}'" unless klass
       klass.new(self, **kwargs)
     end
 
@@ -60,41 +60,40 @@ module Buildizer
       builder.buildizer.command! 'docker logout', desc: "Docker cache account logout"
     end
 
-    def pull_image(image)
-      builder.buildizer.command! "docker pull #{image.base_image}", desc: "Pull docker base image #{image.base_image}"
-      if cache
-        pull_cache_res = builder.buildizer.command(
-          "docker pull #{image.cache_name}",
-           desc: "Try to pull docker cache image #{image.cache_name}"
-        )
-        if pull_cache_res.status.success?
-          builder.buildizer.command! "docker tag -f #{image.cache_name} #{image.name}",
-                                      desc: "Tag cache image #{image.cache_name}" +
-                                            " as prepared build image #{image.name}"
-          builder.buildizer.command! "docker rmi #{image.cache_name}",
-                                      desc: "Remove cache image #{image.cache_name}"
-        end
+    def pull_cache_image(build_image, cache_image)
+      pull_cache_res = builder.buildizer.command(
+        "docker pull #{cache_image.name}",
+         desc: "Try to pull docker cache image #{cache_image.name}"
+      )
+      if pull_cache_res.status.success?
+        builder.buildizer.command! "docker tag -f #{cache_image.name} #{build_image.name}",
+                                    desc: "Tag cache image #{cache_image.name}" +
+                                          " as prepared build image #{build_image.name}"
+        builder.buildizer.command! "docker rmi #{cache_image.name}",
+                                    desc: "Remove cache image #{cache_image.name}"
       end
     end
 
-    def push_image(image)
-      if cache
-        builder.buildizer.command! "docker tag -f #{image.name} #{image.cache_name}",
-                                    desc: "Tag prepared build image #{image.name}" +
-                                          " as cache image #{image.cache_name}"
-        builder.buildizer.command! "docker push #{image.cache_name}",
-                                    desc: "Push cache image #{image.cache_name}"
-      end
+    def cache_build_image(build_image, cache_image)
+      builder.buildizer.command! "docker tag -f #{build_image.name} #{cache_image.name}",
+                                  desc: "Tag prepared build image #{build_image.name}" +
+                                        " as cache image #{cache_image.name}"
+      builder.buildizer.command! "docker push #{cache_image.name}",
+                                  desc: "Push cache image #{cache_image.name}"
     end
 
-    def build_image!(target)
-      pull_image target.image
+    def make_build_image(target)
+      pull_cache_image(target.build_image, target.cache_image) if target.cache_image
+
+      target.build_image.dockerfile_write!
 
-      target.image_work_path.join('Dockerfile').write! [*target.image.instructions, nil].join("\n")
-      builder.buildizer.command! "docker build -t #{target.image.name} #{target.image_work_path}",
-                                  desc: "Build docker image #{target.image.name}"
+      builder.buildizer.command! "docker build " +
+                                 "-t #{target.build_image.name} " +
+                                 "-f #{target.build_image.dockerfile_path} " +
+                                 "#{target.build_image.dockerfile_path.dirname}",
+                                  desc: "Build docker image #{target.build_image.name}"
 
-      push_image target.image
+      cache_build_image(target.build_image, target.cache_image) if target.cache_image
     end
 
     def container_package_path
@@ -117,14 +116,15 @@ module Buildizer
       Pathname.new('/extra')
     end
 
-    def run_target_container!(target:, env: {})
-      container = SecureRandom.uuid
-      builder.buildizer.command! [
-        "docker run --detach --name #{container}",
-        *Array(_prepare_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
+    def run_container!(name: nil, image:, env: {}, desc: nil, docker_opts: {})
+      (name || SecureRandom.uuid).tap do |name|
+        builder.buildizer.command! [
+          "docker run --detach --name #{name}",
+          *Array(_prepare_docker_opts(docker_opts)),
+          *Array(_prepare_container_params(image, env: env)),
+          _wrap_docker_command("while true ; do sleep 1 ; done"),
+        ].join(' '), desc: desc
+      end
     end
 
     def shutdown_container!(container:)
@@ -132,38 +132,74 @@ module Buildizer
       builder.buildizer.command! "docker rm #{container}", desc: "Remove container '#{container}'"
     end
 
-    def run_in_container!(container:, cmd:, desc: nil)
-      builder.buildizer.command! [
-        "docker exec #{container}",
-        _wrap_docker_exec(cmd),
-      ].join(' '), timeout: 24*60*60, desc: desc
+    def with_container(**kwargs, &blk)
+      container = run_container!(**kwargs)
+      begin
+        yield container if block_given?
+      ensure
+        shutdown_container!(container: container)
+      end
+    end
+
+    def shell_in_container(container:)
+      system "docker exec -ti #{container} bash -lec 'cd #{container_package_mount_path}; bash'"
     end
 
-    def run_in_image!(target:, cmd:, env: {}, desc: nil)
-      builder.buildizer.command! [
+    def run_in_container(container:, cmd:, desc: nil, cmd_opts: {}, docker_opts: {})
+      builder.buildizer.command [
+        "docker exec",
+        *Array(_prepare_docker_opts(docker_opts)),
+        container,
+        _wrap_docker_command(cmd),
+      ].join(' '), timeout: 24*60*60, desc: desc, **cmd_opts
+    end
+
+    def run_in_container!(cmd_opts: {}, **kwargs)
+      cmd_opts[:do_raise] = true
+      cmd_opts[:log_failure] = true
+      run_in_container(cmd_opts: cmd_opts, **kwargs)
+    end
+
+    def run_in_image(image:, cmd:, env: {}, desc: nil, cmd_opts: {}, docker_opts: {})
+      builder.buildizer.command [
         "docker run --rm",
-        *Array(_prepare_docker_params(target, env)),
-        _wrap_docker_run(cmd),
-      ].join(' '), timeout: 24*60*60, desc: desc
+        *Array(_prepare_docker_opts(docker_opts)),
+        *Array(_prepare_container_params(image, env: env)),
+        _wrap_docker_command(cmd),
+      ].join(' '), timeout: 24*60*60, desc: desc, **cmd_opts
+    end
+
+    def run_in_image!(cmd_opts: {}, **kwargs)
+      cmd_opts[:do_raise] = true
+      run_in_image(cmd_opts: cmd_opts, **kwargs)
     end
 
-    def _prepare_docker_params(target, env)
-      target.image_extra_path.mkpath
-      target.image_build_path.mkpath
+    def _prepare_container_params(image, env: {})
+      image.extra_path.mkpath
+      image.build_path.mkpath
 
       [*env.map {|k,v| "-e #{k}=#{v}"},
        "-v #{builder.buildizer.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]
+       "-v #{image.extra_path}:#{container_extra_path}:ro",
+       "-v #{image.build_path}:#{container_build_path}",
+       image.name].compact
     end
 
-    def _wrap_docker_exec(cmd)
-      "/bin/bash -lec '#{_make_cmd(cmd)}'"
+    def _prepare_docker_opts(docker_opts)
+      docker_opts.map do |k, v|
+        next if v.nil?
+
+        to_opt = ->(value) {"--#{k}=#{value}"}
+        if v.is_a? Array
+          v.map(&to_opt)
+        else
+          to_opt[v]
+        end
+      end.flatten.compact
     end
 
-    def _wrap_docker_run(cmd)
-      "'#{['set -e', _make_cmd(cmd)].join('; ')}'"
+    def _wrap_docker_command(cmd)
+      "/bin/bash -lec '#{_make_cmd(cmd)}'"
     end
 
     def _make_cmd(cmd)

data/lib/buildizer/image.rb

@@ -1,4 +1,47 @@
 module Buildizer
-  module Image
+  class Image
+    attr_reader :name
+    attr_reader :target
+
+    attr_reader :instructions
+    attr_reader :from
+
+    def initialize(name, target, from: nil)
+      @name = name
+      @target = target
+
+      @instructions = []
+      @from = from
+
+      instruction :FROM, from if from
+    end
+
+    def instruction(instruction, cmd)
+      instructions << [instruction.to_s.upcase, cmd].join(' ')
+    end
+
+    def build_path
+      target.image_build_path
+    end
+
+    def extra_path
+      target.image_extra_path
+    end
+
+    def dockerfile_name
+      "#{name}.dockerfile"
+    end
+
+    def dockerfile_path
+      target.image_work_path.join(dockerfile_name)
+    end
+
+    def dockerfile_dump
+      [instructions, nil].join("\n")
+    end
+
+    def dockerfile_write!
+      dockerfile_path.write! dockerfile_dump
+    end
   end # Image
 end # Buildizer