foreman_pipeline 0.0.1

data/app/lib/actions/foreman_pipeline/job/cv_promote_job_hook.rb

@@ -0,0 +1,22 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class CvPromoteJobHook < JobHook
+
+        def self.subscribe
+          Katello::ContentView::Promote
+        end
+
+        def plan(version, environment, is_force = false)          
+          valid_jobs = version.content_view.jobs.select { |job| job.is_valid? }
+          jobs_to_run = valid_jobs.select { |job| version.eql? job.target_cv_version }
+          allowed_jobs = jobs_to_run.select { |job| job.levelup_trigger && !job.version_already_promoted? }
+          
+          plan_self(:trigger => trigger.output,
+                    :job_ids => allowed_jobs.map(&:id),
+                    :job_names => allowed_jobs.map(&:name))    
+        end        
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/cv_publish_job_hook.rb

@@ -0,0 +1,22 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class CvPublishJobHook < JobHook
+
+        def self.subscribe
+          Katello::ContentView::Publish
+        end
+
+        def plan(content_view, descripton)
+          valid_jobs = content_view.jobs.select { |job| job.is_valid? }
+          jobs_to_run = valid_jobs.select { |job| job.environment.library? }
+          allowed_jobs = jobs_to_run.select { |job| job.levelup_trigger && !job.version_already_promoted? }
+
+          plan_self(:trigger => trigger.output,
+                    :job_ids => allowed_jobs.map(&:id),
+                    :job_names => allowed_jobs.map(&:name))
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/deploy_new_host.rb

@@ -0,0 +1,25 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class DeployNewHost < Actions::EntryAction
+        include Mixins::UriExtension
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def plan(job)
+          sequence do
+            redeploy = plan_action(Redeploy, job)
+
+            packages = plan_action(FindPackagesToInstall, :job_id => job.id)
+
+            bulk_build = plan_action(Jenkins::BulkBuild,
+                                      job.jenkins_projects,
+                                      :job_id => job.id,
+                                      :data => redeploy.output,
+                                      :packages => packages.output[:package_names])
+            plan_action(Promote, :job_id => job.id, :build_fails => bulk_build.output[:failed_count])
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/find_packages_to_install.rb

@@ -0,0 +1,16 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class FindPackagesToInstall < Actions::EntryAction
+        middleware.use ::Actions::Middleware::RemoteAction
+        include ::Dynflow::Action::Cancellable
+
+        def run
+          job = ::ForemanPipeline::Job.find input.fetch(:job_id)
+          output[:package_names] = job.target_cv_version.packages.map(&:name)
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/job_hook.rb

@@ -0,0 +1,24 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class JobHook < Actions::EntryAction
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def run
+          fail "Multiple jobs defined for the same content view and environment: #{input[:job_names]}.
+               This may result in an unexpected behaviour.
+               Resolve the conflict to avoid skipping this action." if input[:job_names].length > 1
+          jobs = input[:job_ids].map { |id| ::ForemanPipeline::Job.find id }
+          jobs.map do |job|
+            ForemanTasks.trigger(DeployNewHost, job)
+          end
+        end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/multiple_promotions.rb

@@ -0,0 +1,18 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class MultiplePromotions < Actions::EntryAction
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def plan(job)
+          sequence do
+            job.to_environments.each do |env|
+              plan_action(::Actions::Katello::ContentView::Promote, job.target_cv_version, env, false)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/promote.rb

@@ -0,0 +1,38 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class Promote < Actions::EntryAction
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def plan(opts)
+          plan_self(opts)
+        end
+
+        def run
+          unless job.environment.successors.empty?
+            fail "Content View promotion disabled" if job.to_environments.empty?
+            promote_environment
+          end
+        end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
+        private
+
+        def promote_environment
+          output[:cv_to_promote] = job.content_view.name
+          output[:target_environments] = job.to_environments.pluck(:name)
+          output[:in_job] = job.name
+
+          ForemanTasks.trigger(Job::MultiplePromotions, job)
+        end
+
+        def job
+          j = ::ForemanPipeline::Job.find input.fetch(:job_id)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/redeploy.rb

@@ -0,0 +1,45 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class Redeploy < Actions::EntryAction
+
+        def plan(job)
+          sequence do
+            unique_hostname = "#{normalize_name job.name}-#{::Katello::Util::Model.uuid}"
+
+            create_candlepin_key = plan_action(::Actions::Candlepin::ActivationKey::Create, :organization_label => job.content_view.organization.name)
+            create_key = plan_action(CreateActivationKey, :name => unique_hostname,
+                                                          :organization_id => job.content_view.organization.id,
+                                                          :environment_id => job.environment_id,
+                                                          :content_view_id => job.content_view.id,
+                                                          :cp_id => create_candlepin_key.output[:response][:id])
+
+            create_host = plan_action(CreateHost, unique_hostname, job.hostgroup, job.compute_resource, {
+                           :org_id => job.content_view.organization.id,
+                           :content_view_id => job.content_view.id,
+                           :activation_key => create_key.output[:new_key],
+                           :jenkins_instance_id => job.jenkins_instance_id})
+
+            suspend_until = plan_action(SuspendUntilProvisioned, 'host_id' => create_host.output[:host][:id])
+
+            plan_self(:create_host => create_host.output[:host],
+                      :installed_at => suspend_until.output[:object][:installed_at],
+                      :new_key => create_key.output[:new_key])
+
+          end
+        end
+
+        def run
+          output[:host] = input[:create_host]
+          output[:activation_key] = input[:new_key]
+        end
+
+        private
+
+        def normalize_name(repo_name)
+          repo_name.gsub(/[^a-z0-9\-]/, '-')
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/repo_sync_job_hook.rb

