foreman_pipeline 0.0.11 → 0.1.0

data/app/controllers/foreman_pipeline/api/jenkins_users_controller.rb

@@ -41,7 +41,7 @@ module ForemanPipeline
     param_group :jenkins_user_id
     param_group :jenkins_user
     def update
-      if jenkins_user_params[:token].empty? || jenkins_user_params[:token].nil?
+      if jenkins_user_params[:token].empty?
         @jenkins_user.update_attributes!(jenkins_user_params.except(:token).except(:name))
       else
         @jenkins_user.update_attributes!(jenkins_user_params.except(:name))

data/app/controllers/foreman_pipeline/api/jobs_controller.rb

@@ -8,10 +8,11 @@ module ForemanPipeline
     before_filter :find_organization, :only => [:create, :index, :add_projects, :available_paths]
 
     before_filter :find_job, :only => [:update, :show, :destroy, :set_content_view,
-                                       :set_hostgroup, :set_resource, :available_resources,
-                                       :set_jenkins, :set_environment, :run_job,
-                                       :add_projects, :remove_projects, :set_to_environments,
-                                       :available_paths]
+                                       :set_hostgroup, :set_resource,
+                                       :set_jenkins, :run_job, :set_environment,
+                                       :add_projects, :remove_projects, :set_to_environments]
+    before_filter(:only => [:available_resources, :available_paths]) { find_job [] }
+    before_filter :job_filter, :only => [:run_job]
 
     def_param_group :job do
       param :name, String, :desc => N_("Name of the job"), :required => true
@@ -30,7 +31,7 @@ module ForemanPipeline
     param :organization_id, :number, :desc => N_("organization identifier"), :required => true
     param :name, String, :desc => N_("Name of the job")
     def index
-      respond_for_index(:collection => scoped_search(index_relation.uniq, params[:sort_by], params[:sort_order]))
+      respond_for_index(:collection => scoped_search(index_relation.uniq, params[:sort_by], params[:sort_order], :includes => job_includes))
     end
 
     def index_relation
@@ -81,7 +82,6 @@ module ForemanPipeline
     param :content_view_id, :number, :desc => N_("Content view id which will be set"), :required => true
     def set_content_view
       cv = Katello::ContentView.find(params[:content_view_id])
-      fail Katello::HttpErrors::Conflict, "Only non-composite views are accepted" if cv.composite?
       @job.content_view = cv
       @job.save!
       respond_for_show
@@ -121,31 +121,18 @@ module ForemanPipeline
     param_group :job_id
     param :resource_id, :number, :desc => N_("Compute resource id which will be set"), :required => true
     def set_resource
-      if @job.available_compute_resources.map(&:id).include? params[:resource_id]
-        @job.compute_resource = ComputeResource.find(params[:resource_id])
-        @job.save!
-        respond_for_show
-      else
-        fail Katello::HttpErrors::Conflict, "Only a Compute Resource configured for Job's Hostgroup may be set."
-      end
+      @job.compute_resource = ComputeResource.find(params[:resource_id])
+      @job.save!
+      respond_for_show
     end
 
     api :PUT, "/organizations/:organization_id/jobs/:id/set_to_environments", N_("Set 'to environments' for the job")
     param_group :job_id
     param :path_ids, Array, :desc => N_("Identifiers of environments which are successors of job's environment")
     def set_to_environments
-      fail Katello::HttpErrors::Conflict, "Job's environment must be assigned before setting 'to environments'." if @job.environment.nil?
-      fail Katello::HttpErrors::Conflict, "Job's environment does not have any successors" if @job.environment.successors.empty?
-      is_ok = params[:to_environment_ids].map do |new_id|
-        @job.environment.successors.map(&:id).include? new_id
-      end.all?
-      if is_ok
-        @job.to_environment_ids = params[:to_environment_ids]
-        @job.save!
-        respond_for_show
-      else
-        fail Katello::HttpErrors::Conflict, "Only environments that are direct successors of Job's Environment may be set as 'to environments'."
-      end
+      @job.to_environment_ids = params[:to_environment_ids]
+      @job.save!
+      respond_for_show
     end
 
     api :GET, "/organizations/:organization_id/jobs/:id/available_paths", N_("List environment paths available for a job")
