Class: FqdnFacts::Handler

Inherits:
Object show all
Defined in:
lib/fqdn_facts/handler.rb

Overview

base class for all handlers.

DSL collapse

Instance Attribute Summary collapse

DSL collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(data = {}) ⇒ Handler

initilalizer

Parameters:

  • data (Hash) (defaults to: {}) —

    seeds the handler with base data

Options Hash (data):

  • :priority (Integer) —

    sets the initial priority level

  • :conversions (Hash) —

    sets the initial set of conversions

  • :components (Hash) —

    sets the initial component validations

  • :order (Array) —

    sets the initial order of components

  • :facts (Hash) —

    sets the initial set of facts



56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/fqdn_facts/handler.rb', line 56

def initialize(data = {})
  @priority        = data.delete(:priority)        || 1
  @conversions     = data.delete(:conversions)     || {}
  @components      = data.delete(:components)      || DEFAULT_COMPONENTS.dup
  @order           = data.delete(:order)           || DEFAULT_COMPONENTS.keys
  @facts           = data.delete(:facts)           || {}
  @fqdn            = ''

  add_fact(:fqdn) { fqdn }
  add_fact(:handler_class, self.class.to_s)
  add_fact(:handler_name) { handler_class.split('::').last.underscore }
end

Instance Attribute Details

#facts ⇒ Object

Returns the value of attribute facts.



38
39
40
 
# File 'lib/fqdn_facts/handler.rb', line 38

def facts
  @facts
end

#fqdn ⇒ Object

Returns the value of attribute fqdn.



38
39
40
 
# File 'lib/fqdn_facts/handler.rb', line 38

def fqdn
  @fqdn
end

#priority(value) ⇒ Object #priority ⇒ Object

The priority of the registered Fqdn Fact handler

Lower priority fqdn fact handlers win out over higer priority handlers.

Overloads:

  • #priority(value) ⇒ Object

    Sets the priority level

    Parameters:

    • value (Integer) —

      higher numbers denote lower priority, lower numbers denote higher

  • #priority ⇒ Object

    Retrieves the current priority level

Returns:

  • Integer



83
84
85
 
# File 'lib/fqdn_facts/handler.rb', line 83

def priority
  @priority
end

Class Method Details

.copy_from(other) ⇒ Handler

Creates a new instance of this object using the internal state of another handler object

Parameters:

  • other (Handler) —

    the handler to copy

Returns:



33
34
35
 
# File 'lib/fqdn_facts/handler.rb', line 33

def copy_from(other)
  new(other.export)
end

Instance Method Details

#<=>(other) ⇒ -1, ...

Compares the priority of this handler to another handler

Parameters:

  • other (Handler) —

    the handler to compare against

Returns:

  • (-1, 0, 1) —

    if other is <=, =, or >= self



275
276
277
 
# File 'lib/fqdn_facts/handler.rb', line 275

def <=>(other)
  self.priority <=> other.priority
end

#add_fact(name, value = nil, &block) ⇒ Object

Adds a fact, either using a static value, or a Proc/Lambda for runtime determination of the value.

Parameters:

  • name (String) —

    Symbol name of the fact to add

  • value (Scalar, Array, Hash, Proc) (defaults to: nil) —

    value of the fact



183
184
185
186
 
# File 'lib/fqdn_facts/handler.rb', line 183

def add_fact(name, value=nil, &block)
  value = block if block_given?
  facts[name.to_sym] = value
end

#all(prefix = nil) ⇒ Hash{Symbol=><Scalar,Hash,Array>} Also known as: retrieve_facts

