bcome 0.7.0 → 1.0.0

data/lib/stack/base.rb

@@ -1,148 +0,0 @@
-module ::Bcome::Stack
-  class Base 
-
-    include ::Bcome::ContextFunctions
-    include ::Bcome::CommandHelper
-    include ::Bcome::Orchestrator::Registry
-
-    def machines
-      node.machines
-    end
-
-    def interactive
-      ::Bcome::Interactive::Session.run(self)
-    end
-
-    def self.const_missing(constant_name)
-      ## Hook for direct access to stack level resources by constant name where
-      ## cd ServerName should yield the same outcome as cd "ServerName" or cd :ServerName does
-      ## This works at all stack levels, and so is applied to environments and platforms too
-      stack_level_instance = ::IRB.CurrentContext.workspace.main
-      return constant_name.to_s if stack_level_instance.is_stack_level_resource?(constant_name) 
-      super
-    end
-
-    def method_missing(method_sym, *arguments, &block)
-      if command_for_context = command_for_context(method_sym)
-        execute_command_for_context(command_for_context, arguments)
-      elsif recipe = ::Bcome::Orchestrator::Recipe.by_identifier(method_sym.to_s, self)
-        puts "Executing Command Recipe #{recipe.recipe_identifier}".informational
-        puts "Description: #{recipe.description}".command
-        recipe.execute!(machines)
-        return
-      else
-        # Else, this could be a resource level item
-        return method_sym.to_s if is_stack_level_resource?(method_sym)
-        super
-      end
-    end
-
-    def has_sub_nodes?
-      return true
-    end
-
-    ###
-    ## Construction & Initialisation
-    ##
-
-    def recipes
-      @recipes ||= do_load_recipes
-    end
-
-    def node
-      @node ||= construct_node
-    end
-
-    def respond_to_bcome_context_method?(method_sym)
-      return (command_for_context(method_sym) || ::Bcome::Orchestrator::Recipe.by_identifier(method_sym.to_s, self)) ? true : false
-    end
-
-    def should_eager_load_children?
-      return true
-    end
-  
-    def construct_node
-      node_attributes = meta_data
-      if respond_to?(:collection_key)
-        collection = should_eager_load_children? ? (resources.collect(&:node)) : []
-        node_attributes.merge!({
-          collection_key => collection
-        }) 
-      end
- 
-      this_node = node_level_klass.new(node_attributes)
-      this_node.set_stack_peer(self)
-      this_node.set_parent_reference(this_node, child_reference_key, collection_key) if respond_to?(:collection_key) && respond_to?(:child_reference_key)
-      return this_node
-    end
-
-    def node_level_klass
-      raise "Should be overidden in derived stack type"
-    end
-
-    def init
-      node
-    end
-
-    ###
-    ## Core workspace behaviour
-    ##
-
-    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 "\nNo matching #{collection_key} for identifier '#{identifier}'.".failure + "\n\n#{available_resources_options_string}" + "\n\n"
-      else
-        puts "\nFrom #{resource.reference_key}, working on '#{identifier}'.".informational + "\n\n" 
-        puts "Hit 'menu' or 'ls' to see what you can do here.\n\n"
-        become(resource)
-      end
-    end
-    alias :w :workon
-    alias :cd :workon
-
-    def menu
-      ::RENDER.menu(menu_items, self)
-    end
-
-    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 => "cd NodeName", :description => "Select a resource object, and switch to its context.", :usage => "cd YourServerName" },
-        { :command => "exit", :description => "Return to the previous context" },
-        { :command => "exit!", :description => "Close all contexts, and exit bcome."},
-        { :command => "local", :description => "Execute a shell command on your local machine.", :usage => 'local "command"'},
-        { :command => "machines", :description => "Return all servers below the current level to the console. These objects can be manipulated directly" },
-        { :command => "interactive", :description => "Enter an interactive where you may transparently interact with all the machines in your selection at once" },
-      ]
-    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 = "\n\tCollection Key:".menu_item_cyan + "\s#{reference_key}\n\n#{self.do_describe}"
-      else
-        message = "\nNothing to describe. Use 'ls' or 'list' to see namespace options".headsup unless self.respond_to?(:do_describe)
-      end
-      puts message
-    end
-
-  end
-end

data/lib/stack/environment.rb

