dapp 0.21.16 → 0.22.0

data/lib/dapp/dimg/dapp/command/cleanup_repo.rb

@@ -3,23 +3,17 @@ module Dapp
     module Dapp
       module Command
         module CleanupRepo
+          DATE_POLICY = Time.now.to_i - 60 * 60 * 24 * 30
+          GIT_TAGS_LIMIT_POLICY = 10
+
           def cleanup_repo
             lock_repo(repo = option_repo) do
               registry = registry(repo)
 
-              repo_detailed_dimgs_images(registry).select do |image|
-                case image[:labels]['dapp-tag-scheme']
-                  when 'git_tag', 'git_branch', 'git_commit' then true
-                  else false
-                end && !deployed_docker_images.include?([image[:dimg], image[:tag]].join(':'))
-              end.tap do |dimgs_images|
-                cleanup_repo_by_nonexistent_git_tag(registry, dimgs_images)
-                cleanup_repo_by_nonexistent_git_branch(registry, dimgs_images)
-                cleanup_repo_by_nonexistent_git_commit(registry, dimgs_images)
-              end
+              cleanup_repo_by_nonexistent_git_primitive(registry, actual_detailed_dimgs_images_by_scheme(registry))
+              cleanup_repo_by_policies(registry, actual_detailed_dimgs_images_by_scheme(registry))
 
               begin
-                registry.reset_cache
                 repo_dimgs      = repo_dimgs_images(registry)
                 repo_dimgstages = repo_dimgstages_images(registry)
                 repo_dimgstages_cleanup(registry, repo_dimgs, repo_dimgstages)
@@ -27,32 +21,83 @@ module Dapp
             end
           end
 
-          def cleanup_repo_by_nonexistent_git_tag(registry, dimgs_images)
-            cleanup_repo_by_nonexistent_git_base(dimgs_images, 'git_tag') do |dimg_image|
-              delete_repo_image(registry, dimg_image) unless git_local_repo.tags.include?(dimg_image[:tag])
+          def actual_detailed_dimgs_images_by_scheme(registry)
+            {}.tap do |detailed_dimgs_images_by_scheme|
+              tagging_schemes.each { |scheme| detailed_dimgs_images_by_scheme[scheme] = [] }
+              repo_detailed_dimgs_images(registry).each do |image|
+                next unless repo_dimg_image_should_be_ignored?(image)
+                (detailed_dimgs_images_by_scheme[image[:labels]['dapp-tag-scheme']] ||= []) << image
+              end
             end
           end
 
-          def cleanup_repo_by_nonexistent_git_branch(registry, dimgs_images)
-            cleanup_repo_by_nonexistent_git_base(dimgs_images, 'git_branch') do |dimg_image|
-              delete_repo_image(registry, dimg_image) unless git_local_repo.remote_branches.include?(dimg_image[:tag])
-            end
+          def repo_dimg_image_should_be_ignored?(image)
+            image_repository = [option_repo, image[:dimg]].compact.join('/')
+            image_name = [image_repository, image[:tag]].join(':')
+            !deployed_docker_images.include?(image_name)
           end
 
-          def cleanup_repo_by_nonexistent_git_commit(registry, dimgs_images)
-            cleanup_repo_by_nonexistent_git_base(dimgs_images, 'git_commit') do |dimg_image|
-              delete_repo_image(registry, dimg_image) unless git_local_repo.commit_exists?(dimg_image[:tag])
+          def cleanup_repo_by_nonexistent_git_primitive(registry, detailed_dimgs_images_by_scheme)
+            %w(git_tag git_branch git_commit).each do |scheme|
+              cleanup_repo_by_nonexistent_git_base(detailed_dimgs_images_by_scheme, scheme) do |detailed_dimg_image|
+                delete_repo_image(registry, detailed_dimg_image) unless begin
+                  case scheme
+                    when 'git_tag'    then git_local_repo.tags.include?(detailed_dimg_image[:tag])
+                    when 'git_branch' then git_local_repo.remote_branches.include?(detailed_dimg_image[:tag])
+                    when 'git_commit' then git_local_repo.commit_exists?(detailed_dimg_image[:tag])
+                    else
+                      raise
+                  end
+                end
+              end unless detailed_dimgs_images_by_scheme[scheme].empty?
             end
           end
 
