bcome 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a78ef0e9b999c6dc1c605b73791e5d853be3e5fa
-  data.tar.gz: 5585b40b46f2f0b962893161aaa566a698d8ddfd
+  metadata.gz: d0cd22d6c8adce1637dfdc5471fef725d49029c6
+  data.tar.gz: c700c7444533f603a03fb4c013093fc960c94a37
 SHA512:
-  metadata.gz: 4dc3a5c6bfeb933f670a63865cd57f5f697373c6793328a74d46d17c453bbabaf023379da4a16fbb97b1116747c769af5c800aad817f0a37770715fc207970fe
-  data.tar.gz: 0315e88f28e40b7d65fe161b4d982df9a404bb8f674a52c1e003beebc83d75e8df870b7f649a89d5b8108d8ec54c6cd8098f249ff991cc267334e9b346182b7e
+  metadata.gz: be8260d1736e4fd6a774084a5658bd4206c808d754df523eeb8e14fb29c6f2d804c21d0b360cf566eab58bcb0370fbf989a6c280c2a0a42b48d0ead1dcfa5d96
+  data.tar.gz: 91b19768fc4c7e8548d34dea211a7d153d6ece8d39f2f0430ee0f84166a3620c65bef1b649a7f7fe2596257b0539bf4d345259ff181e6e12e28f2dc74488eab7

data/bin/boot.rb

@@ -1,4 +1,8 @@
 
+
+extensions_init_path = "#{Dir.pwd}/bcome/extensions_initializer.rb"
+load extensions_init_path if File.exist?(extensions_init_path)
+
 ### Boot up bcome - used by the shell & exterior bcome processes
 
 unless @no_shell
@@ -110,7 +114,9 @@ if quick_contexts.any?
   end
 
   B_PIN = @context_object
+  RECIPES = ::Bcome::Orchestrator::Loader.new(@context_object.machines)
   B_PIN.init
 else
+  RECIPES = ::Bcome::Orchestrator::Loader.new(ESTATE.machines)
   ESTATE.init
 end

data/lib/bcome/version.rb

@@ -1,3 +1,3 @@
 module Bcome
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/command.rb

@@ -2,11 +2,14 @@ class ::Bcome::Command
 
   # Wraps a command. Convenient flex-point for logging etc
 
-  attr_reader :raw_command, :host_node, :stdout, :stderr, :exit_code, :exit_signal 
+  attr_reader :command, :stdout, :stderr, :exit_code, :exit_signal, :instance, :bootstrap, :success_exit_codes
+
+  def initialize(params)
+    @command = params[:command]
+    @instance = params[:instance]
+    @bootstrap = params[:bootstrap]  # whether to run this in bootstrap mode or not
+    @success_exit_codes = params[:success_exit_codes]
 
-  def initialize(raw_command, host_node)
-    @raw_command = raw_command
-    @host_node = host_node
     @stdout = ""
     @stderr = ""
     @exit_code = nil
@@ -17,13 +20,33 @@ class ::Bcome::Command
     return is_success? ? "Success".success : "Failed".failure
   end
 
+  def ssh_user
+    @bootstrap ? instance.bootstrap_settings[:ssh_user] : instance.ssh_user
+  end
+
+  def bootstrap=(bootstrap_value)
+    @bootstrap = bootstrap_value
+  end
+
+  def ssh_keys
+    @bootstrap ? [instance.bootstrap_settings[:key]] : instance.keys
+  end
+
+  def proxy
+    @bootstrap ? instance.proxy(true) : instance.proxy
+  end
+
   def output
     command_output = is_success? ? @stdout : "Exit code: #{@exit_code}\n\nSTDERR: #{@stderr}"
     return "\n#{command_output}\n"
   end
 
   def is_success?
-    exit_code == 0
+    success_exit_codes.include?(exit_code.to_s)
+  end
+
+  def success_exit_codes
+    return @success_exit_codes ? @success_exit_codes : ["0"]
   end
 
   def stdout=(data)

