hammer_cli_foreman 0.14.0 → 0.15.0

data/lib/hammer_cli_foreman/host.rb

@@ -33,6 +33,7 @@ module HammerCLIForeman
         field nil, _("Host Group"), Fields::SingleReference, :key => :hostgroup, :display_field => 'title'
         field :ip, _("IP")
         field :mac, _("MAC")
+        field :global_status_label, _("Global Status")
       end
 
       build_options :without => [:include, :thin]
@@ -70,6 +71,11 @@ module HammerCLIForeman
         field :installed_at, _("Installed at"), Fields::Date
         field :last_report, _("Last report"), Fields::Date
 
+        label _("Status") do
+          field :global_status_label, _("Global Status")
+          field :build_status_label, _("Build Status")
+        end
+
         label _("Network") do
           field :ip, _("IPv4 address"), Fields::Field, :hide_blank => true
           field :ip6, _("IPv6 address"), Fields::Field, :hide_blank => true
@@ -422,6 +428,21 @@ module HammerCLIForeman
       build_options :without => :power_action
     end
 
+    class ResetCommand < HammerCLIForeman::SingleResourceCommand
+      action :power
+
+      command_name 'reset'
+      desc _('Reset a host')
+      success_message _('Host reset started.')
+      failure_message _('Failed to reset the host')
+
+      def option_power_action
+        :cycle
+      end
+
+      build_options without: [:power_action]
+    end
+
     class SCParamsCommand < HammerCLIForeman::SmartClassParametersList
       build_options_for :hosts
 
@@ -474,11 +495,31 @@ module HammerCLIForeman
       build_options
     end
 
+    class BootCommand < HammerCLIForeman::SingleResourceCommand
+      action :boot
+
+      command_name 'boot'
+      success_message _('The host is booting.')
+      failure_message _('Failed to boot the host from device')
+
+      def execute
+        response = send_request
+        if response['result']
+          output.print_message(success_message)
+          HammerCLI::EX_OK
+        else
+          output.print_error(failure_message)
+          HammerCLI::EX_DATAERR
+        end
+      end
+
+      build_options
+    end
+
     autoload_subcommands
 
     subcommand 'interface', HammerCLIForeman::Interface.desc, HammerCLIForeman::Interface
   end
-
 end
 
 require 'hammer_cli_foreman/compute_resources/all'

data/lib/hammer_cli_foreman/hosts/common_update_options.rb

@@ -72,10 +72,16 @@ module HammerCLIForeman
         end
         params['host']['overwrite'] = option_overwrite unless option_overwrite.nil?
 
-        params['host']['host_parameters_attributes'] = parameter_attributes
+        params['host']['host_parameters_attributes'] = parameter_attributes unless option_parameters.nil?
         params['host']['compute_attributes'] = option_compute_attributes || {}
-        params['host']['compute_attributes']['volumes_attributes'] = nested_attributes(option_volume_list)
-        params['host']['interfaces_attributes'] = interfaces_attributes
+
+        if action == :update
+          params['host']['compute_attributes']['volumes_attributes'] = nested_attributes(option_volume_list) unless option_volume_list.empty?
+          params['host']['interfaces_attributes'] = interfaces_attributes unless option_interface_list.empty?
+        else
+          params['host']['compute_attributes']['volumes_attributes'] = nested_attributes(option_volume_list)
+          params['host']['interfaces_attributes'] = interfaces_attributes
+        end
 
         params['host']['root_pass'] = option_root_password unless option_root_password.nil?
 

data/lib/hammer_cli_foreman/output/fields.rb

@@ -2,25 +2,60 @@ require 'hammer_cli'
 
 module Fields
 
-  class SingleReference < Field
+  class Reference < Field
+    def initialize(options={})
+      super
+      initialize_options
+    end
 
-    def display?(value)
-      id_key = "#{parameters[:key]}_id"
-      display_field = parameters[:display_field] || 'name'
-      display_key = "#{parameters[:key]}_#{display_field}"
+    def initialize_options
+      @options[:details] ||= []
+      @options[:details] = [@options[:details]] unless @options[:details].is_a?(Array)
+      @options[:details] = [id_detail] + @options[:details]
+      @options[:display_field_key] ||= @options[:name_key] || :name
+    end
 
-      (value[display_key.to_sym] || value[display_key]) && (value[id_key.to_sym] || value[id_key])
+    protected
+
+    def id_detail
+      {
+        :label => _('id'),
+        :structured_label => _('Id'),
+        :key => @options[:id_key] || :id,
+        :id => true
+      }
     end
   end
 
