kontena-cli 1.1.0.pre1 → 1.1.0.rc1

data/lib/kontena/cli/stacks/common.rb

@@ -20,16 +20,56 @@ module Kontena::Cli::Stacks
       end
     end
 
+    module StackFileOrNameParam
+      attr_accessor :from_registry
+
+      def self.included(where)
+        where.parameter "[FILE]", "Kontena stack file or a registry stack name (user/stack or user/stack:version)", default: "kontena.yml", attribute_name: :filename do |filename|
+          if !File.exist?(filename) && filename =~ /\A[a-zA-Z0-9\_\.\-]+\/[a-zA-Z0-9\_\.\-]+(?::.*)?\z/
+            @from_registry = true
+          else
+            @from_registry = false
+            require_config_file(filename)
+          end
+          filename
+        end
+      end
+    end
+
+    module StackNameOption
+      def self.included(where)
+        where.option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
+      end
+    end
+
+    module StackValuesFromOption
+      attr_accessor :values
+      def self.included(where)
+        where.option '--values-from', '[FILE]', 'Read variable values from YAML' do |filename|
+          if filename
+            require_config_file(filename)
+            @values = ::YAML.safe_load(File.read(filename))
+          end
+          filename
+        end
+      end
+    end
+
     def stack_name
       @stack_name ||= self.name || stack_name_from_yaml(filename)
     end
 
-    def stack_from_yaml(filename, from_registry: false, name: nil)
-      reader = Kontena::Cli::Stacks::YAML::Reader.new(filename, from_registry: from_registry)
+    def reader_from_yaml(filename, from_registry: false, name: nil, values: nil)
+      reader = Kontena::Cli::Stacks::YAML::Reader.new(filename, from_registry: from_registry, values: values)
       if reader.stack_name.nil?
         exit_with_error "Stack MUST have stack name in YAML top level field 'stack'! Aborting."
       end
       set_env_variables(name || reader.stack_name, current_grid)
+      reader
+    end
+
+    def stack_from_yaml(filename, from_registry: false, name: nil, values: nil)
+      reader = reader_from_yaml(filename, from_registry: from_registry, name: name, values: values)
       outcome = reader.execute
 
       hint_on_validation_notifications(outcome[:notifications]) if outcome[:notifications].size > 0
@@ -42,7 +82,9 @@ module Kontena::Cli::Stacks
         'version' => outcome[:version],
         'source' => reader.raw_content,
         'registry' => 'file://',
-        'services' => kontena_services
+        'services' => kontena_services,
+        'variables' => outcome[:variables],
+        'vault_keys' => outcome[:vault_keys]
       }
       stack
     end

data/lib/kontena/cli/stacks/deploy_command.rb

@@ -15,10 +15,13 @@ module Kontena::Cli::Stacks
 
     def execute
       deployment = nil
-      spinner "Deploying stack #{pastel.cyan(name)}" do
+      spinner "Triggering deployment of stack #{pastel.cyan(name)}" do
         deployment = deploy_stack(name)
-        wait_for_deploy_to_finish(deployment)
       end
+      spinner "Waiting for deployment to start" do
+        wait_for_deployment_to_start(deployment)
+      end
+      wait_for_deploy_to_finish(deployment)
     end
 
     def deploy_stack(name)

data/lib/kontena/cli/stacks/install_command.rb

@@ -8,11 +8,14 @@ module Kontena::Cli::Stacks
 
     banner "Installs a stack to a grid on Kontena Master"
 
-    parameter "[FILE]", "Kontena stack file or a registry stack name (user/stack or user/stack:version)", default: "kontena.yml", attribute_name: :filename
+    include Common::StackFileOrNameParam
 
-    option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
+    include Common::StackNameOption
     option '--deploy', :flag, 'Deploy after installation'
 
+    include Common::StackValuesFromOption
+
+
     requires_current_master
     requires_current_master_token
 
@@ -25,7 +28,8 @@ module Kontena::Cli::Stacks
         require_config_file(filename)
       end
 
-      stack = stack_from_yaml(filename, from_registry: from_registry, name: name)
+      stack = stack_from_yaml(filename, from_registry: from_registry, name: name, values: values)
+
       stack['name'] = name if name
       spinner "Creating stack #{pastel.cyan(stack['name'])} " do
         create_stack(stack)

