dapp 0.0.24 → 0.1.0

data/lib/dapp/build/stage/app_install.rb

@@ -0,0 +1,19 @@
+module Dapp
+  module Build
+    module Stage
+      # AppInstall
+      class AppInstall < Base
+        def initialize(application, next_stage)
+          @prev_stage = Source1.new(application, self)
+          super
+        end
+
+        def image
+          super do |image|
+            application.builder.app_install(image)
+          end
+        end
+      end # AppInstall
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/app_setup.rb

@@ -0,0 +1,19 @@
+module Dapp
+  module Build
+    module Stage
+      # AppSetup
+      class AppSetup < Base
+        def initialize(application, next_stage)
+          @prev_stage = Source3.new(application, self)
+          super
+        end
+
+        def image
+          super do |image|
+            application.builder.app_setup(image)
+          end
+        end
+      end # AppSetup
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/base.rb

@@ -0,0 +1,106 @@
+module Dapp
+  module Build
+    module Stage
+      # Base of all stages
+      class Base
+        include Helper::Sha256
+        include Helper::Trivia
+
+        attr_accessor :prev_stage, :next_stage
+        attr_reader :application
+
+        def initialize(application, next_stage)
+          @application = application
+
+          @next_stage = next_stage
+          @next_stage.prev_stage = self
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def build!
+          return if image.tagged? && !application.log_verbose?
+          prev_stage.build! if prev_stage
+          begin
+            if image.tagged?
+              application.log_state(name, state: application.t(code: 'state.using_cache'))
+            elsif application.dry_run?
+              application.log_state(name, state: application.t(code: 'state.build'), styles: { status: :success })
+            else
+              application.log_process(name, process: application.t(code: 'status.process.building'), short: should_be_not_detailed?) do
+                image_build!
+              end
+            end
+          ensure
+            log_build
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def save_in_cache!
+          return if image.tagged?
+          prev_stage.save_in_cache!                                                          if prev_stage
+          image.tag!(log_verbose: application.log_verbose?, log_time: application.log_time?) unless application.dry_run?
+        end
+
+        def signature
+          hashsum prev_stage.signature
+        end
+
+        def image
+          @image ||= begin
+            StageImage.new(name: image_name, from: from_image).tap do |image|
+              image.add_volume "#{application.build_path}:#{application.container_build_path}"
+              yield image if block_given?
+            end
+          end
+        end
+
+        protected
+
+        def name
+          class_to_lowercase.to_sym
+        end
+
+        def should_be_not_detailed?
+          image.send(:bash_commands).empty?
+        end
+
+        def image_build!
+          image.build!(log_verbose: application.log_verbose?, log_time: application.log_time?)
+        end
+
+        def from_image
+          prev_stage.image if prev_stage || begin
+            fail Error::Build, code: :from_image_required
+          end
+        end
+
+        def image_name
+          "dapp:#{signature}"
+        end
+
+        def image_info
+          date, bytesize = image.info
+          _date, from_bytesize = from_image.info
+          [date, (from_bytesize.to_i - bytesize.to_i).abs]
+        end
+
+        def format_image_info
+          date, bytesize = image_info
+          application.t(code: 'image.info', data: { date: Time.parse(date).localtime, size: to_mb(bytesize.to_i)})
+        end
+
+        def log_build
+          application.with_log_indent do
+            application.log_info application.t(code: 'image.signature', data: { signature: image_name})
+            application.log_info format_image_info if image.tagged?
+            unless (bash_commands = image.send(:bash_commands)).empty?
+              application.log_info application.t(code: 'image.commands')
+              application.with_log_indent { application.log_info bash_commands.join("\n") }
+            end
+          end if application.log? && application.log_verbose?
+        end
+      end # Base
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/from.rb

@@ -0,0 +1,40 @@
+module Dapp
+  module Build
+    module Stage
+      # From
+      class From < Base
+        def signature
+          hashsum [from_image_name,
+                   application.config._docker._from_cache_version,
+                   Dapp::BUILD_CACHE_VERSION]
+        end
+
+        def save_in_cache!
+          from_image.untag! if from_image.pulled?
+          super
+        end
+
+        protected
+
+        def image_build!
+          from_image.pull!(log_verbose: application.log_verbose?, log_time: application.log_time?)
+          super
+        end
+
+        private
+
+        def from_image_name
+          application.config._docker._from
+        end
+
+        def from_image
+          StageImage.new(name: from_image_name)
+        end
+
+        def image_info
+          image.info
+        end
+      end # Prepare
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/infra_install.rb

