dapp 0.10.2 → 0.36.24

data/lib/dapp/dapp/dappfile.rb

@@ -1,41 +1,67 @@
 module Dapp
   class Dapp
     module Dappfile
-      def local_git_artifact_exclude_paths(&blk)
-        super do |exclude_paths|
-          exclude_paths << 'Dappfile'
-
-          yield exclude_paths if block_given?
-        end
-      end
-
-      def build_configs
-        @configs ||= begin
-          dimgs(dappfile_path).flatten.tap do |dimgs|
-            raise Error::Dapp, code: :no_such_dimg, data: { dimgs_patterns: dimgs_patterns.join(', ') } if dimgs.empty?
+      module Error
+        class DappfileYmlErrorResponse < ::Dapp::Error::Default
+          def initialize(error_code, response)
+            net_status = {}
+            net_status[:code] = error_code
+            net_status[:message] = response["message"] if response["message"]
+            super(net_status)
           end
         end
       end
 
-      def dappfile_path
-        raise Error::Dapp, code: :dappfile_not_found unless (dappfile_path = search_file_upward('Dappfile'))
-        dappfile_path
-      end
-
-      def work_dir
-        File.expand_path(cli_options[:dir] || Dir.pwd)
-      end
-
       def expand_path(path, number = 1)
         path = File.expand_path(path)
         number.times.each { path = File.dirname(path) }
         path
       end
 
-      def dimgs(dappfile_path)
-        Dimg::Config::DimgGroupMain.new(dapp: self) do |conf|
+      def dappfile_exists?
+        File.exist?(path("dappfile.yml")) ||
+          File.exist?(path("dappfile.yaml")) ||
+            File.exist?(path("Dappfile")) ||
+              ENV["DAPP_LOAD_CONFIG_PATH"]
+      end
+
+      def config
+        @config ||= begin
+          config = nil
+
+          dappfile_yml = path("dappfile.yml").to_s
+          dappfile_yaml = path("dappfile.yaml").to_s
+          dappfile_ruby = path("Dappfile").to_s
+
+          if ENV["DAPP_LOAD_CONFIG_PATH"]
+            config = YAML.load_file ENV["DAPP_LOAD_CONFIG_PATH"]
+          elsif File.exist? dappfile_yml
+            config = load_dappfile_yml(dappfile_yml)
+          elsif File.exist? dappfile_yaml
+            config = load_dappfile_yml(dappfile_yaml)
+          elsif File.exist? dappfile_ruby
+            config = load_dappfile_ruby(dappfile_ruby)
+          else
+            raise ::Dapp::Error::Dapp, code: :dappfile_not_found
+          end
+
+          if ENV["DAPP_DUMP_CONFIG"]
+            puts "-- DAPP_DUMP_CONFIG BEGIN"
+            puts YAML.dump(config)
+            puts "-- DAPP_DUMP_CONFIG END"
+          end
+
+          config.tap do
+            config.after_parsing!
+            config.validate!
+          end
+        end # begin
+      end
+
+      def load_dappfile_ruby(dappfile_path)
+        ::Dapp::Config::Config.new(dapp: self).tap do |config|
           begin
-            conf.instance_eval File.read(dappfile_path), dappfile_path
+            config.instance_eval File.read(dappfile_path), dappfile_path
           rescue SyntaxError, StandardError => e
             backtrace = e.backtrace.find { |line| line.start_with?(dappfile_path) }
             message = begin
@@ -49,12 +75,67 @@ module Dapp
               end
             end
             message = "#{backtrace[/.*(?=:in)/]}: #{message}" if backtrace
-            raise Error::Dappfile, code: :incorrect, data: { error: e.class.name, message: message }
+            raise ::Dapp::Error::Dappfile, code: :incorrect, data: { error: e.class.name, message: message }
+          end # begin-rescue
+        end
+      end
+
+      def load_dappfile_yml(dappfile_path)
+        if dappfile_yml_bin_path = ENV["DAPP_BIN_DAPPFILE_YML"]
+          unless File.exists? dappfile_yml_bin_path
+            raise ::Dapp::Error::Dapp, code: :dappfile_yml_bin_path_not_found, data: {path: dappfile_yml_bin_path}
           end
