hammer_cli_foreman 0.1.1 → 0.1.2

data/lib/hammer_cli_foreman/auth.rb

@@ -45,5 +45,4 @@ module HammerCLIForeman
     autoload_subcommands
   end
 
-  HammerCLI::ShellMainCommand.subcommand 'auth', _("Foreman connection login/logout."), HammerCLIForeman::Auth
 end

data/lib/hammer_cli_foreman/commands.rb

@@ -2,6 +2,10 @@ module HammerCLIForeman
 
   CONNECTION_NAME = 'foreman'
 
+  RESOURCE_NAME_MAPPING = {
+    :usergroup => :user_group
+  }
+
   def self.credentials
     @credentials ||= Credentials.new(
       :username => (HammerCLI::Settings.get(:_params, :username) || ENV['FOREMAN_USERNAME'] || HammerCLI::Settings.get(:foreman, :username)),
@@ -12,11 +16,11 @@ module HammerCLIForeman
 
   def self.resource_config
     config = {}
-    config[:uri] = HammerCLI::Settings.get(:foreman, :host)
+    config[:uri] = HammerCLI::Settings.get(:_params, :host) || HammerCLI::Settings.get(:foreman, :host)
     config[:credentials] = credentials
     config[:logger] = Logging.logger['API']
     config[:api_version] = 2
-    config[:aggressive_cache_checking] = HammerCLI::Settings.get(:foreman, :refresh_cache) || true
+    config[:aggressive_cache_checking] = HammerCLI::Settings.get(:foreman, :refresh_cache) || false
     config[:headers] = { "Accept-Language" => HammerCLI::I18n.locale }
     config[:language] = HammerCLI::I18n.locale
     config[:timeout] = HammerCLI::Settings.get(:foreman, :request_timeout)
@@ -32,8 +36,25 @@ module HammerCLIForeman
     )
   end
 
-  def self.foreman_resource(resource)
-    foreman_api_connection.api.resource(resource)
+  def self.foreman_resource!(resource_name, options={})
+    if options[:singular]
+      resource_name = ApipieBindings::Inflector.pluralize(resource_name.to_s).to_sym
+    else
+      resource_name = resource_name.to_sym
+    end
+    foreman_api_connection.api.resource(resource_name)
+  end
+
+  def self.foreman_resource(resource_name, options={})
+    begin
+      foreman_resource!(resource_name, options)
+    rescue NameError
+      nil
+    end
+  end
+
+  def self.param_to_resource(param_name)
+    HammerCLIForeman.foreman_resource(param_name.gsub(/_id$/, ""), :singular => true)
   end
 
   def self.collection_to_common_format(data)
@@ -77,10 +98,36 @@ module HammerCLIForeman
       self.class.resolver
     end
 
+    def dependency_resolver
+      self.class.dependency_resolver
+    end
+
     def searchables
       self.class.searchables
     end
 
+    def self.create_option_builder
+      configurator = BuilderConfigurator.new(searchables, dependency_resolver)
+
+      builder = ForemanOptionBuilder.new(searchables)
+      builder.builders = []
+      builder.builders += configurator.builders_for(resource, resource.action(action)) if resource_defined?
+      builder.builders += super.builders
+      builder
+    end
+
+    def self.resource_name_mapping
+      HammerCLIForeman::RESOURCE_NAME_MAPPING
+    end
+
+    def self.build_options(builder_params={})
+      builder_params[:resource_mapping] ||= resource_name_mapping
+      builder_params = HammerCLIForeman::BuildParams.new(builder_params)
+      yield(builder_params) if block_given?
+
+      super(builder_params.to_hash, &nil)
+    end
+
     def get_identifier
       @identifier ||= get_resource_id(resource)
       @identifier
@@ -104,6 +151,10 @@ module HammerCLIForeman
       HammerCLIForeman::IdResolver.new(api, HammerCLIForeman::Searchables.new)
     end
 
+    def self.dependency_resolver
+      HammerCLIForeman::DependencyResolver.new
+    end
+
     def self.searchables
       @searchables ||= HammerCLIForeman::Searchables.new
       @searchables
@@ -113,16 +164,33 @@ module HammerCLIForeman
       HammerCLIForeman.record_to_common_format(super)
     end
 
