dapp 0.0.24 → 0.1.0

data/lib/dapp/builder/ci_tagging.rb

@@ -1,53 +0,0 @@
-module Dapp
-  class Builder
-    # CI tagging strategy
-    module CiTagging
-      def tag_ci(image_id)
-        return unless opts[:tag_ci] || opts[:tag_build_id]
-
-        raise 'CI environment required (Travis or GitLab CI)' unless ENV['GITLAB_CI'] || ENV['TRAVIS']
-
-        spec = {
-          name: name,
-          repo: opts[:docker_repo]
-        }
-
-        tag_ci_branch_and_tag image_id, spec
-        tag_ci_build_id image_id, spec
-      end
-
-      private
-
-      def tag_ci_branch_and_tag(image_id, spec)
-        return unless opts[:tag_ci]
-
-        log 'Applying CI tagging strategy'
-
-        if ENV['GITLAB_CI']
-          branch = ENV['CI_BUILD_REF_NAME']
-          tag = ENV['CI_BUILD_TAG']
-        elsif ENV['TRAVIS']
-          branch = ENV['TRAVIS_BRANCH']
-          tag = ENV['TRAVIS_TAG']
-        end
-
-        docker.tag image_id, spec.merge(tag: branch) if branch
-        [tag, 'latest'].each { |t| docker.tag image_id, spec.merge(tag: t) } if tag
-      end
-
-      def tag_ci_build_id(image_id, spec)
-        return unless opts[:tag_build_id]
-
-        log 'Applying CI build id tag'
-
-        if ENV['GITLAB_CI']
-          build_id = ENV['CI_BUILD_ID']
-        elsif ENV['TRAVIS']
-          build_id = ENV['TRAVIS_BUILD_NUMBER']
-        end
-
-        docker.tag image_id, spec.merge(tag: build_id) if build_id
-      end
-    end
-  end
-end

data/lib/dapp/builder/git_tagging.rb

@@ -1,21 +0,0 @@
-module Dapp
-  class Builder
-    # Git tagging strategy
-    module GitTagging
-      def tag_git(image_id)
-        spec = {
-          name: name,
-          repo: opts[:docker_repo]
-        }
-
-        { commit: 'rev-parse HEAD', branch: 'rev-parse --abbrev-ref HEAD' }.each do |tag_type, git_command|
-          next unless opts[:"tag_#{tag_type}"]
-
-          log "Applying git #{tag_type} tag"
-
-          docker.tag image_id, spec.merge(tag: shellout("git -C #{home_path} #{git_command}").stdout.strip)
-        end
-      end
-    end
-  end
-end

data/lib/dapp/builder/manual_tagging.rb

@@ -1,22 +0,0 @@
-module Dapp
-  class Builder
-    # Manual tagging strategy
-    module ManualTagging
-      def tag_manual(image_id)
-        return unless opts[:tags]
-
-        log 'Applying manual tags'
-
-        opts[:tags].each do |tag|
-          spec = {
-            name: name,
-            tag: tag,
-            repo: opts[:docker_repo]
-          }
-
-          docker.tag image_id, spec
-        end
-      end
-    end
-  end
-end

data/lib/dapp/builder/ubuntu1404.rb

@@ -1,20 +0,0 @@
-module Dapp
-  class Builder
-    # Ubuntu 16.04 support
-    module Ubuntu1404
-      def from_ubuntu1404
-        # use ubuntu 14.04
-        docker.from 'ubuntu:14.04'
-        docker.run(
-          'apt-get update',
-          'apt-get -y dist-upgrade',
-          'apt-get -y install apt-utils git curl apt-transport-https',
-          step: :begining
-        )
-
-        # TERM & utf8
-        docker.env TERM: 'xterm', LANG: 'C.UTF-8', step: :begining
-      end
-    end
-  end
-end

data/lib/dapp/builder/ubuntu1604.rb