-          def cleanup_repo_by_nonexistent_git_base(dimgs_images, dapp_tag_scheme)
+          def cleanup_repo_by_nonexistent_git_base(repo_dimgs_images_by_scheme, dapp_tag_scheme)
+            return if repo_dimgs_images_by_scheme[dapp_tag_scheme].empty?
             log_step_with_indent(:"nonexistent #{dapp_tag_scheme.split('_').join(' ')}") do
-              dimgs_images
+              repo_dimgs_images_by_scheme[dapp_tag_scheme]
                 .select { |dimg_image| dimg_image[:labels]['dapp-tag-scheme'] == dapp_tag_scheme }
                 .each { |dimg_image| yield dimg_image }
             end
           end
 
+          def cleanup_repo_by_policies(registry, detailed_dimgs_images_by_scheme)
+            %w(git_tag git_commit).each_with_object([]) do |scheme, dimgs_images|
+              dimgs_images.concat begin
+                detailed_dimgs_images_by_scheme[scheme].map do |dimg|
+                  dimg[:created_at] = begin
+                    if scheme == 'git_tag'
+                      git_local_repo.tag_at(dimg[:tag])
+                    elsif scheme == 'git_commit'
+                      git_local_repo.commit_at(dimg[:tag])
+                    end
+                  end
+                  dimg
+                end
+              end
+            end
+              .sort_by { |dimg| dimg[:created_at] }
+              .tap do |sorted_dimgs_images|
+                expired_dimgs_images, not_expired_dimgs_images = sorted_dimgs_images.partition do |dimg_image|
+                  dimg_image[:created_at] < DATE_POLICY
+                end
+
+                log_step_with_indent(:"date policy (before #{DateTime.strptime(DATE_POLICY.to_s, '%s')})") do
+                  expired_dimgs_images.each { |dimg| delete_repo_image(registry, dimg) }
+                end
+
+                {}.tap do |images_by_dimg|
+                  not_expired_dimgs_images.each { |dimg| (images_by_dimg[dimg[:dimg]] ||= []) << dimg }
+                  images_by_dimg.each do |dimg, images|
+                    log_step_with_indent(:"limit policy (> #{GIT_TAGS_LIMIT_POLICY}) (`#{dimg}`)") do
+                      images[GIT_TAGS_LIMIT_POLICY..-1].each { |dimg| delete_repo_image(registry, dimg) }
+                    end unless images[GIT_TAGS_LIMIT_POLICY..-1].nil?
+                  end
+                end
+              end
+          end
+
           def repo_detailed_dimgs_images(registry)
             repo_dimgs_images(registry).each do |dimg|
               image_history = registry.image_history(dimg[:tag], dimg[:dimg])
@@ -62,7 +107,36 @@ module Dapp
           end
 
           def deployed_docker_images
-            []
+            # open kube client, get all pods and select containers' images
+            ::Dapp::Kube::Kubernetes::Client.tap do |kube|
+              config_file = kube.kube_config_path
+              unless File.exist?(config_file)
+                return []
+              end
+            end
+
+            client = ::Dapp::Kube::Kubernetes::Client.new
+
+            namespaces = []
+            # check connectivity for 2 seconds
+            begin
+              namespaces = client.namespace_list(excon_parameters: {:connect_timeout => 30})
+            rescue Excon::Error::Timeout
+              raise Kube::Error::Base, code: :connect_timeout
+            end
+
+            # get images from containers from pods from all namespaces.
+            @kube_images ||= namespaces['items'].map do |item|
+              item['metadata']['name']
+            end.map do |ns|
+              client.with_namespace(ns) do
+                client.pod_list['items'].map do |pod|
+                  pod['spec']['containers'].map{ |cont| cont['image'] }
+                end
+              end
+            end.flatten.uniq.select do |image|
+              image.start_with?(option_repo)
+            end
           end
         end
       end

data/lib/dapp/dimg/dapp/command/common.rb

@@ -95,8 +95,10 @@ module Dapp
 
           def check_user_containers!(images_ids)
             return if images_ids.empty?
-            run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')} --no-trunc)).tap do |res|
-              raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if res && !res.stdout.strip.empty? && !dry_run?
+            log_step_with_indent(:'check user containers') do
+              run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')} --no-trunc)).tap do |res|
+                raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if res && !res.stdout.strip.empty? && !dry_run?
+              end
             end
           end
 
@@ -148,10 +150,6 @@ module Dapp
             log_step_with_indent(:'proper cache', &blk)
           end
 
