bcome 0.7.0 → 1.0.0

data/lib/helpers/selections.rb

@@ -1,117 +0,0 @@
-module Bcome::Selections
-
-  def manage_object(method, resource_identifier = nil)
-    unless resource_identifier && resource_identifier.is_a?(String)
-      print "You must select a resource identified by its name. #{available_resources_options_string}".headsup
-    else
-      object = find_resource_by_identifier(resource_identifier)
-      unless object
-        print "Cannot find object with identifier #{resource_identifier} within the resources for this collection. #{available_resources_options_string}".failure unless object
-      else
-        send(method, object)
-      end
-    end
-  end
-
-  ## Runs commands over *every* object in the selection
-  def run(raw_commands, bootstrap = false)
-    return unless @objects
-    @objects.pmap {|object|
-      object.run(raw_commands, bootstrap)
-    }
-    return
-  end
-
-  def no_selections?
-    !@objects || @objects.empty?
-  end
-
-  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, bootstrap)
-    end
-    return
-  end
-
-  def get(remote_path)
-    if no_selections?
-      no_selections_error
-      return
-    end
-    @objects.each do |object|
-      object.get(remote_path)
-    end
-    return
-  end
-
-  def add(resource_identifier = nil)
-    resource_identifier = [resource_identifier] unless resource_identifier.is_a?(Array)
-    resource_identifier.each {|ri| manage_object(:add_object, ri) }
-    puts "\n" + "#{resource_identifier.join(",")} added.".menu_item_cyan + "\n\nType 'selections' or 's' to review your selections.'".menu_item_white
-  end
-
-  def remove(resource_identifier = nil)
-    resource_identifier = [resource_identifier] unless resource_identifier.is_a?(Array)
-    resource_identifier.each { |ri| manage_object(:remove_object, ri) }
-    puts "\n Nodes removed.".menu_item_cyan
-  end
-
-  def add!
-    @objects = resources
-    puts "All nodes added".informational
-  end
-  
-  def clear!
-    @objects = []
-    selections
-  end
-
-  def find_resource_by_identifier(resource_identifier)
-    resources.select{|r| r.identifier == resource_identifier }.first
-  end
-
-  def in_resources?(object)
-    resources.include?(object)
-  end
-
-  def add_object(object)
-    return if object_in_selections?(object)
-    @objects = @objects ? (@objects << object) : [object]
-    return
-  end  
-
-  def remove_object(object)
-    return if no_selections?
-    unless object_in_selections?(object)
-      puts "\n#{object.identifier} is not within selections".headsup
-    else
-      @objects = @objects - [object]
-    end
-    return
-  end
-
-  def object_in_selections?(object)
-    return false unless @objects
-    return @objects.include?(object)
-  end
-
-  def selections
-    if no_selections?
-      puts "\n" + "No added nodes.".headsup + "\n"
-    else
-      puts "\n\s\s" + "Selected nodes:".menu_title_green + "\n\n" 
-      puts @objects.collect {|o| o.do_describe }.join + "\n"
-    end
-  end  
-  alias :s :selections
-
-  def no_selections_error 
-    puts "No nodes selected".informational
-  end
-
-end

data/lib/interactive/interactive_session_halt.rb

@@ -1,4 +0,0 @@
-module Bcome::Interactive
-  class SessionHalt < RuntimeError
-  end
-end

data/lib/interactive/session.rb

@@ -1,44 +0,0 @@
-module Bcome::Interactive
-  class Session
-
-    class << self
-      def run(irb_session)
-        irb_pre_session_return_format = irb_session.conf.return_format
-        session_end_message = "\ninteractive session ended".success
-        begin
-          session = ::Bcome::Interactive::Session.new(irb_session)
-          irb_session.conf.return_format = ""
-          system("clear")
-          session.prompt
-        rescue ::Bcome::Interactive::SessionHalt => e
-          irb_session.conf.return_format = irb_pre_session_return_format
-          puts session_end_message
-        end
-      end
-    end
-
-    attr_reader :responses, :irb_session
-
-    def initialize(irb_session)
-      @irb_session = irb_session
-      @responses = {}
-    end
-
-    def prompt
-      item = ::Bcome::Interactive::SessionItem::TransparentSsh.new(self)  
-      print item.start_message
-      process_item(item)
-    end
-
-    def process_item(item)
-      begin
-        item.do
-      rescue Exception => e
-        puts "Exception: #{e.message}"
-        puts e.backtrace.join("\n")
-        raise ::Bcome::Interactive::SessionHalt.new
-      end
-    end
-
-  end
-end