data/lib/kontena/cli/stacks/list_command.rb

@@ -18,8 +18,8 @@ module Kontena::Cli::Stacks
     def list_stacks
       response = client.get("grids/#{current_grid}/stacks")
 
-      titles = ['NAME', 'VERSION', 'SERVICES', 'STATE', 'EXPOSED PORTS']
-      puts "%-60s %-10s %-10s %-10s %-50s" % titles
+      titles = ['NAME', 'STACK', 'SERVICES', 'STATE', 'EXPOSED PORTS']
+      puts "%-30s %-40s %-10s %-10s %-50s" % titles
 
       response['stacks'].each do |stack|
         ports = stack_ports(stack)
@@ -41,13 +41,13 @@ module Kontena::Cli::Stacks
         vars = [
           icon.colorize(color),
           "#{stack['name']}",
-          "#{stack['version']}",
+          "#{stack['stack']}:#{stack['version']}",
           stack['services'].size,
           stack['state'],
           ports.join(",")
         ]
 
-        puts "%s %-58s %-10s %-10s %-10s %-50s" % vars
+        puts "%s %-28s %-40s %-10s %-10s %-50s" % vars
       end
     end
 

data/lib/kontena/cli/stacks/registry/push_command.rb

@@ -12,11 +12,15 @@ module Kontena::Cli::Stacks::Registry
     requires_current_account_token
 
     def execute
-      file = Kontena::Cli::Stacks::YAML::Reader.new(filename, skip_variables: true, replace_missing: "filler")
+      file = Kontena::Cli::Stacks::YAML::Reader.new(
+        filename,
+        skip_variables: true,
+        skip_validation: true
+      )
       file.execute
-      name = "#{file.yaml['stack']}:#{file.yaml['version']}"
+      name = "#{file.stack_name}:#{file.stack_version}"
       spinner("Pushing #{pastel.cyan(name)} to stacks registry") do
-        stacks_client.push(file.yaml['stack'], file.yaml['version'], file.raw_content)
+        stacks_client.push(file.stack_name, file.stack_version, file.raw_content)
       end
     end
   end

data/lib/kontena/cli/stacks/show_command.rb

@@ -26,9 +26,10 @@ module Kontena::Cli::Stacks
 
       puts "#{stack['name']}:"
       puts "  state: #{stack['state']}"
+      puts "  stack: #{stack['stack']}"
+      puts "  version: #{stack['version']}"
       puts "  created_at: #{stack['created_at']}"
       puts "  updated_at: #{stack['updated_at']}"
-      puts "  version: #{stack['version']}"
       puts "  expose: #{stack['expose'] || '-'}"
       puts "  services:"
       stack['services'].each do |service|

data/lib/kontena/cli/stacks/stacks_helper.rb

@@ -2,25 +2,60 @@
 module Kontena::Cli::Stacks
   module StacksHelper
 
+    def wait_for_deployment_to_start(deployment, timeout = 600)
+      started = false
+      Timeout::timeout(timeout) do
+        until started
+          deployment = client.get("stacks/#{deployment['stack_id']}/deploys/#{deployment['id']}")
+          started = true if deployment['service_deploys'].size > 0
+          sleep 1
+        end
+        if deployment['state'] == 'error'
+          deployment['service_deploys'].each do |service_deploy|
+            if service_deploy['state'] == 'error'
+              puts "        #{service_deploy['reason']}"
+            end
+          end
+
+          raise 'deploy failed'
+        end
+      end
+
+      started
+    rescue Timeout::Error
+      raise 'deploy timed out'
+    end
+
     # @param [Hash] deployment
     # @return [Boolean]
     def wait_for_deploy_to_finish(deployment, timeout = 600)
       deployed = false
       states = %w(success error)
+      tracked_services = []
       Timeout::timeout(timeout) do
         until deployed
           deployment = client.get("stacks/#{deployment['stack_id']}/deploys/#{deployment['id']}")