@@ -0,0 +1,23 @@
+module Dapp
+  module Build
+    module Stage
+      # InfraInstall
+      class InfraInstall < Base
+        def initialize(application, next_stage)
+          @prev_stage = From.new(application, self)
+          super
+        end
+
+        def signature
+          hashsum [prev_stage.signature, *application.builder.infra_install_checksum]
+        end
+
+        def image
+          super do |image|
+            application.builder.infra_install(image)
+          end
+        end
+      end # InfraInstall
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/infra_setup.rb

@@ -0,0 +1,19 @@
+module Dapp
+  module Build
+    module Stage
+      # InfraSetup
+      class InfraSetup < Base
+        def initialize(application, next_stage)
+          @prev_stage = Source2.new(application, self)
+          super
+        end
+
+        def image
+          super do |image|
+            application.builder.infra_setup(image)
+          end
+        end
+      end # InfraSetup
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_1.rb

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      # Source1
+      class Source1 < SourceBase
+        def initialize(application, next_stage)
+          @prev_stage = Source1Archive.new(application, self)
+          super
+        end
+
+        def prev_source_stage
+          prev_stage
+        end
+
+        protected
+
+        def dependencies_checksum
+          hashsum [prev_stage.signature,
+                   app_install_files_checksum,
+                   *application.builder.app_install_checksum]
+        end
+
+        private
+
+        def app_install_files_checksum
+          @app_install_files_checksum ||= dependency_files_checksum(application.config._app_install_dependencies)
+        end
+      end # Source1
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_1_archive.rb

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      # Source1Archive
+      class Source1Archive < SourceBase
+        def initialize(application, next_stage)
+          @prev_stage = InfraInstall.new(application, self)
+          super
+        end
+
+        def prev_source_stage
+          nil
+        end
+
+        def next_source_stage
+          next_stage
+        end
+
+        def container_archive_path(git_artifact)
+          application.container_build_path git_artifact.filename '.tar.gz'
+        end
+
+        protected
+
+        def apply_command_method
+          :archive_apply_command
+        end
+      end # Source1Archive
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_2.rb

@@ -0,0 +1,20 @@
+module Dapp
+  module Build
+    module Stage
+      # Source2
+      class Source2 < SourceBase
+        def initialize(application, next_stage)
+          @prev_stage = AppInstall.new(application, self)
+          super
+        end
+
+        protected
+
+        def dependencies_checksum
+          hashsum [prev_stage.signature,
+                   *application.builder.infra_setup_checksum]
+        end
+      end # Source2
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_3.rb

@@ -0,0 +1,27 @@
+module Dapp
+  module Build
+    module Stage
+      # Source3
+      class Source3 < SourceBase
+        def initialize(application, next_stage)
+          @prev_stage = InfraSetup.new(application, self)
+          super
+        end
+
+        protected
+
+        def dependencies_checksum
+          hashsum [prev_stage.signature,
+                   app_setup_files_checksum,
+                   *application.builder.app_setup_checksum]
+        end
+
+        private
+
+        def app_setup_files_checksum
+          @app_setup_files_checksum ||= dependency_files_checksum(application.config._app_setup_dependencies)
+        end
+      end # Source3
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_4.rb

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      # Source4
+      class Source4 < SourceBase
+        MAX_PATCH_SIZE = 1024 * 1024
+
+        def initialize(application, next_stage)
+          @prev_stage = AppSetup.new(application, self)
+          super
+        end
+
+        def next_source_stage
+          next_stage
+        end
+
+        def dependencies_checksum
+          hashsum [super, (changes_size_since_source3 / MAX_PATCH_SIZE).to_i]
+        end
+
+        private
+
+        def changes_size_since_source3
+          application.git_artifacts.map do |git_artifact|
+            git_artifact.patch_size(prev_source_stage.layer_commit(git_artifact), git_artifact.latest_commit)
+          end.reduce(0, :+)
+        end
+      end # Source4
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_5.rb

