bcome 0.7.0 → 1.0.0

data/lib/filters/base.rb

@@ -1,10 +0,0 @@
-module ::Bcome::Filter
-  class Base
-
-    def initialize(resources, environment)
-      @resources = resources
-      @environment = environment
-    end
-
-  end
-end

data/lib/filters/ec2_filter.rb

@@ -1,4 +0,0 @@
-module Bcome::Filter
-  class Ec2Filter < Bcome::Filter::Base
-  end
-end

data/lib/functions.rb

@@ -1,70 +0,0 @@
-module Bcome::Functions
-
-  CONFIGS_PATH = "bcome/config"
-
-  def functions
-    unless cmd_functions
-      puts "\n\n" + "You don't yet have any custom functions defined. Have a read of the docs and define some. They're pretty useful.".warning + "\n\n" 
-    else
-      puts "\n\n\s\s" + "Functions".menu_title_green + "\n\n"
-      cmd_functions.each_with_index do |cmd_function, i|          
-        puts "\tShortcut: ".menu_item_cyan + "\s#{cmd_function[:ref].informational}"
-        puts "\tDescription:".menu_item_cyan + "\s#{cmd_function[:description]}"
-        puts "\tCommand:".menu_item_cyan + "\s#{cmd_function[:command]}"
-        puts "\tUsage:".menu_item_cyan + "\sF \"#{cmd_function[:ref]}\""
-        puts
-      end 
-    end
-    return
-  end
-
-  def F(reference)
-    if self.is_a?(Bcome::Stack::Environment) && no_selections?
-      puts "\n\n" + "You are an an Environment level, and have not selected any nodes to workon.".warning + "\n\n"
-    else
-      command = cmd_for_ref(reference)
-      if command
-         #puts "#{"Executing command '#{command[:ref]}': ".informational} > #{command[:command].command}" 
-         puts run command[:command]
-      end
-    end
-  end 
-
-  def cmd_for_ref(reference)
-    commands = cmd_functions.select{|command| command[:ref].to_s == reference.to_s }
-    raise "Multiple commands found for reference '#{reference}'. Your functions list is ambiguous.".failure if commands.size > 1
-    unless commands.any?
-      puts "No command found for reference '#{reference}'".failure
-      return nil
-    end
-    return commands.first
-  end
-
-  def cmd_functions
-    return unless has_functions_config?
-    @cmd_functions ||= load_cmd_functions
-  end
-
-  def has_cmd_functions?
-    !cmd_functions.nil?
-  end
-
-  def load_cmd_functions
-    configs = YAML.load_file(cmd_config_path)
-    unless configs.has_key?(:single_functions)
-      raise "Invalid functions configuration. Please check your yaml".failure
-    else
-      return configs[:single_functions]
-    end
-  end
-
-  def cmd_config_path
-    "#{CONFIGS_PATH}/functions.yml"
-  end
- 
-  def has_functions_config?
-    File.exist?(cmd_config_path)
-  end
-
-
-end

data/lib/helpers/command_helper.rb

@@ -1,13 +0,0 @@
-module ::Bcome::CommandHelper
-
-  def run_local(command, silent = false)
-    begin
-      puts "(local) > #{command}" if !silent && ::VERBOSE
-      system(command)
-    rescue Interrupt
-      puts "Exiting gracefully from interrupt".warning
-    end
-  end
-  alias :local :run_local
-
-end

data/lib/helpers/environment_ssh.rb

