bcome 0.7.0 → 1.0.0

data/lib/orchestrator/node_target/all_with_roles.rb

@@ -1,14 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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
-    end
-
-  end
-end

data/lib/orchestrator/recipe.rb

@@ -1,60 +0,0 @@
-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!
-        return
-      end
-
-      def by_identifier(identifier, stack_level_instance)
-        all_recipes = stack_level_instance.recipes
-        return all_recipes.select{|recipe| recipe.recipe_identifier == identifier }.first
-      end
-
-      def as_menu_items(stack_level_instance)
-        stack_level_instance.recipes.collect {|recipe| { :command => recipe.recipe_identifier, :description => recipe.description } }
-      end
-
-    end
-
-    attr_reader :command_groups, :recipe_identifier, :description, :bootstrap
-
-    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, :bootstrap]
-    end
-
-    def optional_json_attributes
-      [:bootstrap]
-    end 
-
-    def execute!(current_context_machines)
-      @command_groups.each do |command_group|
-        puts "\nExecuting command group".informational
-        command_group.execute!(current_context_machines, as_bootstrap)
-        puts "\n" 
-      end
-    end
-
-    def as_bootstrap
-      bootstrap ? true : false
-    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/registry.rb

@@ -1,37 +0,0 @@
-module Bcome::Orchestrator::Registry
-
-  CONFIGS_PATH = "bcome/config/orchestration"
-
-  def do_load_recipes
-    return [] unless config_for_registry.any?
-    ::Bcome::Orchestrator::Loader.new(machines, config_for_registry).recipes
-  end
-
-  def config_for_registry
-    return [] unless has_registry_config?
-
-    matching_keys = []
-    recipe_registry.keys.each {|registry_key|
-      matching_keys << registry_key if /^#{registry_key}$/.match(context_breadcrumb)
-    }
-
-    return matching_keys.collect{|registry_key| recipe_registry[registry_key] }.flatten
-  end
-
-  def recipe_registry
-    load_recipe_registry
-  end
-
-  def load_recipe_registry
-    return YAML.load_file(registry_configs_path)
-  end
-
-  def registry_configs_path
-    "#{CONFIGS_PATH}/registry.yml"
-  end
-
-  def has_registry_config?
-    File.exist?(registry_configs_path)
-  end
-
-end

data/lib/orchestrator/validate_and_set.rb

@@ -1,10 +0,0 @@
-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) if !json.has_key?(attribute) && !optional_json_attributes.include?(attribute)
-      instance_variable_set("@#{attribute}".to_sym, json[attribute])
-    }
-  end
-
-end

data/lib/patches/string.rb

