class Topo::Provision::Generator

Attributes

topology[RW]

Public Class Methods

new(topo=nil) click to toggle source
# File lib/topo/provision/generator.rb, line 52
def initialize(topo=nil)
  @topology = topo
  @generators = { @driver_name => self }
end
register_generator(driver, class_name) click to toggle source
# File lib/topo/provision/generator.rb, line 46
def self.register_generator(driver, class_name)
   @@generator_classes[driver] = class_name
end

Public Instance Methods

context() click to toggle source
# File lib/topo/provision/generator.rb, line 179
def context()
  @context ||= Topo::Provision::ContextGenerator.new(@topology.provisioning,  @topology.driver)
end
driver(resource) click to toggle source
# File lib/topo/provision/generator.rb, line 112
def driver(resource)
  if resource['provisioning'] && resource['provisioning']['driver']
    resource_driver = resource['provisioning']['driver'].split(":",2)[0]
  else
  resource_driver = @topology.driver
  end
  resource_driver        
end
generate_context(action) click to toggle source

BASE DRIVER GENERATORS

# File lib/topo/provision/generator.rb, line 141
def generate_context(action)
  cxt_gen = context
  if (cxt_gen.respond_to? action)
    cxt_gen.send(action)
  else
    cxt_gen.send("default_action", action)
  end
end
generate_provisioning_recipe(action=:deploy) click to toggle source

Add resources & their generators to the topology generator, then call them in dependency order to generate the overall recipe TODO: Driver-specific generation of dependencies other than through topo refs, e.g. autoscaling depend on loadbalancer

# File lib/topo/provision/generator.rb, line 83
def generate_provisioning_recipe(action=:deploy)
  
  topology_generator = Topo::Provision::TopologyGenerator.new()
  generator(@topology.driver).generate_context(action)
   
  @topology.services.each do |service|
    depends_on = topo_refs(service).to_a
    process_lazy_attrs(service) if depends_on.length > 0
    topology_generator.add(service, depends_on,
    { :resource_generator => resource_generator(service['type'], service) })
  end
  
  @topology.nodes.each do |node|
    depends_on = topo_refs(node).to_a
    process_lazy_attrs(node) if depends_on.length > 0
    topology_generator.add(node, depends_on, 
    { :resource_generator => resource_generator("node", node) })
  end
  
  if [:undeploy, :stop].include?(action)
    topology_generator.reverse_generate(action)
  else
    topology_generator.generate(action)
  end

end
generator(driver) click to toggle source

Get the right generator for the driver in place (e.g. vagrant, fog)

# File lib/topo/provision/generator.rb, line 58
def generator(driver)
  unless @generators.key?(driver)
    
    generator_class = @@generator_classes[driver] 
    
    unless generator_class          
      begin
       require "topo/provision/#{driver}/generator"
       generator_class = @@generator_classes[driver]
       rescue LoadError => e
        STDERR.puts e.message
        STDERR.puts("#{driver} driver cannot be loaded - using default generator instead")
        generator_class = @@generator_classes["default"]              
      end
    end
            
    @generators[driver] = Object::const_get(generator_class).new(@topology)
  end
  
  @generators[driver]
end
load_balancer(data) click to toggle source
# File lib/topo/provision/generator.rb, line 175
def load_balancer(data)
  Topo::Provision::LoadBalancerGenerator.new(data)
end
node(data) click to toggle source

Functions to return the resource generators

# File lib/topo/provision/generator.rb, line 163
def node(data)
  if (data['provisioning'])
    if(data['provisioning']['node_group'] && data['provisioning']['node_group']['size'])
      Topo::Provision::NodeGroupGenerator.new(data)
    else 
      Topo::Provision::MachineGenerator.new(data)
    end
  else
    Topo::Provision::ChefNodeGenerator.new(data)
  end        
end
process_lazy_attrs(resource) click to toggle source

Convert attributes with references to lazy attributes, and return array of resource names that this resource depends on

# File lib/topo/provision/generator.rb, line 123
def process_lazy_attrs(resource)
  depends_on = Set.new
  if resource['attributes']
    resource['attributes'].each do |key, value|
      deps = topo_refs(value)
      if deps.size > 0
        depends_on.merge(deps)
        resource['lazy_attributes'][key] = lazy_attribute_to_s(value)
        resource['attributes'].delete(key)
      end
    end
  end
  depends_on.to_a
end
resource_generator(resource_type, data) click to toggle source
# File lib/topo/provision/generator.rb, line 150
def resource_generator(resource_type, data) 
  generator = nil
  driver_generator = generator(driver(data))
  if driver_generator.respond_to?(resource_type)
   generator = driver_generator.send(resource_type, data)
  else
    STDERR.puts "Driver #{@topology.driver} does not support resource type #{resource_type}"
  end
  generator
end