data/lib/context_functions.rb

@@ -8,7 +8,9 @@ module Bcome::ContextFunctions
   end
 
   def command_for_context(command)
-    return false unless context_cmd_functions || !context_cmd_functions.any? 
+    return false unless context_cmd_functions
+    return false if !context_cmd_functions.any?
+
     ccfs = context_cmd_functions.select{|ccf| ccf[:command].to_s == command.to_s }
     raise "Multiple context commands found at context level #{context_breadcrumb} for command key #{command}" if ccfs.size > 1 
     return ccfs.first

data/lib/helpers/environment_ssh.rb

@@ -1,17 +1,26 @@
 module ::Bcome::EnvironmentSSH
 
-  def proxy
+  def proxy(bootstrap = false)
     return nil unless ssh_mode_type == ::SSH_JUMP_MODE_IDENTIFIER
-    return Net::SSH::Proxy::Command.new(proxy_command)
+
+    unless bootstrap
+      return Net::SSH::Proxy::Command.new(proxy_command)
+    else
+      return Net::SSH::Proxy::Command.new(bootstrap_proxy_command)
+    end
   end
 
   def proxy_command
     return "ssh -W %h:%p #{bastion_ip_address}"
   end
 
-  def execute_command(commands, instance)
+  def bootstrap_proxy_command
+    return "ssh -i #{bootstrap_settings[:key]} -o StrictHostKeyChecking=no -W %h:%p #{bootstrap_settings[:ssh_user]}@#{bastion_ip_address}"
+  end
+
+  def execute_command(commands, instance, bootstrap = false)
     begin
-      return execute_cmd(commands, instance, proxy)
+      return execute_cmd(commands, instance, proxy(bootstrap), bootstrap)
     rescue Net::SSH::AuthenticationFailed
       raise "Could not authenticate connection to #{instance.identifier}".failure
     rescue Net::SSH::Disconnect
@@ -19,14 +28,14 @@ module ::Bcome::EnvironmentSSH
     end
   end
 
-  def execute_cmd(raw_commands, instance, proxy)
+  def execute_cmd(raw_commands, instance, proxy, bootstrap = false)
     commands = raw_commands.collect{|raw_command|
-      raw_command.is_a?(::Bcome::Command) ? raw_command : ::Bcome::Command.new(raw_command, instance)
+      raw_command.is_a?(::Bcome::Command) ? raw_command : ::Bcome::Command.new(:command => raw_command, :instance => instance, :bootstrap => bootstrap)
     }
 
-    ssh = ::Bcome::Ssh.new(commands, proxy, instance)
+    ssh = ::Bcome::Ssh.new(commands)
     ssh.execute!
-    return
+    return commands
   end
 
   def execute_scp_upload(files, remote_path, instance)
@@ -82,6 +91,10 @@ module ::Bcome::EnvironmentSSH
   end
 
   def bastion_ip_address
+    unless bastion_server
+      raise "Unable to fine the jump host. No instance found with identifier '#{@ssh_mode[:jump_host_identifier]}'.  Check your network.yml config for this stack, and ensure that you've got the correct value for key 'jump_host_identifier'"
+    end
+
     if dynamic_network_lookup? 
       return bastion_server.public_ip_address
     else

data/lib/helpers/instance_command.rb

@@ -1,24 +1,50 @@
 module ::Bcome::InstanceCommand
 
-  def run(raw_commands)
+  def run(raw_commands, bootstrap = false)
     commands = raw_commands.is_a?(String) ? [raw_commands] : raw_commands
-    execute_command(commands)
+    return execute_command(commands, bootstrap)
   end
 
-  def execute_command(commands)
-    @environment.execute_command(commands, self)
+  def execute_command(commands, bootstrap = false)
+    begin
+      return @environment.execute_command(commands, self, bootstrap)
+    rescue
+      unless bootstrap && bootstrap_settings  ### Try bootstrap fallback
+        puts "\n BOOTSTRAP MODE".informational  
+        bootstrap = true
+        return @environment.execute_command(commands, self, bootstrap)
+      end
+    end
   end
 
