katello-foreman-engine 0.0.1

data/Rakefile

@@ -0,0 +1,90 @@
+ENGINE_DIR = File.expand_path('..', __FILE__)
+KATELLO_DIR = 'test/katello_app'
+require 'fileutils'
+
+namespace :test do
+  desc "Download latest katello devel source and install dependencies"
+  task :katello_prepare do
+    katello_repo = 'https://github.com/Katello/katello.git'
+    katello_gemfile = File.join(KATELLO_DIR, "Gemfile")
+    unless File.exists?(katello_gemfile)
+      puts "Katello source code is not present at #{KATELLO_DIR}"
+      puts "Downloading latest Katello development branch into #{KATELLO_DIR}..."
+      FileUtils.mkdir_p(KATELLO_DIR)
+
+      unless system("git clone #{katello_repo} #{KATELLO_DIR}")
+        puts "Error while getting latest Katello code from #{katello_repo} into #{KATELLO_DIR}"
+        fail
+      end
+    end
+
+    gemfile_content = File.read(katello_gemfile)
+    unless gemfile_content.include?('KATELLO_GEMFILE')
+      puts 'Preparing Gemfile'
+      gemfile_content.gsub!('__FILE__', 'KATELLO_GEMFILE')
+      gemfile_content.insert(0, "KATELLO_GEMFILE = __FILE__ unless defined? KATELLO_GEMFILE\n")
+      File.open(katello_gemfile, 'w') { |f| f << gemfile_content }
+    end
+
+    settings_file = "#{KATELLO_DIR}/config/katello.yml"
+    unless File.exists?(settings_file)
+      puts 'Preparing settings file'
+      File.open(settings_file, "w") { |f| f << <<SETTINGS }
+common:
+  foreman:
+    url: https://localhost/foreman/
+
+SETTINGS
+    end
+
+    ["#{ENGINE_DIR}/.bundle/config", "#{KATELLO_DIR}/.bundle/config"].each do |bundle_file|
+      unless File.exists?(bundle_file)
+        FileUtils.mkdir_p(File.dirname(bundle_file))
+        puts 'Preparing bundler configuration'
+        File.open(bundle_file, 'w') { |f| f << <<FILE }
+BUNDLE_WITHOUT: assets:checking:debugging:development_boost:optional
+FILE
+      end
+    end
+
+    puts 'Installing dependencies...'
+    unless system('bundle install')
+      fail
+    end
+  end
+
+  task :db_prepare do
+    unless File.exists?(KATELLO_DIR)
+      puts <<MESSAGE
+Katello source code not prepared. Run
+
+  rake test:katello_prepare
+
+to download katello source and its dependencies
+MESSAGE
+      fail
+    end
+
+    # once we are Ruby19 only, switch to block variant of cd
+    pwd = FileUtils.pwd
+    FileUtils.cd(KATELLO_DIR)
+    unless system('rake db:test:prepare RAILS_ENV=test')
+      puts "Migrating database first"
+      system('rake db:create db:migrate db:schema:dump db:test:prepare RAILS_ENV=test') || fail
+    end
+    FileUtils.cd(pwd)
+  end
+
+  task :set_loadpath do
+    %w[lib test].each do |dir|
+      $:.unshift(File.expand_path(dir, ENGINE_DIR))
+    end
+  end
+
+  task :all => [:db_prepare, :set_loadpath] do
+    Dir.glob('test/**/*_test.rb') { |f| require f.sub('test/','')  unless f.include? '/katello_app/' }
+  end
+
+end
+
+task :test => 'test:all'

data/katello-foreman-engine.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "katello-foreman-engine"
+  s.version = "0.0.1"
+
+  s.authors = ["Katello"]
+  s.date = "2013-04-19"
+  s.description = "Foreman specific parts in Katello"
+  s.email = "katello-devel@redhat.com"
+  s.files = `git ls-files`.split("\n")
+  s.homepage = "http://github.com/katello/katello-foreman-engine"
+  s.licenses = ["GPL-2"]
+  s.require_paths = ["lib"]
+  s.add_dependency "foreman_api"
+  s.add_dependency "deface", "~> 0.7.2"
+  s.add_dependency "dynflow"
+  s.summary = "Foreman specific parts of Katello"
+end

data/lib/katello-foreman-engine.rb

@@ -0,0 +1,2 @@
+require 'deface'
+require 'katello_foreman_engine'

data/lib/katello_foreman_engine/actions/content_view_demote.rb

