dapp 0.0.24 → 0.1.0

data/lib/dapp/config/docker.rb

@@ -0,0 +1,39 @@
+module Dapp
+  module Config
+    # Docker
+    class Docker
+      attr_reader :_expose, :_workdir, :_env
+      attr_reader :_from_cache_version
+
+      def initialize
+        @_expose = []
+        @_env = []
+      end
+
+      def from(image_name, cache_version: nil)
+        @_from = image_name
+        @_from_cache_version = cache_version
+      end
+
+      def expose(*args)
+        @_expose.concat(args)
+      end
+
+      def workdir(path)
+        @_workdir = path
+      end
+
+      def env(*args)
+        @_env.concat(args)
+      end
+
+      def _from
+        @_from || fail(Error::Config, code: :docker_from_not_defined)
+      end
+
+      def clone
+        Marshal.load(Marshal.dump(self))
+      end
+    end
+  end
+end

data/lib/dapp/config/git_artifact.rb

@@ -0,0 +1,78 @@
+module Dapp
+  module Config
+    # GitArtifact
+    class GitArtifact
+      attr_reader :_local
+      attr_reader :_remote
+
+      def initialize
+        @_local  = []
+        @_remote = []
+      end
+
+      def local(*args)
+        @_local.tap { |local| local << Local.new(*args) unless args.empty? }
+      end
+
+      def remote(*args)
+        @_remote.tap { |remote| remote << Remote.new(*args) unless args.empty? }
+      end
+
+      def clone
+        Marshal.load(Marshal.dump(self))
+      end
+
+      # Local
+      class Local
+        attr_accessor :_where_to_add, :_cwd, :_paths, :_owner, :_group
+
+        def initialize(where_to_add, **options)
+          @_cwd          = ''
+          @_where_to_add = where_to_add
+
+          options.each do |k, v|
+            respond_to?("_#{k}=") ? send(:"_#{k}=", v) : fail(Error::Config, code: :git_artifact_unexpected_attribute,
+                                                                             data: { type: object_name, attr: k })
+          end
+        end
+
+        def _artifact_options
+          {
+            where_to_add: _where_to_add,
+            cwd:          _cwd,
+            paths:        _paths,
+            owner:        _owner,
+            group:        _group
+          }
+        end
+
+        def clone
+          Marshal.load(Marshal.dump(self))
+        end
+
+        protected
+
+        def object_name
+          self.class.to_s.split('::').last
+        end
+      end
+
+      # Remote
+      class Remote < Local
+        attr_accessor :_url, :_name, :_branch, :_ssh_key_path
+
+        def initialize(url, where_to_add, **options)
+          @_url          = url
+          @_name         = url.gsub(%r{.*?([^\/ ]+)\.git}, '\\1')
+          @_branch       = options.delete(:branch)
+          @_ssg_key_path = options.delete(:ssg_key_path)
+          super(where_to_add, **options)
+        end
+
+        def _artifact_options
+          super.merge(name: _name, branch: _branch)
+        end
+      end
+    end
+  end
+end

data/lib/dapp/config/main.rb

@@ -0,0 +1,23 @@
+module Dapp
+  module Config
+    # Main
+    class Main < Application
+      def initialize(**options)
+        @_home_path    = Pathname.new(options[:dappfile_path]).parent.expand_path.to_s
+        @_name         = Pathname.new(@_home_path).basename.to_s
+        @_builder      = Pathname.new(@_home_path).join('Berksfile').exist? ? :chef : :shell
+
+        @_docker       = Docker.new
+        @_git_artifact = GitArtifact.new
+        @_shell        = Shell.new
+        @_chef         = Chef.new
+
+        super(nil)
+      end
+
+      def name(value)
+        @_name = value
+      end
+    end
+  end
+end

data/lib/dapp/config/shell.rb