Retrieve all facts, possibly prefixing their names (@see #retrieve)

Parameters:

  • prefix (String) (defaults to: nil) —

    a string to prefix every fact name with

Returns:

  • (Hash{Symbol=><Scalar,Hash,Array>}) 


223
224
225
 
# File 'lib/fqdn_facts/handler.rb', line 223

def all(prefix = nil)
  retrieve prefix: prefix
end

#component(component, validate = :any) ⇒ Object

Define a component’s validation rule.

Validation rules can be one of the following

* :any (the same as /.+/)
* A Hash of sub_component => regexp
* An array of valid values
* A scalar for exact matching

Parameters:

  • component (Symbol) —

    the name of the component to set validation for

  • validate (Hash{Symbol=>Symbol,Hash,Array,Scalar}) (defaults to: :any) —

    validation to perform for component



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/fqdn_facts/handler.rb', line 111

def component(component, validate=:any)
  v = case validate
    when :any then %r:(.+):
    when Hash then
      if @components[component.to_sym].is_a?(Hash)
        basis = @components[component.to_sym]
      else
        basis = {}
      end

      basis.merge(
        Hash[validate.keys.zip(
          validate.values.collect {|v|
            case v
              when :any then %r:(.+):
              when Regexp then v
              else Regexp.new(v)
            end
          }
        )]
      )
    when Array then
      %r:(#{validate.join('|')}):
    else validate
  end

  if @components[component.to_sym]
    # if their not the same class, then remove any conversions
    unless @components[component.to_sym].is_a?(v.class)
      @conversions.delete(component.to_sym)
    end
  end

  @components[component.to_sym]  = v
end

#convert(component, conversion = nil, &block) ⇒ Object

Defines a conversion rule for a given component. The conversion must be a Proc/Lambda

Parameters:

  • component (Symbol) —

    the name of the component to set validation for

  • conversion (Hash, Proc) (defaults to: nil) —

    optional conversion hash, proc/lambda

  • block (Proc) —

    optional block

Raises:

  • (ArgumentError) —

    if conversion isn’t Hash, Proc or Block



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/fqdn_facts/handler.rb', line 154

def convert(component, conversion=nil, &block)
  unless [Proc, Hash].any? { |klass| conversion.is_a?(klass) } || block_given?
    raise ArgumentError, 'expected Hash, Proc or Block'
  end

  component  = component.to_sym
  conversion = conversion || block

  conversion = if conversion.is_a? Hash
    (@conversions[component]||={}).merge(conversion)
  else
    conversion
  end

  @conversions[component] = conversion
end

#export ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Exports the internal state as a hash



281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/fqdn_facts/handler.rb', line 281

def export
  instance_variables.inject({}) do |exports, name|
    varname = name.to_s.tr('@', '').to_sym
    exports[varname] = begin
      Marshal.load(Marshal.dump(instance_variable_get(name)))
    rescue TypeError
      instance_variable_get(name).dup
    end
    exports
  end
end

#get_fact(name) ⇒ Object

Returns the value of a fact

Parameters:



174
175
176
 
# File 'lib/fqdn_facts/handler.rb', line 174

def get_fact(name)
  retrieve_facts[name.to_sym]
end

#match?(fqdn) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Checks to see if the fqdn matches this particular FQDN Fact Handler

Returns:

  • (Boolean) 


237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/fqdn_facts/handler.rb', line 237

def match?(fqdn)
  parts = fqdn.split('.', @order.size)
  return unless parts.size == @order.size

  debug "Validating #{self.class}:"

  test_data = @order.zip(parts)
  debug "  test data -> #{test_data.inspect}"

  test_data.all? do |name, value|
    debug "  validating component '#{name}'"
    validation = case @components[name]
      when Hash then Regexp.new(@components[name].values.join)
      when nil then %r:.+:
      else @components[name]
    end

    case validation
      when Regexp then
        (value =~ validation).tap { |r|
          debug "    Regexp -> #{value.inspect} =~ #{validation.inspect} == #{r.inspect}"
        }
      when Array  then
        validation.include?(value).tap { |r|
          debug "    Array -> #{validation.inspect}.include?(#{value.inspect}) == #{r.inspect}"
        }
      else
        (value == validation).tap { |r|
          debug "    #{validation.class} -> #{value.inspect} == #{validation.inspect} == #{r.inspect}"
        }
    end
  end.tap { |r| debug " ---> validation #{r ? 'successful' : 'failed'} for #{self.class}"}
end

#order(*args) ⇒ Object Also known as: components

Defines the order of the defined components that make up the FQDN.

This defaults to: host, :sub, :tld

Parameters:

  • args (Array<Symbol>) —

    list of ordered components

Raises:

  • (ArgumentError) —

    if args is empty



95
96
97
98
 
# File 'lib/fqdn_facts/handler.rb', line 95

def order(*args)
  raise ArgumentError, 'empty list of components' unless args.present?
  @order = args
end

#remove_fact(name) ⇒ Object

Removes a fact from the list of facts.

Parameters:



190
191
192
 
# File 'lib/fqdn_facts/handler.rb', line 190

def remove_fact(name)
  facts.delete(name.to_sym)
end

#retrieve(options = {}) ⇒ Hash{Symbol=><Scalar,Hash,Array>}

retrieve aggregated facts

Parameters:

  • options (Hash) (defaults to: {}) —

    options to use when retrieving facts

Options Hash (options):

  • :prefix (String) —

    a string to prefix every fact name with

  • :only (Array<Symbol>) —

    a list of specific facts to retrieve

Returns:

  • (Hash{Symbol=><Scalar,Hash,Array>}) 


204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/fqdn_facts/handler.rb', line 204

def retrieve(options={})
  prefix = options.delete(:prefix)
  only   = (o = options.delete(:only)).empty? ? nil : o.collect(&:to_sym)

  assemble.dup.tap do |facts|
    facts.replace(
      Hash[facts.inject({}) do |hash, (fact, value)|
        next hash unless only.empty? || only.include?(fact)
        key = prefix.empty? ? fact : "#{prefix}_#{fact}"
        hash[key] = value
        hash
      end.sort]
    )
  end
end

#to_h ⇒ Object

Returns Hash all aggregate facts.

Returns:

  • Hash all aggregate facts



231
232
233
 
# File 'lib/fqdn_facts/handler.rb', line 231

def to_h
  merge_facts.dup
end