-  def put(local_path, remote_path)
+  def put(local_path, remote_path, bootstrap = false)
     puts "rsync> #{self.identifier}".informational
     if @environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER
-      rsync_command = "rsync #{rsync_is_sudo}-av #{local_path} #{self.ssh_user}@#{self.ip_address}:#{remote_path}"
+      ## DIRECT MODE
+      rsync_command = bootstrap ? direct_rsync_bootstrap(local_path, remote_path) : direct_rsync(local_path, remote_path)
     else
-      rsync_command = "rsync -av -e \"ssh -A #{self.nat_user}@#{@environment.bastion_ip_address} ssh -o StrictHostKeyChecking=no\" #{rsync_is_sudo}#{local_path} #{self.ssh_user}@#{self.ip_address}:#{remote_path}"
+      ## JUMP HOST MODE
+      rsync_command = bootstrap ? jump_host_rsync_bootstrap(local_path, remote_path)  : jump_host_rsync(local_path, remote_path)
     end
     run_local(rsync_command)
   end
 
+  def direct_rsync(local_path, remote_path)
+    "rsync #{rsync_is_sudo}-av #{local_path} #{self.ssh_user}@#{self.ip_address}:#{remote_path}"
+  end
+
+  def jump_host_rsync(local_path, remote_path)
+    "rsync -av -e \"ssh -A #{self.nat_user}@#{@environment.bastion_ip_address} ssh -o StrictHostKeyChecking=no\" #{rsync_is_sudo}#{local_path} #{self.ssh_user}@#{self.ip_address}:#{remote_path}"
+  end
+
+  def direct_rsync_bootstrap(local_path, remote_path)   
+    "rsync -i #{bootstrap_settings[:key]} #{rsync_is_sudo}-av #{local_path} #{bootstrap_settings[:ssh_user]}@#{self.ip_address}:#{remote_path}"
+  end
+
+  def jump_host_rsync_bootstrap(local_path, remote_path) 
+    "rsync -av -e \"ssh -i #{bootstrap_settings[:key]} -A #{bootstrap_settings[:ssh_user]}@#{@environment.bastion_ip_address} ssh -o StrictHostKeyChecking=no\" #{rsync_is_sudo}#{local_path} #{bootstrap_settings[:ssh_user]}@#{self.ip_address}:#{remote_path}"  
+  end
+
   def get(remote_path, local_path = local_download_path)
     raise "No local path specified" unless local_path
     raise "No remote_path specified" unless remote_path

data/lib/helpers/instance_ssh.rb

@@ -8,13 +8,14 @@ module ::Bcome::InstanceSsh
     end
   end
 
-  def ssh
-    execute_task(:do_ssh)
-  end
-
   def do_ssh(command)
     result = execute_task(:run_local, command)
-    raise "Unable to execute result" unless result # TODO node has not been bootstrapped most likely. Implement a fallback
+    unless result
+      if bootstrap_settings
+        puts "\n BOOTSTRAP MODE".informational
+        execute_task(:run_local, non_bootstrapped_ssh_command)
+      end 
+    end  
     return result
   end
   
@@ -63,6 +64,19 @@ module ::Bcome::InstanceSsh
     is_jump_ssh? ? (is_ssh_jump_host? ? do_ssh(ssh_jump_command_to_bastion) : do_ssh(ssh_jump_command_to_internal_node)) : do_ssh(direct_ssh_command)
   end
 
+  def non_bootstrapped_ssh_command
+    command = is_jump_ssh? ? (
+      is_ssh_jump_host? ? (
+       "ssh -i #{bootstrap_settings[:key]} #{bootstrap_settings[:ssh_user]}@#{ip_address}"
+      ) : (
+       "ssh -i #{bootstrap_settings[:key]} -t #{bootstrap_settings[:ssh_user]}@#{bastion_ip_address} ssh -t #{ip_address}"
+      )
+    ) : (
+       "ssh -i #{bootstrap_settings[:key]} #{bootstrap_settings[:ssh_user]}@#{ip_address}"
+    )
+    return command
+  end
+
   def is_ssh_jump_host?
     @role == ::SSH_JUMP_HOST_ROLE_IDENTIFIER
   end