-  class Reference < Field
+  class SingleReference < Reference
+    def initialize_options
+      key = @options[:key]
+      display_field = @options[:display_field] || 'name'
+
+      @options[:id_key] ||= "#{key}_id"
+      @options[:display_field_key] ||= "#{key}_#{display_field}"
+      super
+    end
+
+    def display?(value)
+      id_key = @options[:id_key]
+      display_key = @options[:display_field_key]
+
+      (value[display_key.to_sym] || value[display_key]) && (value[id_key.to_sym] || value[id_key])
+    end
   end
 
   class Template < Reference
+    def initialize_options
+      super
+      @options[:details] << template_kind_detail
+    end
 
-    def initialize(options={})
-      options[:details] ||= [:template_kind_name]
-      super(options)
+    def template_kind_detail
+      {
+        :structured_label => _('Kind'),
+        :key => :template_kind_name,
+      }
     end
   end
 

data/lib/hammer_cli_foreman/output/formatters.rb

@@ -1,69 +1,106 @@
 module HammerCLIForeman::Output
   module Formatters
-
-    class SingleReferenceFormatter < HammerCLI::Output::Formatters::FieldFormatter
-
+    class ReferenceFormatter < HammerCLI::Output::Formatters::FieldFormatter
       def tags
         [:flat]
       end
 
-      def format(resource, field_params={})
-        return "" if resource.nil?
-
-        key = field_params[:key]
-        display_field = field_params[:display_field] || 'name'
-
-        id_key = "#{key}_id"
-        display_key = "#{key}_#{display_field}"
-
-        name = resource[display_key.to_sym] || resource[display_key]
-        id = resource[id_key.to_sym] || resource[id_key]
-
+      # Parameters:
+      # :display_field_key - key where the formmatter will look for the main field to display, default is :name
+      # :details - detail fields to be displayed
+      #  example format:
+      #  :details => [
+      #    { :label => _('Type'), :key => :provider_friendly_name, :structured_label => _('Type') },
+      #    { :label => _('Id'), :key => :id }
+      #  ]
+      def format(data, field_params={})
+        return "" if data.nil?
+
+        name = get_value(data, field_params[:display_field_key] || :name)
         context = field_params[:context] || {}
 
-        out = "#{name}"
-        out += " (id: #{id})" if context[:show_ids] && id
-        out
+        details = format_details(data, field_params[:details] || [], context[:show_ids])
+        if details.empty?
+          "#{name}" if name
+        else
+          "#{name} (#{details.join(', ')})" if name
+        end
       end
 
-    end
+      protected
+      def format_details(data, details, show_ids)
+        details = [details] unless details.is_a?(Array)
+
+        details.map do |detail|
+          if detail.is_a?(Hash)
+            next if detail[:id] && !show_ids
+            if detail[:label]
+              "#{detail[:label]}: #{get_value(data, detail[:key])}"
+            else
+              get_value(data, detail[:key])
+            end
+          else
+            get_value(data, detail)
+          end
+        end.compact
+      end
 
-    class ReferenceFormatter < HammerCLI::Output::Formatters::FieldFormatter
+      def get_value(data, key)
+        data[key] || data[key.to_s]
+      end
+    end
 
+    class StructuredReferenceFormatter < HammerCLI::Output::Formatters::FieldFormatter
       def tags
-        [:flat]
+        [:data]
       end
 
-      def format(reference, field_params={})
-        return "" if reference.nil? || reference == ""
-
-        id_key = field_params[:id_key] || :id
-        name_key = field_params[:name_key] || :name
-
-        name = reference[name_key] || reference[name_key.to_s]
-        id = reference[id_key] || reference[id_key.to_s]
-
-        context = field_params[:context] || {}
-
-        details = field_params[:details] || []
-        details = [details] unless details.is_a? Array
-        values = details.collect do |key|
-          reference[key] || reference[key.to_s]
-        end
-        values << "id: #{id}" if context[:show_ids]
-
-        if values.empty?
-          "#{name}" if name
-        else
-          "#{name} (#{values.join(', ')})" if name && !values.empty?
+      # Parameters:
+      # :display_field_key - key where the formmatter will look for the main field to display, default is :name
+      # :details - detail fields to be displayed
+      #  example format:
+      #  :details => [
+      #    { :label => _('Type'), :key => :provider_friendly_name, :structured_label => _('Type') },
+      #    { :label => _('Id'), :key => :id }
+      #  ]
+      def format(data, field_params={})
+        return  {} if data.nil? || data == ""
+
+        display_field_key = field_params[:display_field_key] || :name
+
+        # TODO: hardcoded name
+        formatted = {
+          _('Name') => get_value(data, display_field_key)
+        }
+
+        details = field_params[:details]
+        details = [details] unless details.is_a?(Array)
+
+        details.map do |detail|
+          if detail.is_a?(Hash)
+            label = detail[:structured_label]
+            label = detail[:label].capitalize if !label && detail[:label]
+            if label
+              formatted[label] = get_value(data, detail[:key])
+            end
+          end
         end
