Class: SparkleFormation::Resources

Inherits:
Object
  • Object
show all
Extended by:
Utils::AnimalStrings
Defined in:
lib/sparkle_formation/resources.rb,
lib/sparkle_formation/resources/aws.rb,
lib/sparkle_formation/resources/heat.rb,
lib/sparkle_formation/resources/azure.rb,
lib/sparkle_formation/resources/google.rb,
lib/sparkle_formation/resources/rackspace.rb,
lib/sparkle_formation/resources/terraform.rb

Overview

Resources helper

Direct Known Subclasses

Aws, Azure, Google, Heat, Rackspace, Terraform

Defined Under Namespace

Classes: Aws, Azure, Google, Heat, Property, Rackspace, Resource, Terraform, UpdateCausesConditional

Constant Summary collapse

RESOURCE_TYPE_TR =

Characters to be removed from supplied key on matching

"_:"
RESOURCE_TYPE_NAMESPACE_SPLITTER =

String to split for resource namespacing

"::"
PROPERTY_UPDATE_CONDITIONALS =

Property update conditionals Format: Smash.new(RESOURCE_TYPE => => [PropertyConditional])

Smash.new

Class Method Summary collapse

Methods included from Utils::AnimalStrings

camel, snake

Class Method Details

.base_key ⇒ String

Returns base registry key.

Returns:

  • (String) —

    base registry key



81
82
83
 
# File 'lib/sparkle_formation/resources.rb', line 81

def base_key
  Bogo::Utility.snake(self.name.split("::").last) # rubocop:disable Style/RedundantSelf
end

.load(json_path_or_hash) ⇒ TrueClass

Register all discovered resources

Parameters:

  • json_path_or_hash (String, Hashish) —

    path to files or hash

Returns:

  • (TrueClass) 


120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/sparkle_formation/resources.rb', line 120

def load(json_path_or_hash)
  case json_path_or_hash
  when String
    content = AttributeStruct.hashish.new(MultiJson.load(File.read(json_path_or_hash)))
  when Hash
    content = json_path_or_hash
  else
    raise TypeError.new("Expecting `String` or `Hash` type but received `#{json_path_or_hash.class}`")
  end
  content.each do |type, hash|
    register(type, hash)
  end
  true
end

.load! ⇒ TrueClass

Load the builtin AWS resources

Returns:

  • (TrueClass) 


138
139
140
 
# File 'lib/sparkle_formation/resources.rb', line 138

def load!
  true
end

.lookup(key) ⇒ Hashish, NilClass

Registry information for given type

Parameters:

  • key (String, Symbol)

Returns:

  • (Hashish, NilClass) 


191
192
193
 
# File 'lib/sparkle_formation/resources.rb', line 191

def lookup(key)
  @@registry[base_key][key] || @@registry[base_key][registry_key(key)]
end

.register(type, hash) ⇒ TrueClass

Register resource

Parameters:

  • type (String) —

    Orchestration resource type

  • hash (Hash) —

    metadata information

Returns:

  • (TrueClass) 


90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/sparkle_formation/resources.rb', line 90

def register(type, hash)
  unless hash.is_a?(Hash)
    raise TypeError.new("Expecting `Hash` type but received `#{hash.class}`")
  end
  unless class_variable_defined?(:@@registry)
    @@registry = AttributeStruct.hashish.new
  end
  @@registry[base_key] ||= AttributeStruct.hashish.new
  @@registry[base_key][type.to_s] = hash
  true
end

.registry ⇒ Hashish

Returns currently loaded AWS registry.

Returns:

  • (Hashish) —

    currently loaded AWS registry



196
197
198
199
200
201
 
# File 'lib/sparkle_formation/resources.rb', line 196

def registry
  unless class_variable_defined?(:@@registry)
    @@registry = AttributeStruct.hashish.new
  end
  @@registry[base_key]
end

.registry_key(key) ⇒ String, NilClass

Discover registry key via part searching

Parameters:

  • key (String, Symbol)

Returns:

  • (String, NilClass) 


146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/sparkle_formation/resources.rb', line 146

def registry_key(key)
  if registry[key]
    result = key
  else
    o_key = key
    key = key.to_s.downcase.tr(self.const_get(:RESOURCE_TYPE_TR), "") # rubocop:disable Style/RedundantSelf
    snake_parts = nil
    result = @@registry[base_key].keys.detect do |ref|
      ref = ref.downcase
      snake_parts = ref.split(resource_type_splitter)
      until snake_parts.empty?
        break if snake_parts.join("") == key
        snake_parts.shift
      end
      !snake_parts.empty?
    end
    if result
      collisions = @@registry[base_key].keys.find_all do |ref|
        split_ref = ref.downcase.split(resource_type_splitter)
        ref = Array(split_ref.slice(split_ref.size - snake_parts.size, split_ref.size)).join("")
        key == ref
      end
      if collisions.size > 1
        raise ArgumentError.new "Ambiguous dynamic name returned multiple matches! " \
                                "`#{o_key.inspect}` -> #{collisions.sort.join(", ")}"
      end
    end
  end
  result
end

.resource(identifier, key = nil) ⇒ Hashish, NilClass

Resource information

Parameters:

  • identifier (String, Symbol) —

    resource identifier

  • key (String, Symbol) (defaults to: nil) —

    specific data

Returns:

  • (Hashish, NilClass) 


107
108
109
110
111
112
113
114
 
# File 'lib/sparkle_formation/resources.rb', line 107

def resource(identifier, key = nil)
  res = lookup(identifier)
  if key && res
    res[key.to_sym]
  else
    res
  end
end

.resource_customizer(struct, lookup_key) ⇒ SparkleStruct

Simple hook method to allow resource customization if the specific provider requires/offers extra setup

Parameters:

Returns:



209
210
211
 
# File 'lib/sparkle_formation/resources.rb', line 209

def resource_customizer(struct, lookup_key)
  struct
end

.resource_lookup(type) ⇒ Resource

Information about specific resource type

Parameters:

  • type (String) —

    resource type

Returns:



217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/sparkle_formation/resources.rb', line 217

def resource_lookup(type)
  result = registry[type]
  if result
    properties = result.fetch("full_properties", {}).map do |p_name, p_info|
      Property.new(p_name,
                   p_info[:description],
                   p_info[:type],
                   p_info[:required],
                   p_info[:update_causes],
                   self.const_get(:PROPERTY_UPDATE_CONDITIONALS).get(type, p_name))
    end
    Resource.new(type, properties, result)
  else
    raise KeyError.new "Failed to locate requested resource type: `#{type}`"
  end
end

.resource_type_splitter ⇒ Regexp

rubocop:disable Style/RedundantSelf

Returns:

  • (Regexp) —

    value for resource splitting



179
180
181
182
183
184
185
 
# File 'lib/sparkle_formation/resources.rb', line 179

def resource_type_splitter
  Regexp.new(
    [self.const_get(:RESOURCE_TYPE_NAMESPACE_SPLITTER)].flatten.compact.map { |value|
      Regexp.escape(value)
    }.join("|")
  )
end