@@ -187,28 +174,29 @@ module ForemanPipeline
     param_group :job_id
     def run_job
       if @job.manual_trigger
-        task = async_task(::Actions::ForemanPipeline::Job::RunJobManually, @job)
-        render :nothing => true
+        if @filter.allow_run_for? @job
+          task = async_task(::Actions::ForemanPipeline::Job::RunJobManually, @job)
+          render :nothing => true
+        else
+          fail ::Katello::HttpErrors::Forbidden, "Job cannot be allowed to run, check your configuration"
+        end
       else
         fail ::Katello::HttpErrors::Forbidden, "Running manually not allowed for Job: #{@job.name}. Try setting it's :manual_trigger property."
       end
     end
 
-    api :GET, "/organizations/:organization_id/jobs/:id/add_projects", N_("Add jenkins projects to the job")
+    api :PUT, "/organizations/:organization_id/jobs/:id/add_projects", N_("Add jenkins projects to the job")
     param_group :job_id
     param :projects, Array, :desc => N_("Names of the jenkins projects to be added to the job")
     def add_projects
-      rollback = {:occured => false}
+      rollback = { :occured => false }
       Job.transaction do
-        projects = params[:projects].map do |p|
-          JenkinsProject.create(:name => p, :organization_id => @organization.id)
+        names = params[:projects].delete_if { |name| @job.jenkins_projects.map(&:name).include? name }
+        projects = names.map do |name|
+          JenkinsProject.create(:name => name, :organization_id => @organization.id, :job_id => @job.id)
         end
-        projects_to_add = projects.delete_if { |p| @job.jenkins_projects.include? p }
-        @job.jenkins_projects = @job.jenkins_projects + projects_to_add
-        @job.save!
 
-        projects_to_add.each do |project|
-          project.reload
+        projects.each do |project|
           task = sync_task(::Actions::ForemanPipeline::Jenkins::GetBuildParams, :job_id => @job.id, :name => project.name)
 
           unless task.output[:build_params]
@@ -217,13 +205,12 @@ module ForemanPipeline
             rollback[:project_name] = project.name
           end
           task.output[:build_params].each do |param|
-            new_param = JenkinsProjectParam.new(:name => param[:name],
-                                                :type => param[:type],
-                                                :description => param[:description],
-                                                :value => param[:default])
-            new_param.organization = @organization
-            new_param.jenkins_project = project
-            new_param.save!
+            JenkinsProjectParam.create(:name => param[:name],
+                                       :type => param[:type],
+                                       :description => param[:description],
+                                       :value => param[:default],
+                                       :organization => @organization,
+                                       :jenkins_project => project)
           end
         end
       end
@@ -234,20 +221,25 @@ module ForemanPipeline
       end
     end
 
-    api :GET, "/organizations/:organization_id/jobs/:id/remove_projects", N_("Remove jenkins projects from the job")
+    api :PUT, "/organizations/:organization_id/jobs/:id/remove_projects", N_("Remove jenkins projects from the job")
     param_group :job_id
     param :projects, Array, :desc => N_("Identifiers of the projects to be removed from the job")
     def remove_projects
       ids = params[:project_ids]
-      jj_projects = JobJenkinsProject.where(:jenkins_project_id => ids)
-      jj_projects.map(&:destroy)
+      projects = JenkinsProject.where(:id => ids)
+      projects.map(&:destroy)
       respond_for_show
     end
 
     protected
 
-    def find_job
-      @job = Job.find_by_id(params[:id])
+    def job_includes
+      [:content_view, :hostgroup, :compute_resource, :jenkins_instance, :to_environments, :environment => [:successors],
+        :jenkins_projects => [:jenkins_project_params]]
+    end
+
+    def find_job(find_includes = job_includes)
+      @job = Job.includes(find_includes).where(:id => params[:id]).first
       fail ::Katello::HttpErrors::NotFound, "Could not find job with id #{params[:id]}" if @job.nil?
       @job
     end
