foreman_pipeline 0.0.1

data/app/controllers/foreman_pipeline/application_controller.rb

@@ -0,0 +1,4 @@
+module ForemanPipeline
+  class ApplicationController < ::ApplicationController
+  end
+end

data/app/helpers/foreman_pipeline/application_helper.rb

@@ -0,0 +1,4 @@
+module ForemanPipeline
+  module ApplicationHelper
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/abstract_jenkins_action.rb

@@ -0,0 +1,20 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class AbstractJenkinsAction < Actions::EntryAction
+
+        def job
+          j = ::ForemanPipeline::Job.find input.fetch(:job_id)
+          fail "no jenkins instance specified for the job with id #{j.id}" if j.jenkins_instance.nil?
+          j.init_run
+          j
+        end
+
+        def jenkins_project
+          ::ForemanPipeline::JenkinsProject.find input[:project_id]
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/build.rb

@@ -0,0 +1,35 @@
+require 'erb'
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class Build < AbstractJenkinsAction
+
+        def run
+          #are we willing to wait longer than 5 mins until build starts?
+          output[:build_num] = job.jenkins_instance.client.job.build(jenkins_project.name, params, 'build_start_timeout' => 300)
+          output[:project_name] = jenkins_project.name
+          output[:build_params] = params
+        end
+
+        def params
+          project_params = jenkins_project.jenkins_project_params
+          return {} if project_params.empty?
+          template_binding project_params
+        end
+
+        def template_binding(project_params)
+          host = input[:data][:host]
+          activation_key = input[:data][:activation_key]
+          packages = input[:data][:packages]
+
+          project_params.each do |param|
+            param.value = ERB.new(param.value).result(binding)
+            param.format_bool
+          end.map do |param|
+            {param.name => param.value}
+          end.reduce(:merge)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/build_project.rb

@@ -0,0 +1,31 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class BuildProject < AbstractJenkinsAction
+
+        def plan(options)
+          sequence do
+            build_task = plan_action(Build, options)
+            wait_task = plan_action(WaitForBuild, :job_id => options[:job_id],
+                                                  :name => options[:project_name],
+                                                  :build_num => build_task.output[:build_num])
+
+            plan_self(:build_status => wait_task.output[:details][:result], :name => options[:project_name])
+          end
+        end
+
+        def run
+          output[:status] = input[:build_status]
+        end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def humanized_name
+          "Build Jenkins Project: %s" % input[:name]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/bulk_build.rb

@@ -0,0 +1,23 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class BulkBuild < Actions::ActionWithSubPlans
+
+        def plan(projects, opts)
+          plan_self(:project_ids => projects.map(&:id), :opts => opts)
+        end
+
+        def create_sub_plans
+          projects = ::ForemanPipeline::JenkinsProject.where(:id => input[:project_ids])
+
+          packs = input[:opts].delete(:packages)
+          input[:opts][:data].merge!({:packages => packs})
+
+          projects.map do |project|
+            trigger(BuildProject, input[:opts].merge({:project_id => project.id, :project_name => project.name}))
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/get_build_details.rb

@@ -0,0 +1,11 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class GetBuildDetails < AbstractJenkinsAction
+        def run
+          output[:details] = job.jenkins_instance.client.job.get_build_details input[:name], input[:build_num]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/get_build_params.rb

@@ -0,0 +1,11 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class GetBuildParams < AbstractJenkinsAction
+        def run
+          output[:build_params] = job.jenkins_instance.client.job.get_build_params input.fetch(:name)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/get_version.rb

@@ -0,0 +1,17 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class GetVersion < Actions::EntryAction
+
+        def run
+          instance = ::ForemanPipeline::JenkinsInstance.find input[:id]
+          output[:version] = instance.create_client.get_jenkins_version
+        end
+
+        def humanized_name
+          "Get Jenkins CI version: %s" % input[:name]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/list.rb

@@ -0,0 +1,15 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class List < AbstractJenkinsAction
+        def run
+          output[:projects] = job.jenkins_instance.client.job.list input[:filter]
+        end
+
+        def humanized_name
+          "List projects in Jenkins Instance: %s" % job.jenkins_instance.name
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/wait_and_poll.rb