data/lib/helpers/selections.rb

@@ -14,10 +14,10 @@ module ::Bcome::Selections
   end
 
   ## Runs commands over *every* object in the selection
-  def run(raw_commands)
+  def run(raw_commands, bootstrap = false)
     return unless @objects
     @objects.each do |object|
-      object.run(raw_commands)
+      object.run(raw_commands, bootstrap)
     end
     return
   end
@@ -26,14 +26,14 @@ module ::Bcome::Selections
     !@objects || @objects.empty?
   end
 
-  def put(local_path, remote_path)
+  def put(local_path, remote_path, bootstrap = false)
     if no_selections?
       no_selections_error
       return  
     end
 
     @objects.each do |object|
-      object.put(local_path, remote_path)
+      object.put(local_path, remote_path, bootstrap)
     end
     return
   end

data/lib/nodes/instance.rb

@@ -16,10 +16,26 @@ module ::Bcome::Node
       @environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER ? public_ip_address : @external_network_interface_address
     end
 
+    def bootstrap_settings
+      @environment.bootstrap_settings
+    end
+
+    def proxy(bootstrap = false)
+      @environment.proxy(bootstrap)
+    end
+
     def public_ip_address
       @public_ip_address
     end
 
+    def hostname_map
+      return "ip-#{ip_address.to_s.gsub(".","-")}"
+    end
+
+    def ec2_hostname
+      return "#{hostname_map}.ec2.internal"
+    end
+
     def role
       @role
     end

data/lib/orchestrator/command_group/base.rb

@@ -0,0 +1,56 @@
+module ::Bcome::Orchestrator::CommandGroup
+  class Base
+
+    class << self
+      def new_of_type_from(json, node_targets, all_machines, direct_command_groups)
+        raise "Missing command type in #{json.inspect}" unless json.has_key?(:type) 
+        raise "Invalid command of type #{json[:type]} in #{json.inspect}" unless klass_for_type.keys.include?(json[:type])
+
+        klass = klass_for_type[json[:type]]
+
+        command_group = klass.new(json)
+        command_group.set_machines(node_targets)
+
+        if klass == ::Bcome::Orchestrator::CommandGroup::Direct 
+          command_group.direct_command_groups = direct_command_groups
+        end
+
+        return command_group
+      end
+ 
+      def klass_for_type
+        {
+          "DIRECT" => ::Bcome::Orchestrator::CommandGroup::Direct,
+          "CUSTOM" => ::Bcome::Orchestrator::CommandGroup::Custom
+        }  
+      end
+    end
+
+    attr_reader :machines
+
+    include ::Bcome::Orchestrator::ValidateAndSet
+
+    def initialize(json)
+      validate_and_set(json)
+    end
+
+    def json_attributes
+      raise "json_attributes should be overidden on derived Orchestrator::Command classes"
+    end
+
+    def set_machines(node_targets)
+      @machines ||= node_targets.select{ |nt|
+         nt.target_key == @target_nodes_key
+       }.collect(&:node_selections).flatten!
+    end
+  
+    def json_attributes
+      [:target_nodes_key]
+    end
+
+    def execute!(*params)
+      raise "Should be overidden"
+    end
+
+  end
+end

data/lib/orchestrator/command_group/custom.rb

@@ -0,0 +1,13 @@
+module ::Bcome::Orchestrator::CommandGroup
+  class Custom < ::Bcome::Orchestrator::CommandGroup::Base
+
+    def json_attributes
+      super + [:bcome_command]
+    end
+
+    def execute!(current_context_machines)
+      ::Bcome::Orchestrator::CustomCommand.send(@bcome_command, current_context_machines)
+    end
+
+  end
+end