-          deployed = true if states.include?(deployment['state'])
-          sleep 1
+          service_deploy = deployment['service_deploys'].find{ |s| s['state'] == 'ongoing' }
+          if service_deploy
+            tracked_services << service_deploy['id']
+            wait_for_service_deploy(service_deploy, states)
+          end
+          if states.include?(deployment['state'])
+            deployed = true
+            deployment['service_deploys'].select{ |s| !tracked_services.include?(s['id']) }.each do |s|
+              wait_for_service_deploy(s, states)
+            end
+          else
+            sleep 1
+          end
         end
         if deployment['state'] == 'error'
           deployment['service_deploys'].each do |service_deploy|
             if service_deploy['state'] == 'error'
-              puts "        #{service_deploy['reason']}"
+              error service_deploy['reason']
             end
           end
-
-          raise 'deploy failed'
+          abort
         end
       end
 
@@ -28,5 +63,20 @@ module Kontena::Cli::Stacks
     rescue Timeout::Error
       raise 'deploy timed out'
     end
+
+    def wait_for_service_deploy(service_deploy, states)
+      service_deployed = false
+      name = service_deploy['service_id'].split('/')[-1]
+      spinner "Deploying service #{pastel.cyan(name)}" do
+        until service_deployed
+          r = client.get("services/#{service_deploy['service_id']}/deploys/#{service_deploy['id']}")
+          if states.include?(r['state'])
+            service_deployed = true
+          else
+            sleep 1
+          end
+        end
+      end
+    end
   end
 end

data/lib/kontena/cli/stacks/upgrade_command.rb

@@ -9,15 +9,18 @@ module Kontena::Cli::Stacks
     banner "Upgrades a stack in a grid on Kontena Master"
 
     parameter "NAME", "Stack name"
-    parameter "[FILE]", "Kontena stack file", default: "kontena.yml"
+
+    include Common::StackFileOrNameParam
+    include Common::StackValuesFromOption
+
     option '--deploy', :flag, 'Deploy after upgrade'
 
     requires_current_master
     requires_current_master_token
 
     def execute
-      require_config_file(file)
-      stack = stack_from_yaml(file, name: name)
+      require_config_file(filename)
+      stack = stack_from_yaml(filename, name: name, values: values, from_registry: from_registry)
       spinner "Upgrading stack #{pastel.cyan(name)} " do
         update_stack(stack)
       end

data/lib/kontena/cli/stacks/validate_command.rb

@@ -0,0 +1,47 @@
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class ValidateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Validates a YAML file"
+
+    include Common::StackFileOrNameParam
+    include Common::StackNameOption
+
+    option '--values-to', '[FILE]', 'Output variable values as YAML to file'
+
+    include Common::StackValuesFromOption
+
+    requires_current_master # the stack may use a vault resolver
+    requires_current_master_token
+
+    def execute
+
+      if !File.exist?(filename) && filename =~ /\A[a-zA-Z0-9\_\.\-]+\/[a-zA-Z0-9\_\.\-]+(?::.*)?\z/
+        from_registry = true
+      else
+        from_registry = false
+        require_config_file(filename)
+      end
+
+      reader = reader_from_yaml(filename, from_registry: from_registry, name: name, values: values)
+      outcome = reader.execute
+      hint_on_validation_notifications(outcome[:notifications]) if outcome[:notifications].size > 0
+      abort_on_validation_errors(outcome[:errors]) if outcome[:errors].size > 0
+
+      if values_to
+        vals = reader.variables.to_h(values_only: true).reject {|k,_| k == 'STACK' || k == 'GRID' }
+        File.write(values_to, ::YAML.dump(vals))
+      end
+      result = reader.fully_interpolated_yaml.merge(
+        # simplest way to stringify keys in a hash
+        'variables' => JSON.parse(reader.variables.to_h(with_values: true, with_errors: true).to_json)
+      )
+      puts ::YAML.dump(result)
+    end
+  end
+end
+

data/lib/kontena/cli/stacks/yaml/opto/prompt_resolver.rb

@@ -1,14 +1,9 @@
-if RUBY_VERSION < '2.1'
-  require 'opto/extensions/hash_string_or_symbol_key'
-  using Opto::Extension::HashStringOrSymbolKey
-end
-
 module Kontena::Cli::Stacks
   module YAML
     class Prompt < Opto::Resolver
       include Kontena::Cli::Common
 
