bcome 0.0.3

data/lib/object.rb

@@ -0,0 +1,72 @@
+class Object
+
+  include ::Bcome::CommandHelper
+
+  def list
+    BOOT.send(:list)  ### Our starting point in the hierarchy... maybe this is all ultimately configurable?
+  end
+  alias :ls :list
+
+  def become_identifier
+    ::START_PROMPT
+  end
+
+  def become(object)
+    BECOME.set(object, self)
+  end
+  
+  def workon(identifier)
+    resource = resource_for_identifier(identifier)
+
+    unless resource
+      puts "No matching #{collection_key} for identifier '#{identifier}'. #{available_resources_options_string}".failure
+    else
+      puts "\\ \nFrom #{resource.reference_key}, working on #{identifier}\n".command
+      become(resource)
+    end
+  end
+  alias :w :workon
+
+  def menu_items
+    [
+      { :command => "list / ls", :description => "List all available resources at the current context." },
+      { :command => "describe", :description => "Describe the resource object at the current context." },
+      { :command => "workon' / w", :description => "Select a resource object, and switch to its context.", :usage => "workon 'identifier'" },
+      { :command => "exit", :description => "Close the current context" },
+      { :command => "exit!", :description => "Close all contexts, and exit Become."},
+      { :command => "local", :description => "Execute a shell command on your local machine.", :usage => 'local "command"'}
+    ]
+  end
+
+  def menu
+    ::RENDER.menu(menu_items)
+  end
+
+  def highlight?
+    false  ## override in stack objects that should be highlighted within a list, e.g. instance objects at the environment level that have been selected to workon on
+  end
+
+  def available_resources_options_string
+    "Please select from one of '#{all_items.join(', ')}'"
+  end
+
+  def describe
+    if self.respond_to?(:do_describe)
+      message = "\nCollection Key: #{reference_key}\n\nResource: #{self.do_describe}".colorize(:green)
+    else
+      message = "\nNothing to describe. Use 'list' to see namespace options".headsup unless self.respond_to?(:do_describe)
+    end
+    puts message
+  end
+
+  def set_irb_prompt(conf)
+    conf[:PROMPT][:CUSTOM] = {
+      :PROMPT_N => "\e[1m:\e[m ",
+      :PROMPT_I => "\e[1m#{BECOME.irb_prompt} >\e[m ",
+      :PROMPT_C => "\e[1m#{BECOME.irb_prompt} >\e[m ",
+      :RETURN => ::VERBOSE ? "%s \n" : "\n"
+    }
+    conf[:PROMPT_MODE] = :CUSTOM
+  end
+
+end

data/lib/patches/string.rb

@@ -0,0 +1,43 @@
+class String
+
+  def informational
+    self.colorize(:white).on_green
+  end
+
+  def command
+    self.colorize(:black).on_white
+  end
+
+  def failure
+    self.colorize(:red).on_white
+  end
+
+  def success
+    self.friendly
+  end
+
+  def friendly
+    self.colorize(:black).on_green
+  end 
+
+  def warning
+    self.colorize(:orange).on_black
+  end
+
+  def menu
+    self.colorize(:yellow).on_black
+  end
+
+  def headsup
+    self.colorize(:yellow).on_black
+  end
+
+  def output
+    self
+  end
+
+  def bg_gray 
+    "\033[47m#{self}\033[0m"
+  end
+
+end

data/lib/render_irb.rb

@@ -0,0 +1,34 @@
+class ::Bcome::RenderIrb
+
+  def list_items(parent_collection, items)
+    if !items || !items.any?
+      print "\nNo resources collections found. Maybe you forgot to add any?".headsup
+    else
+     print  "\n #{parent_collection}\n\n".colorize(:green) # are available:\n\n".colorize(:green)
+     items.each do |item|
+        colour = item.highlight? ? :yellow : :green
+        print "* #{item.do_describe}\n".colorize(colour)
+      end
+    end
+    print "\n"
+  end
+
+  def menu(menu_items)
+    menu_str = "\n** Commands **\n\n"
+    menu_str = "\n\The following commands are available: \n\n"
+    menu_items.each do |item|
+      command = item[:command]
+      description = item[:description]
+      usage = item[:usage]
+
+      menu_str += "> #{command}\n"
+      menu_str += "- #{description}\n"
+      menu_str += "e.g. #{usage}\n" if usage
+
+      menu_str += "\n"
+    end
+    menu_str += "\n\n"
+    print menu_str.menu
+  end
+
+end

data/lib/scp.rb

@@ -0,0 +1,29 @@
+class ::Bcome::Scp
+
+  def initialize(files, remote_path, proxy, node)
+    @files = files
+    @proxy = proxy
+    @node = node
+    @remote_path = remote_path
+  end
+
+  def upload!
+    puts "scp> #{@node.identifier}".informational
+    ::Net::SCP.start(@node.ip_address, @node.ssh_user, { :proxy => @proxy, :keys => @node.keys, :paranoid => false }) do |scp|
+      @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

