dop_common 0.13.0

data/lib/dop_common/credential.rb

@@ -0,0 +1,152 @@
+#
+# DOP Common credential hash parser
+#
+
+module DopCommon
+  class Credential
+    include Validator
+    include HashParser
+
+    attr_reader :hash, :name
+
+    VALID_TYPES = [:username_password, :kerberos, :ssh_key]
+
+    def initialize(name, hash)
+      @name = name
+      @hash = deep_symbolize_keys(hash)
+      DopCommon.add_log_filter(Proc.new {|msg| filter_secrets(msg)})
+    end
+
+    def validate
+      log_validation_method('type_valid?')
+    end
+
+    # This method filters the secrets from a message
+    def filter_secrets(msg)
+      case type
+      when :username_password then msg.gsub(password, '****')
+      else msg
+      end
+    end
+
+    def type
+      @type ||= type_valid? ? @hash[:type].to_sym : nil
+    end
+
+    def username
+      @username ||= username_valid? ? @hash[:username] : nil
+    end
+
+    def password
+      @password ||= password_valid? ? load_content(@hash[:password]) : nil
+    end
+
+    def realm
+      @realm ||= realm_valid? ? @hash[:realm] : nil
+    end
+
+    def service
+      @service ||= service_valid? ? @hash[:service] : nil
+    end
+
+    def keytab
+      @keytab ||= keytab_valid? ? load_content(@hash[:keytab]) : nil
+    end
+
+    def private_key
+      @private_key ||= private_key_valid? ? load_content(@hash[:private_key]) : nil
+    end
+
+    def public_key
+      @public_key ||= public_key_valid? ? load_content(@hash[:public_key]) : nil
+    end
+
+  private
+
+    def type_valid?
+      @hash[:type] or
+        raise PlanParsingError, "You need to specify the 'type' of the credental in #{@name} which can be one of #{VALID_TYPES.join(', ')}"
+      case @hash[:type]
+      when :username_password, 'username_password' then username_password_valid?
+      when :kerberos, 'kerberos'                   then kerberos_valid?
+      when :ssh_key, 'ssh_key'                     then ssh_key_valid?
+      else raise PlanParsingError, "The 'type' of the credental in #{@name} has to be one of #{VALID_TYPES.join(', ')}"
+      end
+      true
+    end
+
+    # This are the type validation methods, they will check if all the mandatory elements are there and
+    # if every supported attribute is valid.
+
+    def username_password_valid?
+      username_valid? or
+        raise PlanParsingError, "A username is missing in the credential #{@name} which is of type #{@hash[:type]}"
+      password_valid? or
+        raise PlanParsingError, "A password is missing in the credential #{@name} which is of type #{@hash[:type]}"
+      true
+    end
+
+    def kerberos_valid?
+      realm_valid? or
+        raise PlanParsingError, "A realm is missing in the credential #{@name} which is of type #{@hash[:type]}"
+      service_valid?
+      keytab_valid?
+      true
+    end
+
+    def ssh_key_valid?
+      username_valid? or
+        raise PlanParsingError, "A username is missing in the credential #{@name} which is of type #{@hash[:type]}"
+      private_key_valid?
+      public_key_valid?
+      true
+    end
+
+    # Attribute verification, will return false if the attribute is not valid, otherwise raise a PlanParsingError
+
+    def username_valid?
+      return false if @hash[:username].nil?
+      @hash[:username].kind_of?(String) or @hash[:username].kind_of?(Fixnum) or
+        raise PlanParsingError, "The username has to be a string or number in the credential #{@name} which is of type #{@hash[:type]}"
+      true
+    end
+
+    def password_valid?
+      credential_load_content_valid?(:password)
+    end
+
+    def keytab_valid?
+      credential_load_content_valid?(:keytab)
+    end
+
+    def private_key_valid?
+      credential_load_content_valid?(:private_key)
+    end
+
+    def public_key_valid?
+      credential_load_content_valid?(:public_key)
+    end
+
+    def credential_load_content_valid?(key)
+      return false if @hash[key].nil?
+      load_content_valid?(@hash[key])
+    rescue PlanParsingError => e
+      raise PlanParsingError, "Error while parsing the value for #{key} in credential #{@name}: #{e.message}"
+    end
+
+    def realm_valid?
+      return false if @hash[:realm].nil?
+      @hash[:realm].kind_of?(String) or
+        raise PlanParsingError, "The realm has to be a string in the credential #{@name} which is of type #{@hash[:type]}"
+      true
+    end
+
+    def service_valid?
+      return false if @hash[:service].nil?
+      @hash[:service].kind_of?(String) or
+        raise PlanParsingError, "The service has to be a string in the credential #{@name} which is of type #{@hash[:type]}"
+      true
+    end
+
+  end
+end