@@ -1,222 +0,0 @@
-module ::Bcome::Stack
-  class Environment < ::Bcome::Stack::Base
-
-    include ::Bcome::BecomeObject
-    include ::Bcome::Selections
-    include ::Bcome::FogHelper
-    include ::Bcome::EnvironmentSSH
-    include ::Bcome::Functions
-
-    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 machines
-      node_machines = node.machines
-      do_load_resources unless node_machines.any?
-      return node.machines
-    end
-
-    def should_eager_load_children?
-      false
-    end
-
-    def views
-      @views ||= do_create_views
-    end
-
-    def has_views?
-      views.any?
-    end
-    
-    def list_views
-      if has_views?
-        ::RENDER.list_items("Sub-views", views)
-      else
-        puts "\n" + "This environment has no configured sub-views".warning + "\n\n"
-      end
-    end
-    alias :lv :list_views
-
-    def resource_identifiers
-      @resource_identifiers ||= resource_identifiers_with_views
-    end
-
-    def resource_identifiers_with_views
-      return has_views? ? (resources.collect(&:identifier) << views.collect(&:identifier)).flatten : resources.collect(&:identifier)
-    end
-
-    def resource_for_identifier(identifier)
-      match = super
-      unless match
-        # Unless we've found a match amongst our server instances, look in our views
-        matches = views.select {|view| view.identifier.to_sym == identifier.to_sym }
-        raise "Retrieved more than one match for #{collection_key} '#{identifier}'. Selection is ambiguous" if matches.size > 1
-        match = matches.first
-      end
-      return match
-    end
-
-    def do_create_views
-      return [] unless meta_data[:sub_views]
-      view_collection = []
-      meta_data[:sub_views].each do |sub_view_data|
-        view_collection << ::Bcome::Stack::View.new(@meta_data, @platform, self, sub_view_data)
-      end
-      return view_collection
-    end
-
-    def menu_items
-      super + [
-        { :command => "add", :description => "Add a resource you wish to work on.", :usage => "add MyServerIdentifier, 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 MyServerIdentifier, OR remove [array, of, identifiers]" },
-        { :command => "clear!", :description => "Remove all selected resources." },
-        { :command => "selections", :description => "Show all added resources.", :usage => "selections / s"},
-        { :command => "run", :description => "Execute a command on all selected resources", :usage => "run 'command'" },
-        { :command => "get", :description => "Download from remote from all selected resources (recursive - uses rsync)", :usage => "get 'remote_path'" },
-        { :command => "put", :description => "Copy files up to all selected resources (recursive - uses rsync)", :usage => "put 'local_path', 'remote_path'" },
-        { :command => "sudo", :description => "Run 'get' and 'put' in sudo mode (assumes you have passwordless sudo setup)" },
-        { :command => 'functions', :description => "List all available custom functions" },
-        { :command => 'lv', :description => "List all configured sub-views" },
-      ]
-    end
-
-    def load_from_static_inventory
-      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
-
-    def refresh_dynamic_inventory
-      loaded_resources = collection_klass.collection_from_fog_data(self, servers)
-      loaded_resources
-    end
-
-
-    def restock
-      puts "\n/ Refreshing server inventory".menu_item_green
-      take_stock!(collection_klass.collection_from_fog_data(self, servers))
-      puts " Done. Inventory written to: #{config_path}\n".menu_item_green
-    end
- 
-    def use_inventory_cache?
-      (dynamic_network_lookup? && self.meta_data[:inventory_cache])
-    end
-
-    def static_inventory_is_set?
-      File.exist?(config_path)
-    end
-
-    def load_and_take_stock
-      loaded_resources = refresh_dynamic_inventory
-      take_stock!(loaded_resources)
-      loaded_resources
-    end
-
-    def do_load_resources(restock_inventory = false)
-      loaded_resources = manage_inventory(restock_inventory)
-      node.set_instances(loaded_resources)
-      return loaded_resources
-    end
-
-    def manage_inventory(restock_inventory = false)
-      return load_from_static_inventory unless dynamic_network_lookup? # No dynamic lookup, load from static
-      return refresh_dynamic_inventory unless use_inventory_cache?   # Dynamic lookup, with no cache, just load from dynamic
-      return load_and_take_stock if !static_inventory_is_set? || restock_inventory # Dynamic lookup and stock, if stock not set or we're explicitly re-stocking
-      return load_from_static_inventory # otherwise just load from static.
-    end
-
-
-    def config_dir
-      "#{CONFIGS_PATH}/static_instances/"
-    end
-
-    def config_path
-      "#{config_dir}#{platform.identifier}_#{identifier}-instances.yml"
-    end
-
-    def take_stock!(resources)
-      `mkdir -p #{config_dir}`
-      inventory = { :instances => [] }  
-      resources.each do |resource|
-        inventory[:instances] << {
-          :identifier => resource.identifier,
-          :external_network_interface_address => resource.external_network_interface_address,
-          :public_ip_address => resource.public_ip_address,
-          :role => resource.role
-        }
-      end
-      File.open(config_path, "w") do |file|
-        file.write inventory.to_yaml
-      end
-    end
-
-    def do_describe
-      description
-    end
-
-    def description
-      desc = "\tNode Id:".menu_item_cyan + "\s#{node.identifier}".menu_item_green + "\n"
-      desc += "\tNet Lookup:".menu_item_cyan + "\s#{node.network_lookup_type}".menu_item_white + "\n"
-      desc += "\tSSH Mode:".menu_item_cyan + "\s#{node.ssh_mode_type}".menu_item_white
-      if has_views?
-        views.each do |view|
-          desc += "\n\t \\ #{"view".menu_item_cyan}: #{view.identifier.menu_item_green}"
-        end
-      end
-      return desc + "\n\n"
-    end
-
-    def collection_klass
-      ::INSTANCE_STACK_KLASS
-    end
-
-    def reference_key
-      :environments
-    end
-
-    def child_reference_key
-      :environment 
-    end
-
-    def collection_key
-      :instances
-    end 
-
-    def node_level_klass
-      ::Bcome::Node::Environment
-    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
-
-  end
-end

