foreman_deployments 0.0.1

data/lib/foreman_deployments.rb

@@ -0,0 +1,7 @@
+require 'foreman_deployments/engine'
+
+module ForemanDeployments
+  def self.registry
+    @task_registry ||= ForemanDeployments::Registry.new
+  end
+end

data/lib/foreman_deployments/engine.rb

@@ -0,0 +1,94 @@
+require 'foreman_tasks'
+require 'safe_yaml/load'
+require 'foreman_deployments/monkey_patches'
+
+module ForemanDeployments
+  class Engine < ::Rails::Engine
+    config.autoload_paths += Dir["#{config.root}/app/**/"]
+    config.autoload_paths += ["#{config.root}/test/"]
+
+    # Add any db migrations
+    initializer 'foreman_deployments.load_app_instance_data' do |app|
+      app.config.paths['db/migrate'] += ForemanDeployments::Engine.paths['db/migrate'].existent
+    end
+
+    initializer 'foreman_deployments.register_plugin', after: :finisher_hook do
+      Foreman::Plugin.register :foreman_deployments do
+        requires_foreman '>= 1.8'
+
+        # Add permissions
+        security_block :foreman_deployments do |map|
+          map.permission :view_deployments,
+                         { :'foreman_deployments/api/v2/deployments' => [:index, :show] },
+                         :resource_type => ForemanDeployments::Deployment.name
+          map.permission :create_deployments,
+                         { :'foreman_deployments/api/v2/deployments' => [:create,
+                                                                         :merge_configuration,
+                                                                         :replace_configuration]
+                         },
+                         :resource_type => ForemanDeployments::Deployment.name
+          map.permission :run_deployments,
+                         { :'foreman_deployments/api/v2/deployments' => [:run] },
+                         :resource_type => ForemanDeployments::Deployment.name
+          map.permission :destroy_deployments,
+                         { :'foreman_deployments/api/v2/deployments' => [:destroy] },
+                         :resource_type => ForemanDeployments::Deployment.name
+
+          map.permission :view_stacks,
+                         { :'foreman_deployments/api/v2/stacks' => [:index, :show] },
+                         :resource_type => ForemanDeployments::Stack.name
+          map.permission :create_stacks,
+                         { :'foreman_deployments/api/v2/stacks' => [:create] },
+                         :resource_type => ForemanDeployments::Stack.name
+          map.permission :edit_stacks,
+                         { :'foreman_deployments/api/v2/stacks' => [:update] },
+                         :resource_type => ForemanDeployments::Stack.name
+          map.permission :destroy_stacks,
+                         { :'foreman_deployments/api/v2/stacks' => [:destroy] },
+                         :resource_type => ForemanDeployments::Stack.name
+        end
+
+        search_path_override('ForemanDeployments') do |resource|
+          "/#{resource.demodulize.underscore.pluralize}/auto_complete_search"
+        end
+      end
+    end
+
+    initializer 'foreman_deployments.apipie' do
+      # rubocop:disable Metrics/LineLength
+      Apipie.configuration.api_controllers_matcher << "#{ForemanDeployments::Engine.root}/app/controllers/foreman_deployments/api/v2/*.rb"
+      Apipie.configuration.checksum_path += ['/foreman_deployments/api/']
+    end
+
+    initializer 'foreman_deployments.require_dynflow', before: 'foreman_tasks.initialize_dynflow' do
+      ::ForemanTasks.dynflow.require!
+      ::ForemanTasks.dynflow.config.eager_load_paths << File.join(ForemanDeployments::Engine.root, 'app/services/foreman_deployments/tasks')
+    end
+
+    initializer 'foreman_deployments.safe_yaml' do
+      SafeYAML::OPTIONS[:default_mode] = :safe
+      SafeYAML::OPTIONS[:deserialize_symbols] = true
+    end
+
+    config.to_prepare do
+      ForemanDeployments.registry.register_task(ForemanDeployments::Tasks::CreationTaskDefinition)
+      ForemanDeployments.registry.register_task(ForemanDeployments::Tasks::SearchTaskDefinition)
+      ForemanDeployments.registry.register_task(ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition)
+      ForemanDeployments.registry.register_input(ForemanDeployments::Inputs::Value)
+    end
+
+    # Include concerns in this config.to_prepare block
+    # config.to_prepare do
+    #   ::Hostgroup.send :include, ForemanDeployments::Concerns::Hostgroup
+    #   ::GroupParameter.send :include, ForemanDeployments::Concerns::GroupParameter
+    # end
+
+    # config.eager_load_paths += ["#{config.root}/app/models/foreman_deployments/resource/"]
+
+    rake_tasks do
+      Rake::Task['db:seed'].enhance do
+        ForemanDeployments::Engine.load_seed
+      end
+    end
+  end
+end

