foreman_scc_manager 1.0.0

data/README.md

@@ -0,0 +1,38 @@
+# ForemanSccManager
+
+Foreman plugin to sync SUSE Customer Center products and repositories into Katello
+
+## Installation
+
+See [How_to_Install_a_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin)
+for how to install Foreman plugins
+
+## Usage
+
+*Usage here*
+
+## TODO
+
+*Todo list here*
+
+## Contributing
+
+Fork and send a Pull Request. Thanks!
+
+## Copyright
+
+Copyright (c) 2017 ATIX AG
+
+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,47 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanSccManager'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+
+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 => _
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/assets/javascripts/foreman_scc_manager/scc_accounts.js.coffee

@@ -0,0 +1,46 @@
+scc_products_after_checked = (target) ->
+  if target.parentNode.dataset.parent
+    parent = $("#" + target.parentNode.dataset.parent + " input")[0]
+    if !parent.checked && !parent.disabled
+      parent.checked = true
+      scc_products_after_checked(parent)
+
+scc_products_after_unchecked = (target) ->
+  $("span.scc_product_checkbox input", target.parentNode.parentNode).each (index, child) ->
+    if child.checked && !child.disabled
+      child.checked = false
+      scc_products_after_unchecked(child)
+
+$ ->
+  $("body").on "change", "span.scc_product_checkbox input", (event) ->
+    target = event.target
+    if target.checked
+      scc_products_after_checked target
+    else
+      scc_products_after_unchecked target
+  $("body").on "click", "a.edit_deferrer", (event) ->
+    event.preventDefault()
+    $("a.edit_deferree", $(event.target).closest("tr"))[0].click()
+  $("body").on "click", "#test_scc_connection_btn", (event) ->
+    $('.tab-error').removeClass('tab-error')
+    $('#connection_test_result')[0].innerHTML = ''
+    $('#test_scc_connection_indicator').show()
+    $.ajax event.target.parentNode.dataset['url'],
+      type: 'PUT'
+      dataType: 'JSON'
+      data: $('form').serialize()
+      success: (result) ->
+        $('#test_scc_connection_btn').addClass('btn-success')
+        $('#test_scc_connection_btn').removeClass('btn-default')
+        $('#test_scc_connection_btn').removeClass('btn-danger')
+      error: (result) ->
+        $('#test_scc_connection_btn').addClass('btn-danger')
+        $('#test_scc_connection_btn').removeClass('btn-default')
+        $('#test_scc_connection_btn').removeClass('btn-success')
+        $('#scc_account_login').closest('.form-group').addClass('tab-error')
+        $('#scc_account_password').closest('.form-group').addClass('tab-error')
+        $('#scc_account_base_url').closest('.form-group').addClass('tab-error')
+        $('#connection_test_result')[0].innerHTML = 'Connection test failed!'
+        $('#scc_account_login').focus()
+      complete: (result) ->
+        $('#test_scc_connection_indicator').hide()

data/app/controllers/scc_accounts_controller.rb