data/lib/interactive/session_item/base.rb

@@ -1,30 +0,0 @@
-module Bcome::Interactive::SessionItem
-  class Base
-
-    def initialize(session)
-      @session = session
-      @irb_session = @session.irb_session
-    end
-
-    def bcome_identifier  
-      @irb_session.become_identifier
-    end
-
-    def irb_session
-      @session.irb_session
-    end
-
-    def options
-      @session.options
-    end
-
-    def set_response_on_session
-      @session.responses[@key] = @response
-    end
-
-    def do(*params)
-      raise "Should be overidden"
-    end
-
-  end
-end

data/lib/interactive/session_item/transparent_ssh.rb

@@ -1,133 +0,0 @@
-module Bcome::Interactive::SessionItem
-  class TransparentSsh < ::Bcome::Interactive::SessionItem::Base
-
-    END_SESSION_KEY = "\\q"
-    HELP_KEY = "\\?"   
-    LIST_KEY = "\\l"
-    
-    DANGER_CMD = "rm\s+-r|rm\s+-f|rm\s+-fr|rm\s+-rf|rm"
-
-    def do
-      show_menu
-      puts ""
-      open_ssh_connections!
-      puts ""
-      list_machines
-      action 
-    end
-
-    def action
-      input = get_input
-      return if exit?(input)
-      if show_menu?(input)
-        show_menu
-      elsif list_machines?(input)
-        list_machines
-      elsif command_may_be_unwise?(input)
-        handle_the_unwise(input)   
-      else
-        execute_on_machines(input)
-      end
-      action
-    end
-
-    def show_menu
-      system("clear") ; print start_message
-    end
-
-    def handle_the_unwise(input)
-      if prompt_for_confirmation("Command may be dangerous to run on all machines. Are you sure you want to proceed? [Y|N] > ".danger)
-        execute_on_machines(input)
-      end
-    end
-
-    def command_may_be_unwise?(input)
-      input =~ /#{DANGER_CMD}/
-    end
-
-    def prompt_for_confirmation(message)
-      answer = get_input(message)
-      unless ["Y", "N"].include?(answer)
-        prompt_for_confirmation(message)
-      end 
-      return answer == "Y" ? true : false 
-    end
-
-    def start_message
-      warning = "\nCommands entered here will be executed on EVERY machine in your selection.".danger
-      second_warning = "\n\nUse with CAUTION.".danger
-      info = "\n\n\\l list machines\n\\q to quit\n\\? this message".informational                                                             
-      return "#{warning}#{second_warning}#{info}\n"
-    end
-
-    def terminal_prompt
-      "#{bcome_identifier}>\s" + "interactive\s>\s".command   # high voltage
-    end
-
-    def valid_response(response)
-      a = response.gsub("\s", "").downcase
-      valid_responses.include?(response)
-    end
-
-    def exit?(input)
-      input == END_SESSION_KEY
-    end
-
-    def show_menu?(input)
-      input == HELP_KEY
-    end
- 
-    def list_machines?(input)
-      input == LIST_KEY 
-    end
-
-    def open_ssh_connections!
-      ProgressBar.instance.reset!
-      machines.pmap {|machine|
-        ProgressBar.instance.indicate_and_increment!("init ssh: ","~~~", "connections")
-        machine.ssh_connect!
-      }
-      ProgressBar.instance.reset!
-    end
-
-    def list_machines
-      puts "\n"
-      machines.each do |machine|
-        env = machine.environment
-        platform = env.platform
-        puts "#{platform.identifier.cyan}:#{env.identifier.orange}:#{machine.identifier.yellow}"
-      end
-    end
- 
-    def get_input(message = terminal_prompt)
-      return ::Readline.readline("\n#{message}", true).squeeze(" " ).to_s
-    end
-
-    def execute_on_machines(user_input)
-      machines.pmap {|machine|
-        machine.run(user_input)
-      }
-    end
-
-    def machines
-      @machines ||= has_selected_machines? ? selected_machines.collect(&:node) : flat_list_of_machines
-    end
-
-    def flat_list_of_machines
-      resources.collect{|resource| resource.node.machines }.flatten
-    end
-
-    def resources
-      @irb_session.resources  
-    end
-
-    def has_selected_machines?
-      selected_machines.is_a?(Array) && selected_machines.any?
-    end
-
-    def selected_machines
-      @selections ||= @irb_session.instance_variable_get(:@objects)
-    end
-
-  end
-end