@@ -0,0 +1,33 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class WaitAndPoll < AbstractJenkinsAction
+        include Dynflow::Action::Polling
+        include Dynflow::Action::Cancellable
+
+        def external_task
+          output[:result]
+        end
+
+        def done?
+          external_task
+        end
+
+        private
+
+        def invoke_external_task
+          nil
+        end
+
+        def external_task=(external_task_data)
+          output[:result] = external_task_data
+        end
+
+        def poll_interval
+          5
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/wait_for_build.rb

@@ -0,0 +1,42 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class WaitForBuild < WaitAndPoll
+
+        def poll_interval
+          10
+        end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def run(event = nil)
+          unless event == Dynflow::Action::Skip
+            super
+          end
+        end
+
+        def external_task=(external_task_data)
+          if external_task_data.is_a?(Hash)
+            output[:result] = !external_task_data[:result].nil?
+            if external_task_data[:result] == "FAILURE"
+              fail "Jenkins build failed"
+            end
+          end
+        end
+
+        private
+
+        def poll_external_task
+          details = job.jenkins_instance.client.job
+                      .get_build_details(input.fetch(:name), input.fetch(:build_num))
+                      .with_indifferent_access
+          output[:details] = details
+          details
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins/wait_host_ready.rb

@@ -0,0 +1,36 @@
+module Actions
+  module ForemanPipeline
+    module Jenkins
+      class WaitHostReady < WaitAndPoll
+        include Mixins::SshExtension
+
+        private
+
+        def poll_external_task
+          status = nil
+          ip = Socket::getaddrinfo(input[:jenkins_instance_hostname], 'www', nil, Socket::SOCK_STREAM)[0][3]
+          Net::SSH.start(ip, 'root', :keys => [input.fetch(:cert_path)]) do |ssh|
+            status = ssh_exec!(ssh, command)
+          end
+          output[:jenkins_ip] = ip
+          output[:status] = status
+          status[2].to_i == 0
+        end
+
+        def command
+          c = []
+          c << "sudo -u jenkins ssh -i #{input[:jenkins_home]}/.ssh/#{input[:jenkins_instance_hostname]} -o StrictHostKeyChecking=no root@#{input[:host_ip]}"
+          c << "'echo"
+          c << echo
+          c << "'"
+          c.join(" ")
+        end
+
+        def echo
+          '"host ready yet?"'
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins_instance/abstract_jenkins_instance_action.rb

@@ -0,0 +1,17 @@
+require 'net/ssh'
+require 'uri'
+
+module Actions
+  module ForemanPipeline
+    module JenkinsInstance
+      class AbstractJenkinsInstanceAction < Actions::EntryAction
+        include Mixins::SshExtension
+        
+        def parse_jenkins_hostname
+          URI(input.fetch(:jenkins_url)).host
+        end
+
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_pipeline/jenkins_instance/create_jenkins_instance_keys.rb

