buildizer 0.0.1 → 0.0.5

data/buildizer.gemspec

@@ -18,8 +18,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor", ">= 0.19.1", "< 1.0"
   spec.add_dependency "net_status", ">= 0.0.1", "< 1.0"
-  spec.add_dependency "mixlib-shellout", ">= 2.2.6", "< 3.0"
-  spec.add_dependency "travis", "~> 1.8", ">= 1.8.2"
+  spec.add_dependency "shellfold", ">= 0.0.1", "< 1.0"
   spec.add_dependency "package_cloud", ">= 0.2", "< 1.0"
 
   spec.add_development_dependency "bundler", "~> 1.7"
@@ -27,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.4", ">= 3.4.0"
   spec.add_development_dependency "pry", ">= 0.10.3", "< 1.0"
   spec.add_development_dependency 'pry-stack_explorer', '>= 0.4.9.2', '< 1.0'
+  spec.add_development_dependency "travis", "~> 1.8", ">= 1.8.2"
 end

data/lib/buildizer/builder/base.rb

@@ -0,0 +1,173 @@
+module Buildizer
+  module Builder
+    class Base
+      attr_reader :packager
+      attr_reader :build_path
+      attr_reader :docker
+
+      def initialize(packager)
+        @packager = packager
+
+        @build_path = Pathname.new(ENV['PREFIX'] || packager.package_path.join('build')).expand_path
+        raise Error, message: "bad build prefix: '#{build_path}' is a file" if build_path.file?
+        build_path.mkdir rescue nil
+
+        @docker = Docker.new(self,
+          username: packager.docker_username,
+          password: packager.docker_password,
+          email: packager.docker_email,
+          server: packager.docker_server,
+        )
+      end
+
+      def build_type
+        raise
+      end
+
+      def target_klass
+        raise
+      end
+
+      def prepare_image_instructions(target)
+      end
+
+      def build_instructions(target)
+      end
+
+      def build_dep
+      end
+
+      def new_target(target_name)
+        os_name, os_version, target_package_name, target_package_version = target_name.split('-', 4)
+
+        image = docker.new_image(os_name, os_version)
+
+        params = merge_os_params(image.os_name)
+        params = merge_os_version_params(image.os_name, image.os_version, into: params)
+        params = merge_base_target_params(target_name, target_package_name, target_package_version,
+                                          into: params) if target_package_name
+        check_params! params
+
+        target_klass.new(self, image, name: target_name, **params).tap do |target|
+          image.target = target
+        end
+      end
+
+      def targets
+        @targets ||= packager.targets.map {|target_name| new_target(target_name)}
+      end
+
+      def initial_target_params
+        {}.tap do |params|
+          params[:package_name] = packager.package_name
+          params[:package_version] = packager.package_version
+          params[:package_cloud] = packager.package_cloud
+          params[:prepare] = packager.prepare
+          params[:build_dep] = packager.build_dep
+          params[:before_build] = packager.before_build
+        end
+      end
+
+      def merge_params(into: nil, params:, &blk)
+        into ||= initial_target_params
+        params ||= {}
+        yield into, params if block_given?
+        do_merge_params into, params
+      end
+
+      def do_merge_params(into, params)
+        {}.tap do |res|
+          res[:package_name] = into[:package_name] || params['package_name']
+          res[:package_version] = into[:package_version] || params['package_version']
+          res[:package_cloud] = into[:package_cloud]
+          res[:prepare] = into[:prepare] + Array(params['prepare'])
+          res[:build_dep] = into[:build_dep] | Array(params['build_dep']).to_set
+          res[:before_build] = into[:before_build] + Array(params['before_build'])
+        end
+      end
+
+      def merge_os_params(os_name, into: nil, &blk)
+        merge_params(into: into, params: packager.os_params(os_name), &blk)
+      end
+
+      def merge_os_version_params(os_name, os_version, into: nil, &blk)
+        merge_params(into: into,
+                     params: packager.os_params([os_name, os_version].join('-')), &blk)
+      end
+
+      def merge_base_target_params(target, target_package_name, target_package_version,
+                                   into: nil, &blk)
+        merge_params(into: into,
+                     params: {'package_name' => target_package_name,
+                              'package_version' => target_package_version}, &blk)
+      end
+
+      def check_params!(params)
+        [:package_name, :package_version, :package_cloud].each do |param|
+          raise(Error,
+                error: :input_error,
+                message: "#{param} is not defined") unless params[param] and not params[param].empty?
+        end
+      end
+
+      def prepare
+        return unless packager.enabled?
+
+        docker.login!
+
+        begin
+          packager.before_prepare.each {|cmd| packager.command! cmd, desc: "Before prepare command: #{cmd}"}
+          targets.each {|target| prepare_target_image(target)}
+          packager.after_prepare.each {|cmd| packager.command! cmd, desc: "After prepare command: #{cmd}"}
+        ensure
+          docker.logout!
+        end
+      end
+
+      def prepare_target_image(target)
+        docker.image_build_path(target.image).mkpath
+
+        (Array(prepare_image_instructions(target)) + target.prepare).each do |cmd|
+          target.image.instruction(:RUN, "bash -lec \"#{cmd}\"")
+        end
+        target.image.build_dep(Array(build_dep).to_set + target.build_dep)
+        docker.build_image! target.image
+      end
+
+      def build
+        return unless packager.enabled?
+        targets.each {|target| build_target(target)}
+      end
+
+      def build_target(target)
+        docker.image_runtime_build_path(target.image).mkpath
+
+        cmd = [
+          "cd /package",
+          *target.before_build,
+          *Array(build_instructions(target)),
+        ]
+
+        docker.run! target.image, cmd: cmd
+      end
+
+      def deploy
+        return unless packager.enabled?
+        targets.each {|target| deploy_target(target)}
+      end
+
+      def deploy_target(target)
+        cmd = Dir[docker.image_runtime_build_path(target.image)
+                        .join("*.#{target.image.fpm_output_type}")]
+                  .map {|p| Pathname.new(p)}
+                  .map {|p| ["package_cloud yank #{target.package_cloud_path} #{p.basename}",
+                             "package_cloud push #{target.package_cloud_path} #{p}",
+                             p.basename]}
+                  .each {|yank, push, package|
+                    packager.command yank, desc: "Package cloud yank package '#{package}'"
+                    packager.command! push, desc: "Package cloud push package '#{package}'"
+                  }
+      end
+    end # Base
+  end # Builder
+end # Buildizer

