dop_common 0.13.0

data/lib/dop_common/infrastructure.rb

@@ -0,0 +1,160 @@
+#
+# DOP Common infrastructure hash parser
+#
+
+require 'uri'
+
+module DopCommon
+  class Infrastructure
+    include Validator
+    include HashParser
+    include RunOptions
+
+    attr_reader :name
+
+    VALID_PROVIDER_TYPES = [:baremetal, :openstack, :ovirt, :vsphere]
+
+    VALID_PROVIDER_ALIASES = {
+      :rhev => :ovirt,
+      :rhevm => :ovirt,
+      :rhos => :openstack,
+      :vmware => :vsphere
+    }
+
+    def initialize(name, hash, parent={})
+      @name = name
+      @hash = symbolize_keys(hash)
+      @parsed_credentials = parent[:parsed_credentials]
+    end
+
+    def validate
+      valitdate_shared_options
+      log_validation_method(:provider_valid?)
+      log_validation_method(:endpoint_valid?)
+      log_validation_method(:networks_valid?)
+      log_validation_method(:affinity_groups_valid?)
+      log_validation_method(:credentials_valid?)
+      try_validate_obj("Infrastructure #{name}: Can't validate the networks part because of a previous error") { networks }
+      try_validate_obj("Infrastructure #{name}: Can't validate the affinity groups part because of a previous error") { affinity_groups }
+    end
+
+    def provider
+      @provider ||= provider_valid? ? @hash[:type].downcase.to_sym : nil
+    end
+    alias_method :type, :provider
+
+    def provides?(*t)
+      t.any? do |p|
+        p = p.downcase.to_sym if p.kind_of?(String)
+        p == provider || p == VALID_PROVIDER_ALIASES[provider]
+      end
+    end
+    alias_method :type?, :provides?
+
+    def endpoint
+      @endpoint ||= endpoint_valid? ? create_endpoint : nil
+    end
+
+    def credentials
+      @credentials ||= credentials_valid? ? create_credentials : nil
+    end
+
+    def networks
+      @networks ||= networks_valid? ? create_networks : []
+    end
+
+    def affinity_groups
+      @affinity_groups ||= affinity_groups_valid? ? create_affinity_groups : []
+    end
+
+    def default_security_groups
+      @defalut_security_groups ||= default_security_groups_valid? ? create_default_security_groups : []
+    end
+
+    private
+
+    def provider_valid?
+      case @hash[:type]
+      when nil
+        raise PlanParsingError, "Infrastructure #{@name}: provider type is a required property"
+      when String
+        p = @hash[:type].downcase.to_sym
+        raise PlanParsingError, "Infrastructure #{@name}: invalid provider type" unless
+          VALID_PROVIDER_TYPES.include?(p) || VALID_PROVIDER_ALIASES.keys.include?(p)
+      else
+        raise PlanParsingError, "Infrastructure #{@name}: provider type must be a string"
+      end
+      true
+    end
+    alias_method :type_valid?, :provider_valid?
+
+    def endpoint_valid?
+      return false if provides?(:baremetal) && @hash[:endpoint].nil?
+      raise PlanParsingError, "Infrastructure #{@name}: endpoint is a required property" if @hash[:endpoint].nil?
+      ::URI.parse(@hash[:endpoint])
+      true
+    rescue URI::InvalidURIError
+      raise PlanParsingError, "Infrastructure #{@name}: the specified endpoint URL is invalid"
+    end
+
+    def credentials_valid?
+      return false if provides?(:baremetal) && @hash[:credentials].nil?
+      raise PlanParsingError, "Infrastructure #{@name}: Credentials pointer must be a string" unless
+        @hash[:credentials].kind_of?(String)
+      raise PlanParsingError, "Infrastructure #{@name}: Missing definition of endpoint credentials" unless
+        @parsed_credentials.has_key?(@hash[:credentials])
+      true
+    end
+
+    def networks_valid?
+      return false if provides?(:baremetal) && @hash[:networks].nil? # Network is optional for baremetal
+      raise PlanParsingError, "Infrastructure #{@name}: network is a required property" if
+        !provides?(:baremetal) && @hash[:networks].nil?
+      raise PlanParsingError, "Infrastructure #{@name}: networks must be a hash" unless
+        @hash[:networks].kind_of?(Hash)
+      raise PlanParsingError, "Infrastructure #{@name}: network names have to be string" unless
+        @hash[:networks].keys.all? { |name| name.kind_of?(String) }
+      raise PlanParsingError, "Infrastructure #{@name}: each network has to be defined as hash" unless
+      @hash[:networks].values.all? { |network| network.kind_of?(Hash) }
+      true
+    end
+
+    def affinity_groups_valid?
+      return false if @hash[:affinity_groups].nil?
+      @hash[:affinity_groups].kind_of?(Hash) or
+        raise PlanParsingError, "Infrastructure #{@name}: affinity_groups must be a hash"
+      @hash[:affinity_groups].keys.all? { |name| name.kind_of?(String) } or
+        raise PlanParsingError, "Infrastructure #{@name}: affinity group names have to be string"
+      @hash[:affinity_groups].values.all? { |ag| ag.kind_of?(Hash) } or
+        raise PlanParsingError, "Infrastructure #{@name}: affinity groups have to be defined as hash"
+    end
+
+    def default_security_groups_valid?
+      return false if @hash[:default_security_groups].nil?
+      @hash[:default_security_groups].kind_of?(Array) or
+        raise PlanParsingError, "Infrastructure #{@name}: default_security_groups must be an array"
+      @hash[:default_security_groups].all? { |name| name.kind_of?(String) } or
+        raise PlanParsingError, "Infrastructure #{@name}: security group names have to be strings"
+    end
+
+    def create_endpoint
+      ::URI.parse(@hash[:endpoint])
+    end
+
+    def create_credentials
+      @parsed_credentials[@hash[:credentials]]
+    end
+
+    def create_networks
+      @hash[:networks].collect { |name,hash| ::DopCommon::Network.new(name, hash) }
+    end
+
+    def create_affinity_groups
+      @hash[:affinity_groups].collect { |name,hash| ::DopCommon::AffinityGroup.new(name, hash) }
+    end
+
+    def create_default_security_groups
+      @hash[:default_security_groups]
+    end
+  end
+end