data/lib/orchestrator/command_group/direct.rb

@@ -0,0 +1,53 @@
+module ::Bcome::Orchestrator::CommandGroup
+  class Direct < ::Bcome::Orchestrator::CommandGroup::Base
+ 
+    attr_reader :commands, :direct_command_groups
+ 
+    def initialize(*params)
+      super
+    end
+
+    def json_attributes
+      super + [:direct_command_set_key]
+    end
+
+    def direct_command_groups=(groups)
+      @direct_command_groups = groups.select{|dcg| dcg.direct_command_set_identifier == @direct_command_set_key}
+    end
+
+    def commands
+      @commands ||= set_commands
+    end
+
+    def execute!(current_context_machines)
+      # Per command group
+      @direct_command_groups.each do |direct_command_group| 
+        # Per unique machine instance
+        current_context_machines.each do |machine|
+          kommands = []
+          direct_command_group.command_instances.flatten.each do |command_instance|
+            kommands << ::Bcome::Command.new(:command => command_instance.cmd, :instance => machine, :bootstrap => command_instance.bootstrap, :success_exit_codes => command_instance.success_exit_codes) 
+          end
+
+          begin 
+            execute_commands(kommands)
+          rescue Net::SSH::AuthenticationFailed => e
+            if machine.bootstrap_settings
+              ## Fallback to execute commands without bootstrap set
+              kommands.each {|kommand| kommand.bootstrap = true }
+              execute_commands(kommands)
+            else
+              raise e
+            end
+          end
+        end
+      end
+    end
+
+    def execute_commands(commands)
+      ssh = ::Bcome::Ssh.new(commands)
+      ssh.execute!
+    end
+
+  end
+end

data/lib/orchestrator/direct_command/group.rb

@@ -0,0 +1,21 @@
+module ::Bcome::Orchestrator::DirectCommand
+  class Group
+
+    include ::Bcome::Orchestrator::ValidateAndSet
+
+    attr_reader :commands, :direct_command_set_identifier, :description
+
+    def initialize(json)
+      validate_and_set(json)
+    end
+
+    def command_instances
+      @command_instances ||= commands.collect{|raw_command| ::Bcome::Orchestrator::DirectCommand::Instance.new(raw_command)}
+    end
+
+    def json_attributes
+      [:direct_command_set_identifier, :commands, :description]
+    end
+
+  end
+end

data/lib/orchestrator/direct_command/instance.rb

@@ -0,0 +1,19 @@
+module ::Bcome::Orchestrator::DirectCommand
+  class Instance
+
+    include ::Bcome::Orchestrator::ValidateAndSet
+
+    attr_reader :cmd, :bootstrap, :success_exit_codes
+
+    def initialize(json)
+      validate_and_set(json)
+      @bootstrap = json[:bootstrap] ? json[:bootstrap] : false
+      @success_exit_codes = json[:success_exit_codes]
+    end
+
+    def json_attributes
+      [:cmd]
+    end
+
+  end
+end

data/lib/orchestrator/factory.rb

@@ -0,0 +1,38 @@
+module Bcome::Orchestrator
+  module Factory
+
+    class << self
+      def create_recipes_from_json(json, node_targets, all_machines, direct_commands)
+        validate_json_collection(json) 
+        return json.collect{|instance_json| ::Bcome::Orchestrator::Recipe.new(instance_json, node_targets, all_machines, direct_commands) }
+      end
+
+      def create_command_groups_from_json(json, node_targets, all_machines, direct_commands)
+        validate_json_collection(json)
+        return json.collect{|instance_json| ::Bcome::Orchestrator::CommandGroup::Base.new_of_type_from(instance_json, node_targets, all_machines, direct_commands) }
+      end
+
+      def create_node_targets_from_json(json, machines)
+        validate_json_collection(json)
+        user_defined_targets = json.collect{|instance_json| ::Bcome::Orchestrator::NodeTarget::Base.new_of_type_from(instance_json, machines) }
+        return user_defined_targets + system_node_targets(machines)
+      end
+
+      def system_node_targets(machines)
+        [
+          ::Bcome::Orchestrator::NodeTarget::All.new(:node_selections => machines, :target_key => "all")
+        ]
+      end
+
+      def create_direct_commands_from_json(json)
+        validate_json_collection(json)
+        return json.collect{|instance_json| ::Bcome::Orchestrator::DirectCommand::Group.new(instance_json) }
+      end
+
+      def validate_json_collection(json)
+        raise "Cannot create Orchestrator recipes - expecting a JSON array" unless json.is_a?(Array)
+      end
+    end
+  
+  end
+end