-      using Opto::Extension::HashStringOrSymbolKey unless RUBY_VERSION < '2.1'
+      using Opto::Extension::HashStringOrSymbolKey
 
       def enum?
         option.type == 'enum'

data/lib/kontena/cli/stacks/yaml/reader.rb

@@ -6,9 +6,9 @@ module Kontena::Cli::Stacks
       include Kontena::Util
       include Kontena::Cli::Common
 
-      attr_reader :file, :raw_content, :result, :errors, :notifications, :variables, :yaml
+      attr_reader :file, :raw_content, :errors, :notifications
 
-      def initialize(file, skip_validation: false, skip_variables: false, replace_missing: nil, from_registry: false)
+      def initialize(file, skip_validation: false, skip_variables: false, from_registry: false, variables: nil, values: nil)
         require 'yaml'
         require_relative 'service_extender'
         require_relative 'validator_v3'
@@ -17,6 +17,7 @@ module Kontena::Cli::Stacks
         require_relative 'opto/vault_resolver'
         require_relative 'opto/prompt_resolver'
         require_relative 'opto/service_instances_resolver'
+        require 'liquid'
 
         @file = file
         @from_registry = from_registry
@@ -29,105 +30,137 @@ module Kontena::Cli::Stacks
           @raw_content = File.read(File.expand_path(file))
         end
 
-        @errors = []
-        @notifications = []
+        @errors           = []
+        @notifications    = []
         @skip_validation  = skip_validation
         @skip_variables   = skip_variables
-        @replace_missing  = replace_missing
+        @variables        = variables
+        @values           = values
       end
 
-      def from_registry?
-        @from_registry == true
+      def internals_interpolated_yaml
+        @internals_interpolated_yaml ||= ::YAML.safe_load(
+          replace_dollar_dollars(
+            interpolate(
+              raw_content,
+              use_opto: false,
+              substitutions: {
+                'GRID' => env['GRID'],
+                'STACK' => env['STACK']
+              },
+              warnings: false
+            )
+          )
+        )
+      rescue Psych::SyntaxError => e
+        raise "Error while parsing #{file}".colorize(:red)+ " " + e.message
+      end
+
+      def fully_interpolated_yaml
+        return @fully_interpolated_yaml if @fully_interpolated_yaml
+        vars = variables.to_h(values_only: true)
+        @fully_interpolated_yaml = ::YAML.safe_load(
+          replace_dollar_dollars(
+            interpolate(
+              interpolate_liquid(
+                raw_content,
+                vars
+              ),
+              use_opto: true,
+              raise_on_unknown: true
+            )
+          )
+        )
+      rescue Psych::SyntaxError => e
+        raise "Error while parsing #{file}".colorize(:red)+ " " + e.message
+      end
+
+      def raw_yaml
+        @raw_yaml ||= ::YAML.safe_load(raw_content)
       end
 
       # @return [Opto::Group]
       def variables
         return @variables if @variables
-        if yaml && yaml.has_key?('variables')
-          variables_yaml = yaml['variables'].to_yaml
-          variables_hash = ::YAML.safe_load(replace_dollar_dollars(interpolate(variables_yaml, use_opto: false)))
-          @variables = Opto::Group.new(variables_hash, defaults: { from: :env, to: :env })
-        else
-          @variables = Opto::Group.new(defaults: { from: :env, to: :env })
+        @variables = Opto::Group.new(
+          (internals_interpolated_yaml['variables'] || {}).merge('STACK' => { type: :string, value: env['STACK']}, 'GRID' => {type: :string, value: env['GRID']}),
+          defaults: {
+            from: :env,
+            to: :env
+          }
+        )
+        if @values
+          @values.each do |key, val|
+            var = @variables.option(key)
+            var.set(val) if var
+          end
         end
         @variables
       end
 
-      def parse_variables
-        raise RuntimeError, "Variable validation failed: #{variables.errors.inspect}" unless variables.valid?
-        variables.run
-      end
-
-      ##
       # @param [String] service_name
       # @return [Hash]
       def execute(service_name = nil)