@@ -0,0 +1,25 @@
+module KatelloForemanEngine
+  module Actions
+    class ContentViewDemote < Dynflow::Action
+
+      def self.subscribe
+        Katello::Actions::ContentViewDemote
+      end
+
+      def plan(content_view, from_env)
+        if foreman_env = Bindings.environment_find(content_view.organization.label,
+                                                   from_env.label, content_view.label)
+          plan_self 'foreman_env_id' => foreman_env['environment']['id']
+        end
+      end
+
+      input_format do
+        param :foreman_env_id, Integer
+      end
+
+      def run
+        Bindings.environment_destroy(input['foreman_env_id'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/content_view_promote.rb

@@ -0,0 +1,28 @@
+module KatelloForemanEngine
+  module Actions
+    class ContentViewPromote < Dynflow::Action
+
+      def self.subscribe
+        Katello::Actions::ContentViewPromote
+      end
+
+      def plan(*args)
+        unless Bindings.environment_find(input['organization_label'], input['to_env_label'], input['label'])
+          plan_self input
+        end
+      end
+
+      input_format do
+        param :id, Integer
+        param :label, String
+        param :organization_label, String
+        param :from_env_label, String
+        param :to_env_label, String
+      end
+
+      def run
+        Bindings.environment_create(input['id'], input['organization_label'], input['to_env_label'], input['label'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/environment_create.rb

@@ -0,0 +1,26 @@
+module KatelloForemanEngine
+  module Actions
+    class EnvironmentCreate < Dynflow::Action
+
+      def self.subscribe
+        Katello::Actions::EnvironmentCreate
+      end
+
+      def plan(env)
+        unless env.library?
+          plan_self 'org_label' => env.organization.label, 'label' => env.label, 'content_view_id' => 'env'
+        end
+      end
+
+      input_format do
+        param :org_label, String
+        param :label, String
+        param :content_view_id, String
+      end
+
+      def run
+        Bindings.environment_create(input['content_view_id'], input['org_label'], input['label'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/environment_destroy.rb

@@ -0,0 +1,27 @@
+module KatelloForemanEngine
+  module Actions
+    class EnvironmentDestroy < Dynflow::Action
+
+      input_format do
+        param :foreman_id, String
+      end
+
+      def self.subscribe
+        Katello::Actions::EnvironmentDestroy
+      end
+
+      def plan(env)
+        if !env.library? && foreman_env = Bindings.environment_find(env.organization.label, env.label)
+          env.content_views.each do |content_view|
+            plan_action(ContentViewDemote, content_view, env)
+          end
+          plan_self 'foreman_id' => foreman_env['environment']['id']
+        end
+      end
+
+      def run
+        Bindings.environment_destroy(input['foreman_id'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/org_create.rb

@@ -0,0 +1,14 @@
+module KatelloForemanEngine
+  module Actions
+    class OrgCreate < Dynflow::Action
+
+      def self.subscribe
+        Headpin::Actions::OrgCreate
+      end
+
+      def run
+        Bindings.organization_create("KT-[#{input['label']}]")
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/org_destroy.rb

@@ -0,0 +1,24 @@
+module KatelloForemanEngine
+  module Actions
+    class OrgDestroy < Dynflow::Action
+
+      input_format do
+        param :foreman_id, String
+      end
+
+      def self.subscribe
+        Headpin::Actions::OrgDestroy
+      end
+
+      def plan(org)
+        if foreman_org = Bindings.organization_find("KT-[#{input['label']}]")
+          plan_self('foreman_id' => foreman_org['organization']['id'])
+        end
+      end
+
+      def run
+        Bindings.organization_destroy(input['foreman_id'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/user_create.rb

@@ -0,0 +1,20 @@
+module KatelloForemanEngine
+  module Actions
+    class UserCreate < Dynflow::Action
+
+      def self.subscribe
+        Headpin::Actions::UserCreate
+      end
+
+      def plan(user)
+        if !user.hidden? && !Bindings.user_find(input['username'])
+          plan_self input
+        end
+      end
+
+      def run
+        Bindings.user_create(input['username'], input['email'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/actions/user_destroy.rb

@@ -0,0 +1,24 @@
+module KatelloForemanEngine
+  module Actions
+    class UserDestroy < Dynflow::Action
+
+      def self.subscribe
+        Headpin::Actions::UserDestroy
+      end
+
+      def plan(user)
+        if foreman_user = Bindings.user_find(input['username'])
+          plan_self 'foreman_user_id' => foreman_user['user']['id']
+        end
+      end
+
+      input_format do
+        param :foreman_user_id, String
+      end
+
+      def run
+        Bindings.user_destroy(input['foreman_user_id'])
+      end
+    end
+  end
+end

data/lib/katello_foreman_engine/bindings.rb

@@ -0,0 +1,101 @@
+require 'foreman_api'
+
+module KatelloForemanEngine
+  module Bindings
+
+    class << self
+
+      def client_config
+        {
+          :base_url => Settings['foreman_url'],
+          :enable_validations => false,
+          :oauth => {
+            :consumer_key => Settings['oauth_consumer_key'],
+            :consumer_secret => Settings['oauth_consumer_secret']
+          },
+        }
+      end
+
+      def base
+        resource(ForemanApi::Base)
+      end
+
+      def environment
+        resource(ForemanApi::Resources::Environment)
+      end
+
+      def user(username = nil)
+        user_resource = resource(ForemanApi::Resources::User)
+        if username && User.current.username == username
+          # this means the first user is created: use the predefined
+          # Foreman admin user for this cases.
+          user_resource.client.options[:headers][:foreman_user] = 'admin'
+        end
+        return user_resource
+      end
+
+      def resource(resource_class)
+        client = resource_class.new(client_config)
+        client.client.options[:headers][:foreman_user] = User.current.username
+        return client
+      end
+
+      def organization_find(name)
+        orgs, _ = base.http_call('get', '/api/organizations', 'search' => "name = #{name}")
+        return orgs.first
+      end
+
+      def organization_create(name)
+        base.http_call('post', '/api/organizations',
+                       :organization => {:name => name,
+                         :ignore_types => %w[User SmartProxy Subnet ComputeResource Medium ConfigTemplate Domain Environment] })
+      end
+
+      def organization_destroy(id)
+        base.http_call('delete', "/api/organizations/#{id}")
+      end
+
+
+      def environment_find(org_label, env_label, content_view_label = nil)
+        env, _ = base.http_call('get', '/foreman_katello_engine/api/environments/show',
+                                {:org => org_label, :env => env_label, :content_view => content_view_label})
+        return env
+      rescue RestClient::ResourceNotFound => e
+        return nil
+      end
+
+      def environment_create(content_view_id, org_label, env_label, content_view_label = nil)
+        params = {:org => org_label, :env => env_label, :content_view => content_view_label, :content_view_id => content_view_id}
+        if foreman_org = organization_find("KT-[#{org_label}]")
+          params[:org_id] = foreman_org['organization']['id']
+        end
+        base.http_call('post', '/foreman_katello_engine/api/environments', params)
+      end
+
+      def environment_destroy(id)
+        environment.destroy('id' => id)
+      end
+
+      def user_find(username)
+        users, _ = user(username).index('search' => "login = #{username}")
+        return users.first
+      end
+
+      def user_create(username, email)
+        user(username).create({ 'user' => {
+                                  'login' => username,
+                                  'mail' => email,
+                                  'password' => Password.generate_random_string(25),
+                                  'auth_source_id' => 1}})
+      end
+
+      def user_destroy(id)
+        user.destroy('id' => id)
+      end
+
+    end
+  end
+
+end
+
+

data/lib/katello_foreman_engine/engine.rb

@@ -0,0 +1,14 @@
+module KatelloForemanEngine
+  #Inherit from the Rails module of the parent app (Foreman), not the plugin.
+  #Thus, inhereits from ::Rails::Engine and not from Rails::Engine
+  class Engine < ::Rails::Engine
+
+    config.after_initialize do
+      require 'katello_foreman_engine/settings'
+      Settings.initialize_settings
+      require 'katello_foreman_engine/bindings'
+      Dir[File.expand_path('../actions/*.rb', __FILE__)].each { |f| require f }
+    end
+
+  end
+end

data/lib/katello_foreman_engine/settings.rb

@@ -0,0 +1,21 @@
+module KatelloForemanEngine
+  class Settings
+
+    def self.initialize_settings
+      @settings = {
+        'foreman_url' => Katello.config.foreman.url.sub(/\/+\Z/,''),
+        'oauth_consumer_key' => Katello.config.foreman.oauth_key,
+        'oauth_consumer_secret' => Katello.config.foreman.oauth_secret
+      }
+    end
+
+    def self.[](key)
+      @settings[key.to_s]
+    end
+
+    def self.[]=(key, value)
+      @settings[key.to_s] = value
+    end
+
+  end
+end

data/lib/katello_foreman_engine.rb

@@ -0,0 +1,5 @@
+module KatelloForemanEngine
+  if defined?(Rails) && Rails::VERSION::MAJOR == 3
+    require 'katello_foreman_engine/engine'
+  end
+end

data/script/rails

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/os_preference/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/test/lib/actions/env_create.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class EnvCreateTest < ActiveSupport::TestCase
+
+      test "doesn't run for library" do
+        org = Organization.new(:label => 'org')
+        env = KTEnvironment.new(:label => 'dev')
+        env.organization = org
+
+        env.library = false
+        plan = prepare_plan(EnvCreate, {}, env)
+        step = plan.run_steps.first
+        assert_equal EnvCreate, step.action_class
+        assert_equal step.input['org_label'], 'org'
+        assert_equal step.input['label'], 'dev'
+        assert_equal step.input['cv_id'], 'env'
+
+        env.library = true
+        plan = prepare_plan(EnvCreate, {}, env)
+        assert_equal [], plan.run_steps
+      end
+
+      test 'calls bindings to create environment' do
+        Bindings.expects(:environment_create).with('env', 'org', 'dev')
+        EnvCreate.new('org_label' => 'org', 'label' => 'dev', 'cv_id' => 'env').run
+      end
+
+    end
+  end
+end

data/test/lib/actions/env_destroy.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class EnvDestroyTest < ActiveSupport::TestCase
+
+      test "runs only when the env is present in Foreman and it's not library" do
+        org = Organization.new(:label => 'org')
+        env = KTEnvironment.new(:label => 'dev')
+        env.organization = org
+
+        foreman_env = { 'environment' => { 'id' => '123' } }
+        Bindings.expects(:environment_find).with('org', 'dev').returns(foreman_env)
+
+        env.library = false
+        plan = prepare_plan(EnvDestroy,{}, env)
+        step = plan.run_steps.first
+        assert_equal EnvDestroy, step.action_class
+        assert_equal step.input['foreman_id'], '123'
+
+        env.library = true
+        plan = prepare_plan(EnvDestroy, {}, env)
+        assert_equal [], plan.run_steps
+
+        env.library = false
+        Bindings.expects(:environment_find).returns(nil)
+        plan = prepare_plan(EnvDestroy, {}, env)
+        assert_equal [], plan.run_steps
+      end
+
+      test 'calls bindings to destroy environment' do
+        Bindings.expects(:environment_destroy).with('123')
+        EnvDestroy.new('foreman_id' => '123').run
+      end
+
+    end
+  end
+end

data/test/lib/actions/org_create.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class OrgCreateTest < ActiveSupport::TestCase
+
+      test 'calls bindings to create organization' do
+        Bindings.expects(:organization_create). with('KT-[ACME]')
+        OrgCreate.new('label' => 'ACME').run
+      end
+
+    end
+  end
+end

data/test/lib/actions/org_destroy.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module KatelloForemanEngine
+  module Actions
+    class OrgDestroyTest < ActiveSupport::TestCase
+
+      test "runs only when the org is present in Foreman" do
+        foreman_org = { 'organization' => { 'id' => '123' } }
+        Bindings.expects(:organization_find).with('KT-[test]').returns(foreman_org)
+        plan = prepare_plan(OrgDestroy, {'label' => 'test'}, nil)
+        step = plan.run_steps.first
+        assert_equal OrgDestroy, step.action_class
+        assert_equal step.input['foreman_id'], '123'
+
+        Bindings.expects(:organization_find).returns(nil)
+        plan = prepare_plan(OrgDestroy, {'label' => 'test'}, nil)
+        assert_equal [], plan.run_steps
+      end
+
+      test 'calls bindings to destroy organization' do
+        Bindings.expects(:organization_destroy).with('123')
+        OrgDestroy.new('foreman_id' => '123').run
+      end
+
+    end
+  end
+end

data/test/lib/bindings_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'mocha/setup'
+
+class BindingsTest < ActiveSupport::TestCase
+
+  def setup
+    KatelloForemanEngine::Settings.initialize_settings
+  end
+
+  test 'client lib setting' do
+    KatelloForemanEngine::Settings['foreman_url'] = 'https://example.com/foreman'
+    KatelloForemanEngine::Settings['oauth_consumer_key'] = 'key'
+    KatelloForemanEngine::Settings['oauth_consumer_secret'] = 'secret'
+    User.current = User.new(:username => 'test')
+    env_resource = KatelloForemanEngine::Bindings.environment
+    config = env_resource.config
+    assert_equal 'https://example.com/foreman', config[:base_url]
+    assert_equal 'key', config[:oauth][:consumer_key]
+    assert_equal 'secret', config[:oauth][:consumer_secret]
+    assert_equal 'test', env_resource.client.options[:headers][:foreman_user]
+  end
+
+end

data/test/lib/settings_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class SettingsTest < ActiveSupport::TestCase
+
+  test "katello specific settings" do
+    KatelloForemanEngine::Settings.initialize_settings
+    assert_equal 'https://localhost/foreman', KatelloForemanEngine::Settings['foreman_url']
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+
+ENV["RAILS_ENV"] ||= 'test'
+require File.join("katello_app/config/environment.rb")
+
+require 'test/unit'
+require 'katello-foreman-engine'
+require 'rails/test_help'
+require 'mocha/setup'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# returns the execution plan for given action, given
+# input from parent action and *args for plan method
+def prepare_plan(action_class, input, *args)
+  action = action_class.new(input)
+  action.plan(*args)
+  return action.execution_plan
+end