@@ -1,122 +0,0 @@
-module ::Bcome::EnvironmentSSH
-
-  def proxy(bootstrap = false)
-    return nil unless ssh_mode_type == ::SSH_JUMP_MODE_IDENTIFIER
-
-    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 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(bootstrap), bootstrap)
-    rescue Net::SSH::AuthenticationFailed
-      raise "Could not authenticate connection to #{instance.identifier}".failure
-    rescue Net::SSH::Disconnect
-      raise "SSH connection to #{instance.identifier} was disconnected".failure
-    end
-  end
-
-  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(:command => raw_command, :instance => instance, :bootstrap => bootstrap)
-    }
-
-    ssh = ::Bcome::Ssh.new(commands)
-    ssh.execute!
-    return commands
-  end
-
-  def execute_scp_upload(files, remote_path, instance)
-    begin
-      scp = ::Bcome::Scp.new(proxy, instance)
-      scp.upload!(files, remote_path)
-    rescue Net::SSH::AuthenticationFailed
-      raise "Could not authenticate connection to #{instance.identifier}".failure
-    rescue Net::SSH::Disconnect 
-      raise "SSH connection to #{instance.identifier} was disconnected".failure
-    end
-  end        
-
-  def execute_scp_download(remote_path, local_path, instance)
-    begin
-      scp = ::Bcome::Scp.new(proxy, instance)
-      scp.download!(remote_path, local_path)
-    rescue Net::SSH::AuthenticationFailed
-      raise "Could not authenticate connection to #{instance.identifier}".failure
-    rescue Net::SSH::Disconnect
-      raise "SSH connection to #{instance.identifier} was disconnected".failure
-    end
-  end   
-
-  def bastion_server
-    machines.select{|instance| instance.identifier == @ssh_mode[:jump_host_identifier] }.first
-  end
-
-  def ssh_mode_type
-    ssh_mode_type = @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 @ssh_mode[:type]
-  end
-
-  def ssh_mode_user
-    return @ssh_mode[:ssh_user]
-  end
-
-  def ssh_user
-    (@ssh_mode && ssh_mode_user) ? ssh_mode_user : `whoami`.gsub("\n","")
-  end
-
-  def ssh_nat_user
-    return @ssh_mode[:nat_user]
-  end
-
-  def ssh_key_path
-    return @ssh_mode[:ssh_key_path]
-  end
-
-  def valid_ssh_modes
-    [::SSH_JUMP_MODE_IDENTIFIER, ::SSH_DIRECT_MODE_IDENTIFIER]
-  end
-
-  def bastion_ip_address
-    unless bastion_server
-      raise "Unable to find jump host for #{self.namespace}. 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
-      bastion_ip_address = @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 @network_lookup
-    return @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

data/lib/helpers/fog_helper.rb

@@ -1,108 +0,0 @@
-module ::Bcome::FogHelper
-
-  def credentials_key
-    network_lookup[:credentials_key]
-  end
-
-  def fog_client
-    @fog_client ||= get_fog_client
-  end
- 
-  def ec2_filters
-    network_lookup[:ec2_server_lookup_filters] ? network_lookup[:ec2_server_lookup_filters] : unfiltered_search_params 
-  end  
-
-  def reload!
-    @unfiltered_servers = fog_client.servers.all(ec2_filters)
-    restock_inventory = true 
-    @resources = do_load_resources(restock_inventory)
-    @node = construct_node
-    system("clear")
-    list
-  end
-
-  def unfiltered_search_params
-    { 'instance-id' => [] }
-  end
-
-  ## FOG filter lookups - TODO: misnomers & good intentions ------------
-
-  ## smell
-  def render_servers_not_returned_by_filtered_lookup
-    return unless show_all_unfiltered_status?
-    unfiltered_servers = servers(servers_not_returned_by_filtered_lookup)
-    if unfiltered_servers.any?
-      puts "\n#{network_lookup[:show_all_unfiltered_title]}".informational
-      puts unfiltered_servers.collect{|server| 
-        "#{server.tags["Name"].menu_item_cyan} - #{server.state.send(colour_code_for_server_status[server.state])}"
-      }.join("\n")
-    end
-  end
-
-  def colour_code_for_server_status
-    {
-      "pending" => :headsup,
-      "running" => :friendly,
-      "terminated" => :menu_item_white, #durr
-      "stopping" => :headsup,
-      "stopped" => :danger
-    } 
-  end
-
-  def servers_not_returned_by_filtered_lookup
-    filtered_lookup_names = resources.collect(&:identifier)
-    return unfiltered_fog_lookup.select{|server| !filtered_lookup_names.include?(server.tags["Name"]) }  
-  end
-
-  def unfiltered_fog_lookup
-    fog_client.servers.all(unfiltered_search_params)
-  end
-
-  def show_all_unfiltered_status?
-    self.network_lookup[:show_all_unfiltered]
-  end
-
-  def unfiltered_servers  ### Misnomer - these are filtered
-    @unfiltered_servers ||= fog_client.servers.all(ec2_filters)
-  end
-
-  ## ---------------------------------------------------------------------
-
-  def ec2_tags
-    network_lookup[:ec2_tag_filter]
-  end
-
-  def servers(all = unfiltered_servers)
-    filtered_by_tags = ec2_tags ? filter_by_tags(all) : all
-    custom_filter_method = @meta_data[:network_lookup][:custom_post_process_filter_method]
-
-    if custom_filter_method
-      filter = ::Bcome::Filter::Ec2Filter.new(filtered_by_tags, self)
-      raise "Custom filter method #{custom_filter_method} is missing. Make sure you've added it".failure unless filter.respond_to?(custom_filter_method.to_sym)
-      return filter.send(custom_filter_method.to_sym) 
-    else
-      return filtered_by_tags
-    end
-  end
-
-  def filter_by_tags(instances)
-    return instances.select{|instance| instance_matches_tags?(instance)}
-  end
-
-  def instance_matches_tags?(instance)
-    tags = instance.tags
-    return ec2_tags.select{|key, value| tags[key.to_s] == value }.size == ec2_tags.keys.size
-  end
-
-  private
- 
-  def get_fog_client
-    ::Fog.credential = credentials_key
-    client = ::Fog::Compute.new(
-      :provider => "AWS",
-      :region => network_lookup[:provisioning_region]
-    )
-    return client
-  end
-
-end