data/lib/stack/estate.rb

@@ -1,50 +0,0 @@
-module ::Bcome::Stack
-  class Estate < ::Bcome::Stack::Base
-
-    include ::Bcome::BecomeObject
-
-    def config_path
-      "#{CONFIGS_PATH}/platform.yml"
-    end
-
-    def collection_klass 
-      ::PLATFORM_STACK_KLASS
-    end  
-
-    def collection_key
-      :platforms
-    end
-
-    def to_s
-      "Estate"
-    end
-
-    def become_identifier
-      ::START_PROMPT
-    end
-
-    def namespace
-      starting_namespace
-    end
-
-    def starting_namespace
-      ""  # Used to determine where to store downloaded file - this is the start point directory, relative to the bcome install directory
-    end
-
-    def init
-      n = ::Bcome::Node::Estate.new({ :platforms => resources.collect(&:node) })
-      n.set_stack_peer(self)
-      n.set_parent_reference(n, :estate, :platforms)
-      return n
-    end
-
-    def node
-      @node ||= init
-    end
-
-    def menu_items
-      super
-    end
-
-  end
-end

data/lib/stack/instance.rb

@@ -1,130 +0,0 @@
-module ::Bcome::Stack
-  class Instance < ::Bcome::Stack::Base
-
-    include ::Bcome::BecomeObject
-    include ::Bcome::Functions
-    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, :meta_data, :external_network_interface_address, :public_ip_address, :role
-
-    def initialize(meta_data, parent)
-      @meta_data = meta_data
-      @environment = parent
-      @external_network_interface_address = meta_data[:external_network_interface_address]
-      @public_ip_address = meta_data[:public_ip_address]
-      @role = meta_data[:role]
-    end
-
-    def identifier
-      node.identifier
-    end
-
-    def override_instance_identifier_for_wbz_stacks?
-      environment.meta_data[:override_instance_identifier_for_wbz_stacks] ? true : false
-    end
-
-    def overriden_identifier_prefix
-      environment.meta_data[:override_instance_identifier_for_wbz_stacks]
-    end
-
-    def has_sub_nodes?
-      return false
-    end
-
-    def do_load_resources
-      [self]
-    end
-
-    ## Commands
-    def ssh
-      node.ssh
-    end
-
-    def put(*params)
-      node.put(*params)
-    end 
-
-    def run(*params)
-      node.run(*params)
-      return
-    end
-
-    def get(*params)
-      node.get(*params)
-    end
-
-    def menu_items
-      super + [
-        { :command => "run", :description => "Execute a command.", :usage => "run 'command'" },
-        { :command => "put", :description => "Copy files to remote (recursive - uses rsync)", :usage => "put 'local_path', 'remote_path'" },
-        { :command => "get", :description => "Download from remote (recursive - uses rsync).", :usage => "get 'remote_path'"},
-        { :command => "ssh", :description => "Initiate an SSH connection." },
-        { :command => 'functions', :description => "List all available custom functions" }
-      ]
-    end
-
-    def platform
-      @environment.platform
-    end
-
-    def is_sudo?
-      super || @environment.is_sudo?
-    end
-
-    def responds_to_list?
-      false
-    end
- 
-    def reference_key
-      :instances
-    end
-
-    def child_reference_key
-      :instance
-    end 
-
-    def highlight?
-      @environment.object_in_selections?(self)
-    end
-
-    def do_describe
-      description = "\tNode Id:".menu_item_cyan + "\s\s#{node.identifier.menu_item_yellow}"
-      description += "\n\t" + "Internal IP: ".menu_item_cyan + "#{@meta_data[:external_network_interface_address]}".menu_item_white
-      description += "\n\t" + "External IP: ".menu_item_cyan + "#{node.display_ip_address}".menu_item_white if node.public_ip_address
-      description += "\n\t" + "Role: ".menu_item_cyan + "#{node.role}".menu_item_white if node.role 
-      description += "\n\n"
-      return description    
-    end
-
-    def node_level_klass
-      ::Bcome::Node::Instance
-    end
-
-  end
-end