@@ -0,0 +1,118 @@
+class SccAccountsController < ApplicationController
+  before_filter :find_resource, only: [:show, :edit, :update, :destroy, :sync, :bulk_subscribe]
+  include Api::TaxonomyScope
+  include Foreman::Controller::AutoCompleteSearch
+
+  # GET /scc_accounts
+  def index
+    @scc_accounts = resource_base.search_for(params[:search], order: params[:order])
+                                 .paginate(page: params[:page])
+  end
+
+  # GET /scc_accounts/new
+  def new
+    @scc_account = SccAccount.new
+    @scc_account.organization = Organization.current
+  end
+
+  # POST /scc_accounts
+  def create
+    @scc_account = SccAccount.new(scc_account_params)
+    if @scc_account.save
+      process_success
+    else
+      process_error
+    end
+  end
+
+  # GET /scc_accounts/1/edit
+  def edit; end
+
+  # POST /scc_accounts/test_connection
+  def test_connection
+    @scc_account = SccAccount.new(scc_account_params)
+    if params[:scc_account_id].present? && scc_account_params[:password].empty?
+      @scc_account.password = SccAccount.find_by!(id: params[:scc_account_id]).password
+    end
+    respond_to do |format|
+      if @scc_account.test_connection
+        format.json { render json: nil, status: :ok }
+      else
+        format.json { render json: nil, status: 404 }
+      end
+    end
+  end
+
+  # PATCH/PUT /scc_accounts/1
+  def update
+    if @scc_account.update(scc_account_params)
+      process_success
+    else
+      process_error
+    end
+  end
+
+  # DELETE /scc_accounts/1
+  def destroy
+    if @scc_account.destroy
+      process_success
+    else
+      process_error
+    end
+  end
+
+  # PUT /scc_accounts/1/sync
+  def sync
+    begin
+      sync_task = ForemanTasks.async_task(::Actions::SccManager::Sync, @scc_account)
+      notice _("Sync task started.")
+    rescue ::Foreman::Exception => e
+      error _("Failed to add task to queue: %s") % e.to_s
+    rescue ForemanTasks::Lock::LockConflict => e
+      error _("Lock on SCC account already taken: %s") % e.to_s
+    ensure
+      redirect_to scc_accounts_path
+    end
+  end
+
+  def bulk_subscribe
+    begin
+      scc_products_to_subscribe =
+        @scc_account.scc_products.where(id: scc_bulk_subscribe_params[:scc_subscribe_product_ids])
+      ForemanTasks.async_task(::Actions::BulkAction,
+                              ::Actions::SccManager::SubscribeProduct,
+                              scc_products_to_subscribe)
+      notice _("Task to subscribe products started.")
+    rescue ::Foreman::Exception => e
+      error _("Failed to add task to queue: %s") % e.to_s
+    rescue ForemanTasks::Lock::LockConflict => e
+      error _("Lock on SCC account already taken: %s") % e.to_s
+    ensure
+      redirect_to scc_accounts_path
+    end
+  end
+
+  private
+
+  # Use callbacks to share common setup or constraints between actions.
+  # Only allow a trusted parameter "white list" through.
+  def scc_account_params
+    params[:scc_account].delete(:password) if params[:scc_account][:password].blank?
+    params.require(:scc_account).permit(:name, :login, :password, :base_url, :organization_id)
+  end
+
+  def scc_bulk_subscribe_params
+    params.require(:scc_account).permit(:scc_subscribe_product_ids => [])
+  end
+
+  def action_permission
+    case params[:action]
+    when 'sync', 'test_connection'
+      :sync
+    when 'bulk_subscribe'
+      :bulk_subscribe
+    else
+      super
+    end
+  end
+end

data/app/controllers/scc_products_controller.rb

@@ -0,0 +1,24 @@
+class SccProductsController < ApplicationController
+  before_filter :find_resource, only: [:show, :subscribe, :unsubscribe]
+  include Api::TaxonomyScope
+  include Foreman::Controller::AutoCompleteSearch
+
+  def index
+    # TODO: Organization...
+    @scc_products = SccProduct.all
+    respond_to do |format|
+      format.json { render json: @scc_products.to_json }
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.json { render json: @scc_product.to_json }
+    end
+  end
+
+  def subscribe
+    @scc_product.subscribe
+    redirect_to @scc_product.scc_account
+  end
+end

data/app/helpers/scc_accounts_helper.rb

@@ -0,0 +1,2 @@
+module SccAccountsHelper
+end

data/app/helpers/scc_product_helper.rb

@@ -0,0 +1,2 @@
+module SccProductHelper
+end

data/app/lib/actions/scc_manager/subscribe_product.rb

@@ -0,0 +1,72 @@
+module Actions
+  module SccManager
+    class SubscribeProduct < Actions::EntryAction
+      def plan(scc_product)
+        raise _('Product already subscribed!') if scc_product.product
+        ::Foreman::Logging.logger('foreman_scc_manager')
+                          .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
+        sequence do
+          product_create_action = plan_action(CreateProduct,
+                                              product_name: scc_product.uniq_name,
+                                              product_description: scc_product.description,
+                                              organization_id: scc_product.organization.id)
+          scc_product.scc_repositories.each do |repo|
+            uniq_name = scc_product.uniq_name + ' ' + repo.description
+            arch = scc_product.arch || 'noarch'
+            plan_action(CreateRepository,
+                        :product_id => product_create_action.output[:product_id],
+                        :uniq_name => uniq_name,
+                        :url => repo.full_url,
+                        :arch => arch)
+          end
+          action_subject(scc_product, product_id: product_create_action.output[:product_id])
+          plan_self
+        end
+      end
+
+      def finalize
+        scc_product = SccProduct.find(input[:scc_product][:id])
+        product = ::Katello::Product.find(input[:product_id])
+        scc_product.update!(product: product)
+      end
+
+      def humanized_name
+        _('Subscribe SCC Product')
+      end
+    end
+
+    class CreateProduct < Actions::Base
+      middleware.use ::Actions::Middleware::KeepCurrentUser
+      include ::Dynflow::Action::WithSubPlans
+
+      def create_sub_plans
+        product = ::Katello::Product.new
+        product.name = input[:product_name]
+        product.description = input[:product_description]
+        trigger(::Actions::Katello::Product::Create,
+                product,
+                Organization.find(input[:organization_id])).tap do
+          output[:product_id] = product.id
+        end
+      end
+    end
+
+    class CreateRepository < Actions::Base
+      middleware.use ::Actions::Middleware::KeepCurrentUser
+      include ::Dynflow::Action::WithSubPlans
+
+      def create_sub_plans
+        product = ::Katello::Product.find(input[:product_id])
+        uniq_name = input[:uniq_name]
+        label = ::Katello::Util::Model.labelize(uniq_name)
+        unprotected = true
+        gpg_key = product.gpg_key
+        repository = product.add_repo(label, uniq_name, input[:url], 'yum', unprotected, gpg_key)
+        repository.arch = input[:arch]
+        repository.mirror_on_sync = true
+        repository.verify_ssl_on_sync = true
+        trigger(::Actions::Katello::Repository::Create, repository, false, false)
+      end
+    end
+  end
+end