@@ -0,0 +1,40 @@
+module Dapp
+  module Config
+    # Shell
+    class Shell
+      attr_reader :_infra_install, :_infra_setup, :_app_install, :_app_setup
+      attr_reader :_infra_install_cache_version, :_infra_setup_cache_version, :_app_install_cache_version, :_app_setup_cache_version
+
+      def initialize
+        @_infra_install = []
+        @_infra_setup   = []
+        @_app_install   = []
+        @_app_setup     = []
+      end
+
+      def infra_install(*args, cache_version: nil)
+        @_infra_install.concat(args)
+        @_infra_install_cache_version = cache_version
+      end
+
+      def infra_setup(*args, cache_version: nil)
+        @_infra_setup.concat(args)
+        @_infra_setup_cache_version = cache_version
+      end
+
+      def app_install(*args, cache_version: nil)
+        _app_install.concat(args)
+        @_app_install_cache_version = cache_version
+      end
+
+      def app_setup(*args, cache_version: nil)
+        _app_setup.concat(args)
+        @_app_setup_cache_version = cache_version
+      end
+
+      def clone
+        Marshal.load(Marshal.dump(self))
+      end
+    end
+  end
+end

data/lib/dapp/controller.rb

@@ -0,0 +1,103 @@
+module Dapp
+  # Controller
+  class Controller
+    include Helper::Log
+    include Helper::Shellout
+
+    attr_reader :cli_options, :patterns
+
+    def initialize(cli_options:, patterns: nil)
+      @cli_options = cli_options
+      @cli_options[:log_indent] = 0
+
+      @patterns = patterns || []
+      @patterns << '*' unless @patterns.any?
+
+      paint_initialize
+      Helper::I18n.initialize
+      build_confs
+    end
+
+    def build
+      @build_confs.each do |build_conf|
+        log_step(build_conf._name)
+        with_log_indent { Application.new(config: build_conf, cli_options: cli_options).build! }
+      end
+    end
+
+    def list
+      @build_confs.each do |build_conf|
+        log(build_conf._name)
+      end
+    end
+
+    def push(repo)
+      fail Error::Controller, code: :push_command_unexpected_apps unless @build_confs.one?
+      Application.new(config: @build_confs.first, cli_options: cli_options, ignore_git_fetch: true).export!(repo)
+    end
+
+    def smartpush(repo_prefix)
+      @build_confs.each do |build_conf|
+        log_step(build_conf._name)
+        repo = File.join(repo_prefix, build_conf._name)
+        with_log_indent { Application.new(config: build_conf, cli_options: cli_options, ignore_git_fetch: true).export!(repo) }
+      end
+    end
+
+    def flush_build_cache
+      @build_confs.each do |build_conf|
+        log(build_conf._name)
+        app = Application.new(config: build_conf, cli_options: cli_options, ignore_git_fetch: true)
+        FileUtils.rm_rf app.build_cache_path
+      end
+    end
+
+    def self.flush_stage_cache
+      shellout('docker rmi $(docker images --format="{{.Repository}}:{{.Tag}}" dapp)')
+      shellout('docker rmi $(docker images -f "dangling=true" -q)')
+    end
+
+    private
+
+    def build_confs
+      @build_confs ||= begin
+        dappfiles = []
+        if File.exist? dappfile_path
+          dappfiles << dappfile_path
+        elsif File.exist? dapps_path
+          dappfiles += Dir.glob(File.join([dapps_path, '*', 'Dappfile'].compact))
+        else
+          fail Error::Controller, code: :dappfile_not_found
+        end
+        dappfiles.flatten.uniq!
+        dappfiles.map { |dappfile| apps(dappfile, app_filters: patterns) }.flatten.tap do |apps|
+          fail Error::Controller, code: :no_such_app, data: { path: dappfile_path, patterns: patterns.join(', ') } if apps.empty?
+        end
+      end
+    end
+
+    def apps(dappfile_path, app_filters:)
+      config = Config::Main.new(dappfile_path: dappfile_path) do |conf|
+        conf.instance_eval File.read(dappfile_path), dappfile_path
+      end
+      config._apps.select { |app| app_filters.any? { |pattern| File.fnmatch(pattern, app._name) } }
+    end
+
+    def dappfile_path
+      @dappfile_path ||= File.join [cli_options[:dir], 'Dappfile'].compact
+    end
+
+    def dapps_path
+      @dapps_path ||= File.join [cli_options[:dir], '.dapps'].compact
+    end
+
+    def paint_initialize
+      Paint.mode = case cli_options[:log_color]
+                   when 'auto' then STDOUT.tty? ? 8 : 0
+                   when 'on'   then 8
+                   when 'off'  then 0
+                   else fail
+                   end
+    end
+  end # Controller
+end # Dapp

