Project

General

Profile

« Previous | Next » 

Revision 7967034d

Added by Brad Buckingham over 10 years ago

Content Views Rework: APIs for available/current content

This commit contains support for several additional APIs
to support the content view rework. This includes:

ContentView - GET puppet_modules & available_puppet_modules
Filter - GET package_groups & available_package_groups
GET errat & available_errata

It also contains a few small fixes for issues found while
working on the new APIs.

View differences:

app/controllers/katello/api/v2/content_views_controller.rb
before_filter :find_content_view, :except => [:index, :create]
before_filter :find_organization, :only => [:index, :create]
before_filter :find_environment, :only => [:index]
before_filter :load_search_service, :only => [:index, :available_puppet_modules]
before_filter :authorize
......
publish_rule = lambda { @view.publishable? }
{
:index => index_rule,
:show => view_rule,
:create => create_rule,
:update => edit_rule,
:publish => publish_rule
:index => index_rule,
:show => view_rule,
:create => create_rule,
:update => edit_rule,
:publish => publish_rule,
:available_puppet_modules => view_rule
}
end
......
respond :resource => @view
end
api :GET, "/content_views/:id/available_puppet_modules",
"Get puppet modules that are available to be added to the content view"
param :id, :identifier, :desc => "content view numeric identifier", :required => true
def available_puppet_modules
current_ids = @view.content_view_puppet_modules.map(&:uuid)
repo_ids = @view.organization.library.puppet_repositories.pluck(:pulp_id)
search_filters = [{ :terms => { :repoids => repo_ids } },
{ :not => { :terms => { :id => current_ids } } }]
options = { :filters => search_filters }
respond_for_index :template => '../puppet_modules/index',
:collection => item_search(PuppetModule, params, options)
end
private
def find_content_view
app/controllers/katello/api/v2/errata_controller.rb
end
before_filter :find_optional_organization, :only => [:show]
before_filter :find_environment, :only => [:index]
before_filter :find_repository, :only => [:index, :show]
before_filter :find_erratum, :only => [:show]
before_filter :require_repo_or_environment, :only => [:index]
before_filter :find_content_view, :only => [:index]
before_filter :find_filter, :only => [:index]
before_filter :authorize
before_filter :find_erratum, :only => [:show]
def rules
env_readable = lambda { @environment.contents_readable? }
readable = lambda do
(@organization && Repository.any_readable?(@organization)) ||
(@repo.environment.contents_readable? && @repo.product.readable?)
(@filter && @filter.content_view.readable?) ||
(@repo && @repo.environment.contents_readable? && @repo.product.readable?)
end
{
:index => env_readable,
:index => readable,
:show => readable,
}
end
api :GET, "/errata", "List errata"
api :GET, "/content_views/:content_view_id/filters/:filter_id/errata", "List errata"
api :GET, "/filters/:filter_id/errata", "List errata"
api :GET, "/repositories/:repository_id/errata", "List errata"
api :GET, "/environments/:environment_id/errata", "List errata"
param :environment_id, :number, :desc => "The environment containing the errata."
param :product_id, :number, :desc => "The product which contains errata."
param :repository_id, :number, :desc => "The repository which contains errata."
param :severity, String, :desc => "Severity of errata. Usually one of: Critical, Important, Moderate, Low. Case insensitive."
param :type, String, :desc => "Type of errata. Usually one of: security, bugfix, enhancement. Case insensitive."
param :content_view_id, :identifier, :desc => "content view identifier"
param :filter_id, :identifier, :desc => "content view filter identifier"
param :repository_id, :number, :desc => "repository identifier", :required => true
def index
filter = params.symbolize_keys.slice(:repository_id, :product_id, :environment_id, :type, :severity)
respond :collection => Errata.filter(filter)
collection = if @repo && !@repo.puppet?
filter_by_repoids [@repo.pulp_id]
elsif @filter
filter_by_errata_id @filter.erratum_rules.map(&:errata_id)
else
filter_by_repoids
end
respond(:collection => collection)
end
api :GET, "/repositories/:repository_id/errata/:id", "Show an erratum"
api :GET, "/errata/:id", "Show an erratum"
param :repository_id, :identifier, :desc => "repository identifier", :required => true
api :GET, "/repositories/:repository_id/errata/:id", "Show an erratum"
param :repository_id, :number, :desc => "repository identifier"
param :id, String, :desc => "erratum identifier", :required => true
def show
respond :resource => @erratum
......
private
def find_environment
if params.key?(:environment_id)
@environment = KTEnvironment.find(params[:environment_id])
fail HttpErrors::NotFound, _("Couldn't find environment '%s'") % params[:environment_id] if @environment.nil?
@environment
def filter_by_errata_id(ids)
options = sort_params
options[:filters] = [:terms => { :errata_id_exact => ids }]
item_search(Errata, params, options)
end
def filter_by_repoids(repoids = [])
options = sort_params
options[:filters] = [{ :terms => { :repoids => repoids } }]
item_search(Errata, params, options)
end
def find_content_view
@view = ContentView.find(params[:content_view_id]) if params[:content_view_id]
end
def find_filter
if @view
@filter = @view.filters.find_by_id(params[:filter_id])
fail HttpErrors::NotFound, _("Couldn't find Filter with id=%s") % params[:filter_id] unless @filter
else
@filter = Filter.find(params[:filter_id]) if params[:filter_id]
end
end
def find_repository
if params.key?(:repository_id)
@repo = Repository.find(params[:repository_id])
fail HttpErrors::NotFound, _("Couldn't find repository '%s'") % params[:repository_id] if @repo.nil?
@environment ||= @repo.environment
@repo
end
@repo = Repository.find(params[:repository_id]) if params[:repository_id]
end
def find_erratum
......
fail HttpErrors::NotFound, _("Erratum '%s' not found within the repository") % params[:id] unless @repo.nil? || @erratum.repoids.include?(@repo.pulp_id)
@erratum
end
def require_repo_or_environment
fail HttpErrors::BadRequest, _("Either repository or environment is required.") % params[:id] if @repo.nil? && @environment.nil?
end
end
end
app/controllers/katello/api/v2/filters_controller.rb
before_filter :find_content_view
before_filter :find_filter, :except => [:index, :create]
before_filter :load_search_service, :only => [:index, :available_errata, :available_package_groups]
before_filter :authorize
wrap_parameters :include => (Filter.attribute_names + %w(repository_ids))
......
view_editable = lambda { @view.editable? }
{
:index => view_readable,
:create => view_editable,
:show => view_readable,
:update => view_editable,
:destroy => view_editable
:index => view_readable,
:create => view_editable,
:show => view_readable,
:update => view_editable,
:destroy => view_editable,
:available_errata => view_readable,
:available_package_groups => view_readable
}
end
......
api :PUT, "/content_views/:content_view_id/filters/:id", "Update a filter"
api :PUT, "/filters/:id", "Update a filter"
param :content_view_id, :identifier, :desc => "content view identifier"
param :id, :identifier, :desc => "filter identifierr", :required => true
param :id, :identifier, :desc => "filter identifier", :required => true
param :name, String, :desc => "new name for the filter"
param :inclusion, :bool, :desc => "specifies if content should be included or excluded, default: inclusion=false"
param :repository_ids, Array, :desc => "list of repository ids"
......
respond :resource => @filter
end
api :GET, "/content_views/:content_view_id/filters/:id/available_errata",
"Get errata that are available to be added to the filter"
api :GET, "/filters/:id/available_errata",
"Get errata that are available to be added to the filter"
param :content_view_id, :identifier, :desc => "content view identifier"
param :id, :identifier, :desc => "filter identifier", :required => true
def available_errata
current_errata_ids = @filter.erratum_rules.map(&:errata_id)
repo_ids = @filter.applicable_repos.pluck(:pulp_id)
search_filters = [{ :terms => { :repoids => repo_ids } },
{ :not => { :terms => { :errata_id_exact => current_errata_ids } } }]
options = { :filters => search_filters }
respond_for_index :template => '../errata/index',
:collection => item_search(Errata, params, options)
end
api :GET, "/content_views/:content_view_id/filters/:id/available_package_groups",
"Get package groups that are available to be added to the filter"
api :GET, "/filters/:id/available_package_groups",
"Get package groups that are available to be added to the filter"
param :content_view_id, :identifier, :desc => "content view identifier"
param :id, :identifier, :desc => "filter identifier", :required => true
def available_package_groups
current_ids = @filter.package_group_rules.map(&:name)
repo_ids = @filter.applicable_repos.pluck(:pulp_id)
search_filters = [{ :terms => { :repo_id => repo_ids } },
{ :not => { :terms => { :name => current_ids } } }]
options = { :filters => search_filters }
respond_for_index :template => '../package_groups/index',
:collection => item_search(PackageGroup, params, options)
end
private
def find_content_view
app/controllers/katello/api/v2/package_groups_controller.rb
class Api::V2::PackageGroupsController < Api::V2::ApiController
before_filter :find_repository
before_filter :find_content_view, :only => [:index]
before_filter :find_filter, :only => [:index]
before_filter :authorize
before_filter :find_package_group, :only => [:show]
def rules
readable = lambda { @repo.environment.contents_readable? && @repo.product.readable? }
readable = lambda do
(@filter && @filter.content_view.readable?) ||
(@repo && @repo.environment.contents_readable? && @repo.product.readable?)
end
{
:index => readable,
:show => readable
:index => readable,
:show => readable
}
end
api :GET, "/package_groups", "List package groups"
api :GET, "/content_views/:content_view_id/filters/:filter_id/package_groups", "List package groups"
api :GET, "/filters/:filter_id/package_groups", "List package groups"
api :GET, "/repositories/:repository_id/package_groups", "List package groups"
param :content_view_id, :identifier, :desc => "content view identifier"
param :filter_id, :identifier, :desc => "content view filter identifier"
param :repository_id, :identifier, :desc => "repository identifier", :required => true
def index
options = sort_params
options[:filters] = [{ :term => { :repo_id => @repo.pulp_id } }]
collection = if @repo && !@repo.puppet?
filter_by_repo_id @repo.pulp_id
elsif @filter
filter_by_name @filter.package_group_rules.map(&:name)
else
filter_by_repo_id
end
@search_service.model = PackageGroup
respond(:collection => item_search(PackageGroup, params, options))
respond(:collection => collection)
end
api :GET, "/package_groups/:id", "Show a package group"
......
private
def filter_by_name(names)
options = sort_params
options[:filters] = [{ :terms => { :name => names } }]
item_search(PackageGroup, params, options)
end
def filter_by_repo_id(repo_id = [])
options = sort_params
options[:filters] = [{ :term => { :repo_id => repo_id } }]
item_search(PackageGroup, params, options)
end
def find_content_view
@view = ContentView.find(params[:content_view_id]) if params[:content_view_id]
end
def find_filter
if @view
@filter = @view.filters.find_by_id(params[:filter_id])
fail HttpErrors::NotFound, _("Couldn't find Filter with id=%s") % params[:filter_id] unless @filter
else
@filter = Filter.find(params[:filter_id]) if params[:filter_id]
end
end
def find_repository
@repo = Repository.find(params[:repository_id]) if params[:repository_id]
end
app/controllers/katello/api/v2/puppet_modules_controller.rb
module Katello
class Api::V2::PuppetModulesController < Api::V2::ApiController
before_filter :find_repository
before_filter :find_content_view, :only => [:index]
before_filter :find_environment, :only => [:index]
before_filter :authorize
before_filter :find_puppet_module, :only => [:show]
def rules
readable = lambda do
(@view && @view.readable?) ||
(@environment && @environment.contents_readable?) ||
(@repo.environment.contents_readable? && @repo.product.readable?)
(@repo && @repo.environment.contents_readable? && @repo.product.readable?)
end
{
......
end
api :GET, "/puppet_modules", "List puppet modules"
api :GET, "/content_views/:content_view_id/puppet_modules", "List puppet modules"
api :GET, "/environments/:environment_id/puppet_modules", "List puppet modules"
api :GET, "/repositories/:repository_id/puppet_modules", "List puppet modules"
param :content_view_id, :identifier, :desc => "content view identifier"
param :environment_id, :identifier, :desc => "environment identifier"
param :repository_id, :identifier, :desc => "repository identifier", :required => true
def index
repoids = if @repo && @repo.puppet?
[@repo.pulp_id]
elsif @environment
@environment.puppet_repositories.map(&:pulp_id)
else
[]
end
collection = if @repo && @repo.puppet?
filter_by_repoids [@repo.pulp_id]
elsif @environment
filter_by_repoids @environment.puppet_repositories.map(&:pulp_id)
elsif @view
filter_by_id @view.content_view_puppet_modules.map(&:uuid)
else
filter_by_repoids
end
options = sort_params
options[:filters] = [{ :terms => { :repoids => repoids } }]
@search_service.model = PuppetModule
respond(:collection => item_search(PuppetModule, params, options))
respond(:collection => collection)
end
api :GET, "/puppet_modules/:id", "Show a puppet module"
......
private
def filter_by_id(ids)
options = sort_params
options[:filters] = [{ :terms => { :id => ids } }]
item_search(PuppetModule, params, options)
end
def filter_by_repoids(repoids = [])
options = sort_params
options[:filters] = [{ :terms => { :repoids => repoids } }]
item_search(PuppetModule, params, options)
end
def find_content_view
@view = ContentView.non_default.find(params[:content_view_id]) if params[:content_view_id]
end
def find_environment
@environment = KTEnvironment.find(params[:environment_id]) if params[:environment_id]
end
app/controllers/katello/api/v2/system_groups_controller.rb
param :system_id, :identifier, :desc => "system identifier"
def index
subscriptions = if @system
index_system
filter_system
elsif @activation_key
index_activation_key
filter_activation_key
else
index_organization
filter_organization
end
respond_for_index(:collection => subscriptions)
......
private
def index_system
def filter_system
filters = [:terms => {:id => @system.system_groups.pluck(:id)}]
options = {
......
item_search(SystemGroup, params, options)
end
def index_activation_key
def filter_activation_key
filters = [:terms => {:id => @activation_key.system_groups.pluck(:id)}]
options = {
......
item_search(SystemGroup, params, options)
end
def index_organization
def filter_organization
filters = [:terms => {:id => SystemGroup.readable(@organization).pluck(:id)}]
filters << {:term => {:name => params[:name].downcase}} if params[:name]
app/models/katello/erratum_filter_rule.rb
serialize :types, Array
validates :errata_id, :uniqueness => { :scope => :filter_id }
validates :errata_id, :uniqueness => { :scope => :filter_id }, :allow_blank => true
validates_with Validators::ErratumFilterRuleValidator
end
end
app/models/katello/filter.rb
repositories.collect{|r| r.product}.uniq
end
def applicable_repos
if self.repositories.blank?
self.content_view.repositories
else
self.repositories
end
end
protected
def validate_repos
app/models/katello/glue/pulp/puppet_module.rb
base.class_eval do
attr_accessor :_storage_path, :tag_list, :description, :license, :author,
:_ns, :project_page, :summary, :source, :dependencies, :version,
:_content_type_id, :checksums, :_id, :types, :name, :repoids
alias_method 'id=', '_id='
alias_method 'id', '_id'
:_content_type_id, :checksums, :id, :types, :name, :repoids
def self.find(id)
attrs = Katello.pulp_server.extensions.puppet_module.find_by_unit_id(id)
......
module InstanceMethods
def initialize(params = {}, options = {})
params['id'] = params.delete('_id')
params['repoids'] = params.delete(:repository_memberships) if params.key?(:repository_memberships)
params.each_pair {|k, v| instance_variable_set("@#{k}", v) unless v.nil? }
end
app/views/katello/api/v2/errata/index.json.rabl
collection @collection
object false
extends 'katello/api/v2/errata/_attributes'
extends "katello/api/v2/common/metadata"
child @collection[:results] => :results do
extends 'katello/api/v2/errata/_attributes'
end
app/views/katello/api/v2/filter_rules/show.json.rabl
extends 'katello/api/v2/common/identifier'
attributes :filter_id
attributes :version, :if => lambda { |rule| rule.respond_to?(:version) && !rule.version.blank? }
attributes :min_version, :if => lambda { |rule| rule.respond_to?(:min_version) && !rule.min_version.blank? }
attributes :max_version, :if => lambda { |rule| rule.respond_to?(:max_version) && !rule.max_version.blank? }
config/routes/api/v2.rb
post :publish
post :promote
post :refresh
get :available_puppet_modules
end
api_resources :puppet_modules, :controller => :content_view_puppet_modules
api_resources :filters
api_resources :content_view_puppet_modules, :controller => :content_view_puppet_modules
api_resources :filters do
member do
get :available_errata
get :available_package_groups
end
api_resources :errata, :only => [:index]
api_resources :package_groups, :only => [:index]
end
api_resources :puppet_modules, :only => [:index]
api_resources :repositories, :only => [:index]
api_resources :content_view_versions, :only => [:index]
end
......
end
end
api_resources :errata, :only => [:index, :show]
# content view filters
api_resources :filters do
api_resources :errata, :only => [:index]
api_resources :package_groups, :only => [:index]
api_resources :rules, :controller => :filter_rules
member do
get :available_errata
get :available_package_groups
end
end
# content view filter rules
......
api_resources :tasks, :only => [:show]
api_resources :about, :only => [:index]
api_resources :errata, :only => [:show]
# api custom information
match '/custom_info/:informable_type/:informable_id' => 'custom_info#create', :via => :post, :as => :create_custom_info
match '/custom_info/:informable_type/:informable_id' => 'custom_info#index', :via => :get, :as => :custom_info
test/controllers/api/v2/content_views_controller_test.rb
put :update, :id => @content_view.id, :name => "new name"
end
end
def test_available_puppet_modules
get :available_puppet_modules, :id => @content_view.id
assert_response :success
assert_template 'katello/api/v2/content_views/../puppet_modules/index'
end
def test_available_puppet_modules_protected
allowed_perms = [@read_permission]
denied_perms = [@no_permission]
assert_protected_action(:available_puppet_modules, allowed_perms, denied_perms) do
get :available_puppet_modules, :id => @content_view.id
end
end
end
end
test/controllers/api/v2/filters_controller_test.rb
delete :destroy, :content_view_id => @filter.content_view_id, :id => @filter.id
end
end
def test_available_errata
@filter = katello_filters(:populated_erratum_filter)
get :available_errata, :content_view_id => @filter.content_view_id, :id => @filter.id
assert_response :success
assert_template 'katello/api/v2/filters/../errata/index'
end
def test_available_errata_protected
@filter = katello_filters(:populated_erratum_filter)
allowed_perms = [@read_permission]
denied_perms = [@no_permission]
assert_protected_action(:available_errata, allowed_perms, denied_perms) do
get :available_errata, :content_view_id => @filter.content_view_id, :id => @filter.id
end
end
def test_available_package_groups
@filter = katello_filters(:populated_package_group_filter)
get :available_package_groups, :content_view_id => @filter.content_view_id, :id => @filter.id
assert_response :success
assert_template 'katello/api/v2/filters/../package_groups/index'
end
def test_available_package_groups_protected
@filter = katello_filters(:populated_package_group_filter)
allowed_perms = [@read_permission]
denied_perms = [@no_permission]
assert_protected_action(:available_package_groups, allowed_perms, denied_perms) do
get :available_package_groups, :content_view_id => @filter.content_view_id, :id => @filter.id
end
end
end
end

Also available in: Unified diff