data/lib/dop_common/infrastructure_properties.rb

@@ -0,0 +1,185 @@
+#
+# DOP Common infrastructure properties parser
+#
+
+module DopCommon
+  class InfrastructureProperties
+    include Validator
+    include HashParser
+
+    def initialize(hash, parsed_infrastructure)
+      @hash = symbolize_keys(hash)
+      @parsed_infrastructure = parsed_infrastructure
+    end
+
+    def validate
+      log_validation_method(:affinity_groups_valid?)
+      log_validation_method(:keep_ha_valid?)
+      log_validation_method(:datacenter_valid?)
+      log_validation_method(:cluster_valid?)
+      log_validation_method(:default_pool_valid?)
+      log_validation_method(:dest_folder_valid?)
+      log_validation_method(:tenant_valid?)
+      log_validation_method(:use_config_drive_valid?)
+      log_validation_method(:domain_id_valid?)
+      log_validation_method(:endpoint_type_valid?)
+    end
+
+    def affinity_groups
+      @affinity_groups ||= affinity_groups_valid? ? @hash[:affinity_groups] : []
+    end
+
+    def security_groups
+      @security_groups ||= security_groups_valid? ? create_security_groups : @parsed_infrastructure.default_security_groups
+    end
+
+    def keep_ha?
+      @keep_ha ||= keep_ha_valid? ? @hash[:keep_ha] : true
+    end
+    alias_method :keep_ha, :keep_ha?
+
+    def datacenter
+      @datacenter ||= datacenter_valid? ? @hash[:datacenter] : nil
+    end
+
+    def cluster
+      @cluster ||= cluster_valid? ? @hash[:cluster] : nil
+    end
+
+    def default_pool
+      @default_pool ||= default_pool_valid? ? @hash[:default_pool] : nil
+    end
+
+    def dest_folder
+      @dest_folder ||= dest_folder_valid? ? @hash[:dest_folder] : nil
+    end
+
+    def tenant
+      @tenant ||= tenant_valid? ? @hash[:tenant] : nil
+    end
+
+    def use_config_drive?
+      @use_config_drive ||= use_config_drive_valid? ? @hash[:use_config_drive] : false
+    end
+    alias_method :use_config_drive, :use_config_drive?
+
+    def domain_id
+      @domain_id ||= domain_id_valid? ? create_domain_id : nil
+    end
+
+    def endpoint_type
+      @endpoint_type ||= endpoint_type_valid? ? create_endpoint_type : nil
+    end
+
+    private
+
+    def affinity_groups_valid?
+      ags = @hash[:affinity_groups]
+      return false if ags.nil?
+      raise PlanParsingError, "Infrastructure properties: Affinity groups, if specified, must be a non-empty array" if
+        !ags.kind_of?(Array) || ags.empty?
+      raise PlanParsingError, "Infrastructure properties: Each affinity group must be a non-empty string" if
+        ags.any? { |ag| !ag.kind_of?(String) || ag.empty? }
+      true
+    end
+
+    def security_groups_valid?
+      return false unless @hash[:security_groups] or @hash[:additional_security_groups]
+      raise PlanParsingError, "Infrastructure properties: security_groups and additional_security_groups are mutually exclusive" if
+        @hash[:security_groups] and @hash[:additional_security_groups]
+      sgs = @hash[:security_groups] || @hash[:additional_security_groups]
+      raise PlanParsingError, "Infrastructure properties: (additional_)security_groups must be non-empty arrays" if
+        !sgs.kind_of?(Array) || sgs.empty?
+      raise PlanParsingError, "Infrastructure properties: (additional_)security_groups must be non-empty strings" if
+        sgs.any? {|sg| !sg.kind_of?(String) || sg.empty? }
+      true
+    end
+
+    def keep_ha_valid?
+      return false if @hash[:keep_ha].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'keep_ha' is valid only for OVirt/RHEVm infrastructure types" unless
+        @parsed_infrastructure.provides?(:ovirt)
+      raise PlanParsingError, "Infrastructure properties: The 'keep_ha' must be boolean" unless
+        @hash[:keep_ha].kind_of?(TrueClass) || @hash[:keep_ha].kind_of?(FalseClass)
+      true
+    end
+
+    def datacenter_valid?
+      return false unless @parsed_infrastructure.provides?(:ovirt, :vsphere)
+      raise PlanParsingError, "Infrastructure properties: The 'datacenter' must be defined" if
+        @parsed_infrastructure.provides?(:ovirt, :vsphere) && @hash[:datacenter].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'datacenter' must be a non-empty string" if
+        !@hash[:datacenter].kind_of?(String) || @hash[:datacenter].empty?
+      true
+    end
+
+    def cluster_valid?
+      return false unless @parsed_infrastructure.provides?(:ovirt, :vsphere)
+      raise PlanParsingError, "Infrastructure properties: The 'cluster' must be defined" if
+        @parsed_infrastructure.provides?(:ovirt, :vsphere) && @hash[:cluster].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'cluster' must be a non-empty string" if
+        !@hash[:cluster].kind_of?(String) || @hash[:cluster].empty?
+      true
+    end
+
+    def default_pool_valid?
+      return false if @hash[:default_pool].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'default_pool' must be a non-empty string" if
+        !@hash[:default_pool].kind_of?(String) || @hash[:default_pool].empty?
+      true
+    end
+
+    def dest_folder_valid?
+      return false if @hash[:dest_folder].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'dest_folder' must be a non-empty string" if
+        !@hash[:dest_folder].kind_of?(String) || @hash[:dest_folder].empty?
+      true
+    end
+
+    def tenant_valid?
+      return false unless @parsed_infrastructure.provides?(:openstack)
+      raise PlanParsingError, "Infrastructure properties: The 'tenant' must be defined" if
+        @parsed_infrastructure.provides?(:openstack) && @hash[:tenant].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'tenant' must be a non-empty string" if
+        !@hash[:tenant].kind_of?(String) || @hash[:tenant].empty?
+      true
+    end
+
+    def domain_id_valid?
+      return false unless @parsed_infrastructure.provides?(:openstack)
+      return true if @hash[:domain_id].nil?
+      raise PlanParsingError, "Infrastructure properties: The domain_id must be a non-empty string" if
+        !@hash[:domain_id].kind_of?(String) || @hash[:domain_id].empty?
+      true
+    end
+
+    def endpoint_type_valid?
+      return false unless @parsed_infrastructure.provides?(:openstack)
+      return true if @hash[:endpoint_type].nil?
+      raise PlanParsingError, "Infrastructure properties: The endpoint must be 'publicURL', 'internalURL' or 'adminURL'" unless
+      @hash[:endpoint_type].kind_of?(String) && %w(publicURL internalURL adminURL).include?(@hash[:endpoint_type])
+      true
+    end
+
+    def use_config_drive_valid?
+      return false if @hash[:use_config_drive].nil?
+      raise PlanParsingError, "Infrastructure properties: The 'use_config_drive' is valid only for OpenStack infrastructure types" unless @parsed_infrastructure.provides?(:openstack)
+      raise PlanParsingError, "Infrastructure properties: The 'use_config_drive' must be boolean" unless
+        @hash[:use_config_drive].kind_of?(TrueClass) || @hash[:use_config_drive].kind_of?(FalseClass)
+      true
+    end
+
+    def create_security_groups
+      sgs = @hash[:security_groups]
+      sgs ? sgs : (@parsed_infrastructure.default_security_groups + @hash[:additional_security_groups]).uniq
+    end
+
+    def create_domain_id
+      @hash[:domain_id].nil? ? 'default' : @hash[:domain_id]
+    end
+    
+    def create_endpoint_type
+      @hash[:endpoint_type].nil? ? 'publicURL' : @hash[:endpoint_type]
+    end
+  end
+end

