foreman_deployments 0.0.1

data/app/lib/foreman_deployments/config/configurator.rb

@@ -0,0 +1,23 @@
+module ForemanDeployments
+  module Config
+    class Configurator
+      def initialize(stack_definition)
+        @stack_definition = stack_definition
+      end
+
+      def configure(configuration)
+        ForemanDeployments::Config::LoadVisitor.load(@stack_definition, configuration)
+      end
+
+      def merge(*configurations)
+        configurations.each do |c|
+          ForemanDeployments::Config::MergeVisitor.merge(@stack_definition, c)
+        end
+      end
+
+      def dump(configuration)
+        ForemanDeployments::Config::SaveVisitor.save(@stack_definition, configuration)
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/config/hash.rb

@@ -0,0 +1,81 @@
+module ForemanDeployments
+  module Config
+    class Hash < ActiveSupport::HashWithIndifferentAccess
+      def merge_configuration(values)
+        values.each do |key, value|
+          configure_key(key, value, :merge_configuration)
+        end
+      end
+
+      def configure(values)
+        configuration_storage.clear
+        values.each do |key, value|
+          configure_key(key, value, :configure)
+        end
+      end
+
+      def configured
+        result = configuration_storage.deep_clone
+        each do |key, item|
+          if item.respond_to?(:configured)
+            result[key.to_s] = item.configured
+          else
+            result[key.to_s] = item
+          end
+        end
+        result
+      end
+
+      def configuration
+        result = configuration_storage.deep_clone
+        each do |key, value|
+          if value.respond_to?(:configuration)
+            result[key.to_s] = value.configuration unless value.configuration.nil?
+          end
+        end
+        result.empty? ? nil : result
+      end
+
+      def transform!(&block)
+        keys.each do |key|
+          new_key, new_value = block.call(key, self[key])
+          self[key] = new_value
+          self[new_key] = delete(key) if new_key != key
+        end
+        self
+      end
+
+      protected
+
+      def configuration_storage
+        @configuration_storage ||= {}
+      end
+
+      def configure_key(key, value, method)
+        preconfigured = self[key]
+
+        if preconfigured.nil?
+          update_configuration_storage(key, value)
+        elsif preconfigured.respond_to?(method)
+          preconfigured.send(method, value)
+        else
+          fail(InvalidValueException, _("You can't override values hardcoded in the stack definition"))
+        end
+      end
+
+      def update_configuration_storage(key, value)
+        if value.is_a? ::Hash
+          self[key] = Config::Hash.new
+          self[key].configure(value)
+        elsif value.is_a? ::Array
+          self[key] = Config::Array.new(value.size)
+          self[key].configure(value)
+        elsif value.nil?
+          configuration_storage.delete(key.to_s)
+        else
+          configuration_storage[key.to_s] = value
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/config/load_visitor.rb

@@ -0,0 +1,23 @@
+module ForemanDeployments
+  module Config
+    class LoadVisitor
+      def initialize(config_storage)
+        @config_storage = config_storage
+      end
+
+      def visit(subject)
+        configure_task_definition(subject) if subject.is_a? ForemanDeployments::Tasks::BaseDefinition
+      end
+
+      def self.load(stack_definition, config_storage)
+        stack_definition.accept(LoadVisitor.new(config_storage))
+      end
+
+      private
+
+      def configure_task_definition(task)
+        task.configure(@config_storage.get_config_for(task))
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/config/merge_visitor.rb

@@ -0,0 +1,23 @@
+module ForemanDeployments
+  module Config
+    class MergeVisitor
+      def initialize(config_storage)
+        @config_storage = config_storage
+      end
+
+      def visit(subject)
+        configure_task_definition(subject) if subject.is_a? ForemanDeployments::Tasks::BaseDefinition
+      end
+
+      def self.merge(stack_definition, config_storage)
+        stack_definition.accept(MergeVisitor.new(config_storage))
+      end
+
+      private
+
+      def configure_task_definition(task)
+        task.merge_configuration(@config_storage.get_config_for(task))
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/config/save_visitor.rb

@@ -0,0 +1,23 @@
+module ForemanDeployments
+  module Config
+    class SaveVisitor
+      def initialize(config_storage)
+        @config_storage = config_storage
+      end
+
+      def visit(subject)
+        configure_task_definition(subject) if subject.is_a? ForemanDeployments::Tasks::BaseDefinition
+      end
+
+      def self.save(stack_definition, config_storage)
+        stack_definition.accept(SaveVisitor.new(config_storage))
+      end
+
+      private
+
+      def configure_task_definition(task)
+        @config_storage.set_config_for(task, task.configuration)
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/inputs/base_input_definition.rb