data/lib/orchestrator/loader.rb

@@ -0,0 +1,43 @@
+module Bcome::Orchestrator
+  class Loader
+
+    def initialize(machines)
+      config_path = "#{Dir.pwd}/bcome/config/orchestration"
+      @recipes_path = "#{config_path}/command_recipes.yml"
+      @machine_targets_path = "#{config_path}/node_target_selectors.yml"
+      @direct_commands_path = "#{config_path}/direct_command_sets.yml"
+      @machines = machines
+    end
+
+    def recipes
+      @recipes ||= ::Bcome::Orchestrator::Factory.create_recipes_from_json(do_load_recipes, node_targets, @machines, direct_commands)
+    end
+
+    def node_targets
+      @node_targets ||= ::Bcome::Orchestrator::Factory.create_node_targets_from_json(do_load_machine_targets, @machines)
+    end
+
+    def direct_commands
+      @direct_commands ||= ::Bcome::Orchestrator::Factory.create_direct_commands_from_json(do_load_direct_commands)
+    end
+
+    def do_load_recipes
+      return json_from_file(@recipes_path)
+    end
+
+    def do_load_direct_commands
+      return json_from_file(@direct_commands_path)
+    end
+
+    def do_load_machine_targets
+      return json_from_file(@machine_targets_path)
+    end
+
+    def json_from_file(file_path)
+      raise "Cannot load file #{file_path}" unless File.exist?(file_path)
+      file_contents = File.read(file_path)
+      return  YAML.load(file_contents)
+    end
+
+  end
+end

data/lib/orchestrator/node_target/all.rb

@@ -0,0 +1,14 @@
+module ::Bcome::Orchestrator::NodeTarget
+  class All < ::Bcome::Orchestrator::NodeTarget::Base
+
+    def initialize(params)
+      @node_selections = params[:node_selections]
+      @target_key = params[:target_key]
+    end
+  
+    def override_validate_and_set?
+      true
+    end
+
+  end
+end

data/lib/orchestrator/node_target/all_excluding_roles.rb

@@ -0,0 +1,14 @@
+module ::Bcome::Orchestrator::NodeTarget
+  class AllExcludingRoles < ::Bcome::Orchestrator::NodeTarget::Base
+
+    def set_machines(machines)
+      exclusion_roles = @selectors[:exclusion_roles]
+      raise "No exclusion roles set for node target of type all_excluding_roles" unless exclusion_roles
+
+      @node_selections = machines.select{|machine|
+        !exclusion_roles.include?(machine.role)
+      }
+    end
+
+  end
+end

data/lib/orchestrator/node_target/all_with_roles.rb

@@ -0,0 +1,14 @@
+module ::Bcome::Orchestrator::NodeTarget
+  class AllWithRoles < ::Bcome::Orchestrator::NodeTarget::Base
+
+    def set_machines(machines)
+      inclusion_roles = @selectors[:inclusion_roles]
+      raise "No exclusion roles set for node target of type all_with_roles" unless inclusion_roles
+
+      @node_selections = machines.select{|machine|
+        inclusion_roles.include?(machine.role)
+      }
+    end
+
+  end
+end

data/lib/orchestrator/node_target/base.rb