@@ -256,6 +248,10 @@ module ForemanPipeline
       params.require(:job).permit(:name, :manual_trigger, :sync_trigger, :levelup_trigger, :projects, :promote)
     end
 
+    def job_filter
+      @filter ||= ForemanPipeline::JobFilter.new
+    end
+
     def format_paths(paths)
       formated_paths = paths.inject([]) do |result, path|
         result << { :environments => path }

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

@@ -5,10 +5,12 @@ module Actions
       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)
+          timeout = job.jenkins_instance.timeout_sec
           output[:project_name] = jenkins_project.name
           output[:build_params] = params
+          output[:build_num] = job.jenkins_instance.client.job.build(jenkins_project.name, params, 'build_start_timeout' => timeout)
+        rescue => e
+          fail "Jenkins build for #{jenkins_project.name} failed to start in a timely manner."
         end
 
         def params
@@ -17,6 +19,10 @@ module Actions
           template_binding project_params
         end
 
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
         def template_binding(project_params)
           host = input[:data][:host]
           activation_key = input[:data][:activation_key]
@@ -32,4 +38,4 @@ module Actions
       end
     end
   end
-end
+end

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

@@ -16,6 +16,8 @@ module Actions
 
         def run
           output[:status] = input[:build_status]
+          output[:name] = input[:name]
+          fail "Build on Jenkins failed for #{output[:name]}" unless output[:build_status] == "SUCCESS"
         end
 
         def rescue_strategy_for_self

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

@@ -17,6 +17,10 @@ module Actions
             trigger(BuildProject, input[:opts].merge({:project_id => project.id, :project_name => project.name}))
           end
         end
+
+        def check_for_errors!
+          # Do nothing. Just wait for all builds to finish and gather results
+        end
       end
     end
   end

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

@@ -6,6 +6,10 @@ module Actions
           output[:projects] = job.jenkins_instance.client.job.list input[:filter]
         end
 
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
+
         def humanized_name
           "List projects in Jenkins Instance: %s" % job.jenkins_instance.name
         end

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

@@ -15,7 +15,7 @@ module Actions
           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|
+          Net::SSH.start(ip, 'root', :keys => [input.fetch(:cert_path)], :non_interactive => true) 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"

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

@@ -36,7 +36,7 @@ module Actions
 
           organization_param
           keys_param
-
+          host.apply_compute_profile(InterfaceMerge.new)
           host.save!
           jenkins_pubkey_param_for host
           host.power.start
@@ -77,7 +77,7 @@ module Actions
         end
 
         def jenkins_pubkey_param_for(host)
-          ::HostParameter.create(:name => 'foreman_pipeline_jenkins_pubkey', :value => jenkins_pubkey, :reference_id => host.id)
+          ::HostParameter.create(:name => 'pipeline_jenkins_pubkey', :value => jenkins_pubkey, :reference_id => host.id)
         end
       end
     end

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

@@ -8,9 +8,7 @@ module Actions
         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.not_yet_promoted? }
+          allowed_jobs = filter.allowed_jobs_for_cvv version
 
           plan_self(:trigger => trigger.output,
                     :job_ids => allowed_jobs.map(&:id),

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

@@ -8,9 +8,7 @@ module Actions
         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.not_yet_promoted? }