data/lib/dop_common/interface.rb

@@ -0,0 +1,113 @@
+#
+# DOP Common configuration lookup
+#
+require 'ipaddr'
+
+module DopCommon
+  class Interface
+    include Validator
+    include HashParser
+
+    attr_reader :name
+
+    def initialize(name, hash, parent={})
+      @name = name
+      @hash = symbolize_keys(hash)
+      @parsed_networks = parent[:parsed_networks]
+    end
+
+    def validate
+      log_validation_method('network_valid?')
+      log_validation_method('ip_valid?')
+      log_validation_method('set_gateway_valid?')
+      log_validation_method('virtual_switch_valid?')
+      log_validation_method('floating_network_valid?')
+    end
+
+    def network
+      @network ||= network_valid? ? network_obj.name : nil
+    end
+
+    def ip
+      @ip ||= ip_valid? ? @hash[:ip] : nil
+    end
+
+    def netmask
+      @netmask ||= network_obj.ip_netmask.to_s
+    end
+
+    def set_gateway?
+      @set_gateway ||= set_gateway_valid? ? (gateway == false ? false : @hash[:set_gateway]) : true
+    end
+    alias_method :set_gateway, :set_gateway?
+
+    def gateway
+      @gateway ||= false == network_obj.ip_defgw ? false : network_obj.ip_defgw.to_s
+    end
+
+    def virtual_switch
+      @virtual_switch ||= virtual_switch_valid? ? @hash[:virtual_switch] : nil
+    end
+
+    def floating_network
+      @floating_network ||= floating_network_valid? ? @hash[:floating_network] : nil
+    end
+
+  private
+    def network_valid?
+      raise PlanParsingError, "Interface #{@name}: 'network' must be specified" if
+        @hash[:network].nil?
+      raise PlanParsingError, "Interface #{@name}: 'network' must be a non-empty string" if
+        !@hash[:network].kind_of?(String) || @hash[:network].empty?
+      raise PlanParsingError, "Interface #{@name}: no such network definition '#{@hash[:network]}'" unless
+      network_obj
+      true
+    end
+
+    def ip_valid?
+      raise PlanParsingError, "Interface #{@name}: 'ip' must be a string or symbol" unless
+        [String, Symbol].include?(@hash[:ip].class)
+      case @hash[:ip]
+      when :dhcp, 'dhcp'
+        @hash[:ip] = :dhcp
+      when :none, 'none'
+        @hash[:ip] = :none
+      else
+        ip_addr = IPAddr.new(@hash[:ip])
+        raise PlanParsingError, "Interface #{name}: IP address '#{@hash[:ip]}' " \
+          "is outside of '#{network_obj.ip_pool[:from]} - #{network_obj.ip_pool[:to]}' range" if
+          ip_addr < network_obj.ip_pool[:from] || ip_addr > network_obj.ip_pool[:to]
+      end
+      true
+    rescue ArgumentError
+        raise PlanParsingError, "Interface #{@name}: the specified IP is not valid"
+    end
+
+    def set_gateway_valid?
+      return (gateway == false ? true : false) if @hash[:set_gateway].nil?
+      raise PlanParsingError, "Interface #{@name}: The 'set_gateway', must be true or false" unless
+        [TrueClass, FalseClass].include?(@hash[:set_gateway].class)
+      raise PlanParsingError, "Interface #{@name}: No gateway specified for network '#{network}'" if
+        gateway == false && @hash[:set_gateway] == true
+      true
+    end
+
+    def virtual_switch_valid?
+      return false if @hash[:virtual_switch].nil?
+      raise PlanParsingError, "Interface #{@name}: The 'virtual_switch' must be a non-empty string" if
+        !@hash[:virtual_switch].kind_of?(String) || @hash[:virtual_switch].empty?
+      true
+    end
+
+    def floating_network_valid?
+      return false if @hash[:floating_network].nil?
+      raise PlanParsingError, "Interface #{@name}: the floating network must be a non-empty string" if
+        !@hash[:floating_network].kind_of?(String) || @hash[:floating_network].empty?
+      true
+    end
+
+    def network_obj
+      @network_obj ||= @parsed_networks.find { |n| n.name == @hash[:network] }
+    end
+  end
+end