@@ -0,0 +1,43 @@
+module ::Bcome::Orchestrator::NodeTarget
+  class Base
+
+    class << self
+      def new_of_type_from(json, machines)
+        raise "Missing node target type in #{json.inspect}" unless json.has_key?(:type)
+        raise "Invalid node target of type #{json[:type]} in #{json.inspect}" unless klass_for_type.keys.include?(json[:type])
+        node_target = klass_for_type[json[:type]].new(json)
+        node_target.set_machines(machines)
+        return node_target
+     end
+
+      def klass_for_type
+        {
+          "single" => ::Bcome::Orchestrator::NodeTarget::Single,
+          "all_excluding_roles" => ::Bcome::Orchestrator::NodeTarget::AllExcludingRoles,
+          "all_with_roles" => ::Bcome::Orchestrator::NodeTarget::AllWithRoles
+        } 
+      end
+    end
+
+    include ::Bcome::Orchestrator::ValidateAndSet
+
+    attr_reader :node_selections, :target_key
+ 
+    def initialize(json)
+      validate_and_set(json) unless override_validate_and_set?
+    end
+
+    def override_validate_and_set?
+      false
+    end
+
+    def json_attributes
+      [:target_key, :selectors]
+    end
+
+    def set_machines(*params)
+      raise "Override set_machines in derived types - each type has its own distinct selector, and is passed an array of machines available at the current bcome context." 
+    end
+
+  end
+end

data/lib/orchestrator/node_target/single.rb

@@ -0,0 +1,13 @@
+module ::Bcome::Orchestrator::NodeTarget
+  class Single < ::Bcome::Orchestrator::NodeTarget::Base
+
+    def set_machines(machines)
+      machine_role = @selectors[:role]
+      raise "No machine role set for node target of type single" unless machine_role
+      @node_selections = machines.select{|machine| machine.role == machine_role }
+      raise "Multiple machines found with role #{machine_role}. Selection is ambiguous. Maybe you meant to use the 'all_with_roles' node_target type?" if @node_selections.size > 1
+      raise "No machines found with role #{machine_role} for node_target type single." unless @node_selections.any?
+    end
+
+  end
+end

data/lib/orchestrator/recipe.rb

@@ -0,0 +1,51 @@
+module ::Bcome::Orchestrator
+  class Recipe
+
+    class << self
+      def execute!(params)
+        raise "No recipe name provided" unless params && params.is_a?(Hash) && params[:name]
+        recipe = by_identifier(params[:name])
+        raise "No recipe found matching #{params[:name]}" unless recipe
+        recipe.execute!
+      end
+
+      def by_identifier(identifier)
+        all_recipes = RECIPES.recipes
+        return all_recipes.select{|recipe| recipe.recipe_identifier == identifier }.first
+      end
+
+      def as_menu_items
+        ::RECIPES.recipes.collect {|recipe| { :command => recipe.recipe_identifier, :description => "(Command recipe): #{recipe.description}" } }
+      end
+
+    end
+
+    attr_reader :command_groups, :recipe_identifier, :description
+
+    include ::Bcome::Orchestrator::ValidateAndSet
+
+    def initialize(json, node_targets, all_machines, direct_commands)
+      validate_and_set(json)
+      set_command_groups(json, node_targets, all_machines, direct_commands)        
+    end
+
+    def json_attributes
+      [:recipe_identifier, :description]
+    end
+
+    def execute!(current_context_machines)
+      @command_groups.each do |command_group|
+        puts "\nExecuting command group".informational
+        command_group.execute!(current_context_machines)
+        puts "\n" 
+      end
+    end
+
+    def set_command_groups(json, node_targets, all_machines, direct_commands)
+      commands_json = json[:commands]
+      raise "Expecting commands within an Orchestrator recipe as an Array" unless commands_json.is_a?(Array)
+      @command_groups = ::Bcome::Orchestrator::Factory.create_command_groups_from_json(commands_json, node_targets, all_machines, direct_commands)
+    end
+
+  end
+end

data/lib/orchestrator/validate_and_set.rb