-        load_yaml(false)
-        parse_variables unless skip_variables?
-        load_yaml
+        process_variables unless skip_variables?
         validate unless skip_validation?
 
         result = {}
         Dir.chdir(from_registry? ? Dir.pwd : File.dirname(File.expand_path(file))) do
-          result[:stack]         = yaml['stack']
+          result[:stack]         = raw_yaml['stack']
           result[:version]       = self.stack_version
           result[:name]          = self.stack_name
           result[:registry]      = @registry if from_registry?
-          result[:expose]        = yaml['expose']
+          result[:expose]        = fully_interpolated_yaml['expose']
           result[:errors]        = errors unless skip_validation?
           result[:notifications] = notifications
           result[:services]      = errors.count == 0 ? parse_services(service_name) : {}
-          result[:variables]     = variables.to_h(values_only: true).reject { |k,_| variables.option(k).to.has_key?(:vault) } unless skip_variables?
+          unless skip_variables?
+            result[:variables]     = variables.to_h(values_only: true).reject do |k,_|
+              k == 'GRID' || k == 'STACK' || variables.option(k).to.has_key?(:vault) || variables.option(k).from.has_key?(:vault)
+            end
+          end
+          result[:vault_keys]    = extract_vault_keys(result[:services])
         end
         result
       end
 
-      def stack_name
-        yaml = ::YAML.safe_load(raw_content)
-        yaml['stack'].split('/').last.split(':').first if yaml['stack']
-      end
 
-      def stack_version
-        yaml['version'] || yaml['stack'].to_s[/:(.*)/, 1] || '1'
+      def process_variables
+        variables.run
+        raise RuntimeError, "Variable validation failed: #{variables.errors.inspect}" unless variables.valid?
       end
 
-      private
+      def interpolate_liquid(content, vars)
+        Liquid::Template.error_mode = :strict
+        template = Liquid::Template.parse(content)
+        template.render(vars, strict_variables: true, strict_filters: true)
+      end
 
-      # A hash such as { "${MYSQL_IMAGE}" => "MYSQL_IMAGE } where the key is the
-      # string to be substituted and value is the pure name part
-      # @return [Hash]
-      def yaml_substitutables
-        @content_variables ||= raw_content.scan(/((?<!\$)\$(?!\$)\{?(\w+)\}?)/m)
+      def stack_name
+        @stack_name ||= parse_stack_name(::YAML.safe_load(raw_content)['stack'].to_s)[:stack]
       end
 
-      def load_yaml(interpolate = true)
-        if interpolate
-          @yaml = ::YAML.safe_load(replace_dollar_dollars(interpolate(raw_content)))
-        else
-          @yaml = ::YAML.safe_load(raw_content)
-        end
-      rescue Psych::SyntaxError => e
-        raise "Error while parsing #{file}".colorize(:red)+ " "+e.message
+      def stack_version
+        @stack_version ||= raw_yaml['version'] || parse_stack_name(raw_yaml['stack'].to_s)[:version] || '0.0.1'
       end
 
       # @return [Array] array of validation errors
       def validate
-        result = validator.validate(yaml)
+        result = validator.validate(fully_interpolated_yaml)
         store_failures(result)
         result
       end
 
       def skip_validation?
-        @skip_validation == true
+        !!@skip_validation
       end
 
       def skip_variables?
-        @skip_variables == true
+        !!@skip_variables
       end
 
-      def store_failures(data)
-        errors << { file => data[:errors] } unless data[:errors].empty?
-        notifications << { file => data[:notifications] } unless data[:notifications].empty?
+      def from_registry?
+        !!@from_registry
       end
 
       # @return [Kontena::Cli::Stacks::YAML::ValidatorV3]
@@ -142,7 +175,7 @@ module Kontena::Cli::Stacks
         if service_name.nil?
           services.each do |name, config|
             services[name] = process_config(config)
-            if process_service?(config)
+            if process_hash?(config)
               services[name].delete('only_if')
               services[name].delete('skip_if')
             else
@@ -156,12 +189,16 @@ module Kontena::Cli::Stacks
         end
       end
 