data/lib/dop_common/log.rb

@@ -0,0 +1,78 @@
+#
+# This builds a multi-destination logger and pluggable filters for
+# around the standard ruby logger.
+#
+require 'logger'
+
+module DopCommon
+
+  def self.log
+    @log ||= create_logger(STDOUT)
+  end
+
+  def self.logger=(logger)
+    logger.formatter = DopCommon.filter_formatter
+    @log = logger
+  end
+
+  def self.formatter
+    @formatter ||= Logger::Formatter.new
+  end
+
+  def self.formatter=(formatter_proc)
+    @formatter ||= formatter_proc
+  end
+
+  def self.reset_logger
+    @log = nil
+    @log_filters = []
+    @log_junction = []
+  end
+
+  def self.log_filters
+    @log_filters ||= []
+  end
+
+  def self.add_log_filter(filter_proc)
+    log_filters << filter_proc
+  end
+
+  def self.log_junctions
+    @log_junction ||= []
+  end
+
+  def self.add_log_junction(logger)
+    log_junctions << logger
+  end
+
+  def self.remove_log_junction(logger)
+    log_junctions.delete(logger)
+  end
+
+  private
+
+  def self.create_logger(logdev = STDOUT)
+    logger = Logger.new(logdev)
+    logger.formatter = DopCommon.filter_formatter
+    logger
+  end
+
+  def self.filter_formatter
+    Proc.new do |severity, datetime, progname, msg|
+      filtered_message = msg
+      log_filters.each do |filter|
+        filtered_message = case filtered_message
+                           when Exception
+                             filtered_message.exception(filter.call(filtered_message.message))
+                           when String
+                             filter.call(filtered_message)
+                           else
+                             filter.call(filtered_message.inspect)
+                           end
+      end
+      log_junctions.each {|logger| logger.log(::Logger.const_get(severity), filtered_message, progname)}
+      formatter.call(severity, datetime, progname, filtered_message)
+    end
+  end
+
+end