data/lib/buildizer/builder/fpm.rb

@@ -0,0 +1,129 @@
+module Buildizer
+  module Builder
+    class Fpm < Base
+      FPM_SCRIPT_EVENTS = [:before, :after].map {|at|
+                            [:install, :upgrade, :remove].map {|event|
+                              "#{at}_#{event}"}}.flatten
+
+      def build_type
+        'fpm'
+      end
+
+      def target_klass
+        Target::Fpm
+      end
+
+      def initial_target_params
+        super.tap do |params|
+          raise(Error,
+                error: :input_error,
+                message: [
+                  "explicit definition of package_version in #{build_type} ",
+                  "build type is forbidden ",
+                  "(use TRAVIS_TAG, CI_BUILD_TAG env variables)",
+                ].join) if params[:package_version]
+          params[:package_version] = ENV['TRAVIS_TAG'] || ENV['CI_BUILD_TAG']
+          params[:fpm_script] = Array(packager.buildizer_conf['fpm_script'])
+          params[:fpm_config_files] = packager.buildizer_conf['fpm_config_files'].to_h
+          params[:fpm_files] = packager.buildizer_conf['fpm_files'].to_h
+        end
+      end
+
+      def cannot_redefine_package_params!(params, redefine_for: nil)
+        [:package_name, :package_version].each do |param|
+          raise(Error,
+            error: :input_error,
+            message: [
+              "cannot redefine #{param}",
+              redefine_for ? "for #{redefine_for}" : nil,
+              "in #{build_type} build_type",
+            ].compact.join(' ')
+          ) if params.key? param.to_s
+        end
+      end
+
+      def do_merge_params(into, params)
+        super.tap do |res|
+          res[:fpm_script] = into[:fpm_script] + Array(params['fpm_script'])
+          res[:fpm_config_files] = into[:fpm_config_files].merge params['fpm_config_files'].to_h
+          res[:fpm_files] = into[:fpm_files].merge params['fpm_files'].to_h
+        end
+      end
+
+      def merge_os_params(os_name, **kwargs, &blk)
+        super(os_name, **kwargs) do |into, params|
+          yield into, params if block_given?
+          cannot_redefine_package_params!(params, redefine_for: "os '#{os_name}'")
+        end
+      end
+
+      def merge_os_version_params(os_name, os_version, **kwargs, &blk)
+        super(os_name, os_version, **kwargs) do |into, params|
+          yield into, params if block_given?
+          cannot_redefine_package_params!(params,
+                                          redefine_for: "os version '#{os_name}-#{os_version}'")
+        end
+      end
+
+      def merge_base_target_params(target, target_package_name, target_package_version, **kwargs, &blk)
+        super(target, target_package_name, target_package_version, **kwargs) do |into, params|
+          yield into, params if block_given?
+          cannot_redefine_package_params!(params, redefine_for: "target '#{target}'")
+        end
+      end
+
+      def check_params!(params)
+        super
+        if [:fpm_files, :fpm_config_files].all? {|param| params[param].empty?}
+          raise Error, error: :input_error,
+                       message: ["either of fpm_files or fpm_config_files ",
+                                 "required in #{build_type} build_type"].join
+        end
+      end
+
+      def build_instructions(target)
+        fpm_script = target.fpm_script.reduce({}) do |res, spec|
+          conditions = Array(spec['when'])
+          raise Error, message: ["no when conditions given ",
+                                 "for fpm_script of target ",
+                                 "'#{target.name}'"].join unless conditions.any?
+
+          cmd = Array(spec['do'])
+          next res unless cmd.any?
+          conditions.each do |_when|
+            raise(
+              Error,
+              message: "unknown fpm_script event #{_when.inspect}"
+            ) unless FPM_SCRIPT_EVENTS.include? _when
+            res[_when] ||= {fpm_option: "--#{_when.split('_').join('-')}",
+                            file: docker.image_runtime_build_path(target.image)
+                                        .join("fpm_#{_when}.sh"),
+                            container_file: Pathname.new('/package/build').join("fpm_#{_when}.sh"),
+                            cmd: []}
+            res[_when][:cmd] += cmd
+          end
+          res
+        end
+
+        fpm_script.values.map do |desc|
+          desc[:file].write ["#!/bin/bash", *desc[:cmd], nil].join("\n")
+          desc[:file].chmod 0755
+        end
+
+        version, release = target.package_version.split('-')
+
+        ["fpm -s dir",
+         "--force",
+         "-p #{docker.container_build_path}",
+         "-t #{target.image.fpm_output_type}",
+         "-n #{target.package_name}",
+         "--version=#{version}",
+         "--iteration=#{release}",
+         *fpm_script.values.map {|desc| "#{desc[:fpm_option]}=#{desc[:container_file]}"},
+         *Array(target.image.fpm_extra_params),
+         *target.fpm_config_files.values.map {|p| "--config-files=#{p}"},
+         *target.fpm_files.merge(target.fpm_config_files).map {|p1, p2| "#{p1}=#{p2}"}].join(' ')
+      end
+    end # Fpm
+  end # Builder
+end # Buildizer