@@ -0,0 +1,49 @@
+class ::Bcome::Ssh
+
+  attr_reader :commands
+
+  def initialize(commands, proxy, node)
+    @commands = commands
+    @proxy = proxy
+    @node = node
+  end
+
+  def execute!
+    ::Net::SSH.start(@node.ip_address, @node.ssh_user, :proxy => @proxy, :keys => @node.keys, :paranoid => false) do |ssh|
+      @commands.each do |command|
+        puts "(#{@node.identifier}) #{@user}$ #{command.raw_command}".command
+        ssh_exec!(ssh, command)
+
+        puts command.output
+
+        print command.pretty_result
+        puts "\n"
+      end
+      ssh.close
+    end
+  end
+
+  def ssh_exec!(ssh, command)
+    ssh.open_channel do |channel|
+      channel.exec(command.raw_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

data/lib/stack/environment.rb

@@ -0,0 +1,117 @@
+module ::Bcome::Stack
+  class Environment
+
+    include ::Bcome::BecomeObject
+    include ::Bcome::Selections
+    include ::Bcome::FogHelper
+    include ::Bcome::EnvironmentSSH
+
+    class << self
+      def collection_from_config(parent, configuration)
+        collection = []
+        configuration.each do |meta_data|
+          collection << new(meta_data, parent) if meta_data[:network].to_s == parent.identifier.to_s 
+        end
+        return collection
+      end
+    end
+
+    attr_reader :identifier, :platform, :meta_data
+
+    def initialize(meta_data, parent)
+      @meta_data = meta_data
+      @identifier = meta_data[:environment]
+      @platform = parent
+    end  
+
+    def menu_items
+      super + [
+        { :command => "add", :description => "Add a resource you wish to work on.", :usage => "add 'identifier', OR add ['array', 'of', 'identifiers']" },
+        { :command => "add!", :description => "Add all resources from the current context." },
+        { :command => "remove", :description => "Remove a resource you no longer with to work on.", :usage => "remove 'identifier', OR remove ['array', 'of','identifiers']" },
+        { :command => "clear!", :description => "Remove all selected resources." },
+        { :command => "selections", :description => "Show all added resources." },
+        { :command => "rsync", :description => "Rsync files to all selected resources.", :usage => "rsync 'localpath', 'remotepath'" },
+        { :command => "run", :description => "Execute a command on all selected resources", :usage => "run 'command'" },
+        { :command => "scp", :description => "SCP files up to all selected resources", :usage => "scp ['array','of', 'file', 'paths'], 'remote_path'" },
+      ]
+    end
+  
+    def bastion_server
+      resources.select{|resource| resource.identifier == @meta_data[:ssh_mode][:jump_host_identifier] }.first
+    end
+
+    def ssh_mode_type
+      ssh_mode_type = @meta_data[:ssh_mode][:type]
+      raise "Invalid ssh mode type #{ssh_mode_type}. Should be one of #{valid_ssh_modes.join(", ")}".failure unless valid_ssh_modes.include?(ssh_mode_type)
+      return @meta_data[:ssh_mode][:type]
+    end
+
+    def ssh_mode_user
+      return @meta_data[:ssh_mode][:ssh_user]
+    end 
+
+    def valid_ssh_modes
+      [::SSH_JUMP_MODE_IDENTIFIER, ::SSH_DIRECT_MODE_IDENTIFIER]
+    end
+ 
+    def bastion_ip_address
+      if dynamic_network_lookup?  
+        return bastion_server.public_ip_address
+      else
+        bastion_ip_address = @meta_data[:ssh_mode][:jump_host_ip_address]
+        raise "No jump_host_ip_address specified in your configuration.".failure unless bastion_ip_address
+        return bastion_ip_address
+      end
+    end
+
+    def network_lookup
+      raise "Missing network lookup in networks_environment configuration".failure unless @meta_data[:network_lookup]
+      return @meta_data[:network_lookup]
+    end
+
+    def network_lookup_type
+      type = network_lookup[:type]
+      raise "Unknown network lookup type '#{type}" unless ["dynamic", "static"].include?(type)
+      return type
+    end
+
+    def dynamic_network_lookup?
+      return network_lookup_type == "dynamic"
+    end
+
+    def do_load_resources
+     if dynamic_network_lookup? 
+       return collection_klass.collection_from_fog_data(self, servers)
+     else
+       path = config_path
+       raise "Missing instances.yml configuration for your environment. You've selected a static network lookup, and yet I cannot find #{config_path}".failure unless File.exist?(config_path)
+       config = YAML.load_file(path)
+       return collection_klass.collection_from_config(self, config)
+     end
+    end
+
+    def config_path
+      "#{CONFIGS_PATH}/static_instances/#{platform.identifier}_#{identifier}-instances.yml"
+    end
+
+    def do_describe
+      desc = "#{identifier}"
+      desc += "\t[ Net lookup: #{network_lookup_type}"
+      desc += "\t * SSH Mode: #{ssh_mode_type} ]"
+    end
+
+    def collection_klass
+      ::INSTANCE_STACK_KLASS
+    end
+
+    def reference_key
+      :environments
+    end
+
+    def collection_key
+      :instances
+    end 
+
+  end
+end

data/lib/stack/instance.rb

@@ -0,0 +1,92 @@
+module ::Bcome::Stack
+  class Instance
+
+    include ::Bcome::BecomeObject
+    include ::Bcome::InstanceSsh
+    include ::Bcome::InstanceCommand
+
+    class << self
+      def collection_from_fog_data(parent, fog_instances)
+        collection = []
+        fog_instances.each do |f_instance|
+
+          meta_data = {
+            :identifier => f_instance.tags["Name"],
+            :external_network_interface_address => f_instance.private_ip_address,
+            :public_ip_address => f_instance.public_ip_address,
+            :role => f_instance.tags["function"]
+          }
+          collection << new(meta_data, parent)
+        end
+        return collection
+      end
+
+      def collection_from_config(parent, configuration)
+        conf_for_env = configuration[:instances]
+        collection = []
+        conf_for_env.each do |meta_data|
+          collection << new(meta_data, parent) 
+        end
+        return collection
+      end
+    end
+
+    attr_reader :environment
+
+    def initialize(meta_data, parent)
+      @meta_data = meta_data
+      @environment = parent
+    end
+
+    def menu_items
+      super + [
+        { :command => "rsync", :description => "Rsync files.", :usage => "rsync 'localpath', 'remotepath'" },
+        { :command => "run", :description => "Execute a command.", :usage => "run 'command'" },
+        { :command => "scp", :description => "SCP files.", :usage => "scp ['array','of', 'file', 'paths'], 'remote_path'" },
+        { :command => "ssh", :description => "Initiate an SSH connection." }
+      ]
+    end
+
+    def platform
+      @environment.platform
+    end
+
+    def responds_to_list?
+      false
+    end
+ 
+    def identifier
+      @meta_data[:identifier] 
+    end
+
+    def ip_address
+     @environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER ? public_ip_address : @meta_data[:external_network_interface_address]
+    end
+
+    def public_ip_address
+      @meta_data[:public_ip_address]
+    end
+
+    def role
+      @meta_data[:role]
+    end
+
+    def reference_key
+      :instances
+    end
+
+    def highlight?
+      @environment.object_in_selections?(self)
+    end
+
+    def do_describe
+      description = "#{identifier}"
+      description += "\n\t* Internal IP #{@meta_data[:external_network_interface_address]}"
+      description += "\n\t* External IP #{public_ip_address}" if public_ip_address
+      description += "\n\t* #{role}" if role 
+      description += "\n"
+      return description    
+    end
+
+  end
+end

data/lib/stack/platform.rb

@@ -0,0 +1,62 @@
+module ::Bcome::Stack
+  class Platform
+
+    include ::Bcome::BecomeObject
+
+    class << self
+      def collection_from_config(parent, configuration)
+        return unless configuration
+        collection = []
+        configuration.each do |conf_data|
+          collection << new(conf_data[:name], conf_data)
+        end
+        return collection
+      end
+    end
+
+    attr_reader :identifier
+    attr_reader :quick_contexts
+
+    def initialize(identifier, meta_data)
+      @identifier = identifier
+      @meta_data = meta_data
+      @quick_contexts = @meta_data[:quick_contexts]
+    end
+
+    def menu_items
+      super
+    end
+
+    def do_describe
+      "#{identifier}\n - #{@meta_data[:description]}\n"
+    end
+
+    def config_path
+      "#{CONFIGS_PATH}/network.yml"
+    end
+
+    def collection_klass
+      ::ENV_STACK_KLASS
+    end
+
+    def reference_key
+      :platforms
+    end 
+
+    def collection_key
+      :environments
+    end
+
+    def has_quick_contexts?
+      return !quick_contexts.nil?
+    end
+
+    def quick_context_for_reference(context_reference)
+      return nil unless has_quick_contexts?
+      matches = quick_contexts.select{|qc| qc[:ref] == context_reference }
+      raise "Multiple quick context matches found on platform #{@identifier} for context key #{context_reference}. Cannot load quick context - selection is ambiguous." if matches.size > 1
+      return matches.first 
+    end
+ 
+  end
+end