@@ -1,86 +0,0 @@
-class String
-
-  # with thanks to http://simianuprising.com/wp-content/uploads/2012/08/solarized-reference-horizontal.png
-  def colour_codes
-    {
-      :yellow => "#b58900",
-      :orange => "#cb4b16",
-      :red => "#dc322f",
-      :magenta => "#d33682",
-      :violet => "#6c71c4",
-      :blue => "#268bd2",
-      :cyan => "#2aa198",
-      :green => "#859900",
-      :white => "#ffffff"
-    }
-  end
-
-  def highlight_colour_codes
-    {
-      :yellow => "#002b36",
-      :orange => "#073642",
-      :red => "#586e75",
-      :magenta => "#657b83",
-      :violet => "#839496",
-      :blue => "#93a1a1",
-      :cyan => "#eee8d5",
-      :green => "#fdf6e3"
-    }
-  end
-
-  def colours
-    {
-      :informational => { :colour => :yellow },
-      :failure => { :colour => :red },
-      :success => { :colour => :green },
-      :title => { :colour => :green },
-      :command => {  :colour => :cyan, :highlight => true },
-      :danger => { :colour => :red },
-      :warning => { :colour => :orange },
-      :friendly => { :colour => :green },
-      :menu_item_green => { :colour => :green },
-      :menu_title_orange => { :colour => :orange, :highlight => true },
-      :menu_item_orange => { :colour => :orange },
-      :menu_title_green => { :colour => :green, :highlight => true },
-      :menu_item_white => { :colour => :white },
-      :menu_item_yellow => { :colour => :yellow },
-      :menu_item_cyan => { :colour => :cyan },
-      :selections => { :colour => :cyan },
-      :menu_title_cyan => { :colour => :cyan, :highlight => true },
-      :headsup => { :colour => :orange, :highlight => true },
-      :menu_item_magenta => { :colour => :magenta },
-      :cyan => { :colour => :cyan },
-      :yellow => { :colour => :yellow },
-      :orange => { :colour => :orange }
-    }
-  end
-
-  def has_colour?(colour_key)
-    colours.has_key?(colour_key)
-  end
-
-  def method_missing(method_sym, *arguments, &black)
-    super unless has_colour?(method_sym)
-    colour_data = colours[method_sym]
-
-    colour = colour_codes[colour_data[:colour]]
-
-    unless colour_data[:highlight]
-      return Rainbow(self).color(colour)
-    else
-      coloured_string = Rainbow(self).color(colour)
-      return "\e[1m#{coloured_string}\033[0m"
-
-      #highlight_colour = highlight_colour_codes[colour_data[:colour]]
-      #highlight_string = Rainbow(self).color(highlight_colour).bg(colour)
-      return "\e[1m#{highlight_string}\033[0m"
-    end
-  end
-
-  def swatch
-     colours.each { |colour_key, colour_attributes|
-       puts "#{colour_key} : #{send(colour_key)}"
-     }
-  end
-
-end

data/lib/progress_bar.rb

@@ -1,31 +0,0 @@
-require 'singleton'
-
-class ProgressBar
-
-  include Singleton
-
-  attr_reader :count
-
-  def initialize
-    @count = 0
-  end
-
-  def increment!
-    @count += 1
-  end
-
-  def reset!
-    @count = 0
-  end
-
-  def indicate(bar_prefix, bar_indice, indice_descriptor)
-    bar = "#{bar_prefix}" + "#{bar_indice * @count}>".cyan + " (#{@count} #{indice_descriptor})" + "\r"    
-    print bar
-  end
-
-  def indicate_and_increment!(bar_prefix, bar_indice, indice_descriptor)
-    increment!
-    indicate(bar_prefix, bar_indice, indice_descriptor)
-  end
-
-end

data/lib/render_irb.rb

@@ -1,53 +0,0 @@
-class ::Bcome::RenderIrb
-
-  def list_items(parent_collection, items)
-    if !items || !items.any?
-      print "\nNo active resource collections found.\n".headsup
-    else
-     print "\n\s"
-     puts "#{parent_collection.to_s.menu_title_green}\n".menu_title_green
-     items.sort_by {|item| item.identifier }.each do |item|
-        puts "\t*/added".danger + "\n" if item.highlight?
-        print item.do_describe
-      end
-      print "\n\s\sTo work on any given node, use the cd command e.g. cd #{items.first.identifier}\n\n"
-    end
-  end
-
-  def menu(menu_items, stack_level_instance)
-    menu_str = "\n\s#{"Basic Commands".menu_title_green}\n\n"
-    menu_items.each_with_index do |item, index|
-      menu_str += construct_menu_item_string(item, index, :menu_item_green)
-    end
-
-    recipe_menu_items = ::Bcome::Orchestrator::Recipe.as_menu_items(stack_level_instance)    
-    if recipe_menu_items.any?  
-      menu_str += "\n\s#{"Orchestration Menu".menu_title_orange}\n\n"   
-      recipe_menu_items.each_with_index do |item, index|
-        menu_str += construct_menu_item_string(item, index, :menu_item_orange)
-      end 
-    end
-
-    menu_str += stack_level_instance.context_commands if stack_level_instance.context_commands
-
-    menu_str += "\n\n"
-    print menu_str
-    return
-  end
-
-  def construct_menu_item_string(item, index, colour)
-    command = item[:command]
-    description = item[:description]
-    usage = item[:usage]
-    menu_str = "#{tab}#{index+1}. #{description}".send(colour) + "\n"
-    menu_str += "#{tab}" + "Command: ".menu_item_cyan + "#{command}\n".menu_item_white
-    menu_str += "#{tab}" + "Usage: ".menu_item_cyan + "#{usage}\n".menu_item_white if usage
-    menu_str += "\n"
-    return menu_str
-  end
-
-  def tab
-    "\s\s\s"
-  end
-
-end