+          allowed_jobs = filter.allowed_jobs_for_cv content_view
 
           plan_self(:trigger => trigger.output,
                     :job_ids => allowed_jobs.map(&:id),

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

@@ -5,15 +5,16 @@ module Actions
         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 filter
+          @filter ||= ::ForemanPipeline::JobFilter.new
+        end
+
         def rescue_strategy_for_self
           Dynflow::Action::Rescue::Skip
         end

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

@@ -8,24 +8,11 @@ module Actions
         end
 
         def plan(repo)
-          valid_jobs = repo.jobs.select { |job| job.is_valid? }
+          allowed_jobs = filter.allowed_jobs_for_repo repo
 
-          jobs_to_run = valid_jobs.select { |job| job.target_cv_version_avail? }
-          allowed_jobs = jobs_to_run.select { |job| job.sync_trigger && job.not_yet_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
+          plan_self(:trigger => trigger.output,
+                    :job_ids => allowed_jobs.map(&:id),
+                    :job_names => allowed_jobs.map(&:name))
         end
       end
     end

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

@@ -4,21 +4,12 @@ module Actions
       class RunJobManually < Actions::EntryAction
 
         def plan(job)
-          if job.is_valid? && job.target_cv_version_avail? && job.not_yet_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, :fail => true)
-          end
+          plan_action(DeployNewHost, job)
+          plan_self(:info => "Manually triggered job started.", :name => job.name)
         end
 
         def run
           output = input
-          fail input[:info] if input[:fail]
-        end
-
-        def rescue_strategy_for_self
-          Dynflow::Action::Rescue::Skip
         end
 
         def humanized_name

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

@@ -34,8 +34,11 @@ module Actions
         end
 
         def build_status(host = nil)
+          info = "Cannot find host by id" if host.nil?
+          info = "Host not yet created, no reports received" if !host.nil? && host.reports.count < 1
+          info = "Host has invalid configuration" if !host.nil? && (host.reports.count > 1) && host.reports.last.error?
           status = (!host.nil? && (host.reports.count > 1) && !host.reports.last.error?)
-          { :build => status }
+          { :build => status, :info => info }
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Actions
         require 'uri'
 
         def jenkins_hostname(job)
-          URI(job.jenkins_instance.url).host  
+          URI(job.jenkins_instance.url).host
         end
       end
     end

data/app/models/foreman_pipeline/jenkins_instance.rb

@@ -8,8 +8,6 @@ module ForemanPipeline
     include Katello::Glue
     include ForemanPipeline::Authorization::JenkinsInstance
 
-    attr_accessible :name, :url, :organization_id, :pubkey, :jenkins_home, :cert_path, :jenkins_user_id
-
     belongs_to :organization
     has_many :jobs, :class_name => "ForemanPipeline::Job", :dependent => :nullify
     belongs_to :jenkins_user, :class_name => "ForemanPipeline::JenkinsUser"
@@ -17,8 +15,9 @@ module ForemanPipeline
     FILEPATH_REGEX = /\A(\/|~)[a-z0-9\-_.\/]*[^\/]\z/i
 
     validates :name, :presence => true
-    validates :cert_path, :format => {:with => FILEPATH_REGEX }
-    validates :url, :uniqueness => true, :format => { :with => /\A(http|https):\/\/\S+:\d{1,4}\z/}
+    validates :timeout, :numericality => { :only_integer => true, :greater_than_or_equal_to => 0 }
+    validates :cert_path, :format => { :with => FILEPATH_REGEX }
+    validates :url, :uniqueness => true, :format => { :with => /\A(http|https):\/\/\S+:\d{1,4}\z/ }
     validates :organization, :presence => true
     validates :jenkins_home, :format => { :with => FILEPATH_REGEX }
 
@@ -37,6 +36,10 @@ module ForemanPipeline
       @client
     end
 
+    def timeout_sec
+      timeout * 60
+    end
+
     private
 
     def authenticated_client(username, password, hash_args)
@@ -49,6 +52,5 @@ module ForemanPipeline
       return JenkinsApi::Client.new(hash_args) if username.nil?
       authenticated_client username, password, hash_args
     end
-
   end
-end
+end

data/app/models/foreman_pipeline/jenkins_project.rb

@@ -7,11 +7,9 @@ module ForemanPipeline
 
     belongs_to :organization
 
-    attr_accessible :name, :organization_id
-
-    has_many :job_jenkins_projects, :dependent => :destroy
-    has_many :jobs, :through => :job_jenkins_projects, :class_name => 'ForemanPipeline::Job'
+    validates :name, :presence => true, :uniqueness => true
 
+    belongs_to :job, :class_name => 'ForemanPipeline::Job', :inverse_of => :jenkins_projects
     has_many :jenkins_project_params, :class_name => 'ForemanPipeline::JenkinsProjectParam', :dependent => :destroy
 
     accepts_nested_attributes_for :jenkins_project_params