-        end._dimg.select { |dimg| dimgs_patterns.any? { |pattern| dimg._name.nil? || File.fnmatch(pattern, dimg._name) } }.tap do |dimgs|
-          dimgs.each { |dimg| dimg.send(:validate!) }
+        else
+          dappfile_yml_bin_path = File.join(::Dapp::Dapp.home_dir, "bin", "dappfile-yml", ::Dapp::VERSION, "dappfile-yml")
+          unless File.exists? dappfile_yml_bin_path
+            download_dappfile_yml_bin(dappfile_yml_bin_path)
+          end
+        end
+
+        cmd_res = shellout "#{dappfile_yml_bin_path} -dappfile #{dappfile_path}"
+
+        raw_json_response = nil
+        if cmd_res.exitstatus == 0
+          raw_json_response = cmd_res.stdout
+        elsif cmd_res.exitstatus == 16
+          raw_json_response = cmd_res.stderr
+        else
+          shellout_cmd_should_succeed! cmd_res
         end
+
+        response = JSON.parse(raw_json_response)
+
+        log_warning(response["warning"]) unless response["warning"].empty?
+        raise ::Dapp::Dapp::Dappfile::Error::DappfileYmlErrorResponse.new(response["error"], response) if response["error"]
+
+        YAML.load response["dappConfig"]
       end
+
+      def download_dappfile_yml_bin(dappfile_yml_bin_path)
+        lock("downloader.bin.dappfile-yml", default_timeout: 1800) do
+          return if File.exists? dappfile_yml_bin_path
+
+          log_process("Downloading dappfile-yml dapp dependency") do
+            location = URI("https://dl.bintray.com/dapp/ruby2go/#{::Dapp::VERSION}/dappfile-yml")
+
+            tmp_bin_path = File.join(self.class.tmp_base_dir, "dappfile-yml-#{SecureRandom.uuid}")
+            ::Dapp::Downloader.download(location, tmp_bin_path, show_progress: true, progress_titile: dappfile_yml_bin_path)
+
+            checksum_location = URI("https://dl.bintray.com/dapp/ruby2go/#{::Dapp::VERSION}/dappfile-yml.sha")
+            tmp_bin_checksum_path = tmp_bin_path + ".checksum"
+            ::Dapp::Downloader.download(checksum_location, tmp_bin_checksum_path)
+
+            if Digest::SHA256.hexdigest(File.read(tmp_bin_path)) != File.read(tmp_bin_checksum_path).strip
+              raise ::Dapp::Error::Dapp, code: :download_failed_bad_dappfile_yml_checksum, data: {url: location.to_s, checksum_url: checksum_location.to_s}
+            end
+
+            File.chmod(0755, tmp_bin_path)
+            FileUtils.mkdir_p File.dirname(dappfile_yml_bin_path)
+            FileUtils.mv tmp_bin_path, dappfile_yml_bin_path
+          end # log_process
+        end # lock
+      end
+
     end # Dappfile
   end # Dapp
 end # Dapp

data/lib/dapp/dapp/deps/base.rb

@@ -2,46 +2,23 @@ module Dapp
   class Dapp
     module Deps
       module Base
-        BASE_VERSION = '0.1.15'.freeze
-
-        def base_container_name # FIXME: hashsum(image) or dockersafe()
-          "dappdeps_base_#{BASE_VERSION}"
+        def base_container
+          dappdeps_container(:base)
         end
 
-        def base_container
-          @base_container ||= begin
-            if shellout("docker inspect #{base_container_name}").exitstatus.nonzero?
-              log_secondary_process(t(code: 'process.base_container_creating'), short: true) do
-                shellout!(
-                  ['docker create',
-                   "--name #{base_container_name}",
-                   "--volume /.dapp/deps/base/#{BASE_VERSION} dappdeps/base:#{BASE_VERSION}"].join(' ')
-                )
-              end
-            end
-            base_container_name
-          end
+        def dappdeps_base_path
+          ruby2go_dappdeps_command(dappdeps: :base, command: :path)
         end
 
         %w(rm rsync diff date cat
-           stat test sleep mkdir find
-           install sed cp true
-           bash tar sudo).each do |cmd|
-          define_method("#{cmd}_bin") { "/.dapp/deps/base/#{BASE_VERSION}/bin/#{cmd}" }
+           stat readlink test sleep mkdir
+           install sed cp true find
+           bash tar sudo base64).each do |bin|
+          define_method("#{bin}_bin") { ruby2go_dappdeps_command(dappdeps: :base, command: :bin, options: { bin: bin }) }
         end
 
         def sudo_command(owner: nil, group: nil)
