souffle 0.0.1 → 0.0.2

data/lib/souffle/provider/vagrant.rb

@@ -1,15 +1,52 @@
-require 'souffle/provider'
+require 'souffle/template'
+require 'ostruct'
 
 # The Vagrant souffle provider.
-class Souffle::Provider::Vagrant < Souffle::Provider
+class Souffle::Provider::Vagrant < Souffle::Provider::Base
+  attr_reader :vagrant_dir
 
   # Setup the internal Vagrant configuration and object.
-  def setup
+  def initialize
+    super()
+    @vagrant_dir = @system.try_opt(:vagrant_dir)
+    create_new_vm_group unless current_folder_has_souffle_config?
+    generate_vagrant_config
   end
 
-  # The name of the given provider.
-  def name; "Vagrant"; end
+  # Creates a system using vagrant as the provider.
+  # 
+  # @param [ Souffle::System ] system The system to instantiate.
+  # @param [ String ] tag_prefix The tag prefix to use for the system.
+  def create_system(system, tag_prefix=nil)
+  end
+
+  # Takes a node definition and begins the provisioning process.
+  # 
+  # @param [ Souffle::Node ] node The node to instantiate.
+  # @param [ String ] tag The tag to use for the node.
+  def create_node(node, tag=nil)
+  end
 
   # Noop.
   def create_raid; end
+
+  # Checks if the current folder has the souffle configuration object.
+  # 
+  # @return [ Boolean ] Whether or not we're in a souffle Vagrant project.
+  def current_folder_has_souffle_config?
+    File.exists? "#{Dir.pwd}/souffle.json"
+  end
+
+  # Creates a new virtualmachine group.
+  def create_new_vm_group
+  end
+
+  # Generates the multi-vm configuration.
+  def generate_vagrant_config
+    template = Souffle::Template.new('Vagrantfile.erb')
+    temp_binding = OpenStruct.new
+    temp_binding.version = Souffle::VERSION
+    
+    template.render(temp_binding)
+  end
 end

data/lib/souffle/provisioner.rb

@@ -0,0 +1,55 @@
+# Starts up the base provisioner class with system and node state machines.
+class Souffle::Provisioner; end
+
+require 'souffle/provisioner/node'
+require 'souffle/provisioner/system'
+
+# Starts up the base provisioner class with system and node state machines.
+class Souffle::Provisioner
+  attr_reader :provider, :system
+
+  # Creates a new provisioner.
+  def initialize
+    @provider = initialize_provider
+    @provisioner = nil
+  end
+
+  # Creates the system object from a hash.
+  # 
+  # @param [ Hash ] system_hash The system represented in hash format.
+  def setup_system(system_hash)
+    @system = Souffle::System.from_hash(system_hash)
+    @provider = initialize_provider(
+      cleanup_provider(@system.try_opt[:provider]))
+  end
+
+  # Cleans up the provider name to match the providers we have.
+  # 
+  # @param [ String ] provider The name of the provider to use.
+  # 
+  # @return [ String ] The cleaned up provider name.
+  def cleanup_provider(provider)
+    lookups = {}
+    Souffle::Provider.constants.each { |k| lookups[k.to_s.downcase] = k.to_s }
+    lookups.fetch([provider.downcase], provider)
+  end
+
+  # Sets up the given provider to be used for the creation of a system.
+  # 
+  # @param [ String ] provider The system provider to use for provisioning.
+  def initialize_provider(provider=nil)
+    prv = cleanup_provider(Souffle::Config[:provider])
+    Souffle::Provider.const_get(prv).new
+  rescue Souffle::Exceptions::InvalidAwsKeys => e
+    Souffle::Log.error "#{e.message}:\n#{e.backtrace.join("\n")}"
+  rescue Exception
+    raise Souffle::Exceptions::InvalidProvider,
+      "The provider Souffle::Provider::#{prv} does not exist."
+  end
+
+  # Starts the provisioning process keeping a local lookup to the provisioner.
+  def begin_provisioning
+    @provisioner = Souffle::Provisioner::System.new(@system, @provider)
+  end
+  
+end

data/lib/souffle/provisioner/node.rb