data/lib/dapp/docker_image.rb

@@ -0,0 +1,51 @@
+module Dapp
+  # DockerImage
+  class DockerImage
+    include Helper::Shellout
+
+    attr_reader :from
+    attr_reader :name
+
+    def initialize(name:, from: nil)
+      @from = from
+      @name = name
+    end
+
+    def id
+      @id || begin
+        unless (output = shellout!("docker images -q --no-trunc=true #{name}").stdout.strip).empty?
+          output
+        end
+      end
+    end
+
+    def untag!
+      fail Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
+      shellout!("docker rmi #{name}")
+    end
+
+    def push!(log_verbose: false, log_time: false)
+      fail Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+      shellout!("docker push #{name}", log_verbose: log_verbose, log_time: log_time)
+    end
+
+    def pull!(log_verbose: false, log_time: false)
+      return if tagged?
+      shellout!("docker pull #{name}", log_verbose: log_verbose, log_time: log_time)
+      @pulled = true
+    end
+
+    def tagged?
+      !!id
+    end
+
+    def pulled?
+      !!@pulled
+    end
+
+    def info
+      fail Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
+      shellout!("docker inspect --format='{{.Created}} {{.Size}}' #{name}").stdout.strip.split
+    end
+  end # DockerImage
+end # Dapp

data/lib/dapp/error/application.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Application
+    class Application < Base; end
+  end
+end

data/lib/dapp/error/base.rb

@@ -0,0 +1,10 @@
+module Dapp
+  module Error
+    # Base
+    class Base < NetStatus::Exception
+      def initialize(net_status = {})
+        super(net_status.merge(context: self.class.to_s.split('::').last.downcase))
+      end
+    end
+  end
+end

data/lib/dapp/error/build.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Build
+    class Build < Base; end
+  end
+end

data/lib/dapp/error/config.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Config
+    class Config < Base; end
+  end
+end

data/lib/dapp/error/controller.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Controller
+    class Controller < Base; end
+  end
+end

data/lib/dapp/error/shellout.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Shellout
+    class Shellout < Base; end
+  end
+end

data/lib/dapp/filelock.rb

@@ -28,7 +28,7 @@ module Dapp
     protected
 
     def filelock_lockfile(filelock, error_message: 'Already in use!', timeout: 10)
-      File.open(build_path(filelock), File::RDWR | File::CREAT, 0644) do |file|
+      File.open(build_path(filelock), File::RDWR | File::CREAT, 0o644) do |file|
         Timeout.timeout(timeout) do
           file.flock(File::LOCK_EX)
         end

data/lib/dapp/git_artifact.rb

@@ -1,233 +1,83 @@
 module Dapp
   # Artifact from Git repo
   class GitArtifact
-    # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-    def initialize(builder, repo, where_to_add, name: nil, branch: 'master', cwd: nil, paths: nil, owner: nil, group: nil,
-                   interlayer_period: 7 * 24 * 3600, build_path: nil, flush_cache: false)
-      @builder = builder
+    attr_reader :repo
+    attr_reader :name
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(repo, where_to_add:, name: nil, branch: nil, commit: nil,
+                   cwd: nil, paths: nil, owner: nil, group: nil)
       @repo = repo
       @name = name
 
       @where_to_add = where_to_add
