lakitu 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 155a2c909441c1801e8d3e8d1812662e8d01e387
-  data.tar.gz: efec47e44e4caf032c1dbade96842605753aba94
+  metadata.gz: a39c34d03f0b881eb80772851d0d81bd5b290525
+  data.tar.gz: 22a3bb290adbaec68dfeb32b8077a51b8c92be62
 SHA512:
-  metadata.gz: 0c56082dde0a6c3489871c7b85d315a7d27efbb2ce8dd6f48ccff127a2b796ce6671c23084d6567591b4af56d3ba3f91d08b93308f9fb46bd33805b5e360a83b
-  data.tar.gz: 1e6e3fbec46fc6d332a35b0d42b39e10a7a0046d42a017ec629adf853c1cb2c5ecb3f235c62722ba17f3dcab426e63fb634eabb48c20693b7eaaa6abd7b94266
+  metadata.gz: 3dd6856ef1ca80e7f1f553aa055a742d157597e698a09c01e3e93f199403b8e5c333466e487bbc6e103be4afc3277cc45d630257ef733765560744a4154a61e3
+  data.tar.gz: 608987d97b1e3539c6d1e613b649223cb263ba4eb98ca18b1f5fe1cdd8321f47ba43dafa845bef6c755efff930e0cde6cd8eda15ad3cb136f363af9bb864fd21

data/.rspec

@@ -0,0 +1,2 @@
+-r ./spec/spec_helper.rb
+-I ./lib/lakitu

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p598

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in lakitu.gemspec
 gemspec
+
+gem "thor", "~>0.19"
+gem 'aws-sdk', '~> 2'
+gem "iniparse"
+
+group :development do
+  gem "rspec", "~>3.2"
+  gem "simplecov"
+end

data/README.md

@@ -1,31 +1,51 @@
 # Lakitu