+        formatted
       end
 
+      protected
+      def get_value(data, key)
+        data[key] || data[key.to_s]
+      end
     end
 
-    HammerCLI::Output::Output.register_formatter(SingleReferenceFormatter.new, :SingleReference)
+    HammerCLI::Output::Output.register_formatter(ReferenceFormatter.new, :SingleReference)
+    HammerCLI::Output::Output.register_formatter(StructuredReferenceFormatter.new, :SingleReference)
+
     HammerCLI::Output::Output.register_formatter(ReferenceFormatter.new, :Reference)
+    HammerCLI::Output::Output.register_formatter(StructuredReferenceFormatter.new, :Reference)
     HammerCLI::Output::Output.register_formatter(ReferenceFormatter.new, :Template)
-
+    HammerCLI::Output::Output.register_formatter(StructuredReferenceFormatter.new, :Template)
   end
 end
+

data/lib/hammer_cli_foreman/subnet.rb

@@ -1,5 +1,28 @@
 module HammerCLIForeman
 
+   module SubnetUpdateCreateCommons
+
+    def self.included(base)
+      base.option "--dns", "DNS_NAME", _("DNS Proxy to use within this subnet")
+      base.option "--dhcp", "DHCP_NAME", _("DHCP Proxy to use within this subnet")
+      base.option "--tftp", "TFTP_NAME", _("TFTP Proxy to use within this subnet")
+    end
+
+    def request_params
+      params = super
+      params['subnet']["dns_id"] ||= proxy_feature_id(option_dns) if option_dns
+      params['subnet']["dhcp_id"] ||= proxy_feature_id(option_dhcp) if option_dhcp
+      params['subnet']["tftp_id"] ||= proxy_feature_id(option_tftp) if option_tftp
+      params
+    end
+
+    private
+
+    def proxy_feature_id(name)
+      resolver.smart_proxy_id('option_name' => name) if name
+    end
+  end
+
   class Subnet < HammerCLIForeman::Command
 
     resource :subnets
@@ -55,6 +78,7 @@ module HammerCLIForeman
 
 
     class CreateCommand < HammerCLIForeman::CreateCommand
+      include SubnetUpdateCreateCommons
 
       success_message _("Subnet created.")
       failure_message _("Could not create the subnet")
@@ -64,6 +88,7 @@ module HammerCLIForeman
 
 
     class UpdateCommand < HammerCLIForeman::UpdateCommand
+      include SubnetUpdateCreateCommons
 
       success_message _("Subnet updated.")
       failure_message _("Could not update the subnet")

data/lib/hammer_cli_foreman/version.rb

@@ -1,5 +1,5 @@
 module HammerCLIForeman
   def self.version
-    @version ||= Gem::Version.new '0.14.0'
+    @version ||= Gem::Version.new '0.15.0'
   end
 end

data/test/functional/compute_resource_test.rb

@@ -1,6 +1,15 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 describe 'compute-resource' do
+  let(:base_cmd) { ['compute-resource'] }
+  let(:base_params) { ['--id=1'] }
+  let(:compute_resource) do
+    {
+     :id => 1,
+     :name => 'resource'
+    }
+  end
+
   describe 'create' do
     before do
       @cmd = %w(compute-resource create)
@@ -114,4 +123,255 @@ describe 'compute-resource' do
       assert_cmd(success_result("Compute resource created.\n"), result)
     end
   end