data/lib/dop_common/data_disk.rb

@@ -0,0 +1,62 @@
+module DopCommon
+  class DataDisk
+    include Validator
+    include HashParser
+    include Utils
+
+    attr_reader :name
+
+    def initialize(name, hash, parent = {})
+      @name = name
+      @hash = symbolize_keys(hash)
+      @parsed_infrastructure = parent[:parsed_infrastructure]
+      @parsed_infrastructure_properties = parent[:parsed_infrastructure_properties]
+    end
+
+    def validate
+      log_validation_method(:pool_valid?)
+      log_validation_method(:thin_valid?)
+      log_validation_method(:size_valid?)
+      try_validate_obj("Can't validate the 'data_disk' #{@name} because of previous error"){size}
+    end
+
+    def pool
+      @pool ||= pool_valid? ? @hash[:pool] : @parsed_infrastructure_properties.default_pool
+    end
+
+    def size
+      @size ||= size_valid? ? DopCommon::Utils::DataSize.new(@hash[:size]) : nil
+    end
+
+    def thin?
+      @thin ||= thin_valid? ? @hash[:thin] : true
+    end
+
+    private
+
+    def pool_valid?
+      provider = @parsed_infrastructure.provider
+      default_pool = @parsed_infrastructure_properties.default_pool
+      raise PlanParsingError, "Data disk #{@name}: A 'pool' is required for #{provider} provider type" unless
+        @parsed_infrastructure.provides?(:openstack, :baremetal) || @hash.has_key?(:pool) || default_pool
+      return false unless @hash.has_key?(:pool)
+      raise PlanParsingError, "Data disk #{@name}: 'pool', if defined, must be a non-empty string" if
+        !@hash[:pool].kind_of?(String) || @hash[:pool].empty?
+      true
+    end
+
+    def size_valid?
+      raise PlanParsingError, "Data disk #{@name}: 'size' is required" if @hash[:size].nil?
+      raise PlanParsingError, "Data disk #{@name}: 'size' must be of string type" unless
+        @hash[:size].kind_of?(String)
+      true
+    end
+
+    def thin_valid?
+      return false unless @hash.has_key?(:thin)
+      raise PlanParsingError, "Data disk #{@name}: thin, if specified, must be boolean" unless
+        [TrueClass, FalseClass].include?(@hash[:thin].class)
+      true
+    end
+  end
+end

data/lib/dop_common/dns.rb