@@ -0,0 +1,51 @@
+module Dapp
+  module Build
+    module Stage
+      # Source5
+      class Source5 < SourceBase
+        def initialize(application)
+          @prev_stage = Source4.new(application, self)
+          @application = application
+        end
+
+        def prev_source_stage
+          prev_stage
+        end
+
+        def next_source_stage
+          nil
+        end
+
+        def signature
+          hashsum [super, *exposes]
+        end
+
+        def image
+          super do |image|
+            image.add_expose(exposes)  unless exposes.empty?
+            image.add_env(envs)        unless envs.empty?
+            image.add_workdir(workdir) unless workdir.nil?
+          end
+        end
+
+        protected
+
+        def exposes
+          application.config._docker._expose
+        end
+
+        def envs
+          application.config._docker._env
+        end
+
+        def workdir
+          application.config._docker._workdir
+        end
+
+        def layers_commits_write!
+          nil
+        end
+      end # Source5
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/source_base.rb

@@ -0,0 +1,109 @@
+module Dapp
+  module Build
+    module Stage
+      # Base of source stages
+      class SourceBase < Base
+        attr_accessor :prev_source_stage, :next_source_stage
+
+        GITARTIFACT_IMAGE = 'dappdeps/gitartifact:0.1.3'.freeze
+
+        def prev_source_stage
+          prev_stage.prev_stage
+        end
+
+        def next_source_stage
+          next_stage.next_stage
+        end
+
+        def save_in_cache!
+          super
+          layers_commits_write!
+        end
+
+        def signature
+          hashsum [dependencies_checksum, *commit_list]
+        end
+
+        def image
+          super do |image|
+            if application.git_artifacts.any?
+              image.add_volumes_from(gitartifact_container)
+              image.add_commands 'export PATH=/.dapp/deps/gitartifact/bin:$PATH'
+            end
+
+            application.git_artifacts.each do |git_artifact|
+              image.add_volume "#{git_artifact.repo.dir_path}:#{git_artifact.repo.container_build_dir_path}"
+              image.add_commands git_artifact.send(apply_command_method, self)
+            end
+            yield image if block_given?
+          end
+        end
+
+        def dependencies_checksum
+          hashsum [prev_stage.signature]
+        end
+
+        def layer_commit(git_artifact)
+          commits[git_artifact] ||= begin
+            if layer_commit_file_path(git_artifact).exist?
+              layer_commit_file_path(git_artifact).read.strip
+            else
+              git_artifact.latest_commit
+            end
+          end
+        end
+
+        protected
+
+        def gitartifact_container_name # FIXME: hashsum(image) or dockersafe()
+          GITARTIFACT_IMAGE.tr('/', '_').tr(':', '_')
+        end
+
+        def gitartifact_container
+          @gitartifact_container ||= begin
+            if application.shellout("docker inspect #{gitartifact_container_name}").exitstatus != 0
+              application.log_secondary_process(application.t(code: 'process.git_artifact_loading'), short: true) do
+                application.shellout ['docker run',
+                                      '--restart=no',
+                                      "--name #{gitartifact_container_name}",
+                                      "--volume /.dapp/deps/gitartifact #{GITARTIFACT_IMAGE}",
+                                      '2>/dev/null'].join(' ')
+              end
+            end
+            gitartifact_container_name
+          end
+        end
+
+        def should_be_not_detailed?
+          true
+        end
+
+        def apply_command_method
+          :apply_patch_command
+        end
+
+        def commit_list
+          application.git_artifacts.map { |git_artifact| layer_commit(git_artifact) }
+        end
+
+        def layers_commits_write!
+          application.git_artifacts.each { |git_artifact| layer_commit_file_path(git_artifact).write(layer_commit(git_artifact)) }
+        end
+
+        def layer_commit_file_path(git_artifact)
+          application.build_path git_artifact.filename ".#{name}.#{git_artifact.paramshash}.#{dependencies_checksum}.commit"
+        end
+
+        def dependency_files_checksum(regs)
+          hashsum(regs.map { |reg| Dir[File.join(application.home_path, reg)].map { |f| File.read(f) if File.file?(f) } })
+        end
+
+        private
+
+        def commits
+          @commits ||= {}
+        end
+      end # SourceBase
+    end # Stage
+  end # Build
+end # Dapp