@@ -0,0 +1,45 @@
+require 'net/ssh'
+require 'net/scp'
+require 'uri'
+
+module Actions
+  module ForemanPipeline
+    module JenkinsInstance
+      class CreateJenkinsInstanceKeys < AbstractJenkinsInstanceAction
+
+        def run
+          output[:pubkey] = fetch_pubkey(parse_jenkins_hostname)
+        end
+
+        def fetch_pubkey(host)
+          buffer = StringIO.new
+          ip = Socket::getaddrinfo(host, 'www', nil, Socket::SOCK_STREAM)[0][3]
+
+          Net::SSH.start(ip, 'root', :keys => [input.fetch(:cert_path)]) do |ssh|
+            status = ssh_exec!(ssh, "ls #{key_location}")[2]
+            ssh.exec!("mkdir #{key_location}") if status > 0
+            ssh.exec! "sed -i s:Defaults\\.*requiretty:#Defaults\\ requiretty:g /etc/sudoers"
+            ssh.exec! "rm -f #{key_location}/#{parse_jenkins_hostname}.pub #{key_location}/#{parse_jenkins_hostname}"
+            ssh.exec! "sudo -u jenkins ssh-keygen -f #{key_location}/#{parse_jenkins_hostname} -t rsa -N '' -q"
+            ssh.scp.download! "#{key_location}/#{parse_jenkins_hostname}.pub", buffer
+          end
+
+          buffer.string
+        end
+
+        def key_location
+          "#{input.fetch(:jenkins_home)}/.ssh"
+        end
+
+        def finalize
+          if output[:pubkey].match(/^ssh-rsa/)
+            output[:status] = 0
+          else
+            output[:status] = 1
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class CreateActivationKey < Actions::EntryAction
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def run
+          output[:new_key] = ::Katello::ActivationKey.create(
+                        name:             "key-for-#{input[:name]}",
+                        organization_id:   input[:organization_id],
+                        environment_id:    input[:environment_id],
+                        content_view_id:   input[:content_view_id],
+                        user_id:           ::User.current.id,
+                        cp_id:             input[:cp_id] 
+                      )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Actions
+  module ForemanPipeline
+    module Job
+      class CreateHost < Actions::EntryAction
+        middleware.use ::Actions::Middleware::KeepCurrentUser
+
+        def plan(name, hostgroup, compute_resource, options = {})
+          compute_attributes = hostgroup.compute_profile.compute_attributes
+                                .where(compute_resource_id: compute_resource.id)
+                                .first.vm_attrs
+
+          plan_self name:               name,
+                    hostgroup_id:       hostgroup.id,
+                    compute_attributes: compute_attributes,
+                    options:            options
+          input.update compute_resource_id: compute_resource.id if compute_resource
+        end
+
+        def run
+          hostgroup = Hostgroup.find(input[:hostgroup_id])
+          location = Location.where(:name => "foreman_pipeline").first_or_create
+          location.subnet_ids = (location.subnet_ids + [hostgroup.subnet_id]).uniq
+          location.save!
+          host = ::Host::Managed.new(
+                    name:                 input[:name],
+                    hostgroup:            hostgroup,
+                    build:                true,
+                    managed:              true,
+                    enabled:              true,
+                    environment:          hostgroup.environment,
+                    compute_resource_id:  input.fetch(:compute_resource_id),
+                    compute_attributes:   input[:compute_attributes],
+                    puppet_proxy:         hostgroup.puppet_proxy,
+                    puppet_ca_proxy:      hostgroup.puppet_ca_proxy,
+                    organization_id:      input[:options][:org_id],
+                    location:             location
+                  )
+
+          organization_param
+          keys_param
+
+          host.save!
+          jenkins_pubkey_param_for host
+          host.power.start
+
+          output.update host: { id: host.id,
+                                name: host.name,
+                                ip: host.ip,
+                                mac: host.mac,
+                                params: host.params }
+        end
+
+        private
+
+        def kt_org
+           ::Organization.find(input[:options][:org_id]).name
+        end
+
+        def organization_param
+          org_cp = ::CommonParameter.find_by_name('kt_org')
+          if org_cp.nil?
+            ::CommonParameter.create(:name => 'kt_org', :value => kt_org)
+          else
+            org_cp.update_attributes(:value => kt_org)
+          end
+        end
+
+        def keys_param
+          keys_cp = ::CommonParameter.find_by_name('kt_activation_keys')
+          if keys_cp.nil?
+            ::CommonParameter.create(:name => 'kt_activation_keys', :value => input[:options][:activation_key][:name])
+          else
+            keys_cp.update_attributes(:value => input[:options][:activation_key][:name])
+          end
+        end
+
+        def jenkins_pubkey
+          ::ForemanPipeline::JenkinsInstance.find(input.fetch(:options).fetch(:jenkins_instance_id)).pubkey
+        end
+
+        def jenkins_pubkey_param_for(host)
+          ::HostParameter.create(:name => 'foreman_pipeline_jenkins_pubkey', :value => jenkins_pubkey, :host => host)
+        end
+
+      end
+    end
+  end
+end