foreman_pipeline 0.0.1

data/app/assets/javascripts/foreman_pipeline/jobs/views/pln-path-selector.html

@@ -0,0 +1,10 @@
+<div class="path-selector" ng-repeat="path in paths">
+  <ul class="path-list">
+    <li class="path-list-item" ng-repeat="item in path" ng-class="{ 'disabled-item': item.disabled }">
+      <label class="path-list-item-label" ng-disabled="item.disabled" ng-class="{ active: item.selected }" ng-mouseenter="hover" ng-mouseleave="hover = false">
+        <input type="checkbox" ng-model="item.selected" ng-change="itemChanged(item)" ng-disabled="item.disabled"/>
+        {{ item.name }}
+      </label>
+    </li>
+  </ul>
+</div>

data/app/assets/stylesheets/foreman_pipeline/foreman_pipeline.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

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

@@ -0,0 +1,124 @@
+module ForemanPipeline
+  class Api::JenkinsInstancesController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    before_filter :find_jenkins_instance, :only => [:show, :update, :destroy, :check_jenkins, :set_jenkins_user]
+    before_filter :find_organization, :only => [:index, :create]
+    before_filter :load_search_service, :only => [:index]
+
+    def_param_group :jenkins_instance do
+      param :name, String, :desc => N_("Jenkins instance's name")
+      param :url, String, :desc => N_("Jenkins instance's url")
+      param :cert_path, String, :desc => ("Path to the private certificate for passwordless access to jenkins server")
+      param :jenkins_home, String, :desc => ("Location of $JENKINS_HOME")
+    end
+
+    def_param_group :jenkins_instance_id do
+      param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+      param :id, :number, :desc => N_("Jenkins instance identifier"), :required => true
+    end
+
+    api :GET, "/organizations/:organization_id/jenkins_instances", N_("List jenkins instances")
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param :name, String, :desc => N_("Name of the jenkins instance")
+    def index
+      ids = JenkinsInstance.readable.where(:organization_id => @organization.id).pluck(:id)
+      filters = [:terms => {:id => ids}]
+      filters << {:term => {:name => params[:name]}} if params[:name]
+
+      options = {
+        :filters => filters,
+        :load_records? => true
+      }
+
+      respond_for_index(:collection => item_search(JenkinsInstance, params, options))
+    end
+
+    api :POST, "/organizations/:organization_id/jenkins_instances/:id", N_("Create jenkins instance")
+    param_group :jenkins_instance_id
+    param_group :jenkins_instance
+    def create
+      @jenkins_instance = JenkinsInstance.new(jenkins_instance_params)
+      @jenkins_instance.organization = @organization
+
+      rollback = false
+      JenkinsInstance.transaction do
+        @jenkins_instance.save!
+        task = sync_task(::Actions::ForemanPipeline::JenkinsInstance::CreateJenkinsInstanceKeys,
+                      :jenkins_url => jenkins_instance_params[:url],
+                      :cert_path => @jenkins_instance.cert_path,
+                      :jenkins_home => jenkins_instance_params[:jenkins_home])
+
+        @jenkins_instance.pubkey = task.output.fetch(:pubkey)
+        @jenkins_instance.save!
+
+        if task.output.fetch(:status) == 1
+          raise ActiveRecord::Rollback
+          rollback = true
+        end
+      end
+
+      if rollback
+        fail ::Katello::HttpErrors::Conflict, "Could not access Jenkins server, are you sure you set up certificates?"
+      else
+        respond_for_show(:resource => @jenkins_instance)
+      end
+    end
+
+    api :PUT, "/organizations/:organization_id/jenkins_instances/:id", N_("Update jenkins instance")
+    param_group :jenkins_instance_id
+    param_group :jenkins_instance
+    def update
+      @jenkins_instance.update_attributes!(jenkins_instance_params.except(:url).except(:jenkins_home))
+      @jenkins_instance.save!
+
+      respond_for_show(:resource => @jenkins_instance)
+    end
+
+    api :GET, "/organizations/:organization_id/jenkins_instances/:id", N_("Get jenkins_instance by identifier")
+    param_group :jenkins_instance_id
+    def show
+      respond_for_show(:resource => @jenkins_instance)
+    end
+
+    api :DELETE, "/organizations/:organization_id/jenkins_instances/:id", N_("Delete jenkins_instance")
+    param_group :jenkins_instance_id
+    def destroy
+      @jenkins_instance.destroy
+      respond_for_show(:resource => @jenkins_instance)
+    end
+
+    api :GET,  "/organizations/:organization_id/jenkins_instances/:id/check_jenkins", N_("Check jenkins instance reachability")
+    param_group :jenkins_instance_id
+    def check_jenkins
+      task = sync_task(::Actions::ForemanPipeline::Jenkins::GetVersion,
+                         :id => @jenkins_instance.id,
+                         :name => @jenkins_instance.name)
+      @jenkins_instance.server_version = task.output[:version]
+      respond_for_show
+    end
+
+    api :PUT,  "/organizations/:organization_id/jenkins_instances/:id", N_("Set jenkins user")
+    param_group :jenkins_instance_id
+    param :jenkins_user_id, :number, :desc => N_("Jenkins user identifier to be set")
+    def set_jenkins_user
+      @jenkins_instance.jenkins_user = JenkinsUser.find(params[:jenkins_user_id])
+      @jenkins_instance.save!
+      respond_for_show
+    end
+
+    protected
+
+    def find_jenkins_instance
+      @jenkins_instance = JenkinsInstance.find_by_id(params[:id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find Jenkins Instance with id: #{params[:id]}" if @jenkins_instance.nil?
+      @jenkins_instance
+    end
+
+    def jenkins_instance_params
+      params.require(:jenkins_instance).permit(:name, :url, :jenkins_home, :cert_path)
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ForemanPipeline
+  class Api::JenkinsProjectParamsController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    before_filter :find_jenkins_project_param, :only => [:update]
+
+    api :PUT, "/organizations/:organization_id/jenkins_project_params/:id", N_("Update jenkins project param")
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+    param :id, :number, :desc => N_("Jenkins project parameter identifier")
+    param :name, String, :desc => N_("Parameter's name")
+    param :type, ["boolean", "string", "text"], :desc => N_("Parameter's type")
+    param :value, String, :desc => N_("Parameter's value")
+    param :description, String, :desc => N_("Parameter's description")
+    def update
+      @jenkins_project_param.update_attributes!(jenkins_project_param_params)
+      @jenkins_project_param.save!
+      respond_for_show(:resource => @jenkins_project_param)
+    end
+
+    private
+
+    def find_jenkins_project_param
+      @jenkins_project_param = JenkinsProjectParam.find_by_id(params[:id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find Jenkins Project Param with id: #{params[:id]}" if @jenkins_project_param.nil?
+      @jenkins_project_param
+    end
+
+    def jenkins_project_param_params
+      params.require(:jenkins_project_param).permit(:name, :type, :value, :description)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module ForemanPipeline
+  class Api::JenkinsProjectsController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    before_filter :find_jenkins_project, :only => [:show]
+
+    api :GET, "/organizations/:organization_id/jenkins_projects/:id", N_("Get jenkins project by identifier")
+    param :organization_id, :number, :desc => N_("Organization identifier")
+    param :id, :number, :desc => N_("Jenkins project identifier")
+    def show
+      respond_for_show(:resource => @jenkins_project)
+    end
+
+    private
+
+    def find_jenkins_project
+      @jenkins_project = JenkinsProject.find_by_id(params[:id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find Jenkins Project with id: #{params[:id]}" if @jenkins_project.nil?
+      @jenkins_project
+    end
+
+    def jenkins_project_params
+      params.require(:jenkins_project).permit(:name)
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+module ForemanPipeline
+  class Api::JenkinsRequestsController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    before_filter :find_job
+
+    api :GET, "/organizations/:organization_id/jenkins_requests/list"
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+    param :job_id, :number, :desc => N_("Job identifier")
+    param :filter, String, :desc => N_("All jenkins projects with name matching this string will be retrieved")
+    def list
+      fail "filter string not given" if params[:filter].blank?
+      task = async_task(::Actions::ForemanPipeline::Jenkins::List, :job_id => params[:job_id], :filter => params[:filter])
+      respond_for_async(:resource => task)
+    end
+
+    private
+
+    def find_job
+      @job = Job.find_by_id(params[:job_id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find job with id #{params[:job_id]}" if @job.nil?
+      @job
+    end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+module ForemanPipeline
+  class Api::JenkinsUsersController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    before_filter :find_organization, :only => [:create, :index]
+    before_filter :find_jenkins_user, :only => [:show, :destroy, :update]
+
+    def_param_group :jenkins_user_id do
+      param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+      param :id, :number, :desc => N_("Jenkins user identifier"), :required => true
+    end
+
+    def_param_group :jenkins_user do
+      param :name, String, :desc => N_("Jenkins user name")
+      param :token, String, :desc => N_("Jenkins user token")
+    end
+
+    api :GET, "/organizations/:organization_id/jenkins_users", N_("List jenkins users")
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param :name, String, :desc => N_("Name of the jenkins instance")
+    def index
+       ids = JenkinsUser.readable
+            .where(:organization_id => @organization.id)
+            .pluck(:id)
+      filters = [:terms => {:id => ids}]
+      filters << {:term => {:name => params[:name]}} if params[:name]
+
+      options = {
+         :filters => filters,
+         :load_records? => true
+      }
+      respond_for_index(:collection => item_search(JenkinsUser, params, options))
+    end
+
+    api :GET, "/organizations/:organization_id/jenkins_users/:id", N_("Get jenkins user by identifier")
+    param_group :jenkins_user_id
+    def show
+      respond_for_show(:resource => @jenkins_user)
+    end
+
+    api :PUT, "/organizations/:organization_id/jenkins_users/:id", N_("Update jenkins user")
+    param_group :jenkins_user_id
+    param_group :jenkins_user
+    def update
+      if jenkins_user_params[:token].empty? || jenkins_user_params[:token].nil?
+        @jenkins_user.update_attributes!(jenkins_user_params.except(:token).except(:name))
+      else
+        @jenkins_user.update_attributes!(jenkins_user_params.except(:name))
+      end
+      @jenkins_user.save!
+
+      respond_for_show(:resource => @jenkins_user)
+    end
+
+    api :POST, "/organizations/:organization_id/jenkins_users/:id", N_("Update jenkins user")
+    param_group :jenkins_user_id
+    param_group :jenkins_user
+    def create
+      @jenkins_user = JenkinsUser.new(jenkins_user_params)
+      @jenkins_user.organization = @organization
+      @jenkins_user.save!
+
+      respond_for_show(:resource => @jenkins_user)
+    end
+
+    api :DELETE, "/organizations/:organization_id/jenkins_users/:id", N_("Update jenkins user")
+    param_group :jenkins_user_id
+    def destroy
+      @jenkins_user.destroy
+      respond_for_show(:resource => @jenkins_user)
+    end
+
+
+    protected
+
+    def find_jenkins_user
+      @jenkins_user = JenkinsUser.find_by_id(params[:id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find Jenkins User with id #{params[:id]}" if @jenkins_user.nil?
+      @jenkins_user
+    end
+
+    def jenkins_user_params
+      params.require(:jenkins_user).permit(:name, :token)
+    end
+
+  end
+end

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

@@ -0,0 +1,271 @@
+module ForemanPipeline
+  class Api::JobsController < Katello::Api::V2::ApiController
+    respond_to :json
+
+    include Api::Rendering
+
+    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]
+
+    before_filter :load_search_service, :only => [:index]
+
+    def_param_group :job do
+      param :name, String, :desc => N_("Name of the job"), :required => true
+      param :manual_trigger, :bool, :desc => N_("Allow starting job manually"), :required => false
+      param :sync_trigger, :bool, :desc => N_("Allow starting job on successful repo sync"), :required => false
+      param :levelup_trigger, :bool, :desc => N_("Allow starting job on successful content view publish/promote"), :required => false
+      param :promote, :bool, :desc => N_("Allow starting job manually"), :required => false
+    end
+
+    def_param_group :job_id do
+      param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+      param :id, :number, :desc => N_("job identifier"), :required => true
+    end
+
+    api :GET, "/organizations/:organization_id/jobs", N_("List jobs")
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    param :name, String, :desc => N_("Name of the job")
+    def index
+      ids = Job.readable.where(:organization_id => @organization.id).pluck(:id)
+      filters = [:terms => {:id => ids}]
+      filters << {:term => {:name => params[:name]}} if params[:name]
+
+      options = {
+         :filters => filters,
+         :load_records? => true
+      }
+      respond_for_index(:collection => item_search(Job, params, options))
+    end
+
+    api :GET, "/organizations/:organization_id/jobs/:id", N_("Get job by identifier")
+    param_group :job_id
+    def show
+      respond_for_show(:resource => @job)
+    end
+
+    api :POST, "/organizations/:organization_id/jobs/", N_("Create new job")
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+    param_group :job
+    def create
+      @job = Job.new(job_params)
+      @job.organization = @organization
+      @job.save!
+
+      respond_for_show(:resource => @job)
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id", N_("Update job")
+    param_group :job_id
+    param_group :job
+    def update
+      @job.update_attributes!(job_params)
+      @job.save!
+      respond_for_show(:resource => @job)
+    end
+
+    api :DELETE, "/organizations/:organization_id/jobs/:id", N_("Delete job")
+    param_group :job_id
+    def destroy
+      @job.destroy
+      respond_for_show(:resource => @job)
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id/set_content_view", N_("Set content view for job")
+    param_group :job_id
+    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
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id/set_hostgroup", N_("Set hostgroup for job")
+    param_group :job_id
+    param :hostgroup_id, :number, :desc => N_("Hostgroup id which will be set"), :required => true
+    def set_hostgroup
+      @job.hostgroup = Hostgroup.find(params[:hostgroup_id])
+      @job.compute_resource = nil
+      @job.save!
+      respond_for_show
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id/set_jenkins", N_("Set jenkins instance for job")
+    param_group :job_id
+    param :jenkins_instance_id, :number, :desc => N_("Jenkins Instance id which will be set"), :required => true
+    def set_jenkins
+      instance = JenkinsInstance.find(params[:jenkins_instance_id])
+      @job.jenkins_instance = instance
+      @job.save!
+      respond_for_show
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id/set_environment", N_("Set environment for job")
+    param_group :job_id
+    param :environment_id, :number, :desc => N_("Environment id which will be set"), :required => true
+    def set_environment
+      @job.environment = Katello::KTEnvironment.find(params[:environment_id])
+      @job.to_environments = []
+      @job.save!
+      respond_for_show
+    end
+
+    api :PUT, "/organizations/:organization_id/jobs/:id/set_resource", N_("Set compute resource for job")
+    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
+    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
+    end
+
+    api :GET, "/organizations/:organization_id/jobs/:id/available_paths", N_("List environment paths available for a job")
+    param_group :job_id
+    def available_paths
+      available = []
+      paths = []
+      if params[:all_paths]
+        available = @organization.readable_promotion_paths
+        paths = available.inject([]) do |result, path|
+          result << { :environments => [@organization.library] + path }
+        end
+        paths = [{ :environments => [@organization.library] }] if paths.empty?
+      else
+        available = @job.environment.full_paths rescue []
+        paths = available.inject([]) do |result, path|
+          result << { :environments => path }
+        end
+        paths = [{ :environments => [] }] if paths.empty?
+      end
+
+      collection = {
+        :results => paths,
+        :total => paths.size,
+        :subtotal => paths.size
+      }
+
+      respond_for_index(:collection => collection)
+    end
+
+    api :GET, "/organizations/:organization_id/jobs/:id/available_resources", N_("List compute resources available for the job")
+    param_group :job_id
+    def available_resources
+      @compute_resources = @job.available_compute_resources
+      render "api/v2/compute_resources/index"
+    end
+
+    api :GET, "/organizations/:organization_id/jobs/:id/run_job", N_("Start job execution")
+    param_group :job_id
+    def run_job
+      if @job.manual_trigger
+        task = async_task(::Actions::ForemanPipeline::Job::RunJobManually, @job)
+        render :nothing => true
+      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")
+    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}
+      Job.transaction do
+        projects = params[:projects].map do |p|
+          JenkinsProject.create(:name => p, :organization => @organization)
+        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
+          task = sync_task(::Actions::ForemanPipeline::Jenkins::GetBuildParams, :job_id => @job.id, :name => project.name)
+
+          unless task.output[:build_params]
+            raise ActiveRecord::Rollback
+            rollback[:occured] = true
+            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!
+          end
+        end
+      end
+      if rollback[:occured]
+        fail ::Katello::HttpErrors::NotFound, "Could not retrieve build params for Jenkins project: #{rollback[:project_name]}"
+      else
+        respond_for_show
+      end
+    end
+
+    api :GET, "/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)
+      respond_for_show
+    end
+
+    protected
+
+    def find_job
+      @job = Job.find_by_id(params[:id])
+      fail ::Katello::HttpErrors::NotFound, "Could not find job with id #{params[:id]}" if @job.nil?
+      @job
+    end
+
+    def job_params
+      params.require(:job).permit(:name, :manual_trigger, :sync_trigger, :levelup_trigger, :projects, :promote)
+    end
+
+    def format_paths(paths)
+      formated_paths = paths.inject([]) do |result, path|
+        result << { :environments => path }
+      end
+      collection = {
+        :results => formated_paths,
+        :total => formated_paths.size,
+        :subtotal => formated_paths.size
+      }
+      respond_for_index(:collection => collection)
+    end
+
+  end
+end