staypuft 0.3.0 → 0.3.1

data/app/lib/staypuft/seeder.rb

@@ -103,7 +103,9 @@ module Staypuft
         :horizon_ha         => { :name => 'Horizon (HA)', :class => ['quickstack::pacemaker::horizon'] },
         :galera_ha          => { :name => 'Galera (HA)', :class => ['quickstack::pacemaker::galera'] },
         :mysql_ha           => { :name => 'Mysql (HA)', :class => ['quickstack::pacemaker::mysql'] },
-        :neutron_ha         => { :name => 'Neutron (HA)', :class => ['quickstack::pacemaker::neutron'] }
+        :neutron_ha         => { :name => 'Neutron (HA)', :class => ['quickstack::pacemaker::neutron'] },
+        :generic_rhel_7     => { :name => 'Generic RHEL 7', :class => ['quickstack::openstack_common'] },
+        :ceph_osd           => { :name => 'Ceph Storage (OSD) (node)', :class => ['quickstack::openstack_common'] },
     }
 
     # The list of roles is still from astapor
@@ -112,44 +114,94 @@ module Staypuft
     # until we get the real list of roles per layout
     # layout refs below specify layout keys from layouts hash
     ROLES          = [
-        { :name     => 'Controller (Nova)',
-          :class    => 'quickstack::nova_network::controller',
-          :layouts  => [[:non_ha_nova, 1]],
-          :services => [:non_ha_amqp, :mysql, :non_ha_keystone, :nova_controller, :non_ha_glance,
-                        :cinder_controller, :heat, :ceilometer] },
-        { :name     => 'Compute (Nova)',
-          :class    => [],
-          :layouts  => [[:ha_nova, 10], [:non_ha_nova, 10]],
-          :services => [:nova_compute] },
-        { :name     => 'Controller (Neutron)',
-          :class    => 'quickstack::neutron::controller',
-          :layouts  => [[:non_ha_neutron, 1]],
-          :services => [:non_ha_amqp, :mysql, :non_ha_keystone, :neutron_controller, :non_ha_glance,
-                        :cinder_controller, :heat, :ceilometer] },
-        { :name     => 'Compute (Neutron)',
-          :class    => [],
-          :layouts  => [[:ha_neutron, 10], [:non_ha_neutron, 10]],
-          :services => [:neutron_compute] },
-        { :name     => 'Neutron Networker',
-          :class    => [],
-          :layouts  => [[:non_ha_neutron, 3]],
-          :services => [:neutron_networker] },
-        { :name     => 'Cinder Block Storage',
-          :class    => [],
-          :layouts  => [],
-          :services => [:cinder_node] },
-        { :name     => 'Swift Storage Node',
-          :class    => [],
-          :layouts  => [],
-          :services => [:swift] },
-        { :name     => 'HA Controller',
-          :class    => [],
-          :layouts  => [[:ha_nova, 1], [:ha_neutron, 1]],
-          :services => [:ha_controller, :keystone_ha, :load_balancer_ha, :memcached_ha, :qpid_ha,
-                        :glance_ha, :nova_ha, :heat_ha, :cinder_ha, :swift_ha, :horizon_ha, :mysql_ha,
-                        :neutron_ha, :galera_ha] }]
+        { :name          => 'Controller (Nova)',
+          :class         => 'quickstack::nova_network::controller',
+          :layouts       => [[:non_ha_nova, 1]],
+          :services      => [:non_ha_amqp, :mysql, :non_ha_keystone, :nova_controller, :non_ha_glance,
+                             :cinder_controller, :heat, :ceilometer],
+          :orchestration => 'concurrent' },
+        { :name          => 'Compute (Nova)',
+          :class         => [],
+          :layouts       => [[:ha_nova, 10], [:non_ha_nova, 10]],
+          :services      => [:nova_compute],
+          :orchestration => 'leader' },
+        { :name          => 'Controller (Neutron)',
+          :class         => 'quickstack::neutron::controller',
+          :layouts       => [[:non_ha_neutron, 1]],
+          :services      => [:non_ha_amqp, :mysql, :non_ha_keystone, :neutron_controller, :non_ha_glance,
+                             :cinder_controller, :heat, :ceilometer],
+          :orchestration => 'concurrent' },
+        { :name          => 'Compute (Neutron)',
+          :class         => [],
+          :layouts       => [[:ha_neutron, 10], [:non_ha_neutron, 10]],
+          :services      => [:neutron_compute],
+          :orchestration => 'concurrent' },
+        { :name          => 'Neutron Networker',
+          :class         => [],
+          :layouts       => [[:non_ha_neutron, 3]],
+          :services      => [:neutron_networker],
+          :orchestration => 'concurrent' },
+        { :name          => 'Cinder Block Storage',
+          :class         => [],
+          :layouts       => [],
+          :services      => [:cinder_node],
+          :orchestration => 'concurrent' },
+        { :name          => 'Swift Storage Node',
+          :class         => [],
+          :layouts       => [],
+          :services      => [:swift],
+          :orchestration => 'concurrent' },
+        { :name          => 'HA Controller',
+          :class         => [],
+          :layouts       => [[:ha_nova, 1], [:ha_neutron, 1]],
+          :services      => [:ha_controller, :keystone_ha, :load_balancer_ha, :memcached_ha, :qpid_ha,
+                             :glance_ha, :nova_ha, :heat_ha, :cinder_ha, :swift_ha, :horizon_ha, :mysql_ha,
+                             :neutron_ha, :galera_ha],
+          :orchestration => 'concurrent' },
+        { :name          => 'Generic RHEL 7',
+          :class         => '',
+          :layouts       => [[:non_ha_nova, 20],[:non_ha_neutron, 20], [:ha_nova, 20], [:ha_neutron, 20]],
+          :services      => [:generic_rhel_7],
+          :orchestration => 'concurrent' },
+        { :name          => 'Ceph Storage Node (OSD)',
+          :class         => '',
+          :layouts       => [[:non_ha_nova, 20], [:non_ha_neutron, 20], [:ha_nova, 20], [:ha_neutron, 20]],
+          :services      => [:ceph_osd],
+          :orchestration => 'concurrent' },
+      ]
 
     CONTROLLER_ROLES = ROLES.select { |h| h.fetch(:name) =~ /Controller/ }