data/lib/helpers/instance_command.rb

@@ -1,71 +0,0 @@
-module ::Bcome::InstanceCommand
-
-  def run(raw_commands, bootstrap = false)
-    commands = raw_commands.is_a?(String) ? [raw_commands] : raw_commands
-    return execute_command(commands, bootstrap)
-  end
-
-  def execute_command(commands, bootstrap = false)
-    begin
-      return environment.execute_command(commands, self, bootstrap)
-    rescue Exception => e
-       puts e.message
-       puts e.backtrace.join(", ")
-
-      if bootstrap_settings  ### Try bootstrap fallback
-        puts "\n failed to connect. Attempting bootstrap connection".informational  
-        bootstrap = true
-        return environment.execute_command(commands, self, bootstrap)
-      end
-    end
-  end
-
-  def put(local_path, remote_path, bootstrap = false)
-    puts "rsync> #{self.identifier}".informational
-    if environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER
-      ## DIRECT MODE
-      rsync_command = bootstrap ? direct_rsync_bootstrap(local_path, remote_path) : direct_rsync(local_path, remote_path)
-    else
-      ## 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
-
-    if environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER
-      rsync_command = "rsync #{rsync_is_sudo} -chavzP #{self.ssh_user}@#{self.ip_address}:#{remote_path} #{local_path}"
-    else
-      rsync_command = "rsync -chavzP -av -e \"ssh -A #{self.nat_user}@#{environment.bastion_ip_address} ssh -o StrictHostKeyChecking=no\" #{rsync_is_sudo}#{self.ssh_user}@#{self.ip_address}:#{remote_path} #{local_path}"
-    end
-
-    silent = true
-    local("mkdir -p #{local_path}", silent)
-    run_local(rsync_command)
-    puts "done: files copied to #{local_path}".informational
-  end
-
-  def rsync_is_sudo
-    is_sudo? ? " --rsync-path=\"sudo rsync\" " : ""
-  end
-
-end

data/lib/helpers/instance_ssh.rb

@@ -1,83 +0,0 @@
-module ::Bcome::InstanceSsh
-
-  def execute_task(task_name, *args)
-    begin
-      public_send(task_name, *args)
-    rescue ::Seahorse::Client::NetworkingError
-      puts "Could not execute '#{task_name}'. Cannot initiate connection - check your network connection and try again.".failure
-    end
-  end
-
-  def do_ssh(command)
-    result = execute_task(:run_local, command)
-    unless result
-      if bootstrap_settings
-        puts "\n BOOTSTRAP MODE".informational
-        execute_task(:run_local, non_bootstrapped_ssh_command)
-      end 
-    end  
-    return result
-  end
-  
-  def ssh_jump_command_to_bastion
-    command = "ssh -o UserKnownHostsFile=/dev/null -i #{ssh_key_path} #{nat_user}@#{bastion_ip_address}"
-  end
-
-  def ssh_jump_command_to_internal_node
-    command = "ssh -o UserKnownHostsFile=/dev/null -i #{ssh_key_path} -o \"ProxyCommand ssh -W %h:%p -i #{ssh_key_path} #{nat_user}@#{bastion_ip_address}\" #{ssh_user}@#{ip_address}"
-  end
-
-  def direct_ssh_command
-    command = "ssh #{environment.ssh_mode_user}@#{public_ip_address}"
-  end
-
-  def nat_user
-    return environment.ssh_nat_user ? environment.ssh_nat_user : ssh_user
-  end
-
-  def ssh_user(bootstrap = false)
-    bootstrap ? bootstrap_settings[:ssh_user] : (environment.ssh_mode_user ? environment.ssh_mode_user : `whoami`.gsub("\n",""))
-  end
-
-  def ssh_key_path
-    return environment.ssh_key_path ? environment.ssh_key_path : "~/.ssh/id_rsa" 
-  end
-
-  def keys
-    [ssh_key_path]
-  end
-
-  def bastion_ip_address
-    return environment.bastion_ip_address
-  end
-
-  def is_direct_ssh?
-    environment.ssh_mode_type == ::SSH_DIRECT_MODE_IDENTIFIER
-  end
-
-  def is_jump_ssh?
-    environment.ssh_mode_type == ::SSH_JUMP_MODE_IDENTIFIER
-  end
-
-  def ssh
-    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]}@#{bastion_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
-
-end