-      @branch = branch
+
+      @branch = branch || repo.application.cli_options[:git_artifact_branch] || repo.branch
+      @commit = commit
+
       @cwd = cwd
       @paths = paths
       @owner = owner
       @group = group
-
-      @interlayer_period = interlayer_period
-
-      @build_path = build_path || []
-
-      @atomizer = Atomizer.new builder, build_path(filename('.atomizer'))
-
-      # check params hash
-      lock do
-        cleanup! unless !flush_cache && File.exist?(paramshash_path) && File.read(paramshash_path) == paramshash
-        File.write paramshash_path, paramshash
-      end
-    end
-    # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
-
-    def build_path(*paths)
-      builder.build_path(*@build_path, *paths)
     end
+    # rubocop:enable Metrics/ParameterLists
 
-    def add_multilayer!
-      lock_with_repo do
-        # create and add archive
-        create_and_add_archive
-        return if archive_commit == repo_latest_commit
+    def archive_apply_command(stage)
+      credentials = [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
 
-        # add layer patches
-        latest_layer = add_layer_patches
-        if latest_layer
-          latest_layer_commit = layer_commit(latest_layer)
-          return if latest_layer_commit == repo_latest_commit
-        end
+      ["install #{credentials.join(' ')} -d #{where_to_add}",
+       ["git --git-dir=#{repo.container_build_dir_path} archive #{stage.layer_commit(self)}:#{cwd} #{paths}",
+        "#{sudo}tar -x -C #{where_to_add}"].join(' | ')]
+    end
 
-        # empty changes
-        unless any_changes?(latest_layer_commit || archive_commit)
-          remove_latest!
-          return
-        end
+    def apply_patch_command(stage)
+      current_commit = stage.layer_commit(self)
+      prev_commit = stage.prev_source_stage.layer_commit(self)
 
-        # create and add last patch
-        create_and_add_last_patch(latest_layer, latest_layer_commit)
+      if prev_commit != current_commit || any_changes?(prev_commit, current_commit)
+        [["git --git-dir=#{repo.container_build_dir_path} #{diff_command(prev_commit, current_commit)}",
+          "#{sudo}git apply --whitespace=nowarn --directory=#{where_to_add} " \
+          '$(if [[ "$(git --version)" != "git version 1."* ]]; then echo "--unsafe-paths"; fi)'].join(' | ')] # FIXME
+      else
+        []
       end
     end
 
-    def cleanup!
-      lock do
-        FileUtils.rm_f [
-          paramshash_path,
-          archive_path,
-          archive_commitfile_path,
-          Dir.glob(layer_patch_path('*')),
-          Dir.glob(layer_commitfile_path('*')),
-          latest_patch_path,
-          latest_commitfile_path
-        ].flatten
-      end
+    def any_changes?(from, to = latest_commit)
+      !repo.git_bare(diff_command(from, to, quiet: true), returns: [0, 1]).status.success?
     end
 
-    def exist_in_step?(path, step)
-      repo.exist_in_commit?(path, commit_by_step(step))
+    def patch_size(from, to)
+      repo.git_bare("#{diff_command(from, to)} | wc -c").stdout.strip.to_i
     end
 
-    def prepare_step_commit
-      archive_commit
+    def latest_commit
+      @latest_commit ||= commit || repo.latest_commit(branch)
     end
 
-    def build_step_commit
-      layer_commit(layers.last) || archive_commit
+    def paramshash
+      Digest::SHA256.hexdigest [cwd, paths, owner, group].map(&:to_s).join(':::')
     end
 
-    def setup_step_commit
-      latest_commit || layer_commit(layers.last) || archive_commit
+    def paths(with_cwd = false)
+      [@paths].flatten.compact.map { |path| (with_cwd && cwd ? "#{cwd}/#{path}" : path).gsub(%r{^\/*|\/*$}, '') }.join(' ') if @paths
     end
 
-    def commit_by_step(step)
-      send :"#{step}_step_commit"
+    def filename(ending)
+      "#{repo.name}#{name ? "_#{name}" : nil}#{ending}"
     end
 
-    def any_changes?(from)
-      !repo.git_bare("diff --quiet #{from}..#{repo_latest_commit}#{" --relative=#{cwd}" if cwd} -- #{paths(true)}", returns: [0, 1]).status.success?
-    end
+    protected
 
-    attr_reader :repo
-    attr_reader :name
     attr_reader :where_to_add
+    attr_reader :commit
     attr_reader :branch
     attr_reader :cwd
     attr_reader :owner
     attr_reader :group
-    attr_reader :interlayer_period
-
-    protected
-
-    attr_reader :builder
-    attr_reader :atomizer
-
-    def lock_with_repo(&blk)
-      lock do
-        repo.lock(&blk)
-      end
-    end
-
-    def create_and_add_archive
-      create_archive! unless archive_exist?
-      add_archive
-    end
-
-    def add_layer_patches
-      latest_layer = nil
-      layers.each do |layer|
-        add_layer_patch layer
-        latest_layer = layer
-      end
-
-      latest_layer
-    end
-
-    def create_and_add_last_patch_as_layer_patch(latest_layer, latest_layer_commit)
-      remove_latest!
-      layer = latest_layer.to_i + 1
-      create_layer_patch!(latest_layer_commit || archive_commit, layer)
-      add_layer_patch layer
-    end
-
-    def create_and_add_last_patch_as_latest_patch(_latest_layer, latest_layer_commit)
-      if latest_commit != repo_latest_commit
-        create_latest_patch!(latest_layer_commit || archive_commit)
-      end
-      add_latest_patch
-    end
-
-    def create_and_add_last_patch(latest_layer, latest_layer_commit)
-      if (Time.now - repo.commit_at(latest_layer_commit || archive_commit)) > interlayer_period
-        create_and_add_last_patch_as_layer_patch(latest_layer, latest_layer_commit)
-      else
-        create_and_add_last_patch_as_latest_patch(latest_layer, latest_layer_commit)
-      end
-    end
-
-    def paths(with_cwd = false)
-      [@paths].flatten.compact.map { |path| (with_cwd && cwd ? "#{cwd}/#{path}" : path).gsub(%r{^\/*|\/*$}, '') }.join(' ') if @paths
-    end
-
-    def repo_latest_commit
-      repo.latest_commit(branch)
-    end
-
-    def filename(ending)
-      "#{repo.name}#{name ? "_#{name}" : nil}.#{branch}#{ending}"
-    end
-
-    def paramshash_filename
-      filename '.paramshash'
-    end
-
-    def paramshash_path
-      build_path paramshash_filename
-    end
-
-    def paramshash
-      Digest::SHA256.hexdigest [cwd, paths, owner, group].map(&:to_s).join(':::')
-    end
-
-    def archive_filename
-      filename '.tar.gz'
-    end
-
-    def archive_path
-      build_path archive_filename
-    end
-
-    def archive_commitfile_path
-      build_path filename '.commit'
-    end
-
-    def archive_commit
-      File.read archive_commitfile_path
-    end
-
-    def create_arhive_with_owner_substitution!
-      Dir.mktmpdir('dapp_change_archive_owner') do |tmpdir_path|
-        atomizer << tmpdir_path
-        repo.git_bare "archive #{repo_latest_commit}:#{cwd} #{paths} | /bin/tar --extract --directory #{tmpdir_path}"
-        builder.shellout("/usr/bin/find #{tmpdir_path} -maxdepth 1 -mindepth 1 -printf '%P\\n' | /bin/tar -czf #{archive_path} -C #{tmpdir_path}" \
-                         " -T - --owner=#{owner || 'root'} --group=#{group || 'root'}")
-      end
-    end
-
-    def create_simple_archive!
-      repo.git_bare "archive --format tar.gz #{repo_latest_commit}:#{cwd} -o #{archive_path} #{paths}"
-    end
-
-    def create_archive!
-      atomizer << archive_path
-      atomizer << archive_commitfile_path
-
-      if owner || group
-        create_arhive_with_owner_substitution!
-      else
-        create_simple_archive!
-      end
-
-      File.write archive_commitfile_path, repo_latest_commit
-    end
-
-    def archive_exist?
-      File.exist? archive_commitfile_path
-    end
-
-    def add_archive
-      builder.docker.add_artifact archive_path, archive_filename, where_to_add, step: :prepare
-    end
 
     def sudo_format_user(user)
-      user.to_i.to_s == user.to_s ? "\\##{user}" : user
+      user.to_s.to_i.to_s == user ? "\\\##{user}" : user
     end
 
     def sudo
@@ -242,87 +92,8 @@ module Dapp
       sudo
     end
 
-    def add_patch(filename, step:)
-      builder.docker.add_artifact(build_path(filename), filename, '/tmp', step: step)
-
-      builder.docker.run(
-        "zcat /tmp/#{filename} | #{sudo}git apply --whitespace=nowarn --directory=#{where_to_add}",
-        "rm /tmp/#{filename}",
-        step: step
-      )
-    end
-
-    def create_patch!(from, filename, commitfile_path)
-      atomizer << build_path(filename)
-      atomizer << commitfile_path
-
-      repo.git_bare "diff --binary #{from}..#{repo_latest_commit}#{" --relative=#{cwd}" if cwd} -- #{paths(true)} | gzip > #{build_path filename}"
-      File.write commitfile_path, repo_latest_commit
-    end
-
-    def layer_filename(layer, ending)
-      filename "_layer_#{layer.is_a?(Fixnum) ? format('%04d', layer) : layer}#{ending}"
-    end
-
-    def layer_patch_filename(layer)
-      layer_filename(layer, '.patch.gz')
-    end
-
-    def layer_patch_path(layer)
-      build_path layer_patch_filename(layer)
-    end
-
-    def layer_commitfile_path(layer)
-      build_path layer_filename(layer, '.commit')
-    end
-
-    def layer_commit(layer)
-      File.read layer_commitfile_path(layer) if File.exist? layer_commitfile_path(layer)
-    end
-
-    def layers
-      Dir.glob(layer_commitfile_path('*')).map { |path| path.gsub(/.*_(\d+)\.commit$/, '\\1').to_i }.sort
-    end
-
-    def create_layer_patch!(from, layer)
-      create_patch! from, layer_patch_filename(layer), layer_commitfile_path(layer)
-    end
-
-    def add_layer_patch(layer)
-      add_patch layer_patch_filename(layer), step: :build
-    end
-
-    def latest_patch_filename
-      filename '_latest.patch.gz'
-    end
-
-    def latest_patch_path
-      build_path latest_patch_filename
-    end
-
-    def latest_commitfile_path
-      build_path filename '_latest.commit'
-    end
-
-    def latest_commit
-      File.read latest_commitfile_path if File.exist? latest_commitfile_path
-    end
-
-    def create_latest_patch!(from)
-      create_patch! from, latest_patch_filename, latest_commitfile_path
-    end
-
-    def add_latest_patch
-      add_patch latest_patch_filename, step: :setup
-    end
-
-    def remove_latest!
-      FileUtils.rm_f [latest_patch_path, latest_commitfile_path]
-    end
-
-    def lock(**kwargs, &block)
-      builder.filelock(build_path(filename('.lock')), error_message: "Branch #{branch} of artifact #{name ? " #{name}" : nil} #{repo.name}" \
-                       " (#{repo.dir_path}) in use! Try again later.", **kwargs, &block)
+    def diff_command(from, to, quiet: false)
+      "diff #{'--quiet' if quiet} #{from}..#{to} #{"--relative=#{cwd}" if cwd} -- #{paths(true)}"
     end
   end
 end