-          def log_proper_repo_cache(&blk)
-            log_step_with_indent(:'proper repo cache', &blk)
-          end
-
           def one_dimg!
             return if build_configs.one?
             raise Error::Command, code: :command_unexpected_dimgs_number, data: { dimgs_names: build_configs.map(&:_name).join(' ') }
@@ -169,13 +167,6 @@ module Dapp
             '%{repo}:%{tag}'
           end
 
-          def option_repo
-            unless options[:repo].nil?
-              return "localhost:5000/#{name}" if options[:repo] == ':minikube'
-              options[:repo]
-            end
-          end
-
           def with_stages?
             !!options[:with_stages]
           end

data/lib/dapp/dimg/dapp/command/stages/cleanup_local.rb

@@ -21,7 +21,9 @@ module Dapp
             def proper_cache
               log_proper_cache do
                 lock("#{name}.images") do
-                  remove_project_images(dapp_project_images_ids.select { |image_id| !actual_cache_project_images_ids.include?(image_id) })
+                  log_step_with_indent(name) do
+                    remove_project_images(dapp_project_images_ids.select { |image_id| !actual_cache_project_images_ids.include?(image_id) })
+                  end
                 end
               end
             end
@@ -36,15 +38,15 @@ module Dapp
             end
 
             def stages_cleanup_by_repo
-              log_proper_repo_cache do
-                lock("#{name}.images") do
-                  registry   = registry(option_repo)
-                  repo_dimgs = repo_detailed_dimgs_images(registry)
+              registry   = dimg_registry(option_repo)
+              repo_dimgs = repo_dimgs_images(registry)
 
+              lock("#{name}.images") do
+                log_step_with_indent(name) do
                   dapp_project_dangling_images_flush
 
-                  _, dimgstages = dapp_project_images.partition { |image| repo_dimgs.any? { |dimg| dimg[:id] == image[:id] } }
-                  repo_dimgs.each { |repo_dimg| except_dapp_project_image_with_parents(repo_dimg[:parent], dimgstages) }
+                  dimgs, dimgstages = dapp_project_images.partition { |image| repo_dimgs.any? { |dimg| dimg[:id] == image[:id] } }
+                  dimgs.each { |dimg_image| except_dapp_project_image_with_parents(dimg_image[:id], dimgstages) }
 
                   # Удаление только образов старше 2ч
                   dimgstages.delete_if do |dimgstage|

data/lib/dapp/dimg/dapp/command/stages/cleanup_repo.rb

@@ -8,7 +8,7 @@ module Dapp
               lock_repo(repo = option_repo) do
                 raise Error::Command, code: :stages_cleanup_required_option unless stages_cleanup_option?
 
-                registry        = registry(repo)
+                registry        = dimg_registry(repo)
                 repo_dimgs      = repo_dimgs_images(registry)
                 repo_dimgstages = repo_dimgstages_images(registry)
 

data/lib/dapp/dimg/dapp/command/stages/common.rb

@@ -6,11 +6,6 @@ module Dapp
           module Common
             protected
 
-            def registry(repo)
-              validate_repo_name!(repo)
-              ::Dapp::Dimg::DockerRegistry.new(repo)
-            end
-
             def repo_dimgs_images(registry)
               [].tap do |dimgs_images|
                 with_registry_wrapper do
@@ -55,7 +50,7 @@ module Dapp
 
             def delete_repo_image(registry, repo_image)
               if dry_run?
-                log(repo_image[:tag])
+                log([repo_image[:dimg], repo_image[:tag]].compact.join(':'))
               else
                 registry.image_delete(repo_image[:tag], repo_image[:dimg])
               end

data/lib/dapp/dimg/dapp/command/stages/flush_local.rb

@@ -6,9 +6,11 @@ module Dapp
           module FlushLocal
             def stages_flush_local
               lock("#{name}.images") do
-                dapp_project_containers_flush
-                dapp_project_dangling_images_flush
-                remove_project_images(dapp_project_images_ids)
+                log_step_with_indent(name) do
+                  dapp_project_containers_flush
+                  dapp_project_dangling_images_flush
+                  remove_project_images(dapp_project_images_ids)
+                end
               end
             end
           end

data/lib/dapp/dimg/dapp/command/stages/flush_repo.rb