data/lib/foreman_deployments/monkey_patches.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  class Base
+    # adding to_hash to enable for using in dynflog actions' output
+    def to_hash
+      # TODO: replace passwords
+      attributes
+    end
+  end
+end

data/lib/foreman_deployments/version.rb

@@ -0,0 +1,3 @@
+module ForemanDeployments
+  VERSION = '0.0.1'
+end

data/lib/tasks/foreman_deployments_tasks.rake

@@ -0,0 +1,22 @@
+
+# Tests
+namespace :test do
+  desc 'Test ForemanDeployments'
+  Rake::TestTask.new(:foreman_deployments) do |t|
+    test_dir = File.join(File.dirname(__FILE__), '../..', 'test')
+    t.libs << ['test', test_dir]
+    t.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+  end
+end
+
+Rake::Task[:test].enhance do
+  Rake::Task['test:foreman_deployments'].invoke
+end
+
+load 'tasks/jenkins.rake'
+if Rake::Task.task_defined?(:'jenkins:unit')
+  Rake::Task['jenkins:unit'].enhance do
+    Rake::Task['test:foreman_deployments'].invoke
+  end
+end

data/locale/Makefile

@@ -0,0 +1,62 @@
+#
+# Makefile for PO merging and MO generation. More info in the README.
+#
+# make all-mo (default) - generate MO files
+# make check - check translations using translate-tool
+# make tx-update - download and merge translations from Transifex
+# make clean - clean everything
+#
+DOMAIN = foreman_plugin_template
+VERSION = $(shell ruby -e 'require "rubygems";spec = Gem::Specification::load(Dir.glob("../*.gemspec")[0]);puts spec.version')
+POTFILE = $(DOMAIN).pot
+MOFILE = $(DOMAIN).mo
+POFILES = $(shell find . -name '*.po')
+MOFILES = $(patsubst %.po,%.mo,$(POFILES))
+POXFILES = $(patsubst %.po,%.pox,$(POFILES))
+
+%.mo: %.po
+	mkdir -p $(shell dirname $@)/LC_MESSAGES
+	msgfmt -o $(shell dirname $@)/LC_MESSAGES/$(MOFILE) $<
+
+# Generate MO files from PO files
+all-mo: $(MOFILES)
+
+# Check for malformed strings
+%.pox: %.po
+	msgfmt -c $<
+	pofilter --nofuzzy -t variables -t blank -t urls -t emails -t long -t newlines \
+		-t endwhitespace -t endpunc -t puncspacing -t options -t printf -t validchars --gnome $< > $@
+	cat $@
+	! grep -q msgid $@
+
+check: $(POXFILES)
+	msgfmt -c ${POTFILE}
+
+# Merge PO files
+update-po:
+	for f in $(shell find ./ -name "*.po") ; do \
+		msgmerge -N --backup=none -U $$f ${POTFILE} ; \
+	done
+
+# Unify duplicate translations
+uniq-po:
+	for f in $(shell find ./ -name "*.po") ; do \
+		msguniq $$f -o $$f ; \
+	done
+
+tx-pull:
+	tx pull -f
+	for f in $(POFILES) ; do \
+		sed -i 's/^\("Project-Id-Version: \).*$$/\1$(DOMAIN) $(VERSION)\\n"/' $$f; \
+	done
+	-git commit -a -m "i18n - pulling from tx"
+
+reset-po:
+	# merging po files is unnecessary when using transifex.com
+	git checkout -- ../locale/*/*po
+
+tx-update: tx-pull reset-po $(MOFILES)
+	# amend mo files
+	git add ../locale/*/LC_MESSAGES
+	git commit -a --amend -m "i18n - pulling from tx"
+	-echo Changes commited!