+![CircleCI build status](https://circleci.com/gh/bkconrad/lakitu.png?style=shield&circle-token=a622a5a71cc7a5ad0662d05e164a67f8ddbdaff1)
 
-TODO: Write a gem description
+Generate an SSH config from AWS (or potentially other cloud provider) APIs.
 
-## Installation
+## Prework
+To use Lakitu effectively, you will need the following:
 
-Add this line to your application's Gemfile:
+  1. A modern Ruby (2.0+). You may need RVM for this.
+  2. A modern `bash-completion` package installed via `brew`, `apt-get`, or `yum`.
+  3. AWS profiles configured according to the [official documentation](http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html#cli-multiple-profiles) (or via `aws configure`).
 
-```ruby
-gem 'lakitu'
-```
-
-And then execute:
+If you don't have 1-3 above, you will not get the most out of this project (and you are missing out on some other really cool stuff).
 
-    $ bundle
+## Usage
+```
+$ gem install lakitu
+$ lakitu generate
+$ lakitu configure
+$ lakitu edit
+```
 
-Or install it yourself as:
+## Periodic Refresh
+Simply add the following line to your `.bashrc`
+```
+lakitu generate &>~/.lakitu.log &
+```
 
-    $ gem install lakitu
+If you installed lakitu via RVM, you should add the following to your shell profile instead:
+```
+rvm default do lakitu generate &>~/.lakitu.log &
+```
 
-## Usage
+`lakitu generate` waits for a refresh interval to pass before re-generating the SSH config. This means you can safely add it to your `.bashrc` or equivalent, and your ssh config will refresh in the background only when that interval has passed.
 
-TODO: Write usage instructions here
+## Another One?
+There are several projects that will generate an SSH config from AWS instance data. This one aims to provide the following advantages:
 
-## Contributing
+  - **Ease of use**: With a properly configured environment, it will detect your configured profiles for supported providers.
+  - **Configurability**: Easily edit a simple config file to control host alias formatting, profiles to skip, etc.
+  - **Automation**: Periodically refreshes the ssh config (via bashrc), and takes no action unless the config appears to be stale.
+  - **Extensibility**: A simple Provider API allows easy support for new providers.
+  - **Reliability**: A robust test suite ensures that Lakitu probably won't cause your machine to combust unexpectedly.
 
-1. Fork it ( https://github.com/[my-github-username]/lakitu/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+## Other Options
+You could also check out the folowing if this is too much hubbub for you:
+  - https://rubygems.org/gems/knife-ec2-ssh-config
+  - https://rubygems.org/gems/ec2-ssh
+  - https://rubygems.org/gems/aws_ssh
+  - https://rubygems.org/gems/aws-ssh
+  - [An SSH tip for modern AWS patrons](http://codeinthehole.com/writing/an-ssh-tip-for-modern-aws-patrons/)

data/bin/lakitu

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "thor"
+require "#{File.dirname(__FILE__)}/../lib/lakitu.rb"
+
+Lakitu.start

data/lakitu.gemspec

@@ -5,7 +5,7 @@ require 'lakitu/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "lakitu"
-  spec.version       = Lakitu::VERSION
+  spec.version       = LakituVersion::VERSION
   spec.authors       = ["Bryan Conrad"]
   spec.email         = ["bkconrad@gmail.com"]
   spec.summary       = %q{Ride the clouds}

data/lib/lakitu.rb

@@ -1,5 +1,61 @@
-require "lakitu/version"
+$LOAD_PATH << File.dirname(File.expand_path(__FILE__))
+require "logger"
+require "yaml"
+require "thor"
+
+class Lakitu < Thor
+  LOCAL_SSHCONFIG_PATH = File.expand_path '~/.ssh/local.sshconfig'
+  MANAGED_SSH_CONFIG_TOKEN = "# Managed by Lakitu"
+  OPTIONS_FILE_PATH = File.expand_path "~/.lakitu.yml"
+  SSH_PATH = File.expand_path '~/.ssh'
+  SSHCONFIG_PATH = File.expand_path '~/.ssh/config'
+  EDIT_FILE_COMMAND = "$EDITOR #{OPTIONS_FILE_PATH}"
+  DEFAULT_FORMAT = "%{profile}-%{name}-%{id}"
+  EDIT_LOCAL_CONFIG_COMMAND = "$EDITOR #{LOCAL_SSHCONFIG_PATH}"
+
+  class_options %w( force -f ) => :boolean
+  class_options %w( verbose -v ) => :boolean
+
+  desc "generate [options]", "Generate the ssh config"
+  def generate
+    Lakitu::Options.merge options
+    Lakitu::FileOperator.backup_ssh_config!
+    Lakitu::FileOperator.write_ssh_config! Lakitu::Generator.generate if Lakitu::FileOperator::should_overwrite
+  end
+
+  desc "configure [options]", "Open Lakitu's config file in the system editor"
+  def configure
+    Lakitu::Options.merge options
+    Lakitu::Configurer.find_or_create_config
+    Lakitu::Configurer.edit
+  end
 
-module Lakitu
-  # Your code goes here...
+  desc "edit", "edit #{Lakitu::LOCAL_SSHCONFIG_PATH} and generate config after"
+  def edit
+    Lakitu::Options.options[:force] = true
+    invoke :generate if Lakitu::Configurer.edit_local
+  end
+
+  @@logger = nil
+  def self.logger
+    unless @@logger
+      @@logger = ::Logger.new STDOUT
+      logger.level = Lakitu::Options.options.verbose ? ::Logger::DEBUG : ::Logger::INFO
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{severity}: #{msg}\n"
+      end
+    end
+    @@logger
+  end
+
+  def self.logger= arg
+    @@logger = arg
+  end
 end
+
+require "lakitu/version"
+require "lakitu/configurer"
+require "lakitu/file_operator"
+require "lakitu/generator"
+require "lakitu/options"
+require "lakitu/providers/aws"

data/lib/lakitu/configurer.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+module Lakitu::Configurer
+  def self.find_or_create_config
+    unless Lakitu::FileOperator.lakitu_config_exists?
+      Lakitu.logger.debug "Creating new config file"
+      Lakitu::FileOperator.write_lakitu_config Lakitu::Options.default_config
+    end
+
+    Lakitu::FileOperator.read_lakitu_config
+  end
+
+  def self.edit
+    system Lakitu::EDIT_FILE_COMMAND
+  end
+
+  def self.edit_local
+    system Lakitu::EDIT_LOCAL_CONFIG_COMMAND
+  end
+end

data/lib/lakitu/file_operator.rb

@@ -0,0 +1,70 @@
+require 'erb'
+require 'ostruct'
+module Lakitu::FileOperator
+  def self.key_path key_name
+    expected_key_path = File.join Lakitu::SSH_PATH, "#{key_name}.pem"
+    return nil unless File.exist? expected_key_path
+    Lakitu.logger.debug "Found key at #{expected_key_path}"
+    expected_key_path
+  end
+
+  def self.write_ssh_config! content
+    raise RuntimeError.new("Won't overwrite unmanaged ssh config") unless ssh_config_is_managed? or !File.exist?(Lakitu::SSHCONFIG_PATH)
+    Lakitu.logger.info "Writing ssh config to #{Lakitu::SSHCONFIG_PATH}"
+    File.write Lakitu::SSHCONFIG_PATH, content
+  end
+
+  def self.local_ssh_config
+    return File.read(Lakitu::LOCAL_SSHCONFIG_PATH) if File.exist?(Lakitu::LOCAL_SSHCONFIG_PATH)
+    return ""
+  end
+
+  def self.should_overwrite
+    return true unless ssh_config_is_managed?
+    ssh_config_is_stale?
+  end
+
+  def self.backup_ssh_config!
+    return unless File.exist? Lakitu::SSHCONFIG_PATH
+    unless ssh_config_is_managed?
+      Lakitu.logger.debug "SSH config is unmanaged"
+      if File.exist? Lakitu::LOCAL_SSHCONFIG_PATH
+        Lakitu.logger.fatal "Can't back up unmanaged ssh config: #{Lakitu::LOCAL_SSHCONFIG_PATH} already exists."
+        exit 1
+        return
+      end
+
+      Lakitu.logger.info "Moving #{Lakitu::SSHCONFIG_PATH} to #{Lakitu::LOCAL_SSHCONFIG_PATH}"
+      FileUtils.mv Lakitu::SSHCONFIG_PATH, Lakitu::LOCAL_SSHCONFIG_PATH
+    end
+  end
+
+  def self.ssh_config_is_managed?
+    return false unless File.exist? Lakitu::SSHCONFIG_PATH
+    File.read(Lakitu::SSHCONFIG_PATH).include? Lakitu::MANAGED_SSH_CONFIG_TOKEN
+  end
+
+  def self.ssh_config_is_stale?
+    ssh_config_age_minutes = (Time.now - File.mtime(Lakitu::SSHCONFIG_PATH)) / 60
+    effectively_stale = (ssh_config_age_minutes > options.refresh_interval_minutes or options.force)
+    Lakitu.logger.debug "SSH Config modified #{ssh_config_age_minutes} minutes ago, threshold: #{options.refresh_interval_minutes}"
+    Lakitu.logger.info "SSH config is still fresh, use --force to force generation" unless effectively_stale
+    return !!effectively_stale
+  end
+
+  def self.lakitu_config_exists?
+    File.exist? Lakitu::OPTIONS_FILE_PATH
+  end
+
+  def self.read_lakitu_config
+    File.read Lakitu::OPTIONS_FILE_PATH
+  end
+
+  def self.write_lakitu_config content
+    File.write Lakitu::OPTIONS_FILE_PATH, content
+  end
+
+  def self.options
+    Lakitu::Options.options
+  end
+end

data/lib/lakitu/generator.rb

@@ -0,0 +1,50 @@
+require 'erb'
+require 'ostruct'
+module Lakitu::Generator
+  CLAUSE_TEMPLATE=<<-EOF
+Host <%= host %><% if keyfile %>
+  IdentityFile <%= keyfile %>
+  <% end %>
+  HostName <%= public_ip || private_ip %>
+  EOF
+
+  def self.generate
+    ([ Lakitu::MANAGED_SSH_CONFIG_TOKEN, Lakitu::FileOperator::local_ssh_config ] + instances.map do |instance|
+      instance[:host] = format_for(instance[:provider], instance[:profile]) % instance
+      key_path = Lakitu::FileOperator.key_path instance[:key]
+      instance[:keyfile] = key_path if key_path
+      ERB.new(CLAUSE_TEMPLATE).result(OpenStruct.new(instance).instance_eval { binding })
+    end).join("\n")
+  end
+
+  def self.instances
+    result = Lakitu::Provider.providers.map do |provider_class|
+      Lakitu.logger.debug "Getting instances for #{provider_class.name}"
+      get_instances(provider_class.new)
+    end.flatten
+    Lakitu.logger.info "Found #{result.length} instances"
+    result
+  end
+
+  private
+
+  def self.get_instances provider
+    provider.profiles.map do |profile|
+      Lakitu.logger.debug "Profile: #{profile}"
+      provider.regions.map do |region|
+        Lakitu.logger.debug "  Region: #{region}"
+        result = provider.instances(profile, region)
+        Lakitu.logger.debug "    Found #{(result.length rescue 0)} instances"
+        result
+      end
+    end.flatten
+  end
+
+  def self.format_for provider, profile
+    (options[:providers][provider.to_sym][profile.to_sym][:format] rescue nil) || Lakitu::DEFAULT_FORMAT
+  end
+
+  def self.options
+    Lakitu::Options::options
+  end
+end

data/lib/lakitu/options.rb

@@ -0,0 +1,78 @@
+require 'ostruct'
+module Lakitu::Options
+  DEFAULTS = {
+    refresh_interval_minutes: 10
+  }
+
+  PROFILE_DEFAULTS = {
+    ignore: false,
+    format: "%{profile}-%{name}-%{id}"
+  }
+
+  @@options = nil
+
+  def self.options
+    unless @@options
+      @@options = OpenStruct.new(DEFAULTS.merge config_options)
+    end
+    @@options
+  end
+
+  def self.options= arg
+    @@options = arg ? OpenStruct.new(arg) : arg
+  end
+
+  def self.merge arg
+    @@options = OpenStruct.new(options.to_h.merge arg)
+  end
+
+  def self.config_options
+    return { } unless File.exist?(Lakitu::OPTIONS_FILE_PATH)
+    deep_symbolize_keys(::YAML::load(File.read(Lakitu::OPTIONS_FILE_PATH)) || {})
+  end
+
+  def self.default_config
+    create_provider_defaults
+    YAML.dump(deep_stringify_keys(options.to_h))
+  end
+
+  private
+  def self.deep_stringify_keys object
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[key.to_s] = deep_stringify_keys(value)
+      end
+    when Array
+      object.map {|e| deep_stringify_keys(e) }
+    else
+      object
+    end
+  end
+
+  def self.deep_symbolize_keys object
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = deep_symbolize_keys(value)
+      end
+    when Array
+      object.map {|e| deep_symbolize_keys(e) }
+    else
+      object
+    end
+  end
+
+  def self.create_provider_defaults
+    options[:providers] ||= {}
+    Lakitu::Provider.providers.each do |provider_class|
+      provider_key = provider_class.name.downcase.split('::').last.to_sym
+      next if options[:providers][provider_key]
+      result = provider_class.new.profiles.inject({}) do |memo, profile|
+        memo[profile.to_sym] = PROFILE_DEFAULTS.dup
+        memo
+      end
+      options[:providers][provider_key] = result
+    end
+  end
+end

data/lib/lakitu/provider.rb

@@ -0,0 +1,11 @@
+class Lakitu::Provider
+  @@providers = []
+
+  def self.providers
+    @@providers
+  end
+
+  def self.inherited provider
+    @@providers.push provider
+  end
+end

data/lib/lakitu/providers/aws.rb

@@ -0,0 +1,43 @@
+require 'aws-sdk-resources'
+require 'iniparse'
+require 'lakitu/provider'
+
+class Lakitu::Provider::Aws < Lakitu::Provider
+  def profiles
+    IniParse.parse(File.read(File.expand_path('~/.aws/credentials'))).to_hash.keys.reject() do |x| x == '__anonymous__' end
+  end
+
+  def instances profile, region
+    result = ec2(profile, region)
+      .instances
+      .to_a
+      .select { |x| x.state.name == "running" }
+      .map { |x| to_hash x }
+
+    result.each do |x|
+      x[:profile] = profile
+      x[:region] = region
+      x[:provider] = 'aws'
+    end
+  end
+
+  def regions
+    [ 'us-east-1', 'us-west-1', 'us-west-2' ]
+  end
+
+  private
+
+  def ec2 profile, region
+    ::Aws::EC2::Resource.new(region: region, profile: profile)
+  end
+
+  def to_hash instance
+    {
+      id: instance.id,
+      name: (instance.tags.select do |x| x.key == 'Name' end.first.value rescue 'blank'),
+      key: instance.key_name,
+      private_ip: instance.private_ip_address,
+      public_ip: instance.public_ip_address
+    }
+  end
+end

data/lib/lakitu/version.rb

@@ -1,3 +1,3 @@
-module Lakitu
-  VERSION = "1.0.2"
+class LakituVersion
+  VERSION = "1.0.3"
 end

data/spec/configurer_spec.rb

@@ -0,0 +1,29 @@
+describe Lakitu::Configurer do
+  subject { described_class }
+  before :each do
+    mock_config
+    allow(File).to receive(:write).and_return(true)
+  end
+
+  it "creates config file when it doesn't exist" do
+    mock_no_options
+    expect(File).to receive(:write).with(Lakitu::OPTIONS_FILE_PATH, Lakitu::Options.default_config).and_return(true)
+    expect(File).to receive(:read).with(Lakitu::OPTIONS_FILE_PATH).and_return(Lakitu::Options.default_config)
+    expect(subject.find_or_create_config).to eq Lakitu::Options.default_config
+  end
+
+  it "uses existing config file when it exists" do
+    mock_options
+    expect(subject.find_or_create_config).to eq OPTIONS_CONTENT
+  end
+
+  it "opens config file in default editor" do
+    expect(subject).to receive(:system).with(Lakitu::EDIT_FILE_COMMAND)
+    subject.edit
+  end
+
+  it "opens local config file in default editor" do
+    expect(subject).to receive(:system).with(Lakitu::EDIT_LOCAL_CONFIG_COMMAND)
+    subject.edit_local
+  end
+end

data/spec/file_operator_spec.rb

@@ -0,0 +1,57 @@
+describe Lakitu::FileOperator do
+  subject { described_class }
+  before :each do
+    allow(File).to receive(:write).and_return(true)
+  end
+
+  it "moves unmanaged ssh configs to local.sshconfig" do
+    mock_no_ssh_keys
+    mock_unmanaged_sshconfig
+    mock_no_local_sshconfig
+    expect(FileUtils).to receive(:mv).with(Lakitu::SSHCONFIG_PATH, Lakitu::LOCAL_SSHCONFIG_PATH)
+    subject.backup_ssh_config!
+  end
+
+  context "when config is managed" do
+    before :each do mock_managed_sshconfig end
+
+    context "and ssh config is fresh" do
+      before :each do mock_fresh_sshconfig end
+      it "will not overwrite the config" do expect(subject.should_overwrite).to be false end
+
+      context "and force is true" do
+        before :each do subject.send(:options)[:force] = true end
+        it "will overwrite the config" do expect(subject.should_overwrite).to be true end
+      end
+    end
+
+    context "and ssh config is stale" do
+      before :each do mock_stale_sshconfig end
+      it "will overwrite the config" do expect(subject.should_overwrite).to be true end
+    end
+
+    it "does not move ssh configs to local.sshconfig" do
+      expect(FileUtils).not_to receive(:mv).with(Lakitu::SSHCONFIG_PATH, Lakitu::LOCAL_SSHCONFIG_PATH)
+      subject.backup_ssh_config!
+    end
+
+    it "writes the result to ~/.ssh/config" do
+      expect(FileUtils).not_to receive(:mv).with(Lakitu::SSHCONFIG_PATH, Lakitu::LOCAL_SSHCONFIG_PATH)
+      expect(File).to receive(:write).with(Lakitu::SSHCONFIG_PATH, "test")
+      subject.write_ssh_config! "test"
+    end
+  end
+
+  context "when config is unmanaged" do
+    before :each do mock_unmanaged_sshconfig end
+    it "will overwrite the config" do expect(subject.should_overwrite).to be true end
+
+    it "exits when local.sshconfig exists" do
+      mock_no_ssh_keys
+      mock_local_sshconfig_exists
+      expect(FileUtils).not_to receive(:mv).with(Lakitu::SSHCONFIG_PATH, Lakitu::LOCAL_SSHCONFIG_PATH)
+      expect(subject).to receive(:exit).with(1)
+      subject.backup_ssh_config!
+    end
+  end
+end

data/spec/generator_spec.rb

@@ -0,0 +1,50 @@
+describe Lakitu::Generator do
+  subject { described_class }
+  before :each do
+    stub_aws
+    mock_config
+    allow(File).to receive(:write).and_return(true)
+  end
+
+  it "invokes all providers, for all regions, over all profiles" do
+    expect(Lakitu::Provider.providers.length).to be > 0
+    Lakitu::Provider.providers.each do |provider_class|
+      provider = provider_class.new
+      provider.profiles.each do |profile|
+        provider.regions.each do |region|
+          expect_any_instance_of(provider_class).to receive(:instances).with(profile, region).exactly(:once)
+        end
+      end
+    end
+
+    subject.instances
+  end
+
+  it "merges instance lists from the providers" do
+    WRANGLED_INSTANCE_DATA_COMPLETE.each do |x|
+      expect(subject.instances).to include x
+    end
+  end
+
+  it "generates ssh config content from templates" do
+    mock_no_local_sshconfig
+    mock_no_ssh_keys
+    mock_options
+    Lakitu::Options.options = nil
+    result = subject.generate 
+    expect(result).to include SSH_CONFIG_RESULT
+    expect(result).to include "Host formattest"
+  end
+
+  it "reads ~/.ssh/*.sshconfig files" do
+    mock_no_ssh_keys
+    mock_local_sshconfig
+    expect(subject.generate).to include LOCAL_SSHCONFIG
+  end
+
+  it "looks up keys in ~/.ssh/" do
+    mock_ssh_keys
+    mock_no_local_sshconfig
+    expect(subject.generate).to include "IdentityFile #{File.expand_path("~/.ssh/testkey.pem")}"
+  end
+end

data/spec/lakitu_spec.rb

@@ -0,0 +1,28 @@
+describe Lakitu do
+  subject { described_class.new }
+  it "delegates generate!" do
+    expect(Lakitu::FileOperator).to receive(:backup_ssh_config!).and_return(nil)
+    expect(Lakitu::Generator).to receive(:generate).and_return("test")
+    expect(Lakitu::FileOperator).to receive(:write_ssh_config!).and_return(nil)
+    expect(Lakitu::FileOperator).to receive(:should_overwrite).and_return(true)
+    subject.generate
+  end
+
+  it "delegates configure" do
+    expect(Lakitu::Configurer).to receive(:find_or_create_config).and_return(true)
+    expect(Lakitu::Configurer).to receive(:edit).and_return("test")
+    subject.configure
+  end
+
+  it "delegates edit" do
+    expect(Lakitu::Configurer).to receive(:edit_local).and_return(true)
+    expect(subject).to receive(:invoke).with(:generate).and_return(true)
+    subject.edit
+  end
+
+  it "creates a logger" do
+    Lakitu.logger = nil
+    Lakitu::Options.options.verbose = false
+    expect(Lakitu.logger).to be_a(Logger)
+  end
+end

data/spec/options_spec.rb

@@ -0,0 +1,34 @@
+describe Lakitu::Options do
+  subject { described_class }
+  before :each do
+    Lakitu::Options.options= nil
+    allow(File).to receive(:write).and_return(true)
+  end
+
+  it "provides default values for options" do
+    mock_no_options
+    expect(described_class.options.refresh_interval_minutes).to eq 10
+  end
+
+  it "overwrites defaults with config values" do
+    mock_options
+    expect(described_class.options.refresh_interval_minutes).to eq 5
+  end
+
+  it "overwrites config values with command line arguments" do
+    mock_options
+    Lakitu::Options.merge refresh_interval_minutes: 1
+    expect(described_class.options.refresh_interval_minutes).to eq 1
+  end
+
+  it "includes providers and profiles in default config" do
+    mock_no_options
+    mock_config
+    stub_aws
+    result = YAML.load(subject.default_config)
+    expect(result).to be_a Hash
+    expect(result['refresh_interval_minutes']).to eql 10
+    expect(result['providers']).to be_a Hash
+    expect(result['providers']['aws']['client1']['ignore']).to be false
+  end
+end

data/spec/providers/aws_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Lakitu::Provider::Aws do
+  subject { Lakitu::Provider::Aws.new }
+  context "with a valid credentials config" do
+    before :each do
+      mock_config
+    end
+
+    it "gets a list of profiles" do
+      expect(subject.profiles).to eq ['default', 'client1']
+    end
+  end
+
+  context "with a given list of instances" do
+    before do
+      stub_aws
+    end
+
+    it "gets a list of instances for a given profile" do
+      expect(subject.instances('default', 'us-east-1')).to eq(WRANGLED_INSTANCE_DATA_COMPLETE)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,152 @@
+require 'logger'
+require 'simplecov'
+SimpleCov.start
+
+require './lib/lakitu.rb'
+
+# silence the logger
+RSpec.configure do |config|
+  config.before do
+    Lakitu.logger = Logger.new(false)
+  end
+end
+
+def stub_aws
+  Aws.config[:ec2] = {
+    stub_responses: {
+      describe_instances: {
+        reservations: [{
+          instances: [
+            { instance_id: 'i-abcd1234', public_ip_address: '1.2.3.3', key_name: 'testkey', state: { name: 'stopped' }, tags: [ { key: 'Name', value: 'deadman' } ] },
+            { instance_id: 'i-deadbeef', public_ip_address: '1.2.3.4', key_name: 'testkey', state: { name: 'running' }, tags: [ { key: 'Name', value: 'test' } ] },
+            { instance_id: 'i-beeff00d', private_ip_address: '1.2.3.5', key_name: 'testkey2', state: { name: 'running' }, tags: [ { key: 'Name', value: 'test2' } ] }
+          ]}
+        ]
+      }
+    }
+  }
+end
+
+WRANGLED_INSTANCE_DATA_COMPLETE=[
+  {
+    id: 'i-deadbeef',
+    name: 'test',
+    key: 'testkey',
+    profile: 'default',
+    region: 'us-east-1',
+    provider: 'aws',
+    public_ip: '1.2.3.4',
+    private_ip: nil
+  },
+  {
+    id: 'i-beeff00d',
+    name: 'test2',
+    key: 'testkey2',
+    profile: 'default',
+    region: 'us-east-1',
+    provider: 'aws',
+    public_ip: nil,
+    private_ip: '1.2.3.5'
+  }
+]
+
+AWS_CREDENTIALS_CONTENT=<<EOF
+[default]
+aws_access_key_id = ACCESSKEY
+aws_secret_access_key = SECRETKEY
+region = us-west-2
+
+[client1]
+aws_access_key_id = ACCESSKEY
+aws_secret_access_key = SECRETKEY
+region = us-east-1
+EOF
+
+def mock_config
+  allow(File).to receive(:read).and_call_original
+  allow(File).to receive(:read).with(File.expand_path('~/.aws/credentials')).and_return(AWS_CREDENTIALS_CONTENT).at_least(:once)
+end
+
+LOCAL_SSHCONFIG=<<EOF
+User myusername
+EOF
+
+def mock_local_sshconfig_exists
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/local.sshconfig')).and_return(true).at_least(:once)
+end
+
+def mock_local_sshconfig
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/local.sshconfig')).and_return(true).at_least(:once)
+  expect(File).to receive(:read).with(File.expand_path('~/.ssh/local.sshconfig')).and_return(LOCAL_SSHCONFIG).at_least(:once)
+end
+
+def mock_no_local_sshconfig
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/local.sshconfig')).and_return(false).at_least(:once)
+end
+
+SSH_CONFIG_RESULT=<<EOF
+Host default-test-i-deadbeef
+  HostName 1.2.3.4
+
+Host default-test2-i-beeff00d
+  HostName 1.2.3.5
+EOF
+
+UNMANAGED_SSH_CONFIG=<<EOF
+Host default-test-i-deadbeef
+  HostName 1.2.3.4
+EOF
+
+def mock_unmanaged_sshconfig
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/config')).and_return(true).at_least(:once)
+  expect(File).to receive(:read).with(File.expand_path('~/.ssh/config')).and_return(UNMANAGED_SSH_CONFIG).at_least(:once)
+end
+
+MANAGED_SSH_CONFIG=<<EOF
+# Managed by Lakitu
+Host default-test-i-deadbeef
+  HostName 1.2.3.4
+EOF
+
+def mock_managed_sshconfig
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/config')).and_return(true).at_least(:once)
+  expect(File).to receive(:read).with(File.expand_path('~/.ssh/config')).and_return(MANAGED_SSH_CONFIG).at_least(:once)
+end
+
+def mock_fresh_sshconfig
+  expect(File).to receive(:mtime).with(Lakitu::SSHCONFIG_PATH).and_return(Time.now).at_least(:once)
+end
+
+def mock_stale_sshconfig
+  expect(File).to receive(:mtime).with(Lakitu::SSHCONFIG_PATH).and_return(Time.now - 60*60*24).at_least(:once)
+end
+
+def mock_ssh_keys
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/testkey.pem')).and_return(true).at_least(:once)
+  expect(File).to receive(:exist?).with(File.expand_path('~/.ssh/testkey2.pem')).and_return(true).at_least(:once)
+end
+
+def mock_no_ssh_keys
+  allow(File).to receive(:exist?).with(File.expand_path('~/.ssh/testkey.pem')).and_return(false).at_least(:once)
+  allow(File).to receive(:exist?).with(File.expand_path('~/.ssh/testkey2.pem')).and_return(false).at_least(:once)
+end
+
+OPTIONS_CONTENT=<<EOF
+---
+verbose: true
+force: true
+refresh_interval_minutes: 5
+providers:
+  aws:
+    client1:
+      format: "formattest"
+EOF
+def mock_options
+  allow(File).to receive(:exist?).and_call_original
+  expect(File).to receive(:exist?).with(Lakitu::OPTIONS_FILE_PATH).and_return(true).at_least(:once)
+  expect(File).to receive(:read).with(Lakitu::OPTIONS_FILE_PATH).and_return(OPTIONS_CONTENT).at_least(:once)
+end
+
+def mock_no_options
+  expect(File).to receive(:exist?).with(Lakitu::OPTIONS_FILE_PATH).and_return(false).at_least(:once)
+end

metadata

@@ -1,58 +1,75 @@
 --- !ruby/object:Gem::Specification
 name: lakitu
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Bryan Conrad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-15 00:00:00.000000000 Z
+date: 2016-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
 description: ''
 email:
 - bkconrad@gmail.com
-executables: []
+executables:
+- lakitu
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .gitignore
+- .rspec
+- .ruby-version
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/lakitu
 - lakitu.gemspec
 - lib/lakitu.rb
+- lib/lakitu/configurer.rb
+- lib/lakitu/file_operator.rb
+- lib/lakitu/generator.rb
+- lib/lakitu/options.rb
+- lib/lakitu/provider.rb
+- lib/lakitu/providers/aws.rb
 - lib/lakitu/version.rb
+- spec/configurer_spec.rb
+- spec/file_operator_spec.rb
+- spec/generator_spec.rb
+- spec/lakitu_spec.rb
+- spec/options_spec.rb
+- spec/providers/aws_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -63,19 +80,25 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Ride the clouds
-test_files: []
-has_rdoc: 
+test_files:
+- spec/configurer_spec.rb
+- spec/file_operator_spec.rb
+- spec/generator_spec.rb
+- spec/lakitu_spec.rb
+- spec/options_spec.rb
+- spec/providers/aws_spec.rb
+- spec/spec_helper.rb