data/lib/scp.rb

@@ -1,40 +0,0 @@
-class ::Bcome::Scp
-
-   def initialize(proxy, node)
-    @proxy = proxy
-    @node = node
-  end
-
-  def download!(remote_path, local_path = @node.local_download_path)
-    local("mkdir -p #{local_path}", true)
-    ::Net::SCP.start(@node.ip_address, @node.ssh_user, { :proxy => @proxy, :keys => @node.keys, :paranoid => false }) do |scp|
-      scp.download!(remote_path, local_path, { :recursive => true, :preserve => true, :verbose => true }) do |cha, name, received, total|
-        pct = received / total.to_f
-        cnt = ( 72 * pct ).ceil
-        print "%-72s %.2f%%\r" % [ ("#" * cnt), ( pct * 100 ) ]
-      end
-    end
-    puts "done: files copied to #{local_path}".informational
-  end
-
-  def upload!(files, remote_path)
-    puts "scp> #{@node.identifier}".informational
-    ::Net::SCP.start(@node.ip_address, @node.ssh_user, { :proxy => @proxy, :keys => @node.keys, :paranoid => false }) do |scp|
-      files = files.is_a?(Array) ? files : [files]
-      files.each do |local_path|
-        name_old = ""
-        scp.upload!(local_path, remote_path, { :recursive => true }) do |ch, name, sent, total|
-        log_string = "#{name}: #{sent}/#{total}"
-        if name_old == name
-            STDOUT.write "\r#{log_string}"
-          else
-            STDOUT.write "\n\r#{log_string}"
-          end
-          name_old = name
-        end
-      end
-    end
-    puts # we don't control the output here, this moves us down a line:
-  end
-
-end

data/lib/ssh.rb

@@ -1,51 +0,0 @@
-class ::Bcome::Ssh
-
-  attr_reader :commands
-
-  def initialize(commands)
-    @commands = commands
-  end
-
-  def output_append(output_string)
-    @output_string = "#{@output_string}#{output_string}"
-  end
-
-  def print_output
-    print "#{@output_string}\n"
-  end
-
-  def execute!
-    @commands.each do |command|
-      instance = command.instance
-      ssh = instance.ssh_connection(command.bootstrap)
-      ssh_exec!(ssh, command)
-      output_append("\n(#{instance.identifier})$".cyan + ">\s#{command.command} (#{command.pretty_result})\n")
-      output_append("#{command.output}")
-      print_output
-    end
-  end
-
-  def ssh_exec!(ssh, command)
-    ssh.open_channel do |channel|
-      channel.exec(command.command) do |ch, success|
-        unless success
-          abort "FAILED: couldn't execute command (ssh.channel.exec)"
-        end
-        channel.on_data do |ch,data|
-          command.stdout +=data
-        end
-        channel.on_extended_data do |ch,type,data|
-          command.stderr +=data
-        end
-        channel.on_request("exit-status") do |ch,data|
-          command.exit_code = data.read_long
-        end
-        channel.on_request("exit-signal") do |ch, data|
-          command.exit_signal = data.read_long
-        end
-      end
-    end
-    ssh.loop
-  end
-
-end