data/test/factories/foreman_deployments.rb

@@ -0,0 +1,70 @@
+FactoryGirl.define do
+  factory :stack, :class => ForemanDeployments::Stack do
+    sequence(:name) { |n| "stack_#{n}" }
+    definition [
+      'Task1: !task:FakeTask',
+      '  hardcoded_param: hardcoded',
+      'Task2: !task:FakeTask'
+    ].join("\n")
+
+    trait :with_taxonomy do
+      organizations do
+        [FactoryGirl.create(:organization)]
+      end
+      locations do
+        [FactoryGirl.create(:location)]
+      end
+    end
+  end
+
+  factory :configuration, :class => ForemanDeployments::Configuration do
+  end
+
+  factory :deployment, :class => ForemanDeployments::Deployment do
+    sequence(:name) { |n| "deployment_#{n}" }
+    transient do
+      stack nil
+    end
+
+    after(:build) do |deployment, evaluator|
+      unless evaluator.stack.nil?
+        deployment.configuration = FactoryGirl.build(:configuration, :stack => evaluator.stack)
+      end
+    end
+
+    trait :with_stack do
+      stack do
+        FactoryGirl.create(:stack)
+      end
+
+      after(:build) do |deployment, _evaluator|
+        deployment.stack.organizations << deployment.organization
+        deployment.stack.locations << deployment.location
+      end
+    end
+
+    trait :with_stack_taxonomy do
+      after(:build) do |deployment, _evaluator|
+        deployment.organization = deployment.stack.organizations.first
+        deployment.location = deployment.stack.locations.first
+      end
+    end
+
+    trait :with_taxonomy do
+      organization do
+        FactoryGirl.create(:organization)
+      end
+      location do
+        FactoryGirl.create(:location)
+      end
+    end
+  end
+
+  factory :foreman_task, :class => ForemanTasks::Task do
+    sequence(:label) { |n| "task#{n}" }
+    sequence(:id) { |n| 'b8317062-c664-4792-9d9a-8167b23c%04d' % n }
+    type 'Tasks::StackDeployAction'
+    state 'pending'
+    result 'success'
+  end
+end

data/test/functional/api/v2/deployments_controller_test.rb