+    CEPH_ROLES = ROLES.select {|h| h.fetch(:name) =~ /Ceph/ }
+
+    ALL_LAYOUTS = LAYOUTS.keys
+    SUBNET_TYPES = { :pxe             => { :name     => Staypuft::SubnetType::PXE,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :management      => { :name     => Staypuft::SubnetType::MANAGEMENT,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :external        => { :name     => Staypuft::SubnetType::EXTERNAL,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :cluster_mgmt    => { :name     => Staypuft::SubnetType::CLUSTER_MGMT,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :admin_api       => { :name     => Staypuft::SubnetType::ADMIN_API,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :public_api      => { :name     => Staypuft::SubnetType::PUBLIC_API,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :tenant          => { :name     => Staypuft::SubnetType::TENANT,
+                                           :required => true,
+                                           :layouts  => ALL_LAYOUTS},
+                     :storage         => { :name     => Staypuft::SubnetType::STORAGE,
+                                           :required => false,
+                                           :layouts  => ALL_LAYOUTS},
+                     :storage_cluster => { :name     => Staypuft::SubnetType::STORAGE_CLUSTERING,
+                                           :required => false,
+                                           :layouts  => ALL_LAYOUTS}
+    }
 
     def get_host_format(param_name)
       { :string => '<%%= d = @host.deployment; d.ha? ? d.vips.get(:%s) : d.ips.controller_ip %%>' % param_name }
@@ -201,7 +253,7 @@ module Staypuft
       pcmk_fs_manage              = { :string => '<%= @host.deployment.glance.pcmk_fs_manage %>' }
       pcmk_fs_options             = { :string => '<%= @host.deployment.glance.pcmk_fs_options %>' }
       glance_rbd_store_user       = 'images'
-      glance_rbd_store_pool       = 'images' 
+      glance_rbd_store_pool       = 'images'
 
       # Cinder
       volume                      = true
@@ -662,13 +714,15 @@ module Staypuft
 
     def seed_roles
       ROLES.each do |role_hash|
-        role = Staypuft::Role.where(:name => role_hash[:name]).first_or_create!
+        role = Staypuft::Role.where(:name => role_hash[:name]).first_or_initialize
 
         puppet_classes = collect_puppet_classes(Array(role_hash[:class]))
         puppet_classes.each { |pc| apply_astapor_defaults pc }
         role.puppetclasses = puppet_classes
 
         role.description      = role_hash[:description]
+        role.orchestration    = role_hash[:orchestration]
+        role.save!
         old_role_services_arr = role.role_services.to_a
         role_hash[:services].each do |key|
           role_service = role.role_services.where(:service_id => SERVICES[key][:obj].id).first_or_create!
@@ -719,11 +773,31 @@ module Staypuft
       end
     end
 
+    def seed_subnet_types
+      # default subnet types
+      SUBNET_TYPES.each do |key, subnet_type_hash|
+        subnet_type = Staypuft::SubnetType.where(:name => subnet_type_hash[:name]).first_or_initialize
+        subnet_type.is_required = subnet_type_hash[:required]
+        subnet_type.save!
+        old_layout_subnet_types_arr = subnet_type.layout_subnet_types.to_a
+        subnet_type_hash[:layouts].each do |layout|
+          layout_subnet_type              = subnet_type.layout_subnet_types.where(:layout_id => LAYOUTS[layout][:obj].id).first_or_create!
+          old_layout_subnet_types_arr.delete(layout_subnet_type)
+        end
+        # delete any prior mappings that remain
+        old_layout_subnet_types_arr.each do |layout_subnet_type|
+          Rails.logger.warn "destroying old layout_subnet_type for #{layout_subnet_type.layout.name}, #{subnet_type.name}: This should not happen on a clean install"
+          subnet_type.layouts.destroy(layout_subnet_type.layout)
+        end
+      end
+    end
+
     def seed
       seed_layouts
       seed_services
       seed_roles
       seed_functional_dependencies
+      seed_subnet_types
     end
 
     def collect_puppet_classes(puppet_class_names)

data/app/models/staypuft/concerns/host_interface_management.rb

@@ -0,0 +1,28 @@
+module Staypuft
+  module Concerns
+    module HostInterfaceManagement
+      extend ActiveSupport::Concern
+
+      included do
+
+      end
+
+      def clean_vlan_interfaces
+        self.interfaces.virtual.map(&:destroy)
+      end
+
+      def interfaces_identifiers
+        interfaces = [ self.primary_interface ]
+        interfaces += self.respond_to?(:interfaces) ? self.interfaces.where("type <> 'Nic::BMC'").physical.map(&:identifier) : []
+        interfaces
+      end
+
+      def make_all_interfaces_managed
+        self.interfaces.each do |interface|
+          interface.managed = true
+          interface.save!
+        end
+      end
+    end
+  end
+end

data/app/models/staypuft/deployment.rb

@@ -7,12 +7,13 @@ module Staypuft
     STEP_CONFIGURATION = :configuration
     STEP_COMPLETE      = :complete
     STEP_OVERVIEW      = :overview
+    STEP_NETWORKING    = :networking
 
     NEW_NAME_PREFIX = 'uninitialized_'
 
     # supporting import/export
     EXPORT_PARAMS   = [:amqp_provider, :networking, :layout_name, :platform]
-    EXPORT_SERVICES = [:nova, :neutron, :glance, :cinder, :passwords] 
+    EXPORT_SERVICES = [:nova, :neutron, :glance, :cinder, :passwords]
 
     attr_accessible :description, :name, :layout_id, :layout,
                     :amqp_provider, :layout_name, :networking, :platform
@@ -40,11 +41,17 @@ module Staypuft
     has_many :services, :through => :roles
     has_many :hosts, :through => :child_hostgroups
 
+    has_many :subnet_typings, :dependent => :destroy
+    has_many :subnet_types, :through => :subnet_typings
+    has_many :subnets, :through => :subnet_typings
+
     validates :name, :presence => true, :uniqueness => true
 
     validates :layout, :presence => true
     validates :hostgroup, :presence => true
 
+    validate :all_required_subnet_types_associated, :if => Proc.new { |o| o.form_step == STEP_NETWORKING }
+
     after_validation :check_form_complete
     before_save :update_layout
     after_save :update_based_on_settings
@@ -114,6 +121,10 @@ module Staypuft
       ForemanTasks::Lock.locked? self, nil
     end
 
+    def hide_ceph_notification?
+      ceph_hostgroup.hosts.empty?
+    end
+
     # Helper method for getting the in progress foreman task for this
     # deployment.
     def task
@@ -127,7 +138,7 @@ module Staypuft
     end
 
     def progress_summary
-      self.in_progress? ? self.task.humanized[:output] : nil 
+      self.in_progress? ? self.task.humanized[:output] : nil
     end
 
     # Helper method for getting the progress of this deployment
@@ -186,7 +197,8 @@ module Staypuft
 
     class Jail < Safemode::Jail
       allow :amqp_provider, :networking, :layout_name, :platform, :nova_networking?, :neutron_networking?,
-        :nova, :neutron, :glance, :cinder, :passwords, :vips, :ips, :ha?, :non_ha?
+        :nova, :neutron, :glance, :cinder, :passwords, :vips, :ips, :ha?, :non_ha?,
+        :hide_ceph_notification?
     end
 
     # TODO(mtaylor)
@@ -257,6 +269,17 @@ module Staypuft
         first
     end
 
+    def unassigned_subnet_types
+      self.layout.subnet_types - self.subnet_types
+    end
+
+    def ceph_hostgroup
+      Hostgroup.includes(:deployment_role_hostgroup).
+        where(DeploymentRoleHostgroup.table_name => { deployment_id: self,
+                                                      role_id:       Staypuft::Role.cephosd }).
+        first
+    end
+
     private
 
     def update_layout
@@ -269,6 +292,15 @@ module Staypuft
       update_hostgroup_list
     end
 
+    def all_required_subnet_types_associated
+      associated_subnet_types = self.subnet_typings.map(&:subnet_type)
+      missing_required = self.layout.subnet_types.required.select { |t| !associated_subnet_types.include?(t) }
+      unless missing_required.empty?
+        errors.add :base,
+                   _("Some required subnet types are missing association of a subnet. Please drag and drop following types: %s") % missing_required.map(&:name).join(', ')
+      end
+    end
+
     def update_hostgroup_name
       hostgroup.name = self.name
       hostgroup.save!

data/app/models/staypuft/interface_assigner.rb

@@ -0,0 +1,137 @@
+module Staypuft
+  class InterfaceAssigner
+    attr_accessor :deployment, :interface, :subnet, :errors
+
+    def initialize(deployment, interface, subnet)
+      @deployment = deployment
+      if interface.is_a?(Nic::Base)
+        @interface = interface
+      else
+        # interface may be Host::Managed which means primary interface, so we create pseudo-interface object
+        @interface = Nic::Managed.new(
+            :mac => interface.mac,
+            :virtual => false,
+            :identifier => interface.primary_interface,
+            :host => interface,
+            :subnet => interface.subnet)
+      end
+
+      @host = @interface.host
+      @subnet = subnet
+      @errors = []
+    end
+
+    def assign
+      if virtual_assignment?
+        if (existing = conflicting_interface)
+          @errors.push _("Another interface %s on same physical interface with same VLAN exists") % existing.identifier
+          return false
+        end
+        ActiveRecord::Base.transaction do
+          unassign_from_other_nics
+          assign_virtual
+          raise ActiveRecord::Rollback if @errors.present?
+          return true
+        end
+      else
+        if @interface.subnet.present? && @interface.subnet != @subnet
+          @errors.push _("Interface is already assigned to subnet %s") % @interface.subnet.name
+          return false
+        end
+        ActiveRecord::Base.transaction do
+          unassign_from_other_nics
+          assign_physical
+          raise ActiveRecord::Rollback if @errors.present?
+          return true
+        end
+      end
+
+      return false # we can get there only after rollback
+    end
+
+    def unassign
+      base = @host.interfaces
+      base = virtual_assignment? ? base.virtual : base.physical
+      ActiveRecord::Base.transaction do
+        base.where(:subnet_id => @subnet.id).each do |interface|
+          virtual_assignment? ? unassign_virtual(interface) : unassign_physical(interface)
+        end
+        raise ActiveRecord::Rollback if @errors.present?
+      end
+    end
+
+    def virtual_assignment?
+      @subnet.vlanid.present?
+    end
+
+    private
+
+    def assign_virtual
+      interface = Nic::Managed.new(
+          :subnet => @subnet,
+          :physical_device => @interface.identifier,
+          :mac => @interface.mac,
+          :host => @host,
+          :virtual => true,
+          :identifier => @interface.identifier + ".#{@subnet.vlanid}")
+      suggest_ip(interface) if @subnet.ipam?
+      unless interface.save
+        @errors.push(*interface.errors.full_messages)
+      end
+    end
+
+    def assign_physical
+      @interface.subnet = @subnet
+      suggest_ip(@interface) if @subnet.ipam?
+      unless @interface.save
+        @errors.push(*@interface.errors.full_messages)
+      end
+    end
+
+    # we have to be sure that we remove both physical and virtual,
+    # subnet could become virtual/physical meanwhile
+    def unassign_from_other_nics
+      unassign_physicals
+      unassign_virtuals
+    end
+
+    def unassign_physicals
+      @host.interfaces.physical.where(:subnet_id => @subnet.id).each do |interface|
+        unassign_physical(interface)
+      end
+    end
+
+    # if subnet has IP suggesting enabled we also clear the IP that was suggested
+    # this IP will be used for another interface
+    def unassign_physical(interface)
+      interface.ip = nil if interface.subnet.ipam?
+      interface.subnet_id = nil
+      unless interface.save
+        @errors.push(interface.errors.full_messages)
+      end
+    end
+
+    def unassign_virtuals
+      @host.interfaces.virtual.where(:subnet_id => @subnet.id).each do |interface|
+        unassign_virtual(interface)
+      end
+    end
+
+    def unassign_virtual(interface)
+      unless interface.destroy
+        @errors.push _("Interface %s could not be destroyed") % interface.name
+      end
+    end
+
+    def conflicting_interface
+      @host.interfaces.
+          where(:identifier => @interface.identifier + ".#{subnet.vlanid}").
+          where(['id <> ?', @interface.id]).
+          first
+    end
+
+    def suggest_ip(interface)
+      interface.ip = @subnet.unused_ip if interface.ip.blank?
+    end
+  end
+end

data/app/models/staypuft/layout.rb

@@ -5,6 +5,9 @@ module Staypuft
     has_many :layout_roles, :dependent => :destroy, :order => "staypuft_layout_roles.deploy_order ASC"
     has_many :roles, :through => :layout_roles, :order => "staypuft_layout_roles.deploy_order ASC"
 
+    has_many :layout_subnet_types, :dependent => :destroy
+    has_many :subnet_types, :through => :layout_subnet_types
+
     attr_accessible :description, :name, :networking
 
     validates  :name, :presence => true, :uniqueness =>  {:scope => :networking}

data/app/models/staypuft/layout_subnet_type.rb

@@ -0,0 +1,12 @@
+module Staypuft
+  class LayoutSubnetType < ActiveRecord::Base
+    attr_accessible :layout_id, :layout, :subnet_type_id, :subnet_type
+
+    belongs_to :layout
+    belongs_to :subnet_type
+
+    validates :layout, :presence => true
+    validates :subnet_type, :presence => true
+    validates :layout_id, :uniqueness => { :scope => :subnet_type_id }
+  end
+end

data/app/models/staypuft/role.rb

@@ -1,5 +1,16 @@
 module Staypuft
   class Role < ActiveRecord::Base
+    # until we have puppetssh, "run puppet" below means "provision and run puppet"
+
+    # run puppet on all nodes concurrently
+    ORCHESTRATION_CONCURRENT = "concurrent"
+    # run puppet on one node at a time
+    ORCHESTRATION_SERIAL     = "serial"
+    # run puppet on the first mode, then the rest concurrently
+    ORCHESTRATION_LEADER     = "leader"
+
+    ORCHESTRATION_MODES = [ORCHESTRATION_CONCURRENT, ORCHESTRATION_SERIAL, ORCHESTRATION_LEADER]
+
     has_many :layout_roles, :dependent => :destroy
     has_many :layouts, :through => :layout_roles
 
@@ -17,11 +28,15 @@ module Staypuft
 
     validates :name, :presence => true, :uniqueness => true
 
+    validates :orchestration, :inclusion => {:in => ORCHESTRATION_MODES }
+
     scope(:in_deployment, lambda do |deployment|
       joins(:deployment_role_hostgroups).
           where(DeploymentRoleHostgroup.table_name => { deployment_id: deployment })
     end)
 
     scope(:controller, where(name: Seeder::CONTROLLER_ROLES.map { |h| h.fetch(:name) }))
+
+    scope(:cephosd, where(name: Seeder::CEPH_ROLES.map { |h| h.fetch(:name) }))
   end
 end

data/app/models/staypuft/subnet_type.rb

@@ -0,0 +1,27 @@
+module Staypuft
+  class SubnetType < ActiveRecord::Base
+    PXE                = 'Provisioning/PXE'
+
+    MANAGEMENT         = 'Management'
+    EXTERNAL           = 'External'
+    CLUSTER_MGMT       = 'Cluster Management'
+    ADMIN_API          = 'Admin API'
+    PUBLIC_API         = 'Public API'
+    TENANT             = 'Tenant'
+
+    STORAGE            = 'Storage'
+    STORAGE_CLUSTERING = 'Storage Clustering'
+
+    validates :name, :presence => true
+
+    has_many :layout_subnet_types, :dependent => :destroy
+    has_many :layouts, :through => :layout_subnet_types
+
+    attr_accessible :name
+
+    has_many :subnet_typings
+    has_many :subnets, :through => :subnet_typings
+
+    scope :required, lambda { where(:is_required => true) }
+  end
+end

data/app/models/staypuft/subnet_typing.rb

@@ -0,0 +1,11 @@
+module Staypuft
+  class SubnetTyping < ActiveRecord::Base
+    belongs_to :deployment
+    belongs_to :subnet_type
+    belongs_to :subnet
+
+    attr_accessible :subnet_type, :subnet_type_id, :subnet, :subnet_id
+
+    validates :subnet_type_id, :uniqueness => { :scope => :deployment_id }
+  end
+end

data/app/views/staypuft/deployments/_assigned_hosts.html.erb

@@ -5,7 +5,10 @@
     <div class="pull-right top_actions">
       <%= render partial: "hosts_filter" %>
       <div class="pull-right">
-        <%= submit_tag _("Configure Networks"), :class => "btn btn-default btn-sm", :style => "visibility: hidden" %>
+
+        <%= submit_tag _("Configure Networks"), :class => "btn btn-default btn-sm dynamic-submit", :disabled => true,
+                     :'data-submit-to' => deployment_interface_assignments_path(@deployment), :'data-method' => 'GET',
+                     :id => "configure_networks_button"%>
         <%= submit_tag _("Unassign Hosts"), :class => "btn btn-primary btn-sm", :disabled => true, :id => "unassign_hosts_button" %>
       </div>
     </div>
@@ -40,7 +43,7 @@
             </td>
             <td><%= host.cpus %></td>
             <td><%= host.mem %></td>
-            <td><%= host.network_interfaces.join('<br/>') if host.network_interfaces %></td>
+            <td><%= host_nics(host) %></td>
             <td class="hidden-s hidden-xs"><%= host.ip %></td>
           </tr>
         <% end %>

data/app/views/staypuft/deployments/_assigned_hosts_table.html.erb

@@ -1,60 +1,27 @@
 <div class="tab-pane" id="<%= child_hostgroup.name.parameterize.underscore %>_assigned_hosts">
-  <% if child_hostgroup.hosts.present? %>
+  <% if hosts.present? %>
     <%= form_tag(unassign_host_deployment_path(id: deployment), class: 'form-horizontal well association') do |f| %>
-      <h4 class="pull-left"><%= _("Assigned Hosts") %></h4>
-      <button type="button" class="close pull-right" aria-hidden="true">&nbsp;&nbsp;×</button>
-      <%= submit_tag _("Unassign Hosts"), :class => "btn btn-primary btn-sm pull-right" %>
-      <p class="clearfix"></p>
-      <%= hidden_field_tag :hostgroup_id, child_hostgroup.id %>
+
+      <%= render 'hosts_header', :header => _("Assigned Hosts"), :child_hostgroup => child_hostgroup, :assign_text => _("Unassign Hosts") %>
+
       <table class="table table-bordered table-striped table-condensed">
         <thead>
-          <tr>
-            <th class="ca">
-              <%= tag :input, type: 'checkbox', class: 'check_all' %>
-            </th>
-            <th><%= sort :name, :as => _('Name') %></th>
-            <th class="hidden-s hidden-xs"><%= _('Deploying?') %></th>
-            <th class="hidden-s hidden-xs"><%= sort :ip, :as => _('IP Address') %></th>
-          </tr>
+          <%= render 'host_head_row', :deploying_col => true %>
         </thead>
         <tbody>
-          <% child_hostgroup.hosts.each do |host| %>
+          <% hosts.each do |host| %>
             <% disabled = ForemanTasks::Lock.locked?(deployment, nil) && host.open_stack_deployed? %>
-            <tr class="<%= ['checkbox_highlight',
-                            ('deploying' if disabled)
-                           ].compact.join(' ') %>">
-              <td class="ca">
-                <%= check_box_tag 'host_ids[]',
-                                  host.id,
-                                  false,
-                                  id:       "host_ids_#{host.id}",
-                                  disabled: disabled %>
-                <%= hidden_field_tag 'host_ids[]', host.id if disabled %>
-              </td>
-              <td class="ellipsis">
-               <%= host_label(host) %>
-              </td>
-              <td class="hidden-s hidden-xs">
-                <% if disabled %>
-                  <span class="glyphicon glyphicon-cloud-upload"></span>
-                <% else %>
-                  <span class="glyphicon glyphicon-minus"></span>
-                <% end %>
-              </td>
-              <td class="hidden-s hidden-xs"><%= host.ip %></td>
-            </tr>
+            <%= render 'host_row',
+                       :custom_css_class => disabled ? 'deploying' : '',
+                       :disabled => disabled,
+                       :host => host,
+                       :checkbox_value => false %>
           <% end %>
         </tbody>
       </table>
+
     <% end %>
   <% else %>
-    <div class="well association">
-      <button type="button" class="close pull-right" aria-hidden="true">×</button>
-      <h4><%= _("Assigned Hosts") %></h4>
-      <div class="alert alert-warning">
-        <span class="glyphicon glyphicon-warning-sign">&nbsp;</span>
-        <%= _("No hosts were assigned to this group yet.") %>
-      </div>
-    </div>
+    <%= render 'empty_hosts', :header => _("Assigned Hosts"), :message => _("No hosts were assigned to this group yet.") %>
   <% end %>
 </div>