buildizer 0.0.7 → 0.0.8

data/lib/buildizer/cli.rb

@@ -1,64 +1,4 @@
 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
-
-    desc "verify", "Verify targets params"
-    shared_options
-    def verify
-      self.class.construct_packager(options).verify!
-    end
+  module Cli
   end # Cli
 end # Buildizer

data/lib/buildizer/docker.rb

@@ -32,9 +32,9 @@ module Buildizer
 
     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
+           "(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
@@ -49,7 +49,7 @@ module Buildizer
 
       cmd = ["docker login"]
       cmd << "--email=#{cache[:email]}" if cache[:email]
-      cmd << "--username=#{cache[:username]}" if cache[:username]
+      cmd << "--username=#{cache[:user]}" if cache[:user]
       cmd << "--password=#{cache[:password]}" if cache[:password]
       cmd << "--server=#{cache[:server]}" if cache[:server]
       builder.packager.command! cmd.join(' '), desc: "Docker cache account login"
@@ -61,16 +61,30 @@ module Buildizer
     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}") if cache
+      builder.packager.command! "docker pull #{image.base_image}", desc: "Pull docker base image #{image.base_image}"
+      if cache
+        pull_cache_res = builder.packager.command(
+          "docker pull #{image.cache_name}",
+          desc: "Try to pull docker cache image #{image.cache_name}"
+        )
+        if pull_cache_res.status.success?
+          builder.packager.command! "docker tag -f #{image.cache_name} #{image.name}",
+                                     desc: "Tag cache image #{image.cache_name}" +
+                                           " as prepared build image #{image.name}"
+          builder.packager.command! "docker rmi #{image.cache_name}",
+                                     desc: "Remove cache image #{image.cache_name}"
+        end
+      end
     end
 
     def push_image(image)
-      builder.packager.command("docker push #{image.name}",
-                               desc: "Docker push #{image.name}") if cache
+      if cache
+        builder.packager.command! "docker tag -f #{image.name} #{image.cache_name}",
+                                   desc: "Tag prepared build image #{image.name}" +
+                                         " as cache image #{image.cache_name}"
+        builder.packager.command! "docker push #{image.cache_name}",
+                                   desc: "Push cache image #{image.cache_name}"
+      end
     end
 
     def build_image!(target)
@@ -78,7 +92,7 @@ module Buildizer
 
       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}"
+                                 desc: "Build docker image #{target.image.name}"
 
       push_image target.image
     end

data/lib/buildizer/image/base.rb

@@ -48,6 +48,10 @@ module Buildizer
         target.docker_image
       end
 
+      def cache_name
+        target.docker_cache_image
+      end
+
       def instruction(instruction, cmd)
         instructions << [instruction.to_s.upcase, cmd].join(' ')
       end

data/lib/buildizer/packager/buildizer_conf_mod.rb