data/lib/buildizer/builder.rb

@@ -0,0 +1,4 @@
+module Buildizer
+  module Builder
+  end # Builder
+end # Buildizer

data/lib/buildizer/cli.rb

@@ -0,0 +1,58 @@
+module Buildizer
+  class Cli < ::Thor
+    class << self
+      def shared_options
+        (@shared_options || {}).each do |name, options|
+          method_option name, options
+        end
+      end
+
+      def construct_packager(options)
+        Packager.new(options: {'latest' => options['latest']}, debug: options['debug'])
+      end
+    end # << self
+
+    @shared_options = {
+      debug: {type: :boolean, default: false, desc: "turn on live logging for external commands"},
+    }
+
+    desc "init", "Initialize settings (.travis.yml, .buildizer.yml, git pre-commit hook)"
+    shared_options
+    method_option :latest,
+      type: :boolean,
+      desc: "use buildizer github master branch"
+    def init
+      self.class.construct_packager(options).init!
+    end
+
+    desc "update", "Regenerate .travis.yml"
+    shared_options
+    def update
+      self.class.construct_packager(options).update!
+    end
+
+    desc "deinit", "Deinitialize settings (.buildizer.yml, git pre-commit hook)"
+    shared_options
+    def deinit
+      self.class.construct_packager(options).deinit!
+    end
+
+    desc "prepare", "Prepare images for building packages"
+    shared_options
+    def prepare
+      self.class.construct_packager(options).prepare!
+    end
+
+    desc "build", "Build packages"
+    shared_options
+    def build
+      self.class.construct_packager(options).build!
+    end
+
+    desc "deploy", "Deploy packages"
+    shared_options
+    def deploy
+      self.class.construct_packager(options).deploy!
+    end
+  end # Cli
+end # Buildizer