@@ -7,7 +7,7 @@ module Dapp
             def stages_flush_repo
               lock_repo(option_repo) do
                 log_step_with_indent(option_repo) do
-                  registry = registry(option_repo)
+                  registry = dimg_registry(option_repo)
                   repo_dimgstages_images(registry).each { |repo_image| delete_repo_image(registry, repo_image) }
                 end
               end

data/lib/dapp/dimg/docker_registry/dimg.rb

@@ -17,10 +17,6 @@ module Dapp
           tags.select { |tag| !tag.start_with?('dimgstage') }
         end
 
-        def tags
-          (@tags ||= {})[repo_suffix] ||= super
-        end
-
         def image_id(tag, extra_repo_suffix = nil)
           with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
         end
@@ -43,11 +39,6 @@ module Dapp
           end
         end
 
-        def reset_cache
-          @tags = nil
-          @image_history = nil
-        end
-
         protected
 
         def with_repo_suffix(extra_repo_suffix)

data/lib/dapp/dimg/git_repo/base.rb

@@ -3,8 +3,6 @@ module Dapp
     module GitRepo
       # Base class for any Git repo (remote, gitkeeper, etc)
       class Base
-        include Helper::Trivia
-
         attr_reader :name
 
         def initialize(manager, name)
@@ -86,13 +84,18 @@ module Dapp
           raise Error::Rugged, code: :git_repository_reference_error, data: { name: name, message: e.message.downcase }
         end
 
+        def tag_at(name)
+          tag = git.tags.find { |t| t.name == name }
+          commit_at(tag.target)
+        end
+
         def tags
-          git.tags.map { |t| t.name }
+          git.tags.map(&:name)
         end
 
         def remote_branches
           git.branches
-            .map { |b| b.name }
+            .map(&:name)
             .select { |b| b.start_with?('origin/') }
             .map { |b| b.reverse.chomp('origin/'.reverse).reverse }
         end
@@ -129,6 +132,29 @@ module Dapp
         def git(**kwargs)
           @git ||= Rugged::Repository.new(path.to_s, **kwargs)
         end
+
+        private
+
+        def ignore_path?(path, paths: [], exclude_paths: [])
+          is_exclude_path = exclude_paths.any? { |p| check_path?(path, p) }
+          is_include_path = begin
+            paths.empty? ||
+                paths.any? { |p| File.fnmatch?(p, path) || File.fnmatch?(File.join(p, '**'), path) }
+          end
+
+          is_exclude_path || !is_include_path
+        end
+
+        def check_path?(path, format)
+          path_parts = path.split('/')
+          checking_path = nil
+
+          until path_parts.empty?
+            checking_path = [checking_path, path_parts.shift].compact.join('/')
+            return true if File.fnmatch(format, checking_path)
+          end
+          false
+        end
       end
     end
   end

data/lib/dapp/dimg/image/argument.rb

@@ -65,9 +65,7 @@ module Dapp
         def prepare_instructions(options)
           options.map do |key, vals|
             case key