@@ -0,0 +1,55 @@
+require 'ipaddr'
+
+module DopCommon
+  class DNS
+    include Validator
+    include HashParser
+
+    def initialize(hash)
+      @hash = (symbolize_keys(hash) || {}) # DNS is optional.
+    end
+
+    def validate
+      log_validation_method(:name_servers_valid?)
+      log_validation_method(:search_domains_valid?)
+    end
+
+    def name_servers
+      @name_servers ||= name_servers_valid? ? @hash[:name_servers] : []
+    end
+
+    def search_domains
+      @search_domains ||= search_domains_valid? ? @hash[:search_domains] : []
+    end
+
+    private
+
+    def name_servers_valid?
+      return false unless @hash.has_key?(:name_servers)
+      raise PlanParsingError, "DNS: name_servers must be an array of IP addresses" if
+        !@hash[:name_servers].kind_of?(Array) || @hash[:name_servers].empty?
+      @hash[:name_servers].each do |n|
+        begin
+          IPAddr.new(n)
+        rescue
+          raise PlanParsingError, "DNS: name_servers entry '#{n}' is not a valid IP address"
+        end
+      end
+      true
+    end
+
+    def search_domains_valid?
+      regex = /((^[a-z0-9]+(-[a-z0-9]+)*){1,63}$)|(^((?=[a-z0-9-]{1,63}\.)[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}$)/
+      return false unless @hash.has_key?(:search_domains)
+      raise PlanParsingError, "DNS: search_domains must be an array of search domains" if
+        !@hash[:search_domains].kind_of?(Array) || @hash[:search_domains].empty?
+      raise PlanParsingError, "DNS: search_domains entries must be strings" unless
+        @hash[:search_domains].all? { |d| d.kind_of?(String) }
+      @hash[:search_domains].each do |d|
+        raise PlanParsingError, "DNS: search_domain entry '#{d}' is not a valid domain name" unless
+          d =~ regex
+      end
+      true
+    end
+  end
+end

data/lib/dop_common/hash_parser.rb

@@ -0,0 +1,241 @@
+#
+# DOP Common Hash Parser Helper Functions
+#
+
+require 'open3'
+
+module DopCommon
+  module HashParser
+
+    # This method will set the key from a list of defined
+    # aliases or raise an error if multiple values are found
+    def key_aliases(hash, key, key_aliases)
+      value = hash[key]
+      key_aliases.each do |key_alias|
+        next if hash[key_alias].nil?
+        unless value.nil?
+          keys_with_values = key_aliases.select{|a| !hash[a].nil?}
+          keys_with_values << key if hash[key]
+          key_list = keys_with_values.map{|k| k.kind_of?(Symbol) ? ':' + k.to_s : k}.join(', ')
+          raise DopCommon::PlanParsingError,
+            "Two or more values found for the same thing. There can only be one of: #{key_list}"
+        else
+          value = hash[key] = hash.delete(key_alias)
+          key_s = key.kind_of?(Symbol) ? ':' + key.to_s : key
+          DopCommon.log.debug("Key alias found '#{key_alias}', mapping for key #{key_s}")
+        end
+      end
+    end
+    module_function :key_aliases
+
+    def symbolize_keys(hash)
+      if hash.kind_of?(Hash)
+        Hash[hash.map { |k, v| [k.to_sym, v] }] if hash.kind_of?(Hash)
+      else
+        hash
+      end
+    end
+    module_function :symbolize_keys
+
+    def deep_symbolize_keys(hash, stack = [])
+      # prevent loops in recursive function
+      return if stack.include?(hash.object_id)
+      stack << hash.object_id
+
+      if hash.kind_of?(Hash)
+        Hash[
+          hash.map do |k, v|
+            [k.respond_to?(:to_sym) ? k.to_sym : k, deep_symbolize_keys(v, stack)]
+          end
+        ]
+      elsif hash.kind_of?(Array)
+        hash.map { |v| deep_symbolize_keys(v, stack) }
+      else
+        hash
+      end
+    end
+    module_function :deep_symbolize_keys
+
+    # This method will retrun true if the String in 'value' starts and
+    # ends with /, which means it represents a regexp
+    def represents_regexp?(value)
+      if value.kind_of?(String)
+        value[/^\/(.*)\/$/, 1] ? true : false
+      else
+        false
+      end
+    end
+    module_function :represents_regexp?
+
+    # This method will return true if the string in 'value' represents
+    # a regex and if it is possible to create a regexp object
+    def is_valid_regexp?(value)
+      return false unless represents_regexp?(value)
+      regexp = value[/^\/(.*)\/$/, 1]
+      Regexp.new(regexp)
+      true
+    rescue
+      false
+    end
+    module_function :is_valid_regexp?
+
+    # This method takes a hash and a key. It will then validate the
+    # pattern list in the value of that key.
+    #
+    # Examples (Simple String/Regexp):
+    #
+    # hash = { :key => 'my_node'}
+    # hash = { :key => '/my_node/'}
+    #
+    # Examples (Array of Strings, Regexps):
+    #
+    # hash = { :key => [ 'my_node', '/my_node/' ] }
+    #
+    def pattern_list_valid?(hash, key, optional = true)
+      return false if hash[key].nil? && optional
+      [Array, String, Symbol].include? hash[key].class or
+        raise PlanParsingError, "The value for '#{key}' has to be a string, an array or a symbol."
+      [hash[key]].flatten.each do |pattern|
+        [String, Symbol].include? pattern.class or
+          raise PlanParsingError, "The pattern #{pattern} in '#{key}' is not a symbol or string."
+        if HashParser.represents_regexp?(pattern)
+          HashParser.is_valid_regexp?(pattern) or
+            raise PlanParsingError, "The pattern #{pattern} in '#{key}' is not a valid regular expression."
+        end
+      end
+      true
+    end
+    module_function :pattern_list_valid?
+
+    # This method takes a hash where all the values are pattern lists
+    # and checks if they are valid.
+    #
+    # Example:
+    #
+    # hash = {
+    #   :key => {
+    #     'list_1' => [ 'my_node', '/my_node/' ],
+    #     'list_2' => '/my_node'/
+    #   }
+    # }
+    #
+    def hash_of_pattern_lists_valid?(hash, key, optional = true )
+      return false if hash[key].nil? && optional
+      hash[key].kind_of?(Hash) or
+        raise PlanParsingError, "The value for '#{key}' has to be a Hash"
+      hash[key].each_key do |list_name|
+        list_name.kind_of?(String) or
+          raise PlanParsingError, "The key '#{list_name.to_s}' in '#{key}' has to be a String"
+        HashParser.pattern_list_valid?(hash[key], list_name)
+      end
+      true
+    end
+    module_function :hash_of_pattern_lists_valid?
+
+    # This method will parse a valid pattern list and replace regexp
+    # strings with Regexp objects.
+    def parse_pattern_list(hash, key)
+      case hash[key]
+      when 'all', 'All', 'ALL', :all then :all
+      else
+        patterns = [hash[key]].flatten.compact
+        patterns.map do |pattern|
+          HashParser.represents_regexp?(pattern) ? Regexp.new(pattern[/^\/(.*)\/$/, 1]) : pattern
+        end
+      end
+    end
+    module_function :parse_pattern_list
+
+    # This method will parse a hash of pattern lists and replace the
+    # regexp strings with Regexp objects
+    def parse_hash_of_pattern_lists(hash, key)
+      Hash[hash[key].map do |list_name, pattern_list|
+        [list_name, parse_pattern_list(hash[key], list_name)]
+      end]
+    end
+    module_function :parse_hash_of_pattern_lists
+
+    # Load string content from different sources
+    #
+    # the content can be directly a string in which case it will
+    # immediatly return.
+    # load_content('hello world')
+    #
+    # it may also be a hash with the following content:
+    # load_content({ file => '/path/to/some/file' })
+    # This will check if the file exists and load it
+    #
+    # you can also specify a script it will execute to get the
+    # content
+    # load_content({ exec => '/path/to/some/executable_file' })
+    def load_content(value)
+      if value.kind_of?(Hash)
+        method, params = symbolize_keys(value).first
+        file = case params
+        when Array  then params.join(' ')
+        when String then params
+        end
+        case method
+        when :file then File.read(file).chomp
+        when :exec
+          prog = params.first
+          args = params[1, params.length].join(' ')
+          o, e, s = Open3.capture3(Utils::sanitize_env, "#{prog} #{args}", :unsetenv_others => true)
+
+          unless s.success?
+            DopCommon.log.error("Standard error output of '#{prog} #{args}':\n#{e.chomp}")
+            DopCommon.log.error("Standard output of '#{prog} #{args}':\n#{o.chomp}")
+            raise PlanParsingError, "Program '#{prog}' returned non-zero exit status #{s.exitstatus}"
+          end
+
+          o.chomp
+        end
+      else
+        value
+      end
+    end
+    module_function :load_content
+
+    # This is the validation method for the load_content
+    # method and will check if the value is a correctly
+    # specified content source
+    def load_content_valid?(value)
+      case value
+      when String then true
+      when Hash
+        value.count == 1 or
+          raise PlanParsingError, "You can only specify one content type"
+        method, params = symbolize_keys(value).first
+        [:file, :exec].include?(method) or
+          raise PlanParsingError, "#{method} is not a valid content method. valid methods are :exec and :file"
+        file = case params
+        when Array
+          params.count >= 1 or
+            raise PlanParsingError, "The array for method #{method} has to have at least one entry"
+          params.all?{|e| e.kind_of?(String)} or
+            raise PlanParsingError, "The array for method #{method} can only contain strings"
+          method != :file or
+            raise PlanParsingError, "The method :file does not support arrays as an argument"
+          params.first
+        when String
+          params
+        else
+          raise PlanParsingError, "The value for method #{method} has to be an array or string"
+        end
+        File.exists?(file) or
+          raise PlanParsingError, "The file #{file} does not exist."
+        File.readable?(file) or
+          raise PlanParsingError, "The file #{file} is not readable."
+        if method == :exec
+          File.executable?(file) or
+            raise PlanParsingError, "The file #{file} is not executable."
+        end
+      else
+        raise PlanParsingError, 'The content source has to be a string or a hash with a content lookup method'
+      end
+      true
+    end
+    module_function :load_content_valid?
+
+  end
+end

data/lib/dop_common/hooks.rb

@@ -0,0 +1,81 @@
+#
+# DOP common hooks hash parser
+#
+module DopCommon
+  class Hooks
+    include Validator
+    include HashParser
+
+    def initialize(hash)
+      @hash = symbolize_keys(hash)
+    end
+
+    def validate
+      log_validation_method(:pre_create_vm_valid?)
+      log_validation_method(:post_create_vm_valid?)
+      log_validation_method(:pre_update_vm_valid?)
+      log_validation_method(:post_update_vm_valid?)
+      log_validation_method(:pre_destroy_vm_valid?)
+      log_validation_method(:post_destroy_vm_valid?)
+    end
+
+    def pre_create_vm
+      @pre_create_vm ||= pre_create_vm_valid? ? @hash[:pre_create_vm] : []
+    end
+
+    def post_create_vm
+      @post_create_vm ||= post_create_vm_valid? ? @hash[:post_create_vm] : []
+    end
+
+    def pre_update_vm
+      @pre_update_vm ||= pre_update_vm_valid? ? @hash[:pre_update_vm] : []
+    end
+
+    def post_update_vm
+      @post_update_vm ||= post_update_vm_valid? ? @hash[:post_update_vm] : []
+    end
+
+    def pre_destroy_vm
+      @pre_destroy_vm ||= pre_destroy_vm_valid? ? @hash[:pre_destroy_vm] : []
+    end
+
+    def post_destroy_vm
+      @post_destroy_vm ||= post_destroy_vm_valid? ? @hash[:post_destroy_vm] : []
+    end
+
+    private
+
+    def hook_valid?(hook_name)
+      return false unless @hash.has_key?(hook_name)
+      raise PlanParsingError, "Hook #{hook_name}: hooks must be a non-empty array of strings" if
+        !@hash[hook_name].kind_of?(Array) || @hash[hook_name].empty? || !@hash[hook_name].all? { |h| h.kind_of?(String) }
+      raise PlanParsingError, "Hook #{hook_name}: a hook must be an executable file" unless
+        @hash[hook_name].all? { |h| File.file?(h) && File.executable?(h) }
+      true
+    end
+
+    def pre_create_vm_valid?
+      hook_valid?(:pre_create_vm)
+    end
+
+    def post_create_vm_valid?
+      hook_valid?(:post_create_vm)
+    end
+
+    def pre_update_vm_valid?
+      hook_valid?(:pre_update_vm)
+    end
+
+    def post_update_vm_valid?
+      hook_valid?(:post_update_vm)
+    end
+
+    def pre_destroy_vm_valid?
+      hook_valid?(:pre_destroy_vm)
+    end
+
+    def post_destroy_vm_valid?
+      hook_valid?(:post_destroy_vm)
+    end
+  end
+end