staypuft 0.4.0 → 0.4.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZGZkOGMwMDYxYjI0ODE2ZGI3NjNhZWRhMzg0MGNjNTUyMDJlMjYwMA==
-  data.tar.gz: !binary |-
-    YzAyMWVlODdjMzI2ZDE0YzM0ZmM3ODcwNjI5YjZhYmE0NTg5ZGU1ZA==
+SHA1:
+  metadata.gz: a03caebb78c982156156e14071fb90cef35627dd
+  data.tar.gz: 96d1b6b7f38b74f6b081d1e061b7a9d7e5dbab89
 SHA512:
-  metadata.gz: !binary |-
-    MWFiNzBiMzk4NzQzYWRmMDZjMWNmNzZlY2ZhMTkzMGZmOTM2YjM1ZTM5ZDk3
-    MDlhZDM0MzM0NTlkOTg3NTFhYzBjNTlmMzhmNGJjNzE5NjZiNjY1OTkyODg0
-    YzljZjM1ZjQ3NDVkYjU3OWEzMzMwN2FkYzcxZmM1NjI1OGEzNTg=
-  data.tar.gz: !binary |-
-    YjljNjI4NWMxM2ZjMGIxNGM4ZDI1YmU1N2U1M2QwZWY4NmUyZjNjZGFhYWZj
-    ZDdmZjFkMmIxNTIwNWFlMmFjNWRhY2U0NTlmYzJjZmNiYzFkODlkYWRiYmI4
-    ZDgzMDk0ODFkOTdhNDNjOGM5YzMwZmZhYzFiMGM1NWNjYWM1MjE=
+  metadata.gz: 213f86077425ac3969d84c220fce82fe6bc941234ea136e8332d594c9bc93c58e440ba919c7be841ae2e4848c598eb4c9c00cd64076471440331ad6d0fed392f
+  data.tar.gz: 114c5a5a5ad09fc049bb8c6504265a8da3a05717acfb6b7fe232b83a4c023b491bc10f3c78e16349fc50372dd1732535a6f6bc267fc507e072fca1890979825e

data/app/assets/javascripts/staypuft/nics_assignment.js

@@ -44,4 +44,39 @@ var nics_assignment = (function() {
       });
     }
   });
+
+  $('#hosts_to_configure').on('show.bs.collapse', function() {
+    $(this).prev('h3[data-toggle="collapse"]').addClass('active');
+  });
+  $('#hosts_to_configure').on('hide.bs.collapse', function() {
+    $(this).prev('h3[data-toggle="collapse"]').removeClass('active');
+  });
+
+  $('.panel-heading > #bonding_mode > ul > li').on('click', function(event) {
+    var dropdown = $($(event.target).parents('ul')[0]).prev();
+    dropdown.prop('disabled', true);
+
+    var to_assign = $('input:checkbox[name=host_ids[]]:checked').map(
+      function() {
+        return $(this).attr('value');
+      }).get().join();
+    /* remove the first if it's the select all */
+    if(to_assign.substr(0, 2) == 'on') {
+      to_assign = to_assign.substr(3);
+    }
+
+    var to_path = $('#bonding_mode').data('path');
+    $.ajax({
+      url: to_path,
+      type: 'PUT',
+      data: {
+        mode: $(event.target).text(),
+        host_ids: to_assign
+      },
+      success: function(data) {
+        dropdown.text($(event.target).text());
+        dropdown.prop('disabled', false);
+      }
+    });
+  });
 });

data/app/assets/javascripts/staypuft/staypuft.js