data/app/lib/actions/scc_manager/sync.rb

@@ -0,0 +1,36 @@
+module Actions
+  module SccManager
+    class Sync < Actions::EntryAction
+      def plan(scc_account)
+        ::Foreman::Logging.logger('foreman_scc_manager')
+                          .info("Initiating 'sync' for SccAccount '#{scc_account.name}'.")
+        action_subject(scc_account)
+        sequence do
+          sync_repo_action = plan_action(::Actions::SccManager::SyncRepositories, scc_account)
+          sync_prod_action = plan_action(::Actions::SccManager::SyncProducts, scc_account)
+          plan_self(repo_status: sync_repo_action.output[:status], prod_status: sync_prod_action.output[:status])
+        end
+        scc_account.update! sync_status: 'running'
+      end
+
+      def finalize
+        scc_account = SccAccount.find(input[:scc_account][:id])
+        if input[:repo_status] == 'SUCCESS' and input[:prod_status] == 'SUCCESS'
+          scc_account.sync_status = 'successful'
+          scc_account.synced = DateTime.current
+        else
+          scc_account.sync_status = 'failed'
+        end
+        scc_account.save!
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+
+      def humanized_name
+        _('Sync SUSE subscriptions')
+      end
+    end
+  end
+end

data/app/lib/actions/scc_manager/sync_products.rb

@@ -0,0 +1,37 @@
+module Actions
+  module SccManager
+    class SyncProducts < Actions::EntryAction
+      def plan(scc_account)
+        action_subject(scc_account)
+        plan_self(id: scc_account.id,
+                  base_url: scc_account.base_url,
+                  login: scc_account.login,
+                  password: scc_account.password)
+      end
+
+      def run
+        output[:status] = 'SUCCESS'
+        begin
+          output[:data] = ::SccManager.get_scc_data(input.fetch(:base_url),
+                                                    '/connect/organizations/products',
+                                                    input.fetch(:login),
+                                                    input.fetch(:password))
+        rescue
+          output[:status] = 'FAILURE'
+        end
+      end
+
+      def finalize
+        SccAccount.find(input.fetch(:id)).update_scc_products(output.fetch(:data)) if output[:status] == 'SUCCESS'
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+
+      def humanized_name
+        _('Sync SUSE subscriptions (Products)')
+      end
+    end
+  end
+end

data/app/lib/actions/scc_manager/sync_repositories.rb

@@ -0,0 +1,36 @@
+module Actions
+  module SccManager
+    class SyncRepositories < Actions::EntryAction
+      def plan(scc_account)
+        action_subject(scc_account)
+        plan_self(base_url: scc_account.base_url,
+                  login: scc_account.login,
+                  password: scc_account.password)
+      end
+
+      def run
+        output[:status] = 'SUCCESS'
+        begin
+          output[:data] = ::SccManager.get_scc_data(input[:base_url],
+                                                    '/connect/organizations/repositories',
+                                                    input[:login],
+                                                    input[:password])
+        rescue
+          output[:status] = 'FAILURE'
+        end
+      end
+
+      def finalize
+        SccAccount.find(input[:scc_account][:id]).update_scc_repositories(output[:data]) if output[:status] == 'SUCCESS'
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+
+      def humanized_name
+        _('Sync SUSE subscriptions (Repositories)')
+      end
+    end
+  end
+end