@@ -0,0 +1,39 @@
+module ForemanDeployments
+  module Inputs
+    class BaseInputDefinition
+      attr_reader :configured
+
+      def initialize(params = {})
+        @parameters = params
+      end
+
+      def validate(_value)
+        ForemanDeployments::Validation::ValidationResult.new
+      end
+
+      def configure(value)
+        validate(value)
+        @configured = value
+      end
+
+      def configuration
+        @configured
+      end
+
+      def to_hash
+        {
+          '_type' => 'input',
+          '_name' => self.class.tag_name
+        }
+      end
+
+      def self.tag_name
+        name.split('::').last
+      end
+
+      def self.build(*params)
+        new(*params)
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/inputs/value.rb

@@ -0,0 +1,25 @@
+module ForemanDeployments
+  module Inputs
+    class Value < BaseInputDefinition
+      attr_reader :description
+
+      def initialize(params = {})
+        @description = params.delete('description')
+        @default = params.delete('default')
+        super
+      end
+
+      def configured
+        @configured || @default
+      end
+
+      def to_hash
+        super.merge(
+          'description' => @description,
+          'default' => @default,
+          'value' => @configured
+        )
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/planner_visitor.rb

@@ -0,0 +1,26 @@
+module ForemanDeployments
+  class PlannerVisitor < BaseDereferenceVisitor
+    def initialize(parent_action)
+      super()
+      @parent_action = parent_action
+    end
+
+    protected
+
+    def visit_task_definition(task)
+      super
+      task.plan(@parent_action) unless cached?(task)
+    end
+
+    def get_dereference(ref)
+      ref.dereference(get_planned_output(ref.task))
+    end
+
+    def get_planned_output(task)
+      cached(task) do
+        task.parameters = dereference(task.parameters)
+        task.plan(@parent_action).output
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/registry.rb

@@ -0,0 +1,67 @@
+module ForemanDeployments
+  class Registry
+    class TypeException < ::Foreman::Exception; end
+
+    ALLOWED_TYPES = {
+      'task' => 'ForemanDeployments::Tasks::BaseDefinition',
+      'input' => 'ForemanDeployments::Inputs::BaseInputDefinition'
+    }
+
+    def initialize
+      clear!
+    end
+
+    def clear!
+      @available = Hash[ALLOWED_TYPES.keys.map { |k| [k, {}] }]
+    end
+
+    def available(type)
+      @available[type].clone
+    end
+
+    def register(type, registered_class)
+      type = type.to_s
+      unless type_valid?(type)
+        fail(TypeException, "Type needs to be one of: #{ALLOWED_TYPES.keys.join(', ')}")
+      end
+      unless class_valid?(type, registered_class)
+        fail(TypeException, "Registered class need to be descendant of #{ALLOWED_TYPES[type]}")
+      end
+      task_name = registered_class.tag_name.to_s
+      unless name_valid?(task_name)
+        fail(TypeException, "Invalid name #{task_name}")
+      end
+      @available[type][task_name.to_s] = registered_class.name
+    end
+
+    def available_tasks
+      available('task')
+    end
+
+    def register_task(registered_class)
+      register('task', registered_class)
+    end
+
+    def available_inputs
+      available('input')
+    end
+
+    def register_input(registered_class)
+      register('input', registered_class)
+    end
+
+    private
+
+    def name_valid?(name)
+      name =~ /[a-zA-Z0-9][a-zA-Z0-9_]*/
+    end
+
+    def class_valid?(type, registered_class)
+      registered_class < ALLOWED_TYPES[type].constantize
+    end
+
+    def type_valid?(type)
+      ALLOWED_TYPES.keys.include?(type)
+    end
+  end
+end

data/app/lib/foreman_deployments/stack_definition.rb