-      def process_service?(config)
-        return true unless config['skip_if'] || config['only_if']
+      # If the supplied hash contains skip_if/only_if conditionals, process that conditional and return true/false
+      #
+      # @param [Hash]
+      # @return [Boolean]
+      def process_hash?(hash)
+        return true unless hash['skip_if'] || hash['only_if']
         return true if skip_variables? || variables.empty?
 
-        skip_lambdas = normalize_ifs(config['skip_if'])
-        only_lambdas = normalize_ifs(config['only_if'])
+        skip_lambdas = normalize_ifs(hash['skip_if'])
+        only_lambdas = normalize_ifs(hash['only_if'])
 
         if skip_lambdas
           return false if skip_lambdas.any? { |s| s.call }
@@ -174,33 +211,6 @@ module Kontena::Cli::Stacks
         true
       end
 
-      # Generates an array of lambdas that return true if a condition is true
-      # Possible syntaxes:
-      # @example
-      #   normalize_ifs( 'wp' )        # lambdas return true if variable wp is not null or false or 'false'
-      #   normalize_ifs( wp: 1 )       # lambdas return true if value of wp is 1
-      #   normalize_ifs( [:wp, :ws] )  # lambdas return true if wp and ws are not not null or false or 'false'
-      #   normalize_ifs( wp: 1, ws: 1) # lambdas return true if wp and ws are 1
-      #   normalize_ifs(nil)           # returns nil
-      def normalize_ifs(ifs)
-        case ifs
-        when NilClass
-          nil
-        when Array
-          ifs.map do |iff|
-            lambda { val = variables.value_of(iff.to_s); !val.nil? && !val.kind_of?(FalseClass) && val != 'false' }
-          end
-        when Hash
-          ifs.each_with_object([]) do |(k, v), arr|
-            arr << lambda { variables.value_of(k.to_s) == v }
-          end
-        when String, Symbol
-          [lambda { val = variables.value_of(ifs.to_s); !val.nil? && !val.kind_of?(FalseClass) && val != 'false' }]
-        else
-          raise TypeError, "Invalid syntax for if: #{ifs.inspect}"
-        end
-      end
-
       # @param [Hash] service_config
       def process_config(service_config)
         normalize_env_vars(service_config)
@@ -216,14 +226,23 @@ module Kontena::Cli::Stacks
 
       # @return [Hash] - services from YAML file
       def services
-        yaml['services']
+        @services ||= fully_interpolated_yaml['services']
       end
 
+      def from_external_file(filename, service_name, from_registry: false)
+        outcome = Reader.new(filename, skip_validation: skip_validation?, skip_variables: true, from_registry: from_registry, variables: variables).execute(service_name)
+        errors.concat outcome[:errors] unless errors.any? { |item| item.has_key?(filename) }
+        notifications.concat outcome[:notifications] unless notifications.any? { |item| item.has_key?(filename) }
+        outcome[:services]
+      end
+
+      private
+
       ##
-      # @param [String] text - content of YAML file
-      def interpolate(text, use_opto: true)
-        text.split(/[\r\n]/).map do |row|
-          # skip lines that opto is interpolating
+      # @param [String] content - content of YAML file
+      def interpolate(content, use_opto: true, substitutions: {}, raise_on_unknown: false, warnings: true)
+        content.split(/[\r\n]/).map.with_index do |row, line_num|
+          # skip lines that opto may be interpolating
           if row.strip.start_with?('interpolate:') || row.strip.start_with?('evaluate:')
             row
           else
@@ -231,16 +250,22 @@ module Kontena::Cli::Stacks
               var = v.tr('${}', '')
 
               if use_opto
-                val = variables.value_of(var) || ENV[var]
+                opt = variables.option(var)
+                if opt.nil?
+                  raise RuntimeError, "Undeclared variable '#{var}' in #{file}:#{line_num} -- #{row}" if raise_on_unknown
+                  val = nil
+                else
+                  val = opt.value
+                end
               else
-                val = ENV[var]
+                val = substitutions[var]
               end
 
