staypuft 0.1.5 → 0.1.6

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

@@ -3,16 +3,43 @@ module Staypuft
     module HostOpenStackAffiliation
       extend ActiveSupport::Concern
 
+      included do
+        scope(:in_deployment, lambda do |deployment|
+          joins(hostgroup: :deployment_role_hostgroup).
+              where(DeploymentRoleHostgroup.table_name => { deployment_id: deployment })
+        end)
+
+        scope(:in_roles, lambda do |*roles|
+          joins(hostgroup: :deployment_role_hostgroup).
+              where(DeploymentRoleHostgroup.table_name => { role_id: roles })
+        end)
+
+        scope :in_role, lambda { |role| in_roles(role) }
+
+        has_one :deployment, through: :hostgroup
+      end
+
+
       def open_stack_deployed?
+        !deployment.nil? && !deployment.in_progress? &&
+        open_stack_environment_set? && open_stack_assigned?
+      end
+
+      def open_stack_environment_set?
         open_stack_assigned? &&
-            respond_to?(:environment) &&
-            environment != Environment.get_discovery
+        respond_to?(:environment) &&
+        environment != Environment.get_discovery
       end
 
       def open_stack_assigned?
         respond_to?(:hostgroup) &&
             hostgroup.try(:parent).try(:parent) == Hostgroup.get_base_hostgroup
       end
+
+      def open_stack_unassign
+        self.hostgroup = nil
+        save!
+      end
     end
   end
 end

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

@@ -48,9 +48,34 @@ module Staypuft::Concerns::HostgroupExtensions
     end
   end
 
-  def own_and_free_hosts
-    # TODO update to Discovered only?
-    Host::Base.where('hostgroup_id = ? OR hostgroup_id IS NULL', id)
+  def free_hosts
+    Host::Base.where('hostgroup_id IS NULL')
+  end
+
+  # Returns all hosts associated with this hostgroup with the openstack
+  # deployment environment set.  These can be filtered based by setting
+  # errors=true or errors=false to return only the hosts  with no errors or
+  # with errors respectively.
+  def openstack_hosts(errors=nil)
+    oshosts = hosts.select { |h| h.open_stack_environment_set? }
+
+    unless errors.nil?
+      oshosts.select! { |h| (!errors ^ h.error?) }
+    end
+    oshosts
+  end
+
+  # Returns all hosts associated with this hostgroup with the openstack
+  # deployment environment set.  These can be filtered based by setting
+  # errors=true or errors=false to return only the hosts  with no errors or
+  # with errors respectively.
+  def openstack_hosts(errors=nil)
+    oshosts = hosts.select { |h| h.open_stack_environment_set? }
+
+    unless errors.nil?
+      oshosts.select! { |h| (!errors ^ h.error?) }
+    end
+    oshosts
   end
 
   module ClassMethods

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