@@ -0,0 +1,10 @@
+module ::Bcome::Orchestrator::ValidateAndSet
+  
+  def validate_and_set(json)
+    json_attributes.each{|attribute|
+      raise "Missing attribute #{attribute} in #{json.inspect}" unless json.has_key?(attribute)
+      instance_variable_set("@#{attribute}".to_sym, json[attribute])
+    }
+  end
+
+end

data/lib/render_irb.rb

@@ -14,6 +14,9 @@ class ::Bcome::RenderIrb
   end
 
   def menu(menu_items)
+    recipe_menu_items = ::Bcome::Orchestrator::Recipe.as_menu_items
+    menu_items +=  recipe_menu_items if recipe_menu_items.any? 
+
     menu_str = "\n** Commands **\n\n"
     menu_str = "\n\The following commands are available: \n\n"
     menu_items.each do |item|

data/lib/ssh.rb

@@ -2,30 +2,31 @@ class ::Bcome::Ssh
 
   attr_reader :commands
 
-  def initialize(commands, proxy, instance)
+  def initialize(commands)
     @commands = commands
-    @proxy = proxy
-    @instance = instance
   end
 
   def execute!
-    ::Net::SSH.start(@instance.ip_address, @instance.ssh_user, :proxy => @proxy, :keys => @instance.keys, :paranoid => false) do |ssh|
-      @commands.each do |command|
-        puts "(#{@instance.identifier}) #{@user}$ #{command.raw_command}".command
-        ssh_exec!(ssh, command)
+    @commands.each do |command|
+      instance = command.instance
+      ssh_user = command.ssh_user
+      ssh_keys = command.ssh_keys
+      proxy = command.proxy
 
+      ::Net::SSH.start(instance.ip_address, ssh_user, :proxy => proxy, :keys => ssh_keys, :paranoid => false) do |ssh|
+        puts "(#{instance.identifier})$ #{command.command}".command
+        ssh_exec!(ssh, command)
         puts command.output
-
         print command.pretty_result
-        puts "\n"
+        print "\n"
+        ssh.close
       end
-      ssh.close
     end
   end
 
   def ssh_exec!(ssh, command)
     ssh.open_channel do |channel|
-      channel.exec(command.raw_command) do |ch, success|
+      channel.exec(command.command) do |ch, success|
         unless success
           abort "FAILED: couldn't execute command (ssh.channel.exec)"
         end

data/lib/stack/base.rb

@@ -19,6 +19,10 @@ module ::Bcome::Stack
     def method_missing(method_sym, *arguments, &block)
       if command_for_context = command_for_context(method_sym)
         execute_command_for_context(command_for_context)
+      elsif recipe = ::Bcome::Orchestrator::Recipe.by_identifier(method_sym.to_s)
+        puts "Executing Command Recipe #{recipe.recipe_identifier}".informational
+        puts "Description: #{recipe.description}".command
+        recipe.execute!(machines)
       else
         super
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bcome
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Guillaume Roderick (Webzakimbo)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2015-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -145,6 +145,20 @@ files:
 - lib/nodes/instance.rb
 - lib/nodes/platform.rb
 - lib/object.rb
+- lib/orchestrator/command_group/base.rb
+- lib/orchestrator/command_group/custom.rb
+- lib/orchestrator/command_group/direct.rb
+- lib/orchestrator/direct_command/group.rb
+- lib/orchestrator/direct_command/instance.rb
+- lib/orchestrator/factory.rb
+- lib/orchestrator/loader.rb
+- lib/orchestrator/node_target/all.rb
+- lib/orchestrator/node_target/all_excluding_roles.rb
+- lib/orchestrator/node_target/all_with_roles.rb
+- lib/orchestrator/node_target/base.rb
+- lib/orchestrator/node_target/single.rb
+- lib/orchestrator/recipe.rb
+- lib/orchestrator/validate_and_set.rb
 - lib/patches/string.rb
 - lib/render_irb.rb
 - lib/scp.rb