-          sudo = ''
-          if owner || group
-            sudo = "#{sudo_bin} -E "
-            sudo += "-u #{sudo_format_user(owner)} " if owner
-            sudo += "-g #{sudo_format_user(group)} " if group
-          end
-          sudo
-        end
-
-        def sudo_format_user(user)
-          user.to_s.to_i.to_s == user.to_s ? "\\\##{user}" : user
+          ruby2go_dappdeps_command(dappdeps: :base, command: :sudo_command, options: { owner: owner, group: group })
         end
       end # Base
     end # Deps

data/lib/dapp/dapp/deps/common.rb

@@ -0,0 +1,26 @@
+module Dapp
+  class Dapp
+    module Deps
+      module Common
+        def dappdeps_container(dappdeps)
+          dappdeps_containers[dappdeps] ||= ruby2go_dappdeps_command(dappdeps: dappdeps, command: :container)
+        end
+
+        def dappdeps_containers
+          @dappdeps_containers ||= {}
+        end
+
+        def ruby2go_dappdeps_command(dappdeps:, command:, **options)
+          (options[:options] ||= {}).merge!(host_docker_config_dir: self.class.host_docker_config_dir)
+          ruby2go_dappdeps(dappdeps: dappdeps, command: command, **options).tap do |res|
+            unless res["error"].nil?
+              raise Error::Dapp, code: :ruby2go_dappdeps_command_failed_unexpected_error,
+                                 data: { dappdeps: dappdeps, command: command, message: res["error"] }
+            end
+            break res['data']
+          end
+        end
+      end # Base
+    end # Deps
+  end # Dapp
+end # Dapp

data/lib/dapp/dapp/deps/gitartifact.rb

@@ -2,30 +2,12 @@ module Dapp
   class Dapp
     module Deps
       module Gitartifact
-        GITARTIFACT_VERSION = '0.1.7'.freeze
-
-        def gitartifact_container_name # FIXME: hashsum(image) or dockersafe()
-          "dappdeps_gitartifact_#{GITARTIFACT_VERSION}"
-        end
-
         def gitartifact_container
-          @gitartifact_container ||= begin
-            if shellout("docker inspect #{gitartifact_container_name}").exitstatus.nonzero?
-              log_secondary_process(t(code: 'process.gitartifact_container_creating'), short: true) do
-                shellout!(
-                  ['docker create',
-                   "--name #{gitartifact_container_name}",
-                   "--volume /.dapp/deps/gitartifact/#{GITARTIFACT_VERSION}",
-                   "dappdeps/gitartifact:#{GITARTIFACT_VERSION}"].join(' ')
-                )
-              end
-            end
-            gitartifact_container_name
-          end
+          dappdeps_container(:gitartifact)
         end
 
         def git_bin
-          "/.dapp/deps/gitartifact/#{GITARTIFACT_VERSION}/bin/git"
+          ruby2go_dappdeps_command(dappdeps: :gitartifact, command: :bin)
         end
       end # Gitartifact
     end # Deps

data/lib/dapp/dapp/deps/toolchain.rb

@@ -0,0 +1,11 @@
+module Dapp
+  class Dapp
+    module Deps
+      module Toolchain
+        def toolchain_container
+          dappdeps_container(:toolchain)
+        end
+      end # Toolchain
+    end # Deps
+  end # Dapp
+end # Dapp

data/lib/dapp/dapp/git_artifact.rb

@@ -1,10 +1,12 @@
 module Dapp
   class Dapp
     module GitArtifact
-      def local_git_artifact_exclude_paths(&blk)
-        @local_git_artifact_exclude_paths ||= [].tap do |exclude_paths|
-          yield exclude_paths if block_given?
-        end
+      def dimgstage_g_a_commit_label(paramshash)
+        "dapp-git-#{paramshash}-commit"
+      end
+
+      def dimgstage_g_a_type_label(paramshash)
+        "dapp-git-#{paramshash}-type"
       end
     end # GitArtifact
   end # Dapp

data/lib/dapp/dapp/lock.rb

@@ -1,20 +1,21 @@
 module Dapp
   class Dapp
     module Lock
-      def lock_path
-        build_path.join('locks')
+      def locks_dir
+        File.join(self.class.home_dir, "locks")
       end
 
       def _lock(name)
         @_locks ||= {}
-        @_locks[name] ||= ::Dapp::Dimg::Lock::File.new(lock_path, name)
+        @_locks[name] ||= ::Dapp::Dimg::Lock::File.new(locks_dir, name)
       end
 