@@ -0,0 +1,157 @@
+require 'state_machine'
+
+# The node provisioning statemachine.
+class Souffle::Provisioner::Node
+  attr_accessor :time_used
+
+  state_machine :state, :initial => :initializing do
+    after_transition any => :handling_error, :do => :error_handler
+    after_transition any => :creating, :do => :create
+    after_transition :creating => :booting, :do => :boot
+    after_transition :booting => :partitioning_device,
+                          :do => :partition_device
+    after_transition :partitioning_device => :installing_mdadm,
+                          :do => :setup_mdadm
+    after_transition :installing_mdadm => :initializing_raid,
+                          :do => :setup_raid
+    after_transition :initializing_raid => :formatting_device,
+                          :do => :format_device
+    after_transition :formatting_device => :ready_to_provision,
+                          :do => :ready
+    after_transition any => :provisioning, :do => :provision
+
+    event :reclaimed do
+      transition any => :creating
+    end
+
+    event :initialized do
+      transition :initializing => :creating
+    end
+
+    event :created do
+      transition :creating => :booting
+    end
+
+    event :booted do
+      transition :booting => :partitioning_device
+    end
+
+    event :partitioned_device do
+      transition :partitioning_device => :installing_mdadm
+    end
+
+    event :mdadm_installed do
+      transition :installing_mdadm => :initializing_raid
+    end
+
+    event :raid_initialized do
+      transition :initializing_raid => :formatting_device
+    end
+
+    event :device_formatted do
+      transition :formatting_device => :ready_to_provision
+    end
+
+    event :begin_provision do
+      transition :ready_to_provision => :provisioning
+    end
+
+    event :provisioned do
+      transition :provisioning => :complete
+    end
+
+    event :error_occurred do
+      transition any => :handling_error
+    end
+
+    event :failed do
+      transition any => :handling_failure
+    end
+
+    around_transition do |system, transition, block|
+      start = Time.now
+      block.call
+      system.time_used += Time.now - start
+    end
+  end
+
+  # Creates a new node provisioner state machine.
+  # 
+  # @param [ Souffle::Node ] node The node to manage.
+  # @param [ Fixnum ] max_failures The maximum number of failures.
+  def initialize(node, max_failures=3)
+    @time_used = 0
+    @node = node
+    @max_failures = max_failures
+    super() # NOTE: This is here to initialize state_machine.
+  end
+
+  # Creates the node from an api or command.
+  def create
+    Souffle::Log.info "#{@node.log_prefix} Creating a new node..."
+    provider.create_node(@node)
+  end
+
+  # Boots up the node and waits for ssh.
+  def boot
+    Souffle::Log.info "#{@node.log_prefix} Booting node..."
+    provider.boot(@node)
+  end
+
+  # Installs and sets up mdadm.
+  def setup_mdadm
+    Souffle::Log.info "#{@node.log_prefix} Setting up mdadm..."
+    provider.setup_mdadm(@node)
+  end
+
+  # Partitions the soon to be raid device.
+  def partition_device
+    Souffle::Log.info "#{@node.log_prefix} Partitioning the device..."
+    provider.partition(@node)
+  end
+
+  # Formats a device to the configured filesystem.
+  def format_device
+    Souffle::Log.info "#{@node.log_prefix} Formatting the device..."
+    provider.format_device(@node)
+  end
+
+  # Sets up raid to the configured raid-level.
+  def setup_raid
+    Souffle::Log.info "#{@node.log_prefix} Setting up raid..."
+    provider.setup_raid(@node)
+  end
+
+  # Notify the logger when the node is ready for provisioning.
+  def ready
+    Souffle::Log.info "#{@node.log_prefix} Is ready for provisioning..."
+  end
+
+  # Provisions the given node with a chef/chef-solo run.
+  def provision
+    Souffle::Log.info "#{@node.log_prefix} Provisioning node..."
+    provider.provision(@node)
+  end
+
+  # Kills the node entirely.
+  def kill
+    Souffle::Log.info "#{@node.log_prefix} Killing node..."
+    provider.kill(@node)
+  end
+
+  # Kills the node and restarts the creation loop.
+  def kill_and_recreate
+    Souffle::Log.info "#{@node.log_prefix} Recreating node..."
+    provider.kill_and_recreate(@node)
+  end
+
+  # Handles any 
+  def error_handler
+    Souffle::Log.info "#{@node.log_prefix} Handling node error..."
+  end
+
+  # Helper function for the node's system provider.
+  def provider
+    @node.system.provisioner.provider
+  end
+end

data/lib/souffle/provisioner/system.rb