-    def request_params
-      params = super
-      resolver.id_params(resource.action(action)).each do |api_param|
-        param_resource = resolver.param_to_resource(api_param.name)
-        resource_id = get_resource_id(param_resource, :scoped => true, :required => api_param.required?)
-        params[api_param.name] = resource_id if resource_id
+    def customized_options
+      params = options
+      # resolve all '<resource_name>_id' parameters if they are defined as options
+      # (they can be skipped using .without or .expand.except)
+      IdParamsFilter.new(:only_required => false).for_action(resource.action(action)).each do |api_param|
+        param_resource = HammerCLIForeman.param_to_resource(api_param.name)
+        if param_resource && respond_to?(HammerCLI.option_accessor_name("#{param_resource.singular_name}_id"))
+          resource_id = get_resource_id(param_resource, :scoped => true, :required => api_param.required?)
+          params[HammerCLI.option_accessor_name(api_param.name)] = resource_id if resource_id
+        end
       end
+      # resolve 'id' parameter if it's defined as an option
+      id_option_name = HammerCLI.option_accessor_name('id')
+      params[id_option_name] ||= get_identifier if respond_to?(id_option_name)
       params
     end
 
+    def request_params
+      params = customized_options
+      params_pruned = method_options(params)
+
+      # Options defined manualy in commands are removed in method_options.
+      # Manual ids are common so its handling is covered here
+      id_option_name = HammerCLI.option_accessor_name('id')
+      params_pruned['id'] = params[id_option_name] if params[id_option_name]
+      params_pruned
+    end
   end
 
 
@@ -153,7 +221,7 @@ module HammerCLIForeman
 
     def execute
       if respond_to?(:option_page) && respond_to?(:option_per_page)
-        self.option_page ||= 1
+        self.option_page = (self.option_page || 1).to_i
         self.option_per_page ||= HammerCLI::Settings.get(:ui, :per_page) || DEFAULT_PER_PAGE
         browse_collection
       else
@@ -188,68 +256,37 @@ module HammerCLIForeman
       d
     end
 
-    def self.custom_option_builders
-      builders = super
-      if resource_defined?
-        builders += [
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => true, :recursive => true), searchables),
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => false, :recursive => false), searchables)
-        ]
-      end
-      builders
-    end
-
   end
 
 
   class SingleResourceCommand < Command
 
-    def self.custom_option_builders
-      builders = super
-      if resource_defined?
-        builders += [
-          SearchablesOptionBuilder.new(resource, searchables),
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => true, :recursive => true), searchables),
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => false, :recursive => false), searchables)
-        ]
-      end
-      builders
-    end
-
-    def request_params
-      params = super
-      params['id'] ||= get_identifier
-      params
-    end
-
   end
 
 
   class AssociatedResourceListCommand < ListCommand
 
-    option "--id", "ID", " "
-
     def parent_resource
       self.class.parent_resource
     end
 
     def self.parent_resource(name=nil)
-      @parent_api_resource = HammerCLIForeman.foreman_resource(name) unless name.nil?
+      @parent_api_resource = HammerCLIForeman.foreman_resource!(name) unless name.nil?
       return @parent_api_resource if @parent_api_resource
       return superclass.parent_resource if superclass.respond_to? :parent_resource
     end
 
-    def self.custom_option_builders
-      [
-        HammerCLI::Apipie::OptionBuilder.new(resource.action(action), :require_options => false),
-        SearchablesOptionBuilder.new(parent_resource, searchables)
-      ]
+    def self.create_option_builder
+      builder = super
+      builder.builders << SearchablesOptionBuilder.new(parent_resource, searchables)
+      builder.builders << IdOptionBuilder.new(parent_resource)
+      builder
     end
 
     def request_params
       id_param_name = "#{parent_resource.singular_name}_id"
 
-      params = method_options
+      params = super
       params[id_param_name] = get_resource_id(parent_resource)
       params
     end
@@ -290,18 +327,6 @@ module HammerCLIForeman
       super(name) || "create"
     end
 
-    def self.custom_option_builders
-      builders = super
-      if resource_defined?
-        builders += [
-          SearchablesOptionBuilder.new(resource, searchables),
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => true, :recursive => true), searchables),
-          DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => false, :recursive => false), searchables)
-        ]
-      end
-      builders
-    end
-
   end
 
 
@@ -313,14 +338,10 @@ module HammerCLIForeman
       super(name) || "update"
     end
 
-    def self.custom_option_builders
-      builders = super
-      if resource_defined?
-        builders += [
-          SearchablesUpdateOptionBuilder.new(resource, searchables)
-        ]
-      end
-      builders
+    def self.create_option_builder
+      builder = super
+      builder.builders << SearchablesUpdateOptionBuilder.new(resource, searchables) if resource_defined?
+      builder
     end
 
     def method_options_for_params(params, include_nil=true)