@@ -0,0 +1,318 @@
+require 'test_plugin_helper'
+
+class ForemanDeployments::Api::V2::DeploymentsControllerTest < ActionController::TestCase
+  include RegistryStub
+
+  class FakeTask < ForemanDeployments::Tasks::BaseDefinition
+    def validate
+      ForemanDeployments::Validation::ValidationResult.new
+    end
+  end
+
+  class InvalidFakeTask < ForemanDeployments::Tasks::BaseDefinition
+    def validate
+      ForemanDeployments::Validation::ValidationResult.new([
+        'Some validation error'
+      ])
+    end
+  end
+
+  setup do
+    @stack = FactoryGirl.create(:stack,
+                                :organizations => [taxonomies(:organization1), taxonomies(:organization2)],
+                                :locations => [taxonomies(:location1), taxonomies(:location2)]
+    )
+    @deployment = FactoryGirl.create(:deployment, :with_taxonomy, :with_stack)
+
+    @registry = stub_registry
+    @registry.register_task(FakeTask)
+    @registry.register_task(InvalidFakeTask)
+  end
+
+  describe 'creating a deployment' do
+    setup do
+      @deployment_params = {
+        :name => 'A Deployment',
+        :stack_id => @stack.id,
+        :organization_id => taxonomies(:organization1).id,
+        :location_id => taxonomies(:location1).id
+      }
+    end
+
+    test 'it creates a deployment' do
+      assert_difference('ForemanDeployments::Deployment.count', 1) do
+        post :create,  :deployment => @deployment_params
+      end
+      assert_response :success
+
+      parsed_response = JSON.parse(response.body)
+      assert_equal('A Deployment', parsed_response['name'])
+    end
+
+    test 'it creates configuration for the deployment' do
+      assert_difference('ForemanDeployments::Configuration.count', 1) do
+        post :create,  :deployment => @deployment_params
+      end
+      assert_response :success
+    end
+
+    test 'should complain when a name is missing' do
+      assert_difference('ForemanDeployments::Stack.count', 0) do
+        post :create, :deployment => @deployment_params.except(:name)
+      end
+      assert_response :unprocessable_entity
+      parsed_response = JSON.parse(response.body)
+
+      assert_includes(parsed_response['error']['full_messages'], 'Name can\'t be blank')
+    end
+
+    test 'should complain when a stack is missing' do
+      assert_difference('ForemanDeployments::Stack.count', 0) do
+        post :create, :deployment => @deployment_params.except(:stack_id)
+      end
+      assert_response :unprocessable_entity
+      parsed_response = JSON.parse(response.body)
+
+      assert_includes(parsed_response['error']['full_messages'], 'Stack can\'t be blank')
+    end
+  end
+
+  describe 'listing deployments' do
+    setup do
+      @org_deployment = FactoryGirl.create(:deployment, :with_stack,
+                                           :location_id => taxonomies(:location2).id,
+                                           :organization_id => taxonomies(:organization1).id
+      )
+      @loc_deployment = FactoryGirl.create(:deployment, :with_stack,
+                                           :location_id => taxonomies(:location1).id,
+                                           :organization_id => taxonomies(:organization2).id
+      )
+      @both_deployment = FactoryGirl.create(:deployment, :with_stack,
+                                            :location_id => taxonomies(:location1).id,
+                                            :organization_id => taxonomies(:organization1).id
+      )
+    end
+
+    test 'it lists deployments' do
+      get :index
+      assert_response :success
+    end
+
+    test 'should get deployments for location only' do
+      get :index, :location_id => taxonomies(:location1).id
+      assert_response :success
+      assert_equal [@loc_deployment, @both_deployment], assigns(:deployments)
+    end
+
+    test 'should get deployments for organization only' do
+      get :index, :organization_id => taxonomies(:organization1).id
+      assert_response :success
+      assert_equal [@org_deployment, @both_deployment], assigns(:deployments)
+    end
+
+    test 'should get deployments for both location and organization' do
+      get :index, :organization_id => taxonomies(:organization1).id, :location_id => taxonomies(:location1).id
+      assert_response :success
+      assert_equal [@both_deployment], assigns(:deployments)
+    end
+  end
+
+  describe 'configuration' do
+    describe 'new configuration' do
+      test 'it configures the value' do
+        task1_config = {
+          'organization_id' => '1',
+          'location_id' => '2'
+        }
+        task2_config = {
+          'organization_id' => '3',
+          'location_id' => '4'
+        }
+        values = {
+          :Task1 => task1_config,
+          :Task2 => task2_config
+        }
+
+        put :replace_configuration, :id => @deployment.id, :values => values
+        assert_response :success
+
+        @deployment.reload
+        assert_equal(task1_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+        assert_equal(task2_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task2')))
+      end
+
+      test 'it replaces the values from the previous configuration' do
+        previous_config = {
+          'organization_id' => '1',
+          'location_id' => '2'
+        }
+        new_config = {
+          'location_id' => '3',
+          'host_id' => '4'
+        }
+
+        @deployment.configuration.set_config_for(stub(:task_id => 'Task1'), previous_config)
+        @deployment.configuration.save
+
+        put :replace_configuration, :id => @deployment.id, :values => { :Task1 => new_config }
+        assert_response :success
+
+        @deployment.reload
+        assert_equal(new_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+      end
+
+      test 'it fails when a hardcoded value would be overwritten' do
+        task1_config = {
+          'organization_id' => '1',
+          'hardcoded_param' => 'new_value'
+        }
+        values = {
+          :Task1 => task1_config
+        }
+
+        put :replace_configuration, :id => @deployment.id, :values => values
+        assert_response :unprocessable_entity
+
+        parsed_response = JSON.parse(response.body)
+        assert_includes(parsed_response['error']['message'], 'You can\'t override values hardcoded in the stack definition')
+
+        @deployment.reload
+        assert_equal({}, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+        assert_equal({}, @deployment.configuration.get_config_for(stub(:task_id => 'Task2')))
+      end
+    end
+
+    describe 'merge configuration' do
+      test 'it configures the value' do
+        task1_config = {
+          'organization_id' => '1',
+          'location_id' => '2'
+        }
+        task2_config = {
+          'organization_id' => '3',
+          'location_id' => '4'
+        }
+        values = {
+          :Task1 => task1_config,
+          :Task2 => task2_config
+        }
+
+        post :merge_configuration, :id => @deployment.id, :values => values
+        assert_response :success
+
+        @deployment.reload
+        assert_equal(task1_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+        assert_equal(task2_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task2')))
+      end
+
+      test 'it merges with the values from the previous configuration' do
+        previous_config = {
+          'organization_id' => '1',
+          'location_id' => '2'
+        }
+        new_config = {
+          'location_id' => '3',
+          'host_id' => '4'
+        }
+        expected_config = previous_config.merge(new_config)
+
+        @deployment.configuration.set_config_for(stub(:task_id => 'Task1'), previous_config)
+        @deployment.configuration.save
+
+        post :merge_configuration, :id => @deployment.id, :values => { :Task1 => new_config }
+        assert_response :success
+
+        @deployment.reload
+        assert_equal(expected_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+      end
+
+      test 'it allows for removing values when nil (null in json) is passed' do
+        previous_config = {
+          'organization_id' => '1',
+          'location_id' => '2'
+        }
+        new_config = {
+          'location_id' => nil,
+          'host_id' => '4'
+        }
+        expected_config = {
+          'organization_id' => '1',
+          'host_id' => '4'
+        }
+
+        @deployment.configuration.set_config_for(stub(:task_id => 'Task1'), previous_config)
+        @deployment.configuration.save
+
+        post :merge_configuration, :id => @deployment.id, :values => { :Task1 => new_config }
+        assert_response :success
+
+        @deployment.reload
+        assert_equal(expected_config, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+      end
+
+      test 'it fails when a hardcoded value would be overwritten' do
+        task1_config = {
+          'organization_id' => '1',
+          'hardcoded_param' => 'new_value'
+        }
+        values = {
+          :Task1 => task1_config
+        }
+
+        post :merge_configuration, :id => @deployment.id, :values => values
+        assert_response :unprocessable_entity
+
+        parsed_response = JSON.parse(response.body)
+        assert_includes(parsed_response['error']['message'], 'You can\'t override values hardcoded in the stack definition')
+
+        @deployment.reload
+        assert_equal({}, @deployment.configuration.get_config_for(stub(:task_id => 'Task1')))
+        assert_equal({}, @deployment.configuration.get_config_for(stub(:task_id => 'Task2')))
+      end
+    end
+  end
+
+  describe 'run deployments' do
+    test 'it plans the deployment tasks' do
+      @deployment.configuration.set_config_for(stub(:task_id => 'Task1'), 'param2' => '1')
+      @deployment.configuration.set_config_for(stub(:task_id => 'Task2'), 'param2' => '2')
+      @deployment.configuration.save
+
+      ForemanTasks.expects(:async_task).with do |main_task, parsed_stack|
+        assert_equal(ForemanDeployments::Tasks::StackDeployAction, main_task)
+        assert_equal({ 'param2' => '1' }, parsed_stack.tasks['Task1'].configuration)
+        assert_equal({ 'param2' => '2' }, parsed_stack.tasks['Task2'].configuration)
+      end
+
+      post :run, :id => @deployment.id
+      assert_response :success
+    end
+
+    test 'it saves the task id' do
+      task = FactoryGirl.build(:foreman_task)
+      ForemanTasks.stubs(:async_task).returns(task)
+
+      post :run, :id => @deployment.id
+      assert_response :success
+
+      @deployment.reload
+      assert_equal(task.id, @deployment.task_id)
+    end
+
+    test 'it fails when one of the tasks is not valid' do
+      invalid_stack = FactoryGirl.create(:stack, :with_taxonomy,
+                                         :definition => [
+                                           'Task1: !task:InvalidFakeTask',
+                                           'Task2: !task:FakeTask'
+                                         ].join("\n")
+      )
+      deployment = FactoryGirl.create(:deployment, :with_stack_taxonomy, :stack => invalid_stack)
+
+      post :run, :id => deployment.id
+      assert_response :unprocessable_entity
+
+      parsed_response = JSON.parse(response.body)
+      assert_includes(parsed_response['error']['message'], 'Stack definition is invalid')
+    end
+  end
+end