@@ -0,0 +1,195 @@
+require 'state_machine'
+
+require 'souffle/polling_event'
+
+# The system provisioning statemachine.
+class Souffle::Provisioner::System
+  attr_accessor :time_used, :provider
+
+  attr_reader :max_failures
+
+  state_machine :state, :initial => :initializing do
+    after_transition any => :handling_error, :do => :error_handler
+    after_transition :initializing => :creating, :do => :create
+    after_transition :creating => :provisioning, :do => :provision
+    after_transition any => :initializing, :do => :create
+
+    event :initialized do
+      transition :initializing => :creating
+    end
+
+    event :created do
+      transition :creating => :provisioning
+    end
+
+    event :provisioned do
+      transition :provisioning => :complete
+    end
+
+    event :error_occurred do
+      transition any => :handling_error
+    end
+
+    event :creation_halted do
+      transition any => :failed
+    end
+
+    event :reclaimed do
+      transition any => :initializing
+    end
+
+    around_transition do |system, transition, block|
+      start = Time.now
+      block.call
+      system.time_used += Time.now - start
+    end
+  end
+
+  # Creates a new system using a specific provider.
+  # 
+  # @param [ Souffle::System ] system The system to provision.
+  # @param [ Souffle::Provider::Base ] provider The provider to use.
+  # @param [ Fixnum ] max_failures the maximum number of failures.
+  # @param [ Fixnum ] timeout The maximum time to wait for node creation.
+  def initialize(system, provider, max_failures=3, timeout=500)
+    @failures = 0
+    @system = system
+    @provider = provider
+    @time_used = 0
+    @timeout = timeout
+    @max_failures = max_failures
+    super() # NOTE: This is here to initialize state_machine.
+  end
+
+  # Creates the system from an api or command.
+  def create
+    Souffle::Log.info "[#{system_tag}] Creating a new system..."
+    @system.nodes.each do |node|
+      node.provisioner = Souffle::Provisioner::Node.new(node)
+      node.provisioner.initialized
+    end
+    wait_until_created
+  end
+
+  # Provisioning the system.
+  # 
+  # @todo We should really have these provisioned with fibers.
+  def provision
+    Souffle::Log.info "[#{system_tag}] Provisioning the system..."
+    @system.rebalance_nodes
+    @system.nodes.each do |node|
+      when_parents_are_complete(node) { node.provisioner.begin_provision }
+    end
+    wait_until_complete
+  end
+
+  # Wait until all of the parent nodes are in a completed state and yield.
+  def when_parents_are_complete(node)
+    total_nodes = node.parents.size
+    if total_nodes == 0
+      yield if block_given?
+      all_complete = true
+    else
+      all_complete = false
+    end
+    timer = EM::PeriodicTimer.new(2) do
+      nodes_complete = node.parents.select do |n|
+        n.provisioner.state == "complete"
+      end.size
+
+      if nodes_complete == total_nodes
+        all_complete = true
+        timer.cancel
+        yield if block_given?
+      end
+    end
+
+    EM::Timer.new(@timeout) do
+      unless all_complete
+        Souffle::Log.error "[#{system_tag}] Parent creation timeout reached."
+        timer.cancel
+        error_occurred
+      end
+    end
+  end
+
+  # Kills the system.
+  def kill_system
+    # @provider.kill(@system.nodes)
+  end
+
+  # Handles the error state and recreates the system
+  def error_handler
+    @failures += 1
+    if @failures >= @max_failures
+      Souffle::Log.error "[#{system_tag}] Complete failure. Halting Creation."
+      creation_halted
+    else
+      err_msg =  "[#{system_tag}] Error creating system. "
+      err_msg << "Killing and recreating..."
+      Souffle::Log.error(err_msg)
+      kill_system
+      reclaimed
+    end
+  end
+
+  private
+
+  # Helper function for the system tag.
+  # 
+  # @param [ String ] The system or global tag.
+  def system_tag
+    @system.try_opt(:tag)
+  end
+
+  # Wait until all of the nodes are ready to be provisioned and then continue.
+  def wait_until_created
+    total_nodes = @system.nodes.size
+    all_created = false
+    timer = EM::PeriodicTimer.new(2) do
+      nodes_ready = @system.nodes.select do |n|
+        n.provisioner.state == "ready_to_provision"
+      end.size
+
+      if nodes_ready == total_nodes
+        all_created = true
+        timer.cancel
+        created
+      end
+    end
+
+    EM::Timer.new(@timeout) do
+      unless all_created
+        Souffle::Log.error "[#{system_tag}] System creation timeout reached."
+        timer.cancel
+        error_occurred
+      end
+    end
+  end
+
+  # Wait until all of the nodes are provisioned and then continue.
+  def wait_until_complete
+    total_nodes = @system.nodes.size
+    all_complete = false
+    timer = EM::PeriodicTimer.new(2) do
+      nodes_ready = @system.nodes.select do |n|
+        n.provisioner.state == "complete"
+      end.size
+
+      if nodes_ready == total_nodes
+        all_complete = true
+        timer.cancel
+        created
+      end
+    end
+
+    EM::Timer.new(@timeout) do
+      unless all_complete
+        Souffle::Log.error "[#{system_tag}] System provision timeout reached."
+        timer.cancel
+        error_occurred
+      end
+    end
+  end
+
+end