data/lib/nodes/base.rb

@@ -1,60 +0,0 @@
-module ::Bcome::Node
-  class Base
-
-    include ::Bcome::CommandHelper
-
-    attr_reader :meta_data, :stack_peer
-
-    def machines
-      raise "Should be overriden"
-    end
-
-    def ls
-      self.stack_peer.ls
-    end
-  
-    def initialize(meta_data)
-      construct(meta_data)
-    end
-
-    def set_stack_peer(stack_instance)
-      @stack_peer = stack_instance
-    end
-
-    def interactive
-      stack_peer.interactive
-    end
-
-    ## Runs a command over *every* machine in this node
-    def run(raw_command, bootstrap = false)
-      return unless machines
-      machines.pmap {|machine|
-        machine.run([raw_command], bootstrap)
-      }
-      return
-    end
-
-    def method_missing(method_sym, *arguments, &block)
-      if instance_variable_defined?("@#{method_sym}")
-        return instance_variable_get("@#{method_sym}")
-      else
-        super
-      end
-    end
-
-    def set_parent_reference(parent, parent_reference_key, collection_key)
-      instance_variable_get("@#{collection_key}").map{|collection_item|
-        collection_item.instance_variable_set("@#{parent_reference_key}", parent)
-      }
-    end
-
-    private
-
-    def construct(meta_data = {})
-      meta_data.each do |key, value|
-        self.instance_variable_set("@#{key}", value)
-      end
-    end
-
-  end
-end

data/lib/nodes/environment.rb

@@ -1,30 +0,0 @@
-module ::Bcome::Node
-  class Environment < ::Bcome::Node::Base
-
-    include ::Bcome::EnvironmentSSH
-
-    def machines
-      if instances.empty?
-        stack_peer.do_load_resources
-      end
-      instances
-    end
-
-    def identifier
-      @environment
-    end
-
-    def bootstrap_settings
-      @bootstrap_settings
-    end
- 
-    def namespace
-      "#{platform.namespace}/#{identifier}"
-    end
-
-    def set_instances(loaded_resources)
-      @instances = loaded_resources.collect(&:node)
-    end
-
-  end
-end

data/lib/nodes/estate.rb

@@ -1,44 +0,0 @@
-module ::Bcome::Node
-  class Estate < ::Bcome::Node::Base
-
-    include ::Bcome::Selections
-
-    def machines
-      platforms.collect(&:machines).flatten
-    end
-
-    def namespace
-      ""
-    end  
-
-    def run(raw_command, bootstrap = false)
-      return unless platforms
-      platforms.pmap {|platform|
-        platform.run(raw_command, bootstrap)
-      }
-      return
-    end
-
-    def environments
-      @environments ||= platforms.collect(&:environments).flatten
-    end
-
-    def list_all
-      estate_machine_list = "\n"
-      platforms.each do |platform|
-        estate_machine_list += "* #{platform.identifier}\n"
-        platform.environments.each do |environment|
-        estate_machine_list += "\t- #{environment.identifier}\n"
-          environment.instances.each do |instance|
-            estate_machine_list += "\t\t / #{instance.identifier} (#{instance.public_ip_address})\n"
-          end 
-        end
-      end
-
-      puts estate_machine_list
-
-      return ""
-    end 
-
-  end
-end