data/lib/dop_common/network.rb

@@ -0,0 +1,85 @@
+#
+# DOP Common infrastructure hash parser
+#
+
+module DopCommon
+  class Network
+    include Validator
+    include HashParser
+
+    attr_reader :name
+
+    def initialize(name, hash)
+      @name = name
+      @hash = deep_symbolize_keys(hash)
+    end
+
+    def validate
+      log_validation_method(:ip_pool_valid?)
+      log_validation_method(:ip_defgw_valid?)
+      log_validation_method(:ip_netmask_valid?)
+    end
+
+    def ip_netmask
+      @ip_netmask ||= ip_netmask_valid? ? IPAddr.new(@hash[:ip_netmask]) : nil
+    end
+
+    def ip_defgw
+      @ip_defgw ||= ip_defgw_valid? ? (@hash[:ip_defgw] == false ? false : IPAddr.new(@hash[:ip_defgw])) : nil
+    end
+
+    def ip_pool
+      @ip_pool ||= ip_pool_valid? ? create_ip_pool : {}
+    end
+
+    private
+
+    def ip_netmask_valid?
+      return false if @hash.empty?
+      IPAddr.new(@hash[:ip_netmask])
+      true
+    rescue ArgumentError
+      raise PlanParsingError, "Network #{@name}: Invalid network mask definition"
+    end
+
+    def ip_defgw_valid?
+      return false if @hash.empty?
+      return true if @hash[:ip_defgw] == false
+      IPAddr.new(@hash[:ip_defgw])
+      true
+    rescue ArgumentError
+      raise PlanParsingError, "Network #{@name}: Invalid default gateway definition"
+    end
+
+    def ip_pool_valid?
+      return false if @hash.empty? # An empty network specification is valid
+      # It must be a hash with from and to keys if defined
+      raise PlanParsingError, "Network #{@name}: An IP pool must be a hash with 'from' and 'to' keys" unless
+        @hash[:ip_pool].kind_of?(Hash) and
+        @hash[:ip_pool].has_key?(:from) and
+        @hash[:ip_pool].has_key?(:to)
+      # The IP defined by from must be lower than the IP defined by to keyword
+      ip_from = IPAddr.new(@hash[:ip_pool][:from])
+      ip_to   = IPAddr.new(@hash[:ip_pool][:to])
+      raise PlanParsingError, "Network #{@name}: The IP defined by 'from' must to be lower than the IP defined by in 'to'" unless ip_from < ip_to
+      if ip_defgw
+        # The IP of default gateway must be out of IP pool range
+        raise PlanParsingError, "Network #{@name}: The default gateway must be out of IP pool range" unless ip_defgw < ip_from || ip_defgw > ip_to
+        # IPs specified by IP pool and the default gateway must belong to the same network
+        net = ip_defgw.mask(ip_netmask.to_s)
+        raise PlanParsingError, "Network #{@name}: IPs specified by IP pool and the default gateway must belong to the same network" unless
+          net.include?(ip_from) && net.include?(ip_to)
+      elsif ip_defgw.nil?
+        raise PlanParsingError, "Network #{@name}: The default gateway must either be a valid IP or false if there is no default gateway"
+      end
+      true
+    rescue ArgumentError
+      # Invalide IP/Netmasl definition
+      raise PlanParsingError, "Network #{@name}: Invalid IP and/or netmask definition"
+    end
+
+    def create_ip_pool
+      Hash[@hash[:ip_pool].collect { |k,v| [k.to_sym, IPAddr.new(v)] }]
+    end
+  end
+end