@@ -0,0 +1,37 @@
+module ForemanDeployments
+  class StackDefinition
+    attr_accessor :tasks
+
+    def initialize(tasks = {})
+      @tasks = tasks
+      initialize_tasks
+    end
+
+    def accept(visitor)
+      tasks.each do |_task_id, task|
+        task.accept(visitor)
+      end
+      visitor.visit(self)
+    end
+
+    def validate!
+      ForemanDeployments::Validation::Validator.validate!(self)
+    end
+
+    def validate
+      ForemanDeployments::Validation::Validator.validate(self)
+    end
+
+    def to_hash
+      tasks
+    end
+
+    private
+
+    def initialize_tasks
+      tasks.each do |task_id, task|
+        task.task_id = task_id.to_s
+      end
+    end
+  end
+end

data/app/lib/foreman_deployments/stack_parser.rb

@@ -0,0 +1,121 @@
+module ForemanDeployments
+  class StackParseException < ::Foreman::Exception; end
+  class UnknownTaskException < StackParseException; end
+  class UnknownYAMLTagException < StackParseException; end
+  class UnknownReference < StackParseException; end
+
+  class ReferenceVisitor
+    def initialize
+      @references = []
+    end
+
+    def visit(subject)
+      if subject.is_a? ForemanDeployments::TaskReference
+        save_reference(subject)
+      elsif subject.is_a? ForemanDeployments::StackDefinition
+        link_references(subject)
+      end
+    end
+
+    def save_reference(reference)
+      @references << reference
+    end
+
+    def link_references(stack_definition)
+      @references.each do |ref|
+        task = stack_definition.tasks[ref.task_id]
+        if task.nil?
+          fail(UnknownReference, _('%s references unknown task') % ref.task_id)
+        else
+          ref.task = task
+        end
+      end
+    end
+  end
+
+  class StackParser
+    TAG_DOMAIN = 'deployments.theforeman.org,2015'
+
+    def initialize(registry = nil)
+      @registry = registry || ForemanDeployments.registry
+    end
+
+    def parse(stack_definition)
+      stack_definition = prepare_stack(stack_definition)
+
+      begin
+        parsed_stack = SafeYAML.load(stack_definition.to_s, nil,
+                                     :whitelisted_tags => init_whitelisted_tags,
+                                     :raise_on_unknown_tag => true)
+      rescue RuntimeError => e
+        raise wrap_exception(e)
+      end
+
+      unless parsed_stack.is_a? Hash
+        fail(StackParseException, _('Stack definition is invalid'))
+      end
+
+      definition = ForemanDeployments::StackDefinition.new(parsed_stack)
+      definition.accept(ReferenceVisitor.new)
+      definition
+    end
+
+    def self.parse(stack_definition)
+      StackParser.new.parse(stack_definition)
+    end
+
+    private
+
+    def init_whitelisted_tags
+      whitelist = [domain_prefix('reference')] # WARNING: safe_yaml behaves differently when the whitelist is empty
+      YAML.add_domain_type(TAG_DOMAIN, 'reference') do |_tag, params|
+        TaskReference.new(params['object'], params['field'])
+      end
+
+      @registry.available_tasks.each do |task_name, task_class|
+        whitelist << task_prefix(task_name)
+        YAML.add_domain_type(TAG_DOMAIN, 'task:' + task_name) do |_tag, params|
+          task_class.constantize.build(params)
+        end
+      end
+
+      @registry.available_inputs.each do |input_name, input_class|
+        whitelist << input_prefix(input_name)
+        YAML.add_domain_type(TAG_DOMAIN, 'input:' + input_name) do |_tag, params|
+          input_class.constantize.build(params)
+        end
+      end
+      whitelist
+    end
+
+    def prepare_stack(stack_definition)
+      "%TAG ! #{domain_tag}\n---\n#{stack_definition}"
+    end
+
+    def domain_tag
+      "tag:#{TAG_DOMAIN}:"
+    end
+
+    def domain_prefix(name = '')
+      "#{domain_tag}#{name}"
+    end
+
+    def task_prefix(task_name = '')
+      domain_prefix("task:#{task_name}")
+    end
+
+    def input_prefix(input_name = '')
+      domain_prefix("input:#{input_name}")
+    end
+
+    def wrap_exception(e)
+      if e.message =~ /Unknown YAML tag '#{task_prefix}([^']+)/
+        UnknownTaskException.new(_('Unknown stack task %s') % Regexp.last_match[1])
+      elsif e.message =~ /Unknown YAML tag '#{domain_tag}([^']+)/
+        UnknownYAMLTagException.new(_('Unknown YAML tag %s') % Regexp.last_match[1])
+      else
+        e
+      end
+    end
+  end
+end