foreman_deployments 0.0.1

data/README.md

@@ -0,0 +1,52 @@
+# Foreman Multi-Host Deployments
+
+A plugin adding Foreman Multi-Host Deployment support.
+
+
+## Documentation
+
+* [Introduction](doc/introduction.md)
+* [How to write stacks](doc/writing_stacks.md)
+* [Create, configure and deploy a stack](doc/deployment_process.md)
+* Other media:
+  * [Development preview demo](https://www.youtube.com/watch?v=U5qtriQfu6A)
+
+## Design documentation
+
+* [Design](doc/design/design.md)
+* [List of deployment tasks](doc/design/tasks.md)
+* [Examples and usecases](doc/design/examples.md)
+* [User interfaces](doc/design/user_interfaces.md)
+* Other sources:
+  * [Redmine tracker](http://projects.theforeman.org/issues/10092)
+  * [Deep dive](https://www.youtube.com/watch?v=ISQdESgmOqo) about the task-centric approach ([presentation](https://tstrachota.fedorapeople.org/slides/mhd_presentation/))
+  * The original design:
+    * Foreman [Deep dive](https://www.youtube.com/watch?v=CFPLGfA6-jU) ([presentation](https://drive.google.com/file/d/0B4ZecfmLdabga0c2SGNqN1ZDQzg/view?usp=sharing))
+    * Cfgmgmtcamp [presentation](http://blog.pitr.ch/presentations/2015/cfgmgmtcamp/)
+    * Code walk-through [session](https://bluejeans.com/s/83Q9/)
+
+
+## Installation
+
+Add `gem 'foreman_deployments', path: '../foreman_deployments'` to your `Gemfile.local.rb` file.
+For more information see
+[How to Install a Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin).
+
+
+## Copyright
+
+Copyright (c) 2014-2015 Red Hat Inc
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/controllers/foreman_deployments/api/v2/base_controller.rb

@@ -0,0 +1,25 @@
+require_dependency 'foreman_deployments/stack_parser'
+
+module ForemanDeployments
+  module Api
+    module V2
+      class BaseController < ::Api::V2::BaseController
+        rescue_from StackParseException, :with => :unprocessable_entity_error
+
+        resource_description do
+          api_version 'v2'
+        end
+
+        def unprocessable_entity_error(exception)
+          render_error 'standard_error', :locals => { :exception => exception }, :status => :unprocessable_entity
+        end
+
+        def resource_class_for(resource)
+          return "ForemanDeployments::#{resource.classify}".constantize
+        rescue NameError
+          super
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_deployments/api/v2/deployments_controller.rb

@@ -0,0 +1,102 @@
+module ForemanDeployments
+  module Api
+    module V2
+      class DeploymentsController < BaseController
+        include ::Api::TaxonomyScope
+
+        before_filter :find_resource, :only => [:show, :replace_configuration, :merge_configuration, :run]
+
+        rescue_from ForemanDeployments::Config::InvalidValueException, :with => :unprocessable_entity_error
+        rescue_from ForemanDeployments::Validation::ValidationError, :with => :unprocessable_entity_error
+
+        def_param_group :deployment do
+          param :deployment, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true, :desc => N_('Name for the deployment')
+            param :stack_id, :identifier, :required => true, :desc => N_('Id of the stack to deploy')
+          end
+        end
+
+        api :POST, '/deployments/', N_('Create a deployment')
+        param_group :deployment, :as => :create
+        def create
+          deployment_params = params[:deployment]
+
+          if deployment_params[:stack_id]
+            stack = ForemanDeployments::Stack.authorized(:view_stacks).find(deployment_params.delete(:stack_id))
+          end
+          deployment_params[:configuration] = ForemanDeployments::Configuration.new(:stack => stack)
+
+          @deployment = ForemanDeployments::Deployment.new(deployment_params)
+          process_response @deployment.save
+        end
+
+        api :GET, '/deployments/', N_('List deployments')
+        api :GET, '/locations/:location_id/deployments/', N_('List of deployments per location')
+        api :GET, '/organizations/:organization_id/deployments/', N_('List of deployments per organization')
+        param_group :taxonomy_scope, ::Api::V2::BaseController
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        def index
+          @deployments = resource_scope_for_index
+        end
+
+        api :POST, '/deployments/:id/configuration/', N_('Merge a configuration update with current values')
+        param :id, :identifier, :required => true
+        param :values, Hash,
+              :required => true,
+              :desc => N_('Hash with configuration update for tasks (Format: task ID => configuration values).')
+        def merge_configuration
+          configuration_update = ForemanDeployments::Configuration.new(:values => params[:values])
+
+          config = @deployment.configurator
+          config.merge(@deployment.configuration, configuration_update)
+          config.dump(@deployment.configuration)
+
+          @deployment.configuration.save!
+        end
+
+        api :PUT, '/deployments/:id/configuration/', N_('Configure a deployment')
+        param :id, :identifier, :required => true
+        param :values, Hash,
+              :required => true,
+              :desc => N_('Hash with configuration for tasks (Format: task ID => configuration values).')
+        def replace_configuration
+          new_configuration = ForemanDeployments::Configuration.new(:values => params[:values])
+
+          config = @deployment.configurator
+          config.configure(new_configuration)
+          config.dump(@deployment.configuration)
+
+          @deployment.configuration.save!
+        end
+
+        api :GET, '/deployments/:id/', N_('Get information about a deployment')
+        param :id, :identifier, :required => true
+        def show
+          config = @deployment.configurator
+          config.configure(@deployment.configuration)
+
+          @validation_result = @deployment.parsed_stack.validate
+        end
+
+        api :POST, '/deployments/:id/run/', N_('Start a deployment')
+        param :id, :identifier, :required => true
+        def run
+          @deployment.run
+        end
+
+        private
+
+        def action_permission
+          case params[:action]
+          when 'merge_configuration', 'replace_configuration'
+            'create'
+          when 'run'
+            'run'
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_deployments/api/v2/stacks_controller.rb

@@ -0,0 +1,52 @@
+module ForemanDeployments
+  module Api
+    module V2
+      class StacksController < BaseController
+        include ::Api::TaxonomyScope
+
+        before_filter :find_resource, :only => [:show, :update]
+
+        def_param_group :stack do
+          param :stack, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true, :desc => N_('Name for the stack')
+            param :definition, String, :required => true, :desc => N_('Stack definition in YAML format')
+          end
+        end
+
+        api :POST, '/stacks/', N_('Import a stack')
+        param_group :stack, :as => :create
+        def create
+          @stack = Stack.new(params[:stack])
+          # parse the stack to see if it's valid
+          ForemanDeployments::StackParser.parse(@stack.definition)
+          process_response @stack.save
+        end
+
+        api :PUT, '/stacks/:id/', N_('Update imported stack')
+        param_group :stack, :as => :update
+        param :id, :identifier, :required => true
+        def update
+          if !@stack.configurations.empty? && !params[:stack][:definition].nil?
+            render :json => { :error => _("Can't update stack that has been configured") }, :status => :unprocessable_entity
+          else
+            ForemanDeployments::StackParser.parse(params[:stack][:definition]) if params[:stack][:definition]
+            process_response @stack.update_attributes(params[:stack])
+          end
+        end
+
+        api :GET, '/stacks/', N_('List saved stacks')
+        api :GET, '/locations/:location_id/stacks/', N_('List of stacks per location')
+        api :GET, '/organizations/:organization_id/stacks/', N_('List of stacks per organization')
+        def index
+          @stacks = resource_scope_for_index
+        end
+
+        api :GET, '/stacks/:id/', N_('Get information about a stack')
+        param :id, :identifier, :required => true
+        def show
+          @parsed_stack = ForemanDeployments::StackParser.parse(@stack.definition)
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_deployments/create_resources_controller.rb

@@ -0,0 +1,62 @@
+module ForemanDeployments
+  class CreateResourcesController < ApplicationController
+    def index
+    end
+
+    def new
+      @resource = ResourceModels::CreateResource.new
+      @resource.resource_type = User
+      @resource.definition_hash = {
+        login: 'my_user1',
+        mail: 'test@foreman.org'
+      }
+
+      @user = @resource.new_resource
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def create
+      params[:user].delete :admin if params[:user]
+
+      # stack definition
+      # will be selected from DB as Stack object
+      stack = [
+        'user1: !task:SearchResource',
+        '  class: User',
+        '  search_term: "1"',
+        'usergroup1: !task:CreateResource',
+        '  class: Usergroup',
+        '  params:',
+        '    name: zzz',
+        '    user_ids:',
+        '      !reference',
+        '        object: user1',
+        '        field: result.ids'
+      ].join("\n")
+
+      # parse the stack
+      stack_definition = ForemanDeployments::StackParser.parse(stack)
+
+      # configure with user input
+      # stack_definition.tasks['user1'].configure('params' => params[:user])
+      stack_definition.tasks['usergroup1'].configure({})
+
+      # validate
+      result = ForemanDeployments::Validation::Validator.validate(stack_definition)
+      fail "Validation failed:\n #{result.messages}" unless result.valid?
+
+      ForemanTasks.sync_task(Tasks::StackDeployAction, stack_definition)
+
+      redirect_to foreman_tasks_tasks_path
+    end
+
+    def edit
+    end
+
+    def update
+    end
+
+    def destroy
+    end
+  end
+end

data/app/controllers/foreman_deployments/deployments_controller.rb

@@ -0,0 +1,5 @@
+module ForemanDeployments
+  class DeploymentsController < ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+  end
+end

data/app/controllers/foreman_deployments/stacks_controller.rb

@@ -0,0 +1,5 @@
+module ForemanDeployments
+  class StacksController < ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+  end
+end

data/app/lib/foreman_deployments/base_dereference_visitor.rb

@@ -0,0 +1,55 @@
+module ForemanDeployments
+  class BaseDereferenceVisitor
+    def initialize
+      @task_cache = {}
+    end
+
+    def visit(subject)
+      if subject.is_a? ForemanDeployments::Tasks::BaseDefinition
+        visit_task_definition(subject)
+      end
+    end
+
+    protected
+
+    def visit_task_definition(definition)
+      definition.parameters = dereference(definition.parameters)
+    end
+
+    def dereference(value)
+      case value
+      when ForemanDeployments::TaskReference
+        return get_dereference(value)
+      when Config::Array
+        return value.transform! { |obj| dereference(obj) }
+      when Config::Hash
+        return value.transform! { |key, obj| [key, dereference(obj)] }
+      else
+        return value
+      end
+    end
+
+    def get_dereference(_ref)
+      fail NotImplementedError, "Method 'get_dereference' needs to be implemented"
+    end
+
+    def cached(task)
+      key = cache_key(task)
+      if cached?(task)
+        @task_cache[key]
+      else
+        @task_cache[key] = yield
+      end
+    end
+
+    def cached?(task)
+      @task_cache.key?(cache_key(task))
+    end
+
+    private
+
+    def cache_key(task)
+      task.task_id.to_s
+    end
+  end
+end

data/app/lib/foreman_deployments/config.rb

@@ -0,0 +1,16 @@
+module ForemanDeployments
+  module Config
+    class InvalidValueException < ::Foreman::Exception; end
+
+    def self.cast_to_configuration(value)
+      case value
+      when ::Hash
+        ForemanDeployments::Config::Hash[value.map { |key, obj| [key, cast_to_configuration(obj)] }]
+      when ::Array
+        ForemanDeployments::Config::Array[*value.map { |obj| cast_to_configuration(obj) }]
+      else
+        value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module ForemanDeployments
+  module Config
+    class Array < ::Array
+      def merge_configuration(values)
+        values = ensure_hash(values)
+        values.map do |index, value|
+          configure_index(index, value, :merge_configuration)
+        end
+      end
+
+      def configure(values)
+        values = ensure_hash(values)
+        configuration_storage.clear
+        values.map do |index, value|
+          configure_index(index, value, :configure)
+        end
+      end
+
+      def configured
+        map.with_index do |item, index|
+          if item.respond_to?(:configured)
+            item.configured
+          elsif item.nil?
+            configuration_storage[index]
+          else
+            item
+          end
+        end
+      end
+
+      def configuration
+        result = configuration_storage.deep_clone
+        each_with_index do |item, index|
+          if item.respond_to?(:configuration)
+            result[index] = item.configuration unless item.configuration.nil?
+          end
+        end
+        result.empty? ? nil : result
+      end
+
+      def transform!(&block)
+        self.map! do |item|
+          block.call(item)
+        end
+        self
+      end
+
+      protected
+
+      def configuration_storage
+        @configuration_storage ||= {}
+      end
+
+      def ensure_hash(values)
+        if values.is_a? ::Hash
+          ::Hash[values.map { |index, value| sanitize_pair(index, value) }]
+        elsif values.is_a? ::Array
+          ::Hash[values.map.with_index { |value, index| sanitize_pair(index, value) }]
+        else
+          fail(InvalidValueException, _("Unexpected type '%s', only hash or array is accepted") % values.class)
+        end
+      end
+
+      def sanitize_pair(index, value)
+        index = Integer(index)
+        if (index >= size) || (index < 0)
+          fail(InvalidValueException, _('Can\'t configure items outside the range'))
+        end
+        [index, value]
+      rescue ArgumentError
+        raise(InvalidValueException, _("Key '%s' isn't numeric value") % index)
+      end
+
+      def configure_index(index, value, method)
+        preconfigured = self[index]
+
+        if preconfigured.nil?
+          if value.nil?
+            configuration_storage.delete(index)
+          else
+            configuration_storage[index] = value
+          end
+        elsif preconfigured.respond_to?(method)
+          preconfigured.send(method, value)
+        else
+          fail(InvalidValueException, _("You can't override values hardcoded in the stack definition"))
+        end
+      end
+    end
+  end
+end