-            when :cmd, :entrypoint
-              vals = [''] if vals == [] && ::Dapp::Dapp.host_docker_minor_version >= Gem::Version.new('17.10')
-              [vals]
+            when :cmd, :entrypoint then [vals]
             when :env, :label then vals.map(&method(:options_to_args)).flatten
             else vals
             end.map { |val| %(#{key.to_s.upcase} #{val}) }

data/lib/dapp/helper/trivia.rb

@@ -28,41 +28,6 @@ module Dapp
         Pathname.new(File.join(base.to_s, *path.compact.map(&:to_s)))
       end
 
-      def ignore_path?(path, paths: [], exclude_paths: [])
-        ignore_path_base(path, exclude_paths: exclude_paths) do
-          paths.empty? ||
-            paths.any? do |p|
-              File.fnmatch?(p, path, File::FNM_PATHNAME|File::FNM_DOTMATCH) ||
-                File.fnmatch?(File.join(p, '**', '*'), path, File::FNM_PATHNAME|File::FNM_DOTMATCH)
-            end
-        end
-      end
-
-      def ignore_path_base(path, exclude_paths: [])
-        is_exclude_path = exclude_paths.any? { |p| check_path?(path, p) }
-        is_include_path = yield
-        is_exclude_path || !is_include_path
-      end
-
-      def check_path?(path, format)
-        path_checker(path) { |checking_path| File.fnmatch(format, checking_path, File::FNM_PATHNAME|File::FNM_DOTMATCH) }
-      end
-
-      def check_subpath?(path, format)
-        path_checker(format) { |checking_path| File.fnmatch(checking_path, path, File::FNM_PATHNAME|File::FNM_DOTMATCH) }
-      end
-
-      def path_checker(path)
-        path_parts = path.split('/')
-        checking_path = nil
-
-        until path_parts.empty?
-          checking_path = [checking_path, path_parts.shift].compact.join('/')
-          return true if yield checking_path
-        end
-        false
-      end
-
       def self.class_to_lowercase(class_name = self)
         class_name.to_s.split('::').last.split(/(?=[[:upper:]]|[0-9])/).join('_').downcase.to_s
       end

data/lib/dapp/kube/cli/command/kube/deploy.rb

@@ -69,6 +69,12 @@ BANNER
              description: 'Default timeout to wait for resources to become ready, 300 seconds by default.',
              proc: proc {|v| Integer(v)}
 
+      option :without_registry,
+             long: "--without-registry",
+             default: false,
+             boolean: true,
+             description: "Do not connect to docker registry to obtain docker image ids of dimgs being deployed."
+
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
 

data/lib/dapp/kube/dapp/command/common.rb

@@ -31,7 +31,8 @@ module Dapp
                   chart_path: kube_chart_path_for_helm,
                   set: self.options[:helm_set_options],
                   values: [*kube_values_paths, *kube_tmp_chart_secret_values_paths],
-                  deploy_timeout: self.options[:timeout] || 300
+                  deploy_timeout: self.options[:timeout] || 300,
+                  without_registry: self.options[:without_registry],
               )
 
               yield release
@@ -90,23 +91,138 @@ module Dapp
 
           def kube_generate_helm_chart_tpl
             cont = <<-EOF
-{{/* vim: set filetype=mustache: */}}
+{{- define "dapp_secret_file" -}}
+{{-   $relative_file_path := index . 0 -}}
+{{-   $context := index . 1 -}}
+{{-   $context.Files.Get (print "#{kube_tmp_chart_secret_path.subpath_of(kube_chart_path_for_helm)}/" $relative_file_path) -}}
+{{- end -}}
+
+{{- define "_dimg" -}}
+{{-   $context := index . 0 -}}
+{{-   if eq (typeOf $context.Values.global.dapp.docker_image) "map[string]interface {}" -}}
+{{-     required "No dimg specified for template" nil -}}
+{{-   end -}}
+{{    $context.Values.global.dapp.docker_image }}
+{{- end -}}
+
+{{- define "_dimg2" -}}
+{{-   $name := index . 0 -}}
+{{-   $context := index . 1 -}}
+{{-   if ne (typeOf $context.Values.global.dapp.docker_image) "map[string]interface {}" -}}
+{{-     required (printf "No dimg should be specified for template, got `%s`" $name) nil -}}
+{{-   end -}}
+{{    required (printf "Unknown dimg `%s` specified for template" $name) (pluck $name $context.Values.global.dapp.docker_image | first) }}
+{{- end -}}
 
 {{- define "dimg" -}}
-{{- if (ge (len (index .)) 2) -}}
-{{- $name := index . 0 -}}
-{{- $context := index . 1 -}}
-{{- printf "%v/%v:%v" $context.Values.global.dapp.repo $name $context.Values.global.dapp.docker_tag -}}
-{{- else -}}
-{{- $context := index . 0 -}}
-{{- printf "%v:%v" $context.Values.global.dapp.repo $context.Values.global.dapp.docker_tag -}}
+{{-   if eq (typeOf .) "chartutil.Values" -}}
+{{-     $context := . -}}
+{{      tuple $context | include "_dimg" }}
+{{-   else if (ge (len .) 2) -}}
+{{-     $name := index . 0 -}}
+{{-     $context := index . 1 -}}
+{{      tuple $name $context | include "_dimg2" }}
+{{-   else -}}
+{{-     $context := index . 0 -}}
+{{      tuple $context | include "_dimg" }}
+{{-   end -}}
 {{- end -}}
+
+{{- define "_dapp_container__imagePullPolicy" -}}
+{{-   $context := index . 0 -}}
+{{-   if $context.Values.global.dapp.is_branch -}}
+imagePullPolicy: Always
+{{-   end -}}
 {{- end -}}
 
-{{- define "dapp_secret_file" -}}
-{{- $relative_file_path := index . 0 -}}
-{{- $context := index . 1 -}}
-{{- $context.Files.Get (print "#{kube_tmp_chart_secret_path.subpath_of(kube_chart_path_for_helm)}/" $relative_file_path) -}}
+{{- define "_dapp_container__image" -}}
+{{-   $context := index . 0 -}}
+image: {{ tuple $context | include "_dimg" }}
+{{- end -}}
+
+{{- define "_dapp_container__image2" -}}
+{{-   $name := index . 0 -}}
+{{-   $context := index . 1 -}}
+image: {{ tuple $name $context | include "_dimg2" }}
+{{- end -}}
+
+{{- define "dapp_container_image" -}}
+{{-   if eq (typeOf .) "chartutil.Values" -}}
+{{-     $context := . -}}
+{{      tuple $context | include "_dapp_container__image" }}
+{{      tuple $context | include "_dapp_container__imagePullPolicy" }}
+{{-   else if (ge (len .) 2) -}}
+{{-     $name := index . 0 -}}
+{{-     $context := index . 1 -}}
+{{      tuple $name $context | include "_dapp_container__image2" }}
+{{      tuple $context | include "_dapp_container__imagePullPolicy" }}
+{{-   else -}}
+{{-     $context := index . 0 -}}
+{{      tuple $context | include "_dapp_container__image" }}
+{{      tuple $context | include "_dapp_container__imagePullPolicy" }}
+{{-   end -}}
+{{- end -}}
+
+{{- define "_dimg_id" -}}
+{{-   $context := index . 0 -}}
+{{-   if eq (typeOf $context.Values.global.dapp.docker_image_id) "map[string]interface {}" -}}
+{{-     required "No dimg specified for template" nil -}}
+{{-   end -}}
+{{    $context.Values.global.dapp.docker_image_id }}
+{{- end -}}
+
+{{- define "_dimg_id2" -}}
+{{-   $name := index . 0 -}}
+{{-   $context := index . 1 -}}
+{{-   if ne (typeOf $context.Values.global.dapp.docker_image_id) "map[string]interface {}" -}}
+{{-     required (printf "No dimg should be specified for template, got `%s`" $name) nil -}}
+{{-   end -}}
+{{    required (printf "Unknown dimg `%s` specified for template" $name) (pluck $name $context.Values.global.dapp.docker_image_id | first) }}
+{{- end -}}
+
+{{- define "dimg_id" -}}
+{{-   if eq (typeOf .) "chartutil.Values" -}}
+{{-     $context := . -}}
+{{      tuple $context | include "_dimg_id" }}
+{{-   else if (ge (len .) 2) -}}
+{{-     $name := index . 0 -}}
+{{-     $context := index . 1 -}}
+{{      tuple $name $context | include "_dimg_id2" }}
+{{-   else -}}
+{{-     $context := index . 0 -}}
+{{      tuple $context | include "_dimg_id" }}
+{{-   end -}}
+{{- end -}}
+
+{{- define "_dapp_container_env" -}}
+{{-   $context := index . 0 -}}
+{{-   if $context.Values.global.dapp.is_branch -}}
+- name: DOCKER_IMAGE_ID
+  value: {{ tuple $context | include "_dimg_id" }}
+{{-   end -}}
+{{- end -}}
+
+{{- define "_dapp_container_env2" -}}
+{{-   $name := index . 0 -}}
+{{-   $context := index . 1 -}}
+{{-   if $context.Values.global.dapp.is_branch -}}
+- name: DOCKER_IMAGE_ID
+  value: {{ tuple $name $context | include "_dimg_id2" }}
+{{-   end -}}
+{{- end -}}
+
+{{- define "dapp_container_env" -}}
+{{-   if eq (typeOf .) "chartutil.Values" -}}
+{{-     $context := . -}}
+{{      tuple $context | include "_dapp_container_env" }}
+{{-   else if (ge (len .) 2) -}}
+{{-     $name := index . 0 -}}
+{{-     $context := index . 1 -}}
+{{      tuple $name $context | include "_dapp_container_env2" }}
+{{-   else -}}
+{{-     $context := index . 0 -}}
+{{      tuple $context | include "_dapp_container_env" }}
+{{-   end -}}
 {{- end -}}
             EOF
             kube_chart_path_for_helm('templates/_dapp_helpers.tpl').write(cont)