@@ -0,0 +1,72 @@
+module Staypuft::Concerns::LookupKeyExtensions
+  extend ActiveSupport::Concern
+
+  included do
+    alias_method_chain :cast_validate_value, :erb
+    alias_method_chain :value_before_type_cast, :limpet
+
+    # apply only when this extension is included
+    ::Staypuft::Concerns::LookupKeyExtensions.monkey_path_safe_render
+  end
+
+  LIMPET_FORMAT        = '<%%={key_id:%s};'
+  LIMPET_FORMAT_REGEXP = /#{LIMPET_FORMAT % '(\d+)'}/
+
+  def cast_validate_value_with_erb(value)
+    if has_erb? value
+      if value =~ LIMPET_FORMAT_REGEXP
+        value.gsub(/#{LIMPET_FORMAT_REGEXP}/, LIMPET_FORMAT % id)
+      else
+        value.gsub(/<%=/, LIMPET_FORMAT % id)
+      end
+    else
+      cast_validate_value_without_erb value
+    end
+  end
+
+  def cast_validate_value_after_erb(value, type)
+    method = "cast_value_#{type}".to_sym
+    return value unless self.respond_to? method, true
+    self.send(method, value) rescue raise TypeError
+  end
+
+  def has_erb? value
+    value =~ /<%.*%>/
+  end
+
+  def value_before_type_cast_with_limpet(value)
+    value_before_type_cast_without_limpet(value).tap do |v|
+      v.gsub!(LIMPET_FORMAT_REGEXP, '<%=') if has_erb? v
+    end
+  end
+
+  def self.monkey_path_safe_render
+    ::SafeRender.class_eval do
+      def parse_string(string)
+        raise ::ForemanException.new(N_('SafeRender#parse_string was passed a %s instead of a string') % string.class) unless string.is_a? String
+
+        lookup_key_id = string[Staypuft::Concerns::LookupKeyExtensions::LIMPET_FORMAT_REGEXP, 1]
+        if lookup_key_id
+          lookup_key = LookupKey.find(lookup_key_id)
+          type       = lookup_key.key_type
+        end
+
+        p string
+        value = if Setting[:safemode_render]
+                  box = Safemode::Box.new self, @allowed_methods
+                  box.eval(ERB.new(string, nil, '-').src, @allowed_vars)
+                else
+                  @allowed_vars.each { |k, v| instance_variable_set "@#{k}", v }
+                  ERB.new(string, nil, '-').result(binding)
+                end
+
+        if type
+          lookup_key.cast_validate_value_after_erb value, type
+        else
+          value
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+module Staypuft
+  class Deployment::AbstractParamScope
+    include ActiveModel::Validations
+    extend ActiveModel::Callbacks
+    extend Deployment::AttributeParamStorage
+    define_model_callbacks :save, :only => [:after]
+
+    def self.param_scope
+      raise NotImplementedError
+    end
+
+    attr_reader :deployment
+
+    def initialize(deployment)
+      @deployment = deployment
+    end
+
+    def hostgroup
+      deployment.hostgroup
+    end
+
+    # compatibility with validates_associated
+    def marked_for_destruction?
+      false
+    end
+
+    def attributes=(attr_list)
+      attr_list.each { |attr, value| send "#{attr}=", value } unless attr_list.nil?
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Staypuft
+  module Deployment::AttributeParamStorage
+    def param_scope
+      raise NotImplementedError
+    end
+
+    def param_attr(*names)
+      names.each do |name|
+        ivar_name  = :"@#{name}"
+        param_name = "ui::#{param_scope}::#{name}"
+
+        define_method name do
+          instance_variable_get(ivar_name) or
+              instance_variable_set(ivar_name,
+                                    hostgroup.group_parameters.find_by_name(param_name).try(:value))
+        end
+
+        define_method "#{name}=" do |value|
+          instance_variable_set(ivar_name, value)
+        end
+
+        after_save do
+          value = send(name)
+          # FIXME: not sure if hard-coding false is correct here, but without it, false was
+          # being set to 'nil', breaking boolean values (empty arrays may prove to be a similar problem)
+          if value.blank? && !(value == false)
+            hostgroup.
+                group_parameters.
+                find_by_name(param_name).try(:destroy)
+          else
+            param = hostgroup.
+                group_parameters.
+                find_or_initialize_by_name(param_name)
+            param.update_attributes!(value: value)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,87 @@
+module Staypuft
+  class Deployment::CinderService < Deployment::AbstractParamScope
+    def self.param_scope
+      'cinder'
+    end
+
+    param_attr :driver_backend, :nfs_uri, :nfs_mount_options
+
+    module DriverBackend
+      LVM        = 'lvm'
+      NFS        = 'nfs'
+      CEPH       = 'ceph'
+      EQUALLOGIC = 'equallogic'
+      LABELS     = { LVM        => N_('LVM'),
+                     NFS        => N_('NFS'),
+                     CEPH       => N_('Ceph'),
+                     EQUALLOGIC => N_('EqualLogic') }
+      TYPES      = LABELS.keys
+      HUMAN      = N_('Choose Driver Backend')
+    end
+    validates :driver_backend, presence: true, inclusion: { in: lambda {|c| c.backend_types_for_layout } }
+
+    module NfsUri
+      HUMAN = N_('NFS URI:')
+      HUMAN_AFTER = N_('("example.com/path/to/mount")')
+    end
+    validates :nfs_uri,
+              :presence => true,
+              :if       => :nfs_backend?
+    # TODO: uri validation
+
+    # TODO: add ceph UI parameters
+
+    # TODO: add EqualLogic UI parameters
+
+
+    def set_defaults
+      self.driver_backend = DriverBackend::LVM
+    end
+
+    # cinder config always shows up
+    def active?
+      true
+    end
+
+    def lvm_backend?
+      !self.deployment.ha? && (self.driver_backend == DriverBackend::LVM)
+    end
+
+    def nfs_backend?
+      self.driver_backend == DriverBackend::NFS
+    end
+
+    def ceph_backend?
+      self.driver_backend == DriverBackend::CEPH
+    end
+
+    def equallogic_backend?
+      self.driver_backend == DriverBackend::EQUALLOGIC
+    end
+
+
+    # view should use this rather than DriverBackend::LABELS to hide LVM for HA.
+    # TODO: Add back CEPH and EQUALLOGIC as they're suppoirted
+    def backend_labels_for_layout
+      ret_list = DriverBackend::LABELS.clone
+      ret_list.delete(DriverBackend::LVM) if self.deployment.ha?
+      # TODO: remove this line when Ceph is supported
+      ret_list.delete(DriverBackend::CEPH)
+      # TODO: remove this line when EqualLogic is supported
+      ret_list.delete(DriverBackend::EQUALLOGIC)
+
+      ret_list
+    end
+    def backend_types_for_layout
+      ret_list = DriverBackend::TYPES.clone
+      ret_list.delete(DriverBackend::LVM) if self.deployment.ha?
+      # TODO: remove this line when Ceph is supported
+      ret_list.delete(DriverBackend::CEPH)
+      # TODO: remove this line when EqualLogic is supported
+      ret_list.delete(DriverBackend::EQUALLOGIC)
+
+      ret_list
+    end
+
+  end
+end

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

@@ -0,0 +1,85 @@
+module Staypuft
+  class Deployment::GlanceService < Deployment::AbstractParamScope
+    def self.param_scope
+      'glance'
+    end
+
+    param_attr :driver_backend, :nfs_network_path, :gluster_network_path,
+               :gluster_backup_volfile_servers
+
+    module DriverBackend
+      LOCAL   = 'local'
+      NFS     = 'nfs'
+      LABELS  = { LOCAL   => N_('Local File'),
+                  NFS     => N_('NFS') }
+      TYPES   = LABELS.keys
+      HUMAN   = N_('Choose Driver Backend')
+    end
+
+    validates :driver_backend, presence: true, inclusion: { in: lambda {|g| g.backend_types_for_layout } }
+
+    module NfsNetworkPath
+      HUMAN       = N_('network path')
+      HUMAN_AFTER = '(server:localpath)'
+    end
+
+    validates :nfs_network_path,
+              :presence => true,
+              :if       => :nfs_backend?
+    # TODO: network_path validation
+
+    def set_defaults
+      self.driver_backend = DriverBackend::LOCAL
+    end
+
+    # gluster config only shows up for HA
+    # glance UI is HA only until we add ceph (since there's only one option for non-HA)
+    def active?
+      deployment.ha?
+    end
+
+    def local_backend?
+      self.driver_backend == DriverBackend::LOCAL
+    end
+
+    def nfs_backend?
+      self.driver_backend == DriverBackend::NFS
+    end
+
+    def network_path
+      if self.nfs_backend?
+        self.nfs_network_path
+      end
+    end
+
+    def pcmk_fs_device
+      network_path.nil? ? '' : network_path.split(':')[0]
+    end
+
+    def pcmk_fs_dir
+      network_path.nil? ? '' : network_path.split(':')[1]
+    end
+
+    def pcmk_fs_options
+      if self.nfs_backend?
+        "context=\"system_u:object_r:glance_var_lib_t:s0\")"
+      else
+        ""
+      end
+    end
+
+    # view should use this rather than DriverBackend::LABELS to hide LOCAL for HA.
+    def backend_labels_for_layout
+      ret_list = DriverBackend::LABELS.clone
+      ret_list.delete(DriverBackend::LOCAL) if self.deployment.ha?
+      ret_list
+    end
+
+    def backend_types_for_layout
+      ret_list = DriverBackend::TYPES.clone
+      ret_list.delete(DriverBackend::LOCAL) if self.deployment.ha?
+      ret_list
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+module Staypuft
+  class Deployment::IPS < Deployment::AbstractParamScope
+
+    def controllers
+      @controllers ||= Hostgroup.
+          includes(:deployment_role_hostgroup).
+          where(DeploymentRoleHostgroup.table_name => { deployment_id: deployment,
+                                                        role_id:       Staypuft::Role.controller }).
+          first.
+          hosts
+    end
+
+    def controller_ips
+      controllers.map &:ip
+    end
+
+    def controller_fqdns
+      controllers.map &:fqdn
+    end
+
+    def controller_ip
+      controllers.tap { |v| v.size == 1 or raise }.first.ip
+    end
+
+  end
+end

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

@@ -0,0 +1,165 @@
+module Staypuft
+  class Deployment::NeutronService < Deployment::AbstractParamScope
+    def self.param_scope
+      'neutron'
+    end
+
+    SEGMENTATION_LIST = ['vxlan', 'vlan', 'gre', 'flat']
+
+    param_attr :network_segmentation, :tenant_vlan_ranges, :networker_tenant_interface,
+               :use_external_interface, :external_interface_name, :compute_tenant_interface,
+               :use_vlan_for_external_network, :vlan_ranges_for_external_network
+
+    module NetworkSegmentation
+      VXLAN  = 'vxlan'
+      GRE    = 'gre'
+      VLAN   = 'vlan'
+      FLAT   = 'flat'
+      LABELS = { VXLAN => N_('VXLAN Segmentation'),
+                 GRE   => N_('GRE Segmentation'),
+                 VLAN  => N_('VLAN Segmentation'),
+                 FLAT  => N_('Flat') }
+      TYPES  = LABELS.keys
+      HUMAN  = N_('Tenant Network Type')
+    end
+
+    validates :network_segmentation, presence: true, inclusion: { in: NetworkSegmentation::TYPES }
+
+    module TenantVlanRanges
+      HUMAN       = N_('Tenant (VM data) VLAN Ranges')
+      HUMAN_AFTER = '[1-4094] (i.e. 10:100)'
+    end
+
+    validates :tenant_vlan_ranges,
+              :presence => true,
+              :if       => :vlan_segmentation?
+    # TODO: vlan range format validation
+
+    module NetworkerTenantInterface
+      HUMAN       = N_('Which interface to use for tenant networks:')
+      HUMAN_AFTER = N_('(i.e. eth0, em1, etc.)')
+    end
+
+    validates :networker_tenant_interface,
+              :presence => true
+    # TODO: interface name format validation
+
+    module UseExternalInterface
+      HUMAN = N_('Configure external interface on network node')
+    end
+
+    validates :use_external_interface, inclusion: { in: [true, false, 'true', 'false'] }
+
+    module ExternalInterfaceName
+      HUMAN       = N_('External interface connected to')
+      HUMAN_AFTER = N_('(interface) (i.e. eth1)')
+    end
+
+    validates :external_interface_name,
+              :presence => true,
+              :if       => :use_external_interface?
+    # TODO: interface name format validation
+
+    module UseVlanForExternalNetwork
+      HUMAN = N_('Configure VLAN for external network')
+    end
+
+    validates :use_vlan_for_external_network, inclusion: { in: [true, false, 'true', 'false'] }
+
+    module VlanRangesForExternalNetwork
+      HUMAN       = N_('VLAN Range for external network')
+      HUMAN_AFTER = N_('i.e. physnet1:1000:2999')
+    end
+
+    validates :vlan_ranges_for_external_network,
+              :presence => true,
+              :if       => :external_network_vlan?
+    # TODO: vlan rangesformat validation
+
+    module ComputeTenantInterface
+      HUMAN       = N_('Which interface to use for tenant networks:')
+      HUMAN_AFTER = N_('(i.e. eth0, em1, etc.)')
+    end
+
+    validates :compute_tenant_interface,
+              :presence => true
+    # TODO: interface name format validation
+
+    def set_defaults
+      self.network_segmentation = NetworkSegmentation::VXLAN
+      self.use_external_interface = 'false'
+    end
+
+    def active?
+      deployment.networking == Deployment::Networking::NEUTRON
+    end
+
+    # TODO: make this less clumsy w/ consistent handling of true/false values
+    def use_external_interface?
+      (self.use_external_interface == true) || (self.use_external_interface == 'true')
+    end
+
+    # TODO: make this less clumsy w/ consistent handling of true/false values
+    def use_vlan_for_external_network?
+      (self.use_vlan_for_external_network == true) || (self.use_vlan_for_external_network == 'true')
+    end
+
+    # return list of supported segmentation options with selected option at the
+    # beginning of the list
+    def network_segmentation_list
+      [self.network_segmentation, *(SEGMENTATION_LIST - [self.network_segmentation])]
+    end
+
+    def controller_ovs_bridge_mappings
+      if self.vlan_segmentation?
+        ["physnet-tenants:br-#{self.networker_tenant_interface}",
+         ('physnet-external:br-ex' if self.use_external_interface?)].compact
+      else
+        []
+      end
+    end
+
+    def controller_ovs_bridge_uplinks
+      if self.vlan_segmentation?
+        ["br-#{self.networker_tenant_interface}:#{self.networker_tenant_interface}",
+         ("br-ex:#{self.external_interface_name}" if self.use_external_interface?)]
+      else
+        []
+      end
+    end
+
+    def compute_ovs_bridge_mappings
+      if self.vlan_segmentation?
+        ["physnet-tenants:br-#{self.compute_tenant_interface}"]
+      else
+        []
+      end
+    end
+
+    def compute_ovs_bridge_uplinks
+      if self.vlan_segmentation?
+        ["br-#{self.compute_tenant_interface}:#{self.compute_tenant_interface}"]
+      else
+        []
+      end
+    end
+
+    # FIXME: mapping is off here -- both external and tenant vlan ranges map to the same back end
+    # params: fix this with morazi in the AM
+    def ml2_network_vlan_ranges
+      if self.external_network_vlan?
+        [self.vlan_ranges_for_external_network]
+      else
+        []
+      end
+    end
+    def vlan_segmentation?
+      self.network_segmentation == NetworkSegmentation::VLAN
+    end
+
+    def external_network_vlan?
+      self.use_external_interface? && self.use_vlan_for_external_network?
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module Staypuft
+  class Deployment::NovaService < Deployment::AbstractParamScope
+    def self.param_scope
+      'nova'
+    end
+
+    param_attr :network_manager, :vlan_range, :external_interface_name, :public_floating_range,
+               :compute_tenant_interface, :private_fixed_range
+
+    module NetworkManager
+      FLAT_DHCP = 'FlatDHCPManager'
+      VLAN      = 'VlanManager'
+      LABELS    = { FLAT_DHCP => N_('Flat with DHCP'),
+                    VLAN      => N_('VLAN') }
+      TYPES     = LABELS.keys
+      HUMAN     = N_('Tenant Network Type')
+    end
+
+    validates :network_manager, presence: true, inclusion: { in: NetworkManager::TYPES }
+
+    module VlanRange
+      HUMAN       = N_('VLAN Range')
+      HUMAN_AFTER = '[1-4094] (i.e. 10:100)'
+    end
+
+    validates :vlan_range,
+              :presence => true,
+              :if       => :vlan_manager?
+    # TODO: vlan range format validation
+    # TODO: determine whether this is a true range or a single value
+
+    module ExternalInterfaceName
+      HUMAN       = N_('Which interface to use for external networks:')
+      HUMAN_AFTER = N_('(interface) (i.e. eth1)')
+    end
+
+    validates :external_interface_name, presence: true
+    # TODO: interface name format validation
+
+    module PublicFloatingRange
+      HUMAN       = N_('Floating IP range for external network:')
+      HUMAN_AFTER = N_('("10.0.0.0/24", for example)')
+    end
+
+    validates :public_floating_range, presence: true
+    # TODO: interface format validation
+
+    module ComputeTenantInterface
+      HUMAN       = N_('Which interface to use for tenant networks:')
+      HUMAN_AFTER = N_('(i.e. eth0, em1, etc.)')
+    end
+
+    validates :compute_tenant_interface,
+              :presence => true
+    # TODO: interface name format validation
+
+    module PrivateFixedRange
+      HUMAN       = N_('Private IP range for tenant networks:')
+      HUMAN_AFTER = N_('("10.0.0.0/24", for example)')
+    end
+
+    validates :private_fixed_range, presence: true
+    # TODO: interface format validation
+
+    def set_defaults
+      self.network_manager = NetworkManager::FLAT_DHCP
+    end
+
+    def active?
+      deployment.networking == Deployment::Networking::NOVA
+    end
+
+    def vlan_manager?
+      self.network_manager == NetworkManager::VLAN
+    end
+
+    def network_overrides
+      { 'force_dhcp_release' => false }.tap do |h|
+        h.update 'vlan_start' => self.vlan_range.split(':')[0] if self.vlan_manager?
+      end
+    end
+
+  end
+end