data/lib/buildizer/docker.rb

@@ -0,0 +1,95 @@
+module Buildizer
+  class Docker
+    attr_reader :builder
+    attr_reader :username
+    attr_reader :password
+    attr_reader :email
+    attr_reader :server
+
+    def initialize(builder, username:, password:, email:, server: nil)
+      @builder = builder
+      @username = username
+      @password = password
+      @email = email
+      @server = server
+    end
+
+    def image_klass(os_name, os_version)
+      ({
+        'ubuntu' => {
+          '12.04' => Image::Ubuntu1204,
+          '14.04' => Image::Ubuntu1404,
+          nil => Image::Ubuntu1404,
+        },
+        'centos' => {
+          'centos6' => Image::Centos6,
+          'centos7' => Image::Centos7,
+          nil => Image::Centos7,
+        },
+      }[os_name] || {})[os_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
+      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"
+    end
+
+    def logout!
+      builder.packager.command! 'docker logout', desc: "Docker logout"
+    end
+
+    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}"
+    end
+
+    def push_image!(image)
+      builder.packager.command! "docker push #{image.name}", desc: "Docker push #{image.name}"
+    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}"
+
+      push_image! image
+    end
+
+    def image_build_path(image)
+      builder.build_path.join(image.os_name).join(image.os_version)
+    end
+
+    def image_runtime_build_path(image)
+      image_build_path(image).join('build')
+    end
+
+    def container_package_path
+      Pathname.new('/package')
+    end
+
+    def container_build_path
+      container_package_path.join('build')
+    end
+
+    def run!(image, cmd:, env: {})
+      cmd = Array(cmd)
+
+      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}"
+    end
+  end # Docker
+end # Buildizer

data/lib/buildizer/error.rb

@@ -0,0 +1,4 @@
+module Buildizer
+  class Error < NetStatus::Exception
+  end # Error
+end # Buildizer

data/lib/buildizer/image/base.rb

@@ -0,0 +1,56 @@
+module Buildizer
+  module Image
+    class Base
+      attr_reader :instructions
+      attr_reader :docker
+
+      attr_accessor :target
+
+      def initialize(docker, **kwargs)
+        @instructions = []
+        @docker = docker
+
+        instruction :FROM, base_image
+      end
+
+      def os_name
+        raise
+      end
+
+      def os_package_cloud_name
+        os_name
+      end
+
+      def os_package_cloud_version
+        os_version
+      end
+
+      def os_version
+        raise
+      end
+
+      def fpm_output_type
+        raise
+      end
+
+      def fpm_extra_params
+      end
+
+      def build_dep(build_dep)
+        raise
+      end
+
+      def base_image
+        "buildizer/#{os_name}:#{os_version}"
+      end
+
+      def name
+        target.docker_image
+      end
+
+      def instruction(instruction, cmd)
+        instructions << [instruction.to_s.upcase, cmd].join(' ')
+      end
+    end # Base
+  end # Image
+end # Buildizer