@@ -0,0 +1,63 @@
+module Buildizer
+  class Packager
+    module BuildizerConfMod
+      using Refine
+
+      def buildizer_conf_path
+        package_path.join('Buildizer')
+      end
+
+      def buildizer_conf
+        @buildizer_conf ||= buildizer_conf_path.load_yaml
+      end
+
+      def buildizer_conf_update(conf)
+        buildizer_conf.update conf
+      end
+
+      def buildizer_conf_setup!
+        write_path(buildizer_conf_path, YAML.dump(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 # Packager
+end # Buildizer

data/lib/buildizer/packager/ci_mod.rb

@@ -0,0 +1,27 @@
+module Buildizer
+  class Packager
+    module CiMod
+      def ci_name
+        @ci_name ||= begin
+          case git_remote_url.to_s
+          when /github/
+            'travis'
+          when /gitlab/
+            'gitlab-ci'
+          else
+            raise Error, error: :input_error, message: "unable to determine ci to use"
+          end
+        end
+      end
+
+      def ci
+        @ci ||= begin
+          klass = {'travis' => Ci::Travis,
+                   'gitlab-ci' => Ci::GitlabCi}[ci_name.to_s.downcase]
+          raise Error, message: "unknown ci '#{ci_name}'" unless klass
+          klass.new(self)
+        end
+      end
+    end # CiMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/docker_cache_mod.rb

@@ -0,0 +1,103 @@
+module Buildizer
+  class Packager
+    module DockerCacheMod
+      def docker_cache
+        return unless repo = ENV['BUILDIZER_DOCKER_CACHE']
+        {user: ENV['BUILDIZER_DOCKER_CACHE_USERNAME'],
+         password: ENV['BUILDIZER_DOCKER_CACHE_PASSWORD'],
+         email: ENV['BUILDIZER_DOCKER_CACHE_EMAIL'],
+         server: ENV['BUILDIZER_DOCKER_CACHE_SERVER'],
+         repo: repo}
+      end
+
+      def setup_docker_cache_repo
+        cli.options['docker_cache']
+      end
+
+      def setup_docker_cache_org
+        setup_docker_cache_repo.split('/').first
+      end
+
+      def setup_docker_cache_user
+        cli.options['docker_cache_user'] || user_settings_docker_cache_user_list(setup_docker_cache_org).first
+      end
+
+      def setup_docker_cache_password
+        @setup_docker_cache_password ||= begin
+          settings_password = user_settings_docker_cache_user(setup_docker_cache_user)['password']
+          if cli.options['reset_docker_cache_password'] or settings_password.nil?
+            cli.ask("Docker cache user '#{setup_docker_cache_user}' password:", echo: false).tap{puts}
+          else
+            settings_password
+          end
+        end
+      end
+
+      def setup_docker_cache_email
+        cli.options['docker_cache_email'] || user_settings_docker_cache_user(setup_docker_cache_user)['email']
+      end
+
+      def setup_docker_cache_server
+        cli.options['docker_cache_server'] || user_settings_docker_cache_user(setup_docker_cache_user)['server']
+      end
+
+      def user_settings_docker_cache
+        user_settings['docker_cache'] ||= {}
+      end
+
+      def user_settings_docker_cache_org(org)
+        user_settings_docker_cache['org'] ||= {}
+        user_settings_docker_cache['org'][org] ||= {}
+      end
+
+      def user_settings_docker_cache_user(user)
+        user_settings_docker_cache['user'] ||= {}
+        user_settings_docker_cache['user'][user] ||= {}
+      end
+
+      def user_settings_docker_cache_user_list(org)
+        user_settings_docker_cache_org(org)['user'] ||= []
+      end
+
+      def user_settings_docker_cache_repo_list(org)
+        user_settings_docker_cache_org(org)['repo'] ||= []
+      end
+
+      def docker_cache_update_settings?
+        not setup_docker_cache_repo.nil?
+      end
+
+      def docker_cache_clear_settings?
+        cli.options['clear_docker_cache']
+      end
+
+      def docker_cache_setup!
+        if docker_cache_update_settings?
+          raise Error, error: :input_error,
+                       message: "docker cache user required" unless setup_docker_cache_user
+          raise Error, error: :input_error,
+                       message: "bad docker cache user" if setup_docker_cache_user.empty?
+
+          user_list = user_settings_docker_cache_user_list(setup_docker_cache_org)
+          user_list.push(setup_docker_cache_user) unless user_list.include? setup_docker_cache_user
+
+          raise Error, error: :input_error,
+                       message: 'docker cache email required' unless setup_docker_cache_email
+          raise Error, error: :input_error,
+                       message: "bad docker cache email" unless setup_docker_cache_email =~ /.+@.+/
+
+          user_settings_docker_cache_user(setup_docker_cache_user)['email'] = setup_docker_cache_email
+          user_settings_docker_cache_user(setup_docker_cache_user)['server'] = setup_docker_cache_server
+          user_settings_docker_cache_user(setup_docker_cache_user)['password'] = setup_docker_cache_password
+
+          repo_list = user_settings_docker_cache_repo_list(setup_docker_cache_org)
+          repo_list.push(setup_docker_cache_repo) unless repo_list.include? setup_docker_cache_repo
+
+          user_settings_save!
+        end
+
+        ci.docker_cache_setup!
+      end
+    end # DockerCacheMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/git_mod.rb

@@ -0,0 +1,16 @@
+module Buildizer
+  class Packager
+    module GitMod
+      def git_available?
+        res = raw_command 'git status'
+        res.status.success?
+      end
+
+      def git_remote_url
+        return unless git_available?
+        res = raw_command 'git config --get remote.origin.url'
+        res.stdout.strip
+      end
+    end # GitMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/misc_mod.rb

@@ -0,0 +1,61 @@
+module Buildizer
+  class Packager
+    module MiscMod
+      def command(*args, do_raise: false, log_failure: nil, **kwargs)
+        if debug
+          Shellfold.run(*args, log_failure: log_failure, **kwargs).tap do |cmd|
+            if not cmd.status.success? and do_raise
+              raise Error.new(error: :error, message: "external command error")
+            end
+          end
+        else
+          raw_command(*args, do_raise: do_raise, **kwargs)
+        end
+      end
+
+      def command!(*args, **kwargs)
+        command(*args, do_raise: true, log_failure: true, **kwargs)
+      end
+
+      def raw_command(*args, do_raise: false, **kwargs)
+        Mixlib::ShellOut.new(*args, **kwargs).tap do |cmd|
+          cmd.run_command
+          if not cmd.status.success? and do_raise
+            raise Error.new(error: :error,
+                            message: "external command error: " +
+                                     [args.join(' '),
+                                      cmd.stdout + cmd.stderr].reject(&:empty?).join(' => '))
+          end
+        end
+      end
+
+      def raw_command!(*args, **kwargs)
+        raw_command(*args, do_raise: true, **kwargs)
+      end
+
+      def write_path(path, value)
+        with_log(desc: "Write path #{path}") do |&fin|
+          recreate = path.exist?
+          if path.exist?
+            if path.read == value
+              fin.call 'OK'
+            else
+              path.write value
+              fin.call 'UPDATED'
+            end
+          else
+            path.write value
+            fin.call 'CREATED'
+          end
+        end
+      end
+
+      def with_log(desc: nil, &blk)
+        puts("   #{desc}") if debug and desc
+        blk.call do |status|
+          puts("=> #{desc} [#{status || 'OK'}]") if debug and desc
+        end
+      end
+    end # MiscMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/overcommit_mod.rb

@@ -0,0 +1,85 @@
+module Buildizer
+  class Packager
+    module OvercommitMod
+      using Refine
+
+      def overcommit_conf_path
+        package_path.join('.overcommit.yml')
+      end
+
+      def overcommit_hooks_path
+        package_path.join('.git-hooks')
+      end
+
+      def overcommit_hooks_pre_commit_path
+        overcommit_hooks_path.join('pre_commit')
+      end
+
+      def overcommit_conf
+        @overcommit_conf ||= overcommit_conf_path.load_yaml
+      end
+
+      def overcommit_conf_raw
+        YAML.dump(overcommit_conf)
+      end
+
+      def overcommit_conf_dump!
+        write_path overcommit_conf_path, overcommit_conf_raw
+        command! 'overcommit --sign'
+      end
+
+      def overcommit_setup!
+        overcommit_hooks_path.mkpath
+        overcommit_conf_dump!
+        command! 'overcommit --install'
+      end
+
+      def overcommit_verify_setup!
+        hookcode = <<-HOOKCODE
+module Overcommit::Hook::PreCommit
+  class BuildizerVerify < Base
+    def run
+      return :fail unless system("buildizer verify")
+      :pass
+    end
+  end
+end
+        HOOKCODE
+
+        _overcommit_add_precommit!(:buildizer_verify, hookcode, desc: "Verify Buildizer conf file")
+      end
+
+      def overcommit_ci_setup!
+        hookcode = <<-HOOKCODE
+module Overcommit::Hook::PreCommit
+  class BuildizerCiVerify < Base
+    def run
+      return :fail unless system("buildizer setup --verify-ci")
+      :pass
+    end
+  end
+end
+        HOOKCODE
+
+        _overcommit_add_precommit!(:buildizer_ci_verify, hookcode,
+                                   desc: "Verify #{ci.ci_name} configuration is up to date")
+      end
+
+      def _overcommit_add_precommit!(name, hookcode, desc: nil, required: true)
+        hook_name = name.to_s.split('_').map(&:capitalize).join
+        overcommit_conf['PreCommit'] ||= {}
+        overcommit_conf['PreCommit'][hook_name] = {}.tap do |hook|
+          hook['enabled'] = true
+          hook['required'] = required
+          hook['desc'] = desc if desc
+        end
+        overcommit_conf_dump!
+
+        overcommit_hooks_pre_commit_path.mkpath
+        path = overcommit_hooks_pre_commit_path.join("#{name}.rb")
+        write_path path, hookcode
+        command! 'overcommit --sign pre-commit'
+      end
+    end # OvercommitMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/package_cloud_mod.rb

@@ -0,0 +1,81 @@
+module Buildizer
+  class Packager
+    module PackageCloudMod
+      def package_cloud_repo
+        ENV['PACKAGECLOUD'].to_s.split(',')
+      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 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 user_settings_package_cloud
+        user_settings['package_cloud'] ||= {}
+      end
+
+      def user_settings_package_cloud_token
+        user_settings_package_cloud['token'] ||= {}
+      end
+
+      def setup_package_cloud_repo_list
+        Array(cli.options['package_cloud']).uniq
+      end
+
+      def setup_package_cloud_repo_desc_list
+        setup_package_cloud_repo_list.map do |repo|
+          org, name = repo.split('/')
+          {repo: repo, org: org, name: name, token: user_settings_package_cloud_token[org]}
+        end
+      end
+
+      def setup_package_cloud_org_desc_list
+        setup_package_cloud_repo_desc_list.map {|desc| {org: desc[:org], token: desc[:token]}}.uniq
+      end
+
+      def setup_package_cloud_org_list
+        setup_package_cloud_repo_desc_list.map {|desc| desc[:org]}.uniq
+      end
+
+      def package_cloud_update_settings?
+        cli.options['package_cloud']
+      end
+
+      def package_cloud_clear_settings?
+        cli.options['clear_package_cloud']
+      end
+
+      def package_cloud_setup!
+        if package_cloud_update_settings?
+          update_user_settings = false
+          setup_package_cloud_org_list.each do |org|
+            if user_settings_package_cloud_token[org].nil? or
+               cli.options['reset_package_cloud_token']
+              token = cli.ask("Enter token for package_cloud org '#{org}':",
+                               echo: false, default: 'none').tap{puts}
+              token = (token == 'none' ? nil : token)
+              if user_settings_package_cloud_token[org] != token
+                user_settings_package_cloud_token[org] = token
+                update_user_settings = true
+              end
+            end
+          end
+          user_settings_save! if update_user_settings
+        end
+
+        ci.package_cloud_setup!
+      end
+    end # PackageCloudMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/package_version_tag_mod.rb

@@ -0,0 +1,15 @@
+module Buildizer
+  class Packager
+    module PackageVersionTagMod
+      using Refine
+
+      def package_version_tag_required_for_deploy?
+        ENV['BUILDIZER_REQUIRE_TAG'].to_s.on?
+      end
+
+      def package_version_tag
+        ci.git_tag
+      end
+    end # PackageVersionTagMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/project_settings_mod.rb

@@ -0,0 +1,27 @@
+module Buildizer
+  class Packager
+    module ProjectSettingsMod
+      using Refine
+
+      def project_settings_path
+        package_path.join('.buildizer.yml')
+      end
+
+      def project_settings
+        @project_settings ||= begin
+          (project_settings_path.load_yaml || {}).tap do |settings|
+            settings['master'] = cli.options['master'] if cli.options.key? 'master'
+          end
+        end
+      end
+
+      def project_settings_save!
+        write_path(project_settings_path, YAML.dump(project_settings))
+      end
+
+      def project_settings_setup!
+        project_settings_save!
+      end
+    end # ProjectSettingsMod
+  end # Packager
+end # Buildizer

data/lib/buildizer/packager/user_settings_mod.rb

@@ -0,0 +1,24 @@
+module Buildizer
+  class Packager
+    module UserSettingsMod
+      using Refine
+
+      def user_settings_path
+        work_path.join('settings.yml')
+      end
+
+      def user_settings
+        @user_settings ||= (user_settings_path.load_yaml || {})
+      end
+
+      def user_settings_save!
+        write_path(user_settings_path, YAML.dump(user_settings))
+        user_settings_path.chmod(0600)
+      end
+
+      def user_settings_setup!
+        user_settings_save!
+      end
+    end # UserSettingsMod
+  end # Packager
+end # Buildizer