-              if val
-                val.to_s =~ /[\r\n\"\'\|]/ ? val.inspect : val
+              if val && !val.to_s.empty?
+                val.to_s =~ /[\r\n\"\'\|]/ ? val.inspect : val.to_s
               else
-                puts "Value for #{var} is not set. Substituting with an empty string." unless skip_validation?
-                @replace_missing || ''
+                puts "Value for #{var} is not set. Substituting with an empty string." if warnings
+                ''
               end
             end
           end
@@ -253,6 +278,33 @@ module Kontena::Cli::Stacks
         text.gsub('$$', '$')
       end
 
+      # Generates an array of lambdas that return true if a condition is true
+      # Possible syntaxes:
+      # @example
+      #   normalize_ifs( 'wp' )        # lambdas return true if variable wp is not null or false or 'false'
+      #   normalize_ifs( wp: 1 )       # lambdas return true if value of wp is 1
+      #   normalize_ifs( [:wp, :ws] )  # lambdas return true if wp and ws are not not null or false or 'false'
+      #   normalize_ifs( wp: 1, ws: 1) # lambdas return true if wp and ws are 1
+      #   normalize_ifs(nil)           # returns nil
+      def normalize_ifs(ifs)
+        case ifs
+        when NilClass
+          nil
+        when Array
+          ifs.map do |iff|
+            lambda { val = variables.value_of(iff.to_s); !val.nil? && !val.kind_of?(FalseClass) && val != 'false' }
+          end
+        when Hash
+          ifs.each_with_object([]) do |(k, v), arr|
+            arr << lambda { variables.value_of(k.to_s) == v }
+          end
+        when String, Symbol
+          [lambda { val = variables.value_of(ifs.to_s); !val.nil? && !val.kind_of?(FalseClass) && val != 'false' }]
+        else
+          raise TypeError, "Invalid syntax for if: #{ifs.inspect}"
+        end
+      end
+
       # @param [Hash] service_config
       # @return [Hash] updated service config
       def extend_config(service_config)
@@ -281,13 +333,12 @@ module Kontena::Cli::Stacks
         end
       end
 
-      def from_external_file(filename, service_name, from_registry: false)
-        outcome = Reader.new(filename, skip_validation: @skip_validation, skip_variables: true, replace_missing: @replace_missing, from_registry: from_registry).execute(service_name)
-        errors.concat outcome[:errors] unless errors.any? { |item| item.has_key?(filename) }
-        notifications.concat outcome[:notifications] unless notifications.any? { |item| item.has_key?(filename) }
-        outcome[:services]
+      def store_failures(data)
+        errors << { file => data[:errors] } unless data[:errors].empty?
+        notifications << { file => data[:notifications] } unless data[:notifications].empty?
       end
 
+
       # @param [Hash] options - service config
       def normalize_env_vars(options)
         if options['environment'].kind_of?(Hash)
@@ -310,7 +361,7 @@ module Kontena::Cli::Stacks
 
       # @param [String] path
       def read_env_file(path)
-        File.readlines(path).map { |line| line.strip }.delete_if { |line| line.start_with?('#') || line.empty? }
+        File.readlines(path).map { |line| line.strip }.reject { |line| line.start_with?('#') || line.empty? }
       end
 
       def expand_build_context(options)
@@ -332,6 +383,44 @@ module Kontena::Cli::Stacks
           end
         end
       end
+
+      # Goes through an array of service hashes and extracts vault secret key names
+      # @param [Hash] services_array
+      # @return [Array] keys
+      def extract_vault_keys(services)
+        keys = []
+        services.each do |_, data|
+          Array(services['secrets']).each do |secret|
+            keys << secret['secret']
+          end
+        end
+        keys.uniq.compact
+      end
+
+      # Takes a stack name such as user/foo:1.0.0 and breaks it into components
+      # @param [String] stack_name
+      # @return [Hash] a hash with :user, :stack and :version
+      def parse_stack_name(stack_name)
+        return {} if stack_name.nil?
+        return {} if stack_name.empty?
+        name, version = stack_name.split(':', 2)
+        if name.include?('/')
+          user, stack = name.split('/', 2)
+        else
+          user = nil
+          stack = name
+        end
+        {
+          user: user,
+          stack: stack,
+          version: version
+        }
+      end
+
+
+      def env
+        ENV
+      end
     end
   end
 end