@@ -93,7 +93,9 @@ $(function () {
   showNeutronVlanRange();
   $("input[name='staypuft_deployment[neutron][network_segmentation]']").change(showNeutronVlanRange);
   function showNeutronVlanRange() {
+    $('#staypuft_deployment_neutron_network_segmentation_vlan').parent().parent().parent().removeClass('col-md-4').addClass('col-md-6')
     if ($('#staypuft_deployment_neutron_network_segmentation_vlan').is(":checked")) {
+      $('#staypuft_deployment_neutron_network_segmentation_vlan').parent().after($('.neutron_tenant_vlan_ranges'));
       $('.neutron_tenant_vlan_ranges').fadeIn(duration);
     }
     else {
@@ -115,7 +117,9 @@ $(function () {
   showGlanceNfsNetworkPath();
   $("input[name='staypuft_deployment[glance][driver_backend]']").change(showGlanceNfsNetworkPath);
   function showGlanceNfsNetworkPath() {
+    $('#staypuft_deployment_glance_driver_backend_nfs').parent().parent().parent().removeClass('col-md-4').addClass('col-md-6')
     if ($('#staypuft_deployment_glance_driver_backend_nfs').is(":checked")) {
+      $('#staypuft_deployment_glance_driver_backend_nfs').parent().after($('.glance_nfs_network_path'));
       $('.glance_nfs_network_path').show();
     }
     else {

data/app/assets/javascripts/staypuft/subnets_assignment.js

@@ -2,6 +2,12 @@ $(function() {
   $("div.subnet-type-pull").draggable({
     revert: 'invalid'
   });
+  
+  $("div.subnet-type-pull").live('dragstart', function( event, ui ) {
+    dropped = $(this);
+    dropped.data.left = ui.originalPosition.left;
+    dropped.data.top = ui.originalPosition.top;
+  });
 
   $("div.subnet-drop-zone").droppable({
     activeClass: "panel-droppable",
@@ -13,14 +19,30 @@ $(function() {
           type: 'POST',
           url: ui.draggable.data('create-url'),
           data: 'subnet_type_id=' + ui.draggable.data('subnet-type-id') + '&subnet_id=' + $(this).data('subnet-id'),
-          dataType: 'script'
+          dataType: 'script',
+          success: function(data, event){
+            if(data.indexOf("error =") > -1){
+              dropped.animate({
+                left: dropped.data.left,
+                top: dropped.data.top
+              }, 1000, 'swing');
+            }
+          }          
         })
       } else {
         $.ajax({
           type: 'PUT',
           url: ui.draggable.data('update-url'),
           data: 'subnet_id=' + $(this).data('subnet-id'),
-          dataType: 'script'
+          dataType: 'script',
+          success: function(data, event){
+            if(data.indexOf("error =") > -1){
+              dropped.animate({
+                left: dropped.data.left,
+                top: dropped.data.top
+              }, 1000, 'swing');
+            }
+          }          
         })
       }
     }
@@ -34,7 +56,15 @@ $(function() {
       $.ajax({
         type: 'DELETE',
         url: ui.draggable.data('delete-url'),
-        dataType: 'script'
+        dataType: 'script',
+        success: function(data, event){
+          if(data.indexOf("error =") > -1){
+            dropped.animate({
+              left: dropped.data.left,
+              top: dropped.data.top
+            }, 1000, 'swing');
+          }
+        }          
       });
     }
   });

data/app/assets/stylesheets/staypuft/staypuft.css.scss

@@ -172,3 +172,34 @@ span.editable, span.editable:hover {
     overflow-y: auto;
   }
 }
+
+h3[data-toggle="collapse"] {
+  cursor: pointer;
+  span.glyphicon:before {
+    transition: all .3s ease 0s;
+    display: inline-block;
+  }
+  &.active span.glyphicon:before {
+    color: $brand-primary;
+    -ms-transform: rotate(180deg); /* IE 9 */
+    -webkit-transform: rotate(180deg); /* Chrome, Safari, Opera */
+    transform: rotate(180deg);
+  }
+}
+
+.inset_form {
+  font-size: 85%;
+  .form-group {
+    margin-bottom: 0;
+    .control-label {
+      text-align: left;
+    }
+    .help-block {
+      margin-bottom: 0;
+    }
+  }
+}
+
+.single_password.inset_form {
+  margin-left: 192px;
+}

data/app/controllers/staypuft/bonds_controller.rb

@@ -0,0 +1,131 @@
+module Staypuft
+  class BondsController < Staypuft::ApplicationController
+    before_filter :find_hosts
+    before_filter :find_bonds, :only => %w(destroy add_slave remove_slave change_mode)
+
+    def create
+      @bonds = []
+      @hosts.each do |host|
+
+        existing = host.interfaces.select { |i| i.is_a?(Nic::Bond) }.map(&:identifier)
+        i = 0
+        while existing.include?("bond#{i}") do
+          i +=1
+        end
+
+        bond = Nic::Bond.new
+        bond.identifier = "bond#{i}"
+        params[:interfaces].each do |interface|
+          bond.add_slave(interface)
+        end
+        bond.mode = 'balance-tlb'
+        bond.bond_options = 'miimon=100'
+        bond.host = host
+        @bonds.push bond
+      end
+
+      ActiveRecord::Base.transaction do
+        results = @bonds.map(&:save)
+        @result = results.all?
+        clear_nic_assignments(params[:interfaces])
+        raise ActiveRecord::Rollback unless @result
+      end
+
+      find_unassigned_subnets
+    end
+
+    def destroy
+      ActiveRecord::Base.transaction do
+        clear_nic_assignments([params[:id]])
+        results = @bonds.map(&:destroy)
+        @result = results.all?
+        raise ActiveRecord::Rollback unless @result
+      end
+
+      find_unassigned_subnets
+    end
+
+    def add_slave
+      @bonds.each { |bond| bond.add_slave(params[:interface]) }
+
+      ActiveRecord::Base.transaction do
+        results = @bonds.map(&:save)
+        @result = results.all?
+        clear_nic_assignments([params[:interface]])
+        raise ActiveRecord::Rollback unless @result
+      end
+
+      find_unassigned_subnets
+    end
+
+    def change_mode
+      @bonds.each { |bond| bond.mode = params[:mode] }
+
+      ActiveRecord::Base.transaction do
+        results = @bonds.map(&:save)
+        @result = results.all?
+        raise ActiveRecord::Rollback unless @result
+      end
+
+      render :nothing => true
+    end
+
+
+    def remove_slave
+      @bonds.each { |bond| bond.remove_slave(params[:interface]) }
+
+      ActiveRecord::Base.transaction do
+        results = @bonds.map(&:save)
+        @result = results.all?
+        clear_nic_assignments(params[:interfaces])
+        raise ActiveRecord::Rollback unless @result
+      end
+    end
+
+    private
+
+    def find_bonds
+      @bonds = @hosts.map do |host|
+        host.interfaces.detect { |i| i.identifier == params[:id] }
+      end
+    end
+
+    def find_hosts
+      @hosts = Host::Managed.where(:id => params[:host_ids]).includes(:interfaces)
+      @host = @hosts.first
+      @interfaces = @host.interfaces.where("type <> 'Nic::BMC'").non_vip.order(:identifier).where(['(virtual = ? OR type = ?)', false, 'Nic::Bond'])
+      @deployment = Deployment.find(params[:deployment_id])
+    end
+
+    def find_unassigned_subnets
+      assigned_subnet_ids = ([@host.subnet_id] + @host.interfaces.non_vip.map(&:subnet_id)).compact.uniq
+      @subnets = @deployment.subnets.where(["#{Subnet.table_name}.id NOT IN (?)", assigned_subnet_ids]).uniq
+    end
+
+    def clear_nic_assignments(interface_identifiers)
+      @hosts.each do |host|
+        interface_identifiers.each do |interface_identifier|
+
+          if host.primary_interface == interface_identifier
+            interface = host
+          else
+            interface = host.interfaces.find_by_identifier(interface_identifier)
+          end
+
+          host.interfaces.where(:attached_to => interface_identifier).map(&:subnet).compact.uniq.each do |virtual_subnet|
+            assigner = InterfaceAssigner.new(@deployment, interface, virtual_subnet)
+            assigner.unassign
+          end
+
+          subnet_typing = Staypuft::SubnetTyping.includes('subnet_type').where(:deployment_id => @deployment, :subnet_id => interface.subnet).first
+          if subnet_typing
+            next if subnet_typing.subnet_type.name == Staypuft::SubnetType::PXE
+
+            assigner = InterfaceAssigner.new(@deployment, interface, interface.subnet)
+            assigner.unassign
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/staypuft/interface_assignments_controller.rb

@@ -6,9 +6,14 @@ module Staypuft
       host_ids = params[:host_ids]
       host_ids = host_ids.split(',') unless host_ids.is_a? Array
       @hosts = Host::Managed.where(:id => host_ids).includes(:interfaces)
-      @subnets = @deployment.subnets.uniq
       @host = @hosts.first
-      @interfaces = @host ? @host.interfaces.where("type <> 'Nic::BMC'").non_vip.order(:identifier).physical : []
+      assigned_subnet_ids = ([@host.subnet_id] + @host.interfaces.non_vip.map(&:subnet_id)).compact.uniq
+      @subnets = @deployment.subnets.where(["#{Subnet.table_name}.id NOT IN (?)", assigned_subnet_ids]).uniq
+      if @host
+        @interfaces = @host.interfaces.where("type <> 'Nic::BMC'").non_vip.order(:identifier).where(['(virtual = ? OR type = ?)', false, 'Nic::Bond'])
+      else
+        @interfaces = []
+      end
 
       errors = {}
       @hosts.each do |host|

data/app/controllers/staypuft/steps_controller.rb

@@ -36,7 +36,7 @@ module Staypuft
         # just a helper for user to have all types preassigned to pxe network
         pxe_network = Subnet.where('dhcp_id IS NOT NULL').first
         if pxe_network
-          @deployment.unassigned_subnet_types.each do |type|
+          @deployment.unassigned_pxe_default_subnet_types.each do |type|
             @deployment.subnet_typings.new(:subnet_id => pxe_network.id, :subnet_type_id => type.id).save
           end
         end

data/app/controllers/staypuft/subnet_typings_controller.rb

@@ -1,31 +1,41 @@
 module Staypuft
   class SubnetTypingsController < ActionController::Base
     def create
+      @errors = {}
       @deployment = Deployment.find(params[:deployment_id])
       @subnet_type = SubnetType.find(params[:subnet_type_id])
       @subnet = Subnet.find(params[:subnet_id])
       check_for_existing_assignments
+      check_for_ip_management
+      check_for_unsharable_subnet_types
       @subnet_typing = @deployment.subnet_typings.new(:subnet_id => @subnet.id, :subnet_type_id => @subnet_type.id)
-      @saved = @subnet_typing.save
+      @saved = @errors.blank? ? @subnet_typing.save : false
     end
 
     def update
+      @errors = {}
       @subnet_typing = SubnetTyping.find(params[:id])
       @deployment = @subnet_typing.deployment
       @subnet_type = @subnet_typing.subnet_type
       @subnet = Subnet.find(params[:subnet_id])
       check_for_existing_assignments
+      check_for_ip_management
+      check_for_unsharable_subnet_types
       @subnet_typing.subnet = @subnet
-      @saved = @subnet_typing.save
+      @saved = @errors.blank? ? @subnet_typing.save : false
     end
 
     def destroy
+      @errors = {}
       @subnet_typing = SubnetTyping.find(params[:id])
       @deployment = @subnet_typing.deployment
       @subnet = @subnet_typing.subnet
       check_for_existing_assignments
       @subnet_type = @subnet_typing.subnet_type
-      @destroyed = @subnet_typing.destroy
+      if @subnet_type.is_required
+        @errors[@subnet_type.name] = ["Network traffic type is required."]
+      end
+      @destroyed = @errors.blank? ? @subnet_typing.destroy : false
     end
 
     private
@@ -38,5 +48,37 @@ module Staypuft
         @warn = _('Some hosts interfaces were already assigned to this subnet, check interface assignment before deploying!')
       end
     end
+
+    def check_for_ip_management
+      if @subnet_type.foreman_managed_ips &&
+        !((@subnet.ipam == Subnet::IPAM_MODES[:dhcp] && @subnet.dhcp_boot_mode?) ||
+          (@subnet.ipam == Subnet::IPAM_MODES[:db] && !@subnet.dhcp_boot_mode?))
+        @errors[@subnet_type.name] = ["Foreman-managed IP addresses are required to associate with subnet."]
+        false
+      else
+        true
+      end
+    end
+
+    def check_for_unsharable_subnet_types
+      # if subnet type is unsharable, make sure nothing else is already assigned here
+      if @subnet_type.dedicated_subnet
+        if @deployment.subnet_typings.where(:subnet_id => @subnet.id).size > 0 
+          @errors[@subnet_type.name] = ["Subnet cannot be shared with other traffic types in this deployment."]
+          false
+        else
+          true
+        end
+      #otherwise make sure there's no existing unsharable type already here
+      else
+        existing_dedicated_types = @deployment.subnet_typings.includes(:subnet_type).where(:subnet_id => @subnet.id, "staypuft_subnet_types.dedicated_subnet" => true)
+        if existing_dedicated_types.size > 0 
+          @errors[existing_dedicated_types.first.subnet_type.name] = ["Subnet cannot be shared with other traffic types in this deployment."]
+          false
+        else
+          true
+        end
+      end
+    end
   end
 end

data/app/lib/staypuft/seeder.rb

@@ -175,33 +175,60 @@ module Staypuft
     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}
+    SUBNET_TYPES = { :pxe             => { :name                    => Staypuft::SubnetType::PXE,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :management      => { :name                    => Staypuft::SubnetType::MANAGEMENT,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :external        => { :name                    => Staypuft::SubnetType::EXTERNAL,
+                                           :required                => true,
+                                           :foreman_managed_ips     => false,
+                                           :default_to_provisioning => false,
+                                           :dedicated_subnet        => true,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :cluster_mgmt    => { :name                    => Staypuft::SubnetType::CLUSTER_MGMT,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :admin_api       => { :name                    => Staypuft::SubnetType::ADMIN_API,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :public_api      => { :name                    => Staypuft::SubnetType::PUBLIC_API,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :tenant          => { :name                    => Staypuft::SubnetType::TENANT,
+                                           :required                => true,
+                                           :foreman_managed_ips     => false,
+                                           :default_to_provisioning => false,
+                                           :dedicated_subnet        => true,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :storage         => { :name                    => Staypuft::SubnetType::STORAGE,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS},
+                     :storage_cluster => { :name                    => Staypuft::SubnetType::STORAGE_CLUSTERING,
+                                           :required                => true,
+                                           :foreman_managed_ips     => true,
+                                           :default_to_provisioning => true,
+                                           :dedicated_subnet        => false,
+                                           :layouts                 => ALL_LAYOUTS}
     }
 
     def get_host_format(param_name, subnet_type_name)
@@ -878,6 +905,9 @@ module Staypuft
       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.foreman_managed_ips = subnet_type_hash[:foreman_managed_ips]
+        subnet_type.default_to_provisioning = subnet_type_hash[:default_to_provisioning]
+        subnet_type.dedicated_subnet = subnet_type_hash[:dedicated_subnet]
         subnet_type.save!
         old_layout_subnet_types_arr = subnet_type.layout_subnet_types.to_a
         subnet_type_hash[:layouts].each do |layout|

data/app/models/staypuft/deployment/glance_service.rb

@@ -24,7 +24,7 @@ module Staypuft
     validates :driver_backend, presence: true, inclusion: { in: lambda {|g| g.backend_types_for_layout } }
 
     module NfsNetworkPath
-      HUMAN       = N_('network path')
+      HUMAN       = N_('Network Path')
       HUMAN_AFTER = NFS_HELP
     end
 

data/app/models/staypuft/deployment/neutron_service.rb

@@ -62,7 +62,7 @@ module Staypuft
         :tenant_iface, :networker_ovs_bridge_mappings, :networker_ovs_bridge_uplinks,
         :compute_ovs_bridge_mappings, :compute_ovs_bridge_uplinks, :ovs_tunnel_types,
         :openvswitch_mechanism?, :l2population_mechanism?, :cisco_nexus_mechanism?,
-        :ml2_mechanisms, :nexuses
+        :ml2_mechanisms, :nexuses, :active?, :compute_cisco_nexus_config
     end
 
     def set_defaults

data/app/models/staypuft/deployment.rb

@@ -273,6 +273,10 @@ module Staypuft
       self.layout.subnet_types - self.subnet_types
     end
 
+    def unassigned_pxe_default_subnet_types
+      self.layout.subnet_types.pxe_defaults - self.subnet_types
+    end
+
     def ceph_hostgroup
       Hostgroup.includes(:deployment_role_hostgroup).
         where(DeploymentRoleHostgroup.table_name => { deployment_id: self,

data/app/models/staypuft/interface_assigner.rb

@@ -9,11 +9,11 @@ module Staypuft
       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)
+                :mac => interface.mac,
+                :virtual => false,
+                :identifier => interface.primary_interface,
+                :host => interface,
+                :subnet => interface.subnet)
       end
 
       @host = @interface.host
@@ -51,7 +51,15 @@ module Staypuft
 
     def unassign
       base = @host.interfaces
-      base = virtual_assignment? ? base.virtual : base.physical
+
+      # we should make sure that we delete from right base, subnet vlan may have changed meanwhile which affects
+      # virtual_assignment? result
+      if @interface.is_a?(Nic::Bond)
+        base = base.virtual # we want to find bond and vlans (both virtual)
+      else
+        base = virtual_assignment? ? base.virtual : base.physical
+      end
+
       ActiveRecord::Base.transaction do
         base.where(:subnet_id => @subnet.id).each do |interface|
           virtual_assignment? ? unassign_virtual(interface) : unassign_physical(interface)
@@ -66,25 +74,30 @@ module Staypuft
 
     private
 
+    def build_new_interface(klass = Nic::Managed)
+      klass.new(
+              :attached_to => @interface.identifier,
+              :mac => @interface.mac,
+              :host => @host,
+              :virtual => true,
+              :identifier => @interface.identifier + ".#{@subnet.vlanid}"
+          )
+    end
+
     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
+      interface = build_new_interface
+      assign_interface(interface)
     end
 
     def assign_physical
-      @interface.subnet = @subnet
-      suggest_ip(@interface) if @subnet.ipam?
-      unless @interface.save
-        @errors.push(*@interface.errors.full_messages)
+      assign_interface(@interface)
+    end
+
+    def assign_interface(interface)
+      interface.subnet = @subnet
+      suggest_ip(interface) if @subnet.ipam?
+      unless interface.save
+        @errors.push(*interface.errors.full_messages)
       end
     end
 
@@ -92,6 +105,7 @@ module Staypuft
     # subnet could become virtual/physical meanwhile
     def unassign_from_other_nics
       unassign_physicals
+      unassign_bonds
       unassign_virtuals
     end
 
@@ -111,8 +125,14 @@ module Staypuft
       end
     end
 
+    def unassign_bonds
+      @host.interfaces.bonds.where(:subnet_id => @subnet.id).each do |interface|
+        unassign_physical(interface)
+      end
+    end
+
     def unassign_virtuals
-      @host.interfaces.virtual.where(:subnet_id => @subnet.id).each do |interface|
+      @host.interfaces.virtual.where('type <> ?', Nic::Bond.to_s).where(:subnet_id => @subnet.id).each do |interface|
         unassign_virtual(interface)
       end
     end

data/app/models/staypuft/subnet_type.rb

@@ -23,6 +23,7 @@ module Staypuft
     has_many :subnets, :through => :subnet_typings
 
     scope :required, lambda { where(:is_required => true) }
+    scope :pxe_defaults, lambda { where(:default_to_provisioning => true) }
 
     class Jail < Safemode::Jail
       allow :layouts, :layout_subnet_types, :name, :subnets, :subnet_typings, :required