data/lib/buildizer/image/centos.rb

@@ -0,0 +1,52 @@
+module Buildizer
+  module Image
+    class Centos < Base
+      attr_reader :os_version
+
+      def initialize(docker, os_version, **kwargs)
+        @os_version = os_version
+        super(docker, **kwargs)
+      end
+
+      def os_name
+        'centos'
+      end
+
+      def os_package_cloud_name
+        'el'
+      end
+
+      def os_package_cloud_version
+        os_version.match(/\d+$/).to_s.to_i
+      end
+
+      def fpm_output_type
+        'rpm'
+      end
+
+      def fpm_extra_params
+        Array(super).tap do |res|
+          res << '--rpm-use-file-permissions'
+        end
+      end
+
+      def build_dep(build_dep)
+        instruction :RUN, "yum-builddep -y #{build_dep.to_a.join(' ')}" if build_dep.any?
+      end
+
+      def add_repo(id:, name:, baseurl: nil, enabled: 1, gpgcheck: nil, gpgkey: nil, exclude: nil, includepkgs: nil, mirrorlist: nil)
+        repo = "[#{id}]\
+\\nname=#{name}\
+\\nenabled=#{enabled}\
+#{baseurl ? "\\nbaseurl=#{baseurl}" : nil}\
+#{mirrorlist ? "\\nmirrorlist=#{mirrorlist}" : nil}\
+#{gpgcheck ? "\\ngpgcheck=#{gpgcheck}" : nil}\
+#{gpgkey ? "\\ngpgkey=#{gpgkey}" : nil}\
+#{exclude ? "\\nexclude=#{exclude}" : nil}\
+#{includepkgs ? "\\nincludepkgs=#{includepkgs}" : nil}"
+
+        instruction :RUN, "bash -lec \"echo -e '#{repo}' >> /etc/yum.repos.d/CentOS-Extra-Buildizer.repo\""
+      end
+    end # Centos
+  end # Image
+end # Buildizer

data/lib/buildizer/image/centos6.rb

@@ -0,0 +1,9 @@
+module Buildizer
+  module Image
+    class Centos6 < Centos
+      def initialize(docker, **kwargs)
+        super(docker, 'centos6', **kwargs)
+      end
+    end # Centos6
+  end # Image
+end # Buildizer

data/lib/buildizer/image/centos7.rb

@@ -0,0 +1,9 @@
+module Buildizer
+  module Image
+    class Centos7 < Centos
+      def initialize(docker, **kwargs)
+        super(docker, 'centos7', **kwargs)
+      end
+    end # Centos7
+  end # Image
+end # Buildizer

data/lib/buildizer/image/ubuntu.rb

@@ -0,0 +1,39 @@
+module Buildizer
+  module Image
+    class Ubuntu < Base
+      attr_reader :os_version
+
+      def initialize(docker, os_version, **kwargs)
+        @os_version = os_version
+        super(docker, **kwargs)
+      end
+
+      def os_name
+        'ubuntu'
+      end
+
+      def os_codename
+        raise
+      end
+
+      def os_package_cloud_version
+        os_codename
+      end
+
+      def fpm_output_type
+        'deb'
+      end
+
+      def fpm_extra_params
+        Array(super).tap do |res|
+          res << '--deb-use-file-permissions'
+          res << '--deb-no-default-config-files'
+        end
+      end
+
+      def build_dep(build_dep)
+        instruction :RUN, "apt-get build-dep -y #{build_dep.to_a.join(' ')}" if build_dep.any?
+      end
+    end # Ubuntu
+  end # Image
+end # Buildizer

data/lib/buildizer/image/ubuntu1204.rb

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

data/lib/buildizer/image/ubuntu1404.rb

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

data/lib/buildizer/image.rb

@@ -0,0 +1,4 @@
+module Buildizer
+  module Image
+  end # Image
+end # Buildizer