@@ -0,0 +1,33 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class RepoSyncJobHook < JobHook
+
+        def self.subscribe
+          Katello::Repository::Sync
+        end
+
+        def plan(repo)
+          valid_jobs = repo.jobs.select { |job| job.is_valid? }
+
+          jobs_to_run = valid_jobs.select { |job| job.target_cv_version_avail? }
+          allowed_jobs = jobs_to_run.select { |job| job.sync_trigger && !job.version_already_promoted? }
+          grouped_jobs = allowed_jobs.group_by(&:target_cv_version).values
+
+          if grouped_jobs.max_by(&:length).length > 1
+            grouped_jobs = grouped_jobs.max_by(&:length)
+
+            plan_self(:trigger => trigger.output,
+                      :job_ids => grouped_jobs.map(&:id),
+                      :job_names => grouped_jobs.map(&:name))
+          else
+            grouped_jobs.flatten!
+            plan_self(:trigger => trigger.output,
+                      :job_names => [],
+                      :job_ids => grouped_jobs.map(&:id))
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/run_job_manually.rb

@@ -0,0 +1,25 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class RunJobManually < Actions::EntryAction
+
+        def plan(job)
+          if job.is_valid? && job.target_cv_version_avail? && !job.version_already_promoted?
+            plan_action(DeployNewHost, job)
+            plan_self(:info => "Manually triggered job started.", :name => job.name)
+          else
+            plan_self(:info => "Manually triggered job execution skipped, check job configuration.", :name => job.name)
+          end
+        end
+
+        def run
+          output = input
+        end
+
+        def humanized_name
+          "Run manually ForemanPipeline::Job: #{input[:name]}"
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/job/suspend_until_provisioned.rb

@@ -0,0 +1,13 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class SuspendUntilProvisioned < ::ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition::Action
+        include ::Dynflow::Action::Cancellable
+
+        def done?
+          output[:task][:build]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/mixins/ssh_extension.rb

@@ -0,0 +1,41 @@
+module Actions
+  module ForemanPipeline
+    module Mixins
+      module SshExtension
+        extend ActiveSupport::Concern
+
+        # http://stackoverflow.com/questions/3386233/how-to-get-exit-status-with-rubys-netssh-library
+        def ssh_exec!(ssh, command)
+          stdout_data = ""
+          stderr_data = ""
+          exit_code = nil
+          exit_signal = nil
+          ssh.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              unless success
+                abort "FAILED: couldn't execute command (ssh.channel.exec)"
+              end
+              channel.on_data do |ch, data|
+                stdout_data += data
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                stderr_data += data
+              end
+
+              channel.on_request("exit-status") do |ch, data|
+                exit_code = data.read_long
+              end
+
+              channel.on_request("exit-signal") do |ch, data|
+                exit_signal = data.read_long
+              end
+            end
+          end
+          ssh.loop
+          [stdout_data, stderr_data, exit_code, exit_signal]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/mixins/uri_extension.rb

@@ -0,0 +1,14 @@
+module Actions
+  module ForemanPipeline
+    module Mixins
+      module UriExtension
+        extend ActiveSupport::Concern
+        require 'uri'
+
+        def jenkins_hostname(job)
+          URI(job.jenkins_instance.url).host  
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_pipeline/api/rendering.rb

@@ -0,0 +1,18 @@
+module ForemanPipeline
+  module Api
+    module Rendering
+
+      def respond_with_template(action, resource_name, options = {}, &block)
+        yield if block_given?
+        status = options[:status] || 200
+
+        render :template => "foreman_pipeline/api/#{resource_name}/#{action}",
+               :status => status,
+               :locals => { :object_name => options[:object_name],
+                            :root_name => options[:root_name] },
+               :layout => "katello/api/v2/layouts/#{options[:layout]}" 
+      end
+      
+    end
+  end
+end

data/app/models/foreman_pipeline/authorization/base_model.rb

@@ -0,0 +1,31 @@
+module ForemanPipeline
+  module Authorization::BaseModel
+    extend ActiveSupport::Concern
+
+    include Authorizable
+    include Katello::Authorization
+
+    def readable?
+      authorized?(self.normalize_name("read"))
+    end
+
+    def editable?
+      authorized?(self.normalize_name("edit"))
+    end
+
+    def deletable?
+      authorized?(self.normalize_name("delete"))
+    end
+
+    module ClassMethods
+      def readable
+        authorized(normalize_name("view"))
+      end
+
+      # TODO: remove argument
+      def normalize_name(action_string)
+        (action_string + self.class.name.demodulize.pluralize).underscore.to_sym
+      end
+    end
+  end
+end

data/app/models/foreman_pipeline/authorization/jenkins_instance.rb

@@ -0,0 +1,8 @@
+module ForemanPipeline
+  module Authorization::JenkinsInstance
+    extend ActiveSupport::Concern
+
+    include Authorization::BaseModel
+    
+  end
+end

data/app/models/foreman_pipeline/authorization/jenkins_project.rb

@@ -0,0 +1,8 @@
+module ForemanPipeline
+  module Authorization::JenkinsProject
+    extend ActiveSupport::Concern
+
+    include Authorization::BaseModel
+    
+  end
+end

data/app/models/foreman_pipeline/authorization/jenkins_project_param.rb

@@ -0,0 +1,8 @@
+module ForemanPipeline
+  module Authorization::JenkinsProjectParam
+    extend ActiveSupport::Concern
+
+    include Authorization::BaseModel
+    
+  end
+end

data/app/models/foreman_pipeline/authorization/jenkins_user.rb

@@ -0,0 +1,7 @@
+module ForemanPipeline
+  module Authorization::JenkinsUser
+    extend ActiveSupport::Concern
+
+    include Authorization::BaseModel
+  end
+end