-      def lock(name, *_args, default_timeout: 300, **kwargs, &blk)
+      # default_timeout 24 hours
+      def lock(name, *_args, default_timeout: 86400, **kwargs, &blk)
         if dry_run?
           yield if block_given?
         else
-          timeout = cli_options[:lock_timeout] || default_timeout
+          timeout = options[:lock_timeout] || default_timeout
           _lock(name).synchronize(
             timeout: timeout,
             on_wait: proc do |&do_wait|

data/lib/dapp/dapp/logging/base.rb

@@ -2,32 +2,48 @@ module Dapp
   class Dapp
     module Logging
       module Base
+        class << self
+          def included(base)
+            base.send(:extend, ClassMethods)
+          end
+        end
+
+        module ClassMethods
+          def log_time
+            "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
+          end
+        end
+
         def log_quiet?
-          cli_options[:log_quiet]
+          option_quiet
         end
 
         def log_time?
-          cli_options[:log_time]
+          option_time
         end
 
         def log_verbose?
-          cli_options[:log_verbose]
+          option_verbose
         end
 
         def ignore_config_warning?
-          cli_options[:ignore_config_warning]
+          !!options[:ignore_config_warning]
         end
 
         def introspect_error?
-          cli_options[:introspect_error]
+          !!options[:introspect_error]
         end
 
         def introspect_before_error?
-          cli_options[:introspect_before_error]
+          !!options[:introspect_before_error]
         end
 
         def dry_run?
-          cli_options[:dry_run]
+          option_dry_run
+        end
+
+        def dev_mode?
+          option_dev
         end
 
         def log_info(*args, **kwargs)
@@ -42,9 +58,7 @@ module Dapp
 
         def log_step_with_indent(step)
           log_step(step)
-          with_log_indent do
-            yield
-          end
+          with_log_indent { yield }
         end
 
         def log_step(*args, **kwargs)
@@ -82,7 +96,7 @@ module Dapp
         end
 
         def log_time
-          "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
+          self.class.log_time
         end
 
         def log_format_string(str, time: true, indent: true, style: nil)
@@ -92,12 +106,6 @@ module Dapp
           end.join
         end
 
-        def log_with_indent(message = '', **kwargs)
-          with_log_indent do
-            log(message, **kwargs)
-          end
-        end
-
         def with_log_indent(with = true)
           log_indent_next if with
           yield
@@ -121,9 +129,13 @@ module Dapp
           end
         end
 
-        class << self
-          def included(base)
-            base.extend(self)
+        def service_stream
+          @@service_stream ||= begin
+            fd = IO.sysopen("/tmp/dapp-service.log", "a")
+
+            stream = IO.new(fd)
+            stream.sync = true
+            stream
           end
         end
 

data/lib/dapp/dapp/logging/i18n.rb

@@ -2,6 +2,10 @@ module Dapp
   class Dapp
     module Logging
       module I18n
+        class I18nError < ::NetStatus::Exception
+          include ::Dapp::Error::Mod::User
+        end
+
         def self.initialize
           ::I18n.load_path << Dir[File.join(::Dapp.root, 'config', '**', '*')].select { |path| File.file?(path) }
           ::I18n.reload!
@@ -16,7 +20,7 @@ module Dapp
           paths << [:common, code].join('.')
           ::I18n.t(*paths, **data, raise: true)
         rescue ::I18n::MissingTranslationData => _e
-          raise ::NetStatus::Exception, code: :missing_translation, data: { code: code }
+          raise I18nError, code: :missing_translation, data: { code: code }
         end
       end
     end # Helper

data/lib/dapp/dapp/logging/process.rb

@@ -36,24 +36,24 @@ module Dapp
 
           if quiet
             log_process_quiet(message.to_s, style: style, status: status, &blk)
-          elsif log_verbose? && !short
+          elsif short
+            log_process_short(message.to_s, style: style, status: status, &blk)
+          else
             process ||= t(code: 'status.process.default')
             log_process_verbose(message.to_s, process: process, style: style, status: status, &blk)
-          else
-            log_process_short(message.to_s, style: style, status: status, &blk)
           end
         end
         # rubocop:enable Metrics/ParameterLists
 
         def log_secondary_process(message, **kwargs, &blk)
-          log_process(message, **kwargs.merge(style: { message: :secondary, success: :secondary }, quiet: !log_verbose?), &blk)
+          log_process(message, **kwargs.merge(style: { message: :secondary, success: :secondary }), &blk)
         end
 
         protected
 
         def log_process_quiet(message, style: {}, status: {})
           yield
-        rescue Error::Base => e
+        rescue Error::Default => e
           info                  = paint_string(slice(message), style[:message])
           failed_message        = paint_string(rjust(status[:failed], info), style[:failed])
           before_error_messages = [log_indent + info + failed_message, e.net_status[:data][:before_error_messages]].flatten
@@ -80,7 +80,7 @@ module Dapp
           log info, inline: inline
           message = success_message
           start = Time.now
-          yield
+          with_log_indent { yield }
         rescue Error::Base, SignalException, StandardError => _e
           message = failed_message
           raise

data/lib/dapp/dapp/option_tags.rb

@@ -0,0 +1,98 @@
+module Dapp
+  class Dapp
+    module OptionTags
+      def tagging_schemes
+        %w(git_tag git_branch git_commit custom ci)
+      end
+
+      def tags_by_scheme
+        @tags_by_scheme_name ||= begin
+          if slug_tags[:custom].any?
+            if settings.fetch("sentry", {}).fetch("detect-push-tag-usage", false)
+              sentry_message("--tag or --tag-slug usage detected", extra: {"slug_tags" => slug_tags})
+            end
+          end
+
+          {}.tap do |tags_by_scheme|
+            [slug_tags, branch_tags, ci_tags].each do |_tags_by_scheme|
+              _tags_by_scheme.each do |scheme, tags|
+                tags_by_scheme[scheme] ||= []
+                tags_by_scheme[scheme] += tags.map(&method(:consistent_uniq_slugify))
+              end
+            end
+
+            [plain_tags, commit_tags, build_tags].each do |_tags_by_scheme|
+              _tags_by_scheme.each do |scheme, tags|
+                tags_by_scheme[scheme] ||= []
+                tags_by_scheme[scheme] += tags
+              end
+            end
+
+            tags_by_scheme[:custom] = [:latest] if tags_by_scheme.values.flatten.empty?
+          end
+        end
+      end
+
+      def option_tags
+        tags_by_scheme.values.flatten
+      end
+
+      def slug_tags
+        { custom: [*options[:tag], *options[:tag_slug]]}
+      end
+
+      def plain_tags
+        { custom: options[:tag_plain] }
+      end
+
+      def branch_tags
+        return {} unless options[:tag_branch]
+        raise Error::Dapp, code: :git_branch_without_name if (branch = git_own_repo.head_branch_name) == 'HEAD'
+        { git_branch: [branch] }
+      end
+
+      def commit_tags
+        return {} unless options[:tag_commit]
+        { git_commit: [git_own_repo.head_commit] }
+      end
+
+      def build_tags
+        return {} unless options[:tag_build_id]
+
+        if ENV['GITLAB_CI']
+          build_id = ENV['CI_BUILD_ID'] || ENV['CI_JOB_ID']
+        elsif ENV['TRAVIS']
+          build_id = ENV['TRAVIS_BUILD_NUMBER']
+        else
+          raise Error::Dapp, code: :ci_environment_required
+        end
+
+        { ci: [build_id] }
+      end
+
+      def ci_tags
+        return {} unless options[:tag_ci]
+
+        {}.tap do |tags_by_scheme|
+          if ENV['GITLAB_CI']
+            if ENV['CI_BUILD_TAG'] || ENV['CI_COMMIT_TAG']
+              tags_by_scheme[:git_tag] = [ENV['CI_BUILD_TAG'] || ENV['CI_COMMIT_TAG']]
+            elsif ENV['CI_BUILD_REF_NAME'] || ENV['CI_COMMIT_REF_NAME']
+              tags_by_scheme[:git_branch] = [ENV['CI_BUILD_REF_NAME'] || ENV['CI_COMMIT_REF_NAME']]
+            end
+          elsif ENV['TRAVIS']
+            if ENV['TRAVIS_TAG']
+              tags_by_scheme[:git_tag]    = [ENV['TRAVIS_TAG']]
+            elsif ENV['TRAVIS_BRANCH']
+              tags_by_scheme[:git_branch] = [ENV['TRAVIS_BRANCH']]
+            end
+          else
+            raise Error::Dapp, code: :ci_environment_required
+          end
+
+          tags_by_scheme.delete_if { |_, tags| tags.first.nil? }
+        end
+      end
+    end # Tags
+  end # Dapp
+end # Dapp