+
+  describe 'clusters' do
+    let(:cmd) { base_cmd << 'clusters' }
+    let(:cluster1) { { id: 1, name: 'cluster1' } }
+    let(:cluster2) { { id: 2, name: 'cluster2' } }
+    let(:clusters) { [cluster1, cluster2] }
+
+    it 'lists available clusters for a compute resource' do
+      api_expects(:compute_resources, :available_clusters, 'clusters').with_params(
+        'id' => '1'
+      ).returns(index_response(clusters))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 cluster1],
+          %w[2 cluster2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'networks' do
+    let(:cmd) { base_cmd << 'networks' }
+    let(:network1) { { id: 1, name: 'network1' } }
+    let(:network2) { { id: 2, name: 'network2' } }
+    let(:networks) { [network1, network2] }
+
+    it 'lists available networks for a compute resource' do
+      api_expects(:compute_resources, :available_networks, 'networks').with_params(
+        'id' => '1'
+      ).returns(index_response(networks))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 network1],
+          %w[2 network2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'images' do
+    let(:cmd) { base_cmd << 'images' }
+    let(:image1) { { id: 1, name: 'image1' } }
+    let(:image2) { { id: 2, name: 'image2' } }
+    let(:images) { [image1, image2] }
+
+    it 'lists available images for a compute resource' do
+      api_expects(:compute_resources, :available_images, 'images').with_params(
+        'id' => '1'
+      ).returns(index_response(images))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 image1],
+          %w[2 image2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'flavors' do
+    let(:cmd) { base_cmd << 'flavors' }
+    let(:flavor1) { { id: 1, name: 'flavor1' } }
+    let(:flavor2) { { id: 2, name: 'flavor2' } }
+    let(:flavors) { [flavor1, flavor2] }
+
+    it 'lists available flavors for a compute resource' do
+      api_expects(:compute_resources, :available_flavors, 'flavors').with_params(
+        'id' => '1'
+      ).returns(index_response(flavors))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 flavor1],
+          %w[2 flavor2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'folders' do
+    let(:cmd) { base_cmd << 'folders' }
+    let(:folder1) { { id: 1, name: 'folder1' } }
+    let(:folder2) { { id: 2, name: 'folder2' } }
+    let(:folders) { [folder1, folder2] }
+
+    it 'lists available folders for a compute resource' do
+      api_expects(:compute_resources, :available_folders, 'folders').with_params(
+        'id' => '1'
+      ).returns(index_response(folders))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 folder1],
+          %w[2 folder2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'zones' do
+    let(:cmd) { base_cmd << 'zones' }
+    let(:zone1) { { id: 1, name: 'zone1' } }
+    let(:zone2) { { id: 2, name: 'zone2' } }
+    let(:zones) { [zone1, zone2] }
+
+    it 'lists available zones for a compute resource' do
+      api_expects(:compute_resources, :available_zones, 'zones').with_params(
+        'id' => '1'
+      ).returns(index_response(zones))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 zone1],
+          %w[2 zone2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'resource_pools' do
+    let(:cmd) { base_cmd << 'resource-pools' }
+    let(:params) { base_params + ['--cluster-id=1'] }
+    let(:resource_pool1) { { id: 1, name: 'resource_pool1' } }
+    let(:resource_pool2) { { id: 2, name: 'resource_pool2' } }
+    let(:resource_pools) { [resource_pool1, resource_pool2] }
+
+    it 'lists available resource_pools for a compute resource' do
+      api_expects(:compute_resources, :available_resource_pools, 'resource-pools').with_params(
+        'id' => '1', 'cluster_id' => '1'
+      ).returns(index_response(resource_pools))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 resource_pool1],
+          %w[2 resource_pool2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'storage_domains' do
+    let(:cmd) { base_cmd << 'storage-domains' }
+    let(:storage_domain1) { { id: 1, name: 'storage_domain1' } }
+    let(:storage_domain2) { { id: 2, name: 'storage_domain2' } }
+    let(:storage_domains) { [storage_domain1, storage_domain2] }
+
+    it 'lists available storage_domains for a compute resource' do
+      api_expects(:compute_resources, :available_storage_domains, 'storage-domains').with_params(
+        'id' => '1'
+      ).returns(index_response(storage_domains))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 storage_domain1],
+          %w[2 storage_domain2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'storage_pods' do
+    let(:cmd) { base_cmd << 'storage-pods' }
+    let(:storage_pod1) { { id: 1, name: 'storage_pod1' } }
+    let(:storage_pod2) { { id: 2, name: 'storage_pod2' } }
+    let(:storage_pods) { [storage_pod1, storage_pod2] }
+
+    it 'lists available storage_pods for a compute resource' do
+      api_expects(:compute_resources, :available_storage_pods, 'storage-pods').with_params(
+        'id' => '1'
+      ).returns(index_response(storage_pods))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 storage_pod1],
+          %w[2 storage_pod2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
+
+  describe 'security_groups' do
+    let(:cmd) { base_cmd << 'security-groups' }
+    let(:security_group1) { { id: 1, name: 'security_group1' } }
+    let(:security_group2) { { id: 2, name: 'security_group2' } }
+    let(:security_groups) { [security_group1, security_group2] }
+
+    it 'lists available security_groups for a compute resource' do
+      api_expects(:compute_resources, :available_security_groups, 'security-groups').with_params(
+        'id' => '1'
+      ).returns(index_response(security_groups))
+
+      output = IndexMatcher.new(
+        [
+          %w[ID NAME],
+          %w[1 security_group1],
+          %w[2 security_group2]
+        ]
+      )
+      expected_result = success_result(output)
+
+      result = run_cmd(cmd + base_params)
+      assert_cmd(expected_result, result)
+    end
+  end
 end