@@ -349,17 +370,26 @@ module HammerCLIForeman
 
   class AssociatedCommand < Command
 
-    option "--id", "ID", " "
-
     action :update
 
-    def self.custom_option_builders
-      [
+    def self.create_option_builder
+      configurator = BuilderConfigurator.new(searchables, dependency_resolver)
+
+      builder = ForemanOptionBuilder.new(searchables)
+      builder.builders = [
         SearchablesOptionBuilder.new(resource, searchables),
-        DependentSearchablesOptionBuilder.new(resolver.dependent_resources(resource, :required => true, :recursive => true), searchables),
-        DependentSearchablesOptionBuilder.new(associated_resource, searchables),
-        DependentSearchablesOptionBuilder.new(resolver.dependent_resources(associated_resource, :required => true, :recursive => true), searchables)
+        DependentSearchablesOptionBuilder.new(associated_resource, searchables)
       ]
+
+      resources = []
+      resources += dependency_resolver.resource_dependencies(resource, :only_required => true, :recursive => true)
+      resources += dependency_resolver.resource_dependencies(associated_resource, :only_required => true, :recursive => true)
+      resources.each do |r|
+        builder.builders << DependentSearchablesOptionBuilder.new(r, searchables)
+      end
+      builder.builders << IdOptionBuilder.new(resource)
+
+      builder
     end
 
     def associated_resource
@@ -367,7 +397,7 @@ module HammerCLIForeman
     end
 
     def self.associated_resource(name=nil)
-      @associated_api_resource = HammerCLIForeman.foreman_resource(name) unless name.nil?
+      @associated_api_resource = HammerCLIForeman.foreman_resource!(name) unless name.nil?
       return @associated_api_resource if @associated_api_resource
       return superclass.associated_resource if superclass.respond_to? :associated_resource
     end
@@ -390,7 +420,7 @@ module HammerCLIForeman
     end
 
     def request_params
-      params = method_options
+      params = super
       if params.key?(resource.singular_name)
         params[resource.singular_name] = {"#{association_name}_ids" => get_new_ids }
       else
@@ -414,7 +444,8 @@ module HammerCLIForeman
     end
 
     def self.desc(desc=nil)
-      _("Associate a resource")
+      description = super(desc) || ''
+      description.strip.empty? ? _("Associate a resource") : description
     end
 
     def get_new_ids
@@ -435,7 +466,8 @@ module HammerCLIForeman
     end
 
     def self.desc(desc=nil)
-      _("Disassociate a resource")
+      description = super(desc) || ''
+      description.strip.empty? ? _("Disassociate a resource") : description
     end
 
     def get_new_ids

data/lib/hammer_cli_foreman/common_parameter.rb

@@ -43,9 +43,7 @@ module HammerCLIForeman
       end
 
       def request_params
-        params = method_options
-        params['id'] = option_name
-        params
+        super.update('id' => option_name)
       end
 
     end
@@ -55,6 +53,10 @@ module HammerCLIForeman
       success_message _("Global parameter [%{name}] deleted.")
       failure_message _("Could not delete the global parameter [%{name}]")
 
+      def request_params
+        super.update('id' => option_name)
+      end
+
       build_options :without => :id
     end
 

data/lib/hammer_cli_foreman/compute_resource.rb

@@ -92,6 +92,4 @@ module HammerCLIForeman
 
 end
 
-HammerCLI::MainCommand.subcommand 'compute-resource', _("Manipulate compute resources."), HammerCLIForeman::ComputeResource
-
 

data/lib/hammer_cli_foreman/dependency_resolver.rb

@@ -0,0 +1,32 @@
+module HammerCLIForeman
+
+
+  class DependencyResolver
+
+    def action_dependencies(action, options={})
+      options[:only_required] = (options[:only_required] == true)
+      options[:recursive] = !(options[:recursive] == false)
+
+      resolve_for_action(action, [], options)
+    end
+
+    def resource_dependencies(resource, options={})
+      action_dependencies(resource.action(:index), options)
+    end
+
+    protected
+
+    def resolve_for_action(action, resources_found, options)
+      IdParamsFilter.new(:only_required => options[:only_required]).for_action(action).each do |param|
+        res = HammerCLIForeman.param_to_resource(param.name)
+        if res and !resources_found.map(&:name).include?(res.name)
+          resources_found << res
+          resolve_for_action(res.action(:index), resources_found, options) if options[:recursive]
+        end
+      end
+      resources_found
+    end
+
+  end
+
+end

data/lib/hammer_cli_foreman/domain.rb

@@ -93,5 +93,4 @@ module HammerCLIForeman
 
 end
 
-HammerCLI::MainCommand.subcommand 'domain', _("Manipulate domains."), HammerCLIForeman::Domain
 

data/lib/hammer_cli_foreman/environment.rb

@@ -63,5 +63,3 @@ module HammerCLIForeman
   end
 
 end
-
-HammerCLI::MainCommand.subcommand 'environment', "Manipulate environments.", HammerCLIForeman::Environment

data/lib/hammer_cli_foreman/exception_handler.rb

@@ -72,9 +72,9 @@ module HammerCLIForeman
 
     def handle_apipie_docloading_error(e)
       rake_command = 'foreman-rake apipie:cache'
-      print_error _("Could not load API description from the server\n"\
-          "  - is your server down?\n"\
-          "  - was \"#{rake_command}\" run on the server when using apipie cache? (typical production settings))\n")
+      print_error _("Could not load the API description from the server") + "\n  - " +
+                  _("is the server down?") + "\n  - " +
+                  _("was '%s' run on the server when using apipie cache? (typical production settings)") % rake_command
       log_full_error e
       HammerCLI::EX_CONFIG
     end

data/lib/hammer_cli_foreman/fact.rb

@@ -33,4 +33,4 @@ module HammerCLIForeman
 
 end
 
-HammerCLI::MainCommand.subcommand 'fact', _("Search facts."), HammerCLIForeman::Fact
+

data/lib/hammer_cli_foreman/filter.rb

@@ -0,0 +1,102 @@
+module HammerCLIForeman
+
+  class Filter < HammerCLIForeman::Command
+
+    resource :filters
+
+    class ListCommand < HammerCLIForeman::ListCommand
+      output do
+        field :id, _("Id")
+        field :resource_type, _("Resource type")
+        field :search, _("Search")
+        field :unlimited?, _("Unlimited?"), Fields::Boolean
+        field :role, _("Role"), Fields::Reference
+        field :permissions, _("Permissions"), Fields::List
+      end
+
+      def extend_data(filter)
+        filter['resource_type'] ||= _("(Miscellaneous)")
+        filter['search'] ||= _("none")
+        filter['permissions'] = filter.fetch('permissions', []).collect{|p| p["name"]}
+        filter
+      end
+
+      build_options
+    end
+
+    class InfoCommand < HammerCLIForeman::InfoCommand
+      output ListCommand.output_definition do
+        HammerCLIForeman::References.taxonomies(self)
+        HammerCLIForeman::References.timestamps(self)
+      end
+
+      def extend_data(filter)
+        filter['resource_type'] ||= _("(Miscellaneous)")
+        filter['search'] ||= _("none")
+        filter['permissions'] = filter.fetch('permissions', []).collect{|p| p["name"]}
+        filter
+      end
+
+      build_options
+    end
+
+    class CreateCommand < HammerCLIForeman::CreateCommand
+      success_message _("Permission filter for [%<resource_type>s] created")
+      failure_message _("Could not create the permission filter")
+
+      build_options
+    end
+
+
+    class UpdateCommand < HammerCLIForeman::UpdateCommand
+      success_message _("Permission filter for [%<resource_type>s] updated")
+      failure_message _("Could not update the permission filter")
+
+      build_options
+    end
+
+
+    class DeleteCommand < HammerCLIForeman::DeleteCommand
+      success_message _("Permission filter deleted")
+      failure_message _("Could not delete the permission filter")
+
+      build_options
+    end
+
+
+    class AvailablePermissionsCommand < HammerCLIForeman::ListCommand
+      resource :permissions, :index
+      command_name 'available-permissions'
+
+      output do
+        field :id, _("Id")
+        field :name, _("Name")
+        field :resource_type, _("Resource")
+      end
+
+      def extend_data(filter)
+        filter['resource_type'] ||= _("(Miscellaneous)")
+        filter
+      end
+
+      build_options
+    end
+
+    class AvailableResourcesCommand < HammerCLIForeman::ListCommand
+      resource :permissions, :resource_types
+      command_name 'available-resources'
+
+      output do
+        field :name, _("Name")
+      end
+
+      build_options
+    end
+
+    autoload_subcommands
+  end
+
+end
+
+
+