@@ -1,20 +0,0 @@
-module Dapp
-  class Builder
-    # Ubuntu 16.04 support
-    module Ubuntu1604
-      def from_ubuntu1604
-        # use ubuntu 16.04
-        docker.from 'ubuntu:16.04'
-        docker.run(
-          'apt-get update',
-          'apt-get -y dist-upgrade',
-          'apt-get -y install apt-utils git curl apt-transport-https',
-          step: :begining
-        )
-
-        # TERM & utf8
-        docker.env TERM: 'xterm', LANG: 'C.UTF-8', step: :begining
-      end
-    end
-  end
-end

data/lib/dapp/docker.rb

@@ -1,207 +0,0 @@
-module Dapp
-  # Dockerfile builder and docker binary wrapper
-  class Docker
-    def initialize(builder)
-      @builder = builder
-    end
-
-    def name(name = nil)
-      @name = name || @name
-    end
-
-    def from(from = nil)
-      @from = from || @from
-    end
-
-    def build_path(*path)
-      builder.build_path(builder.home_branch, [name, 'docker'].compact.join('.'), *path)
-    end
-
-    def run(*command, step: :build)
-      add_instruction step, :run, command.join(' && ')
-    end
-
-    def workdir(directory, step: :build)
-      add_instruction step, :workdir, directory
-    end
-
-    def copy(what, where, step: :build)
-      add_instruction step, :copy, what, where
-    end
-
-    def add(what, where, step: :build)
-      add_instruction step, :add, what, where
-    end
-
-    def add_artifact(file_path, filename, where, step: :build)
-      add_instruction step, :add_artifact, file_path, filename, where
-    end
-
-    def expose(*ports, step: :build)
-      add_instruction step, :expose, ports
-    end
-
-    def env(step: :build, **env)
-      add_instruction step, :env, env
-    end
-
-    def volume(*paths, step: :build)
-      add_instruction step, :volume, paths
-    end
-
-    def cmd(*commands, step: :build)
-      add_instruction step, :cmd, commands
-    end
-
-    def initialize_dup(other)
-      super
-
-      @name = @name.dup if @name
-      @from = @from.dup if @from
-
-      @instructions = @instructions.dup
-      @instructions.each do |step, step_instructions|
-        @instructions[step] = step_instructions.dup
-      end
-    end
-
-    def build
-      # prepare
-      generate_dockerfile
-
-      # build
-      res = docker("build --force-rm=true --rm=true #{build_path}", log_verbose: true)
-
-      # return image id
-      res.stdout.lines.grep(/^Successfully built ([0-9a-f]+)\n$/).first.strip.split.last
-    end
-
-    def image_exist?(**kwargs)
-      !image_id(**kwargs).nil?
-    end
-
-    def image_id(**kwargs)
-      image = images(**kwargs).first
-      image ? image[:id] : nil
-    end
-
-    def images(name:, tag: nil, repo: nil)
-      all_images.select { |i| i[:name] == pad_image_name(name: name, repo: repo) && (!tag || i[:tag] == tag) }
-    end
-
-    def all_images
-      docker('images').stdout.lines.drop(1).map(&:strip)
-                      .map { |line| Hash[[:name, :tag, :id].zip(line.strip.split(/\s{2,}/)[0..3])] }
-    end
-
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def tag(origin, new, force: true)
-      # FIXME -f flag was removed since docker v 1.10
-      # cmd = "tag#{' -f' if force} "
-      cmd = "tag "
-
-      if origin.is_a?(String)
-        origin_image_id = origin
-        cmd += origin
-      else
-        origin_image_id = image_id(origin)
-        cmd += pad_image_name(origin)
-      end
-
-      # auto rmi
-      if force && origin_image_id && (new_image_id = image_id(new))
-        rmi new if new_image_id != origin_image_id
-      end
-
-      docker cmd + ' ' + pad_image_name(**new)
-    end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def rmi(**kwargs)
-      docker "rmi #{pad_image_name(**kwargs)}"
-    end
-
-    def push(name:, tag: nil, repo: nil)
-      docker "push #{pad_image_name name: name, tag: tag, repo: repo}", log_verbose: true
-    end
-
-    protected
-
-    def pad_image_name(name:, tag: nil, repo: nil)
-      name = "#{repo}/#{name}" if repo
-      name = "#{name}:#{tag}" if tag
-      name
-    end
-
-    attr_reader :builder
-
-    def instructions(step)
-      (@instructions ||= {})[step] ||= []
-    end
-
-    def add_instruction(step, *args)
-      instructions(step) << args
-    end
-
-    def docker(command, **kwargs)
-      builder.shellout "docker #{command}", **kwargs
-    end
-
-    def dockerfile_path
-      build_path 'Dockerfile'
-    end
-
-    def generate_dockerfile_run(dockerfile, *params)
-      dockerfile.puts 'RUN ' + params[0]
-    end
-
-    def generate_dockerfile_copy(dockerfile, *params)
-      dockerfile.puts "COPY #{params[0]} #{params[1]}"
-    end
-
-    def generate_dockerfile_add(dockerfile, *params)
-      dockerfile.puts "ADD #{params[0]} #{params[1]}"
-    end
-
-    def generate_dockerfile_add_artifact(dockerfile, *params)
-      FileUtils.link params[0], build_path(params[1]), force: true
-      dockerfile.puts "ADD #{params[1]} #{params[2]}"
-    end
-
-    def generate_dockerfile_expose(dockerfile, *params)
-      dockerfile.puts 'EXPOSE ' + params[0].map(&:to_s).join(' ')
-    end
-
-    def generate_dockerfile_env(dockerfile, *params)
-      dockerfile.puts 'ENV ' + params[0].map { |k, v| %(#{k}="#{v}") }.join(' ')
-    end
-
-    def generate_dockerfile_volume(dockerfile, *params)
-      dockerfile.puts 'VOLUME ' + params[0].join(' ')
-    end
-
-    def generate_dockerfile_workdir(dockerfile, *params)
-      dockerfile.puts "WORKDIR  #{params[0]}"
-    end
-
-    def generate_dockerfile_cmd(dockerfile, *params)
-      dockerfile.puts 'CMD ' + params[0].join(' ')
-    end
-
-    def generate_dockerfile_step(dockerfile, step)
-      instructions(step).each do |directive, *params|
-        send :"generate_dockerfile_#{directive}", dockerfile, *params
-      end
-    end
-
-    def generate_dockerfile
-      File.open dockerfile_path, 'w' do |dockerfile|
-        dockerfile.puts 'FROM ' + from
-
-        [:begining, :prepare, :build, :setup].each do |step|
-          generate_dockerfile_step(dockerfile, step)
-        end
-      end
-    end
-  end
-end

data/lib/dapp/git_repo/chronicler.rb

@@ -1,44 +0,0 @@
-module Dapp
-  module GitRepo
-    # Gitkeeper for autogenerated and external data
-    class Chronicler < Base
-      def initialize(builder, name, **kwargs)
-        super
-
-        lock do
-          unless File.directory? chronodir_path
-            git "init --separate-git-dir=#{dir_path} #{chronodir_path}"
-            git_chrono 'commit --allow-empty -m init'
-          end
-        end
-      end
-
-      def chronodir_path(*path)
-        build_path name, *path
-      end
-
-      def commit!(comment = '+')
-        lock do
-          git_chrono 'add --all'
-          unless git_chrono('diff --cached --quiet', returns: [0, 1]).status.success?
-            git_chrono "commit -m #{comment}"
-          end
-        end
-      end
-
-      def cleanup!
-        lock do
-          super
-          FileUtils.rm_rf dir_path
-          FileUtils.rm_rf chronodir_path
-        end
-      end
-
-      protected
-
-      def git_chrono(command, **kwargs)
-        git "-C #{chronodir_path} #{command}", **kwargs
-      end
-    end
-  end
-end