hansolo 0.0.1.alpha.3 → 0.1.0

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title hansolo --protected -M github-markup -M redcarpet lib/**/*.rb

data/README.md

@@ -2,7 +2,7 @@
 
 NOTE: This is alpha code.
 
-Cli tool to automate berkshelf and chef-solo deployment
+CLI tool to automate berkshelf and chef-solo deployment
 
 ## Installation
 
@@ -18,25 +18,89 @@ Or install it yourself as:
 
     $ gem install hansolo
 
-## Example configuration file
+## Usage
 
-    {
-      "urls": [ "vagrant@localhost:2222" ],
-      "runlist": [ "my_app::deploy" ],
-      "app":"my_app",
-      "keydir":"/Applications/Vagrant/embedded/gems/gems/vagrant-1.1.4/keys/vagrant",
-      "aws_access_key_id":"AAAAAAAAAAAAAAAAAAAA",
-      "aws_secret_access_key":"1111111111111111111111111111111111111111",
-      "aws_bucket_name":"acme-data_bags",
-      "aws_data_bag_keys":["my_app/stage/environment.json"]
-    }
+`hansolo` provides three command line utilities for managing nodes with `chef-solo`.
 
-## Usage
+* `hansolo`: runs `rsync` to copy cookbooks and data bags to the target nodes, generates a manifest and executes `chef-solo` against the generated manifest.
+* `hansolo-databag`: Manages data bags.
+* `hansolo-ssh`: SSHs into one of the target nodes.
+
+To see what options can be supplied, run the command with `-h` or `--help`.
+
+
+## `Hanfile` options
+
+```ruby
+Hansolo.configure do |config|
+  # Path to SSH keys
+  config.keydir = '~/.ssh/chef'
+
+  # Gateway server if nodes are in a private network. Must be a valid ssh URI
+  # or URI instance.
+  config.gateway = 'ssh://user@gateway.example.com:20202'
+
+  # Name of the application
+  config.app = 'blog'
+
+  # Nodes to run `chef-solo` on. Can be a single or array of ssh URIs or URI
+  # instance.
+  config.target = 'ssh://user@blog.example.com'
+
+  # List of recipes to run.
+  config.runlist = ['recipe']
+
+  # Local path where cookbooks should be installed to using
+  # `Hansolo.librarian`. Defaults to `./tmp/data_bags`
+  config.cookbooks_path = '/tmp/chef/cookbooks'
+
+  # Local path where data bags will be written when using `hansolo-databag`.
+  # Defaults to `./tmp/cookbooks`
+  config.data_bags_path = '/tmp/chef/cookbooks'
+
+  # Command to run on the node after SSHing.
+  config.post_ssh_command = 'export RAILS_ENV=production; cd /srv/blog/current'
+
+  # Which chef cookbook manager to use. Currently, only `#berkshelf` is
+  # supported.
+  config.librarian = :berkshelf
+
+  # SSH options to use when running `rsync` or `hansolo-ssh`.
+  # Defaults to `-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no`.
+  config.ssh_options = '-vvv'
+end
+```
+
+## Providers
+
+`hansolo`'s behavior can be augmented by different providers by requiring them
+in a `Hanfile`. Currently, AWS is the only provider provided.
+
+```ruby
+# Add AWS functionality to the toolset
+require 'hansolo/providers/aws'
+
+Hansolo.configure do |config|
+  # ...
+end
+```
+
+### AWS Provider
+
+The AWS provider augments `hansolo` to store data\_bags in S3 and adds the
+ability to query EC2 for the IP address of the gateway and/or target nodes.
 
-See the binary:
+Data bags are stored in a bucket with the name `data_bags-:app`. The bucket is
+created if it does not exist.
 
-    $ hansolo -h
+To have the IP address of the gateway queried, use the following URI scheme:
+`<tag_name>://user@<value>:port`. The `<tag_name>` is the name of any tag on
+the instance (e.g. `Name://user@bastion`).
 
+To query instances, set `Hansolo.target` to a hash with the keys `:user`,
+`:host`, and optionally `:port` (if not `22`). The `:host` key should be set to
+the tag to query and the value should be the name of the application (e.g.
+`role://user@api`).
 
 ## Contributing
 

data/bin/hansolo

@@ -1,53 +1,6 @@
 #!/usr/bin/env ruby
 $: << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
 
-require 'hansolo'
-require 'optparse'
+require 'hansolo/commands/solo'
 
-conf_options = {}; options = {}
-
-optparse = OptionParser.new do |opts|
-  opts.banner = Hansolo::Cli.banner
-
-  opts.on( '-h', '--help', 'Display this screen' ) do
-    puts opts
-    puts "\n"
-    puts Hansolo::Cli.help
-    exit
-  end
-
-  opts.on( '-c', '--config file', String, 'Path to config file') do |filename|
-    conf_options = JSON.parse(File.read(filename)) if filename != '' and File.exists?(filename)
-  end
-
-  opts.on( '-u', '--urls a,b,c', Array, "Comma-sep list of urls, e.g.: user@host:port/dest/path") do |o|
-    options[:urls] = o
-  end
-
-  opts.on( '-k', '--keydir s', String, "Your local ssh key directory") do |o|
-    options[:keydir] = o
-  end
-
-  opts.on( '-a', '--app s', String, "The application name") do |o|
-    options[:app] = o
-  end
-
-  opts.on( '-s', '--stage s', String, "The stage name") do |o|
-    options[:stage] = o
-  end
-
-  opts.on( '-r', '--runlist a,b,c', Array, "The runlist you want to effect on the target(s)") do |o|
-    options[:runlist] = o
-  end
-end.parse!(ARGV)
-
-unless conf_options.any?
-  default_conf_filename = File.expand_path(File.join(".",".hansolo.json"))
-  conf_options = JSON.parse(File.read(default_conf_filename)) if File.exists?(default_conf_filename)
-end
-
-
-opts = conf_options.merge(options).inject({}){|m,(k,v)| m[k.to_sym] = v; m}
-
-h = Hansolo::Cli.new conf_options.merge(opts)
-h.all!
+Hansolo::Commands::Solo.run(ARGV)

data/bin/hansolo-databag

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+
+require 'hansolo/commands/data_bag'
+
+Hansolo::Commands::DataBag.run(ARGV)

data/bin/hansolo-ssh

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(__FILE__, '..', '..', 'lib'))
+
+require 'hansolo/commands/ssh'
+
+Hansolo::Commands::SSH.run(ARGV)

data/hansolo.gemspec

@@ -20,9 +20,14 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "aws-sdk"
   spec.add_dependency "net-ssh"
+  spec.add_dependency "net-ssh-gateway"
   spec.add_dependency "json"
+  spec.add_dependency "terminal-table"
+  spec.add_dependency "cocaine"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "mocha"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "redcarpet"
 end

data/lib/hansolo/commands/base.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+require 'cocaine'
+require 'net/ssh'
+require 'net/ssh/gateway'
+require 'hansolo'
+require 'hansolo/providers/default'
+
+module Hansolo
+  module Commands
+    # Responsible for taking in command line options and reading in `Hanfile`.
+    # Any unique command line options should be added in a subclass. Provides
+    # minimal helpers for executing commands.
+    class Base
+      include Providers::DefaultBehavior
+
+      # @!attribute [r] bastion
+      #   @return [URI] attributes of the bastion server
+      attr_reader :bastion
+
+      # Run the command
+      # @see {#run}
+      def self.run(arguments)
+        new(arguments).run
+      end
+
+      # Sets up command
+      #
+      # * Loads the `Hanfile`
+      # * Parses command line arguments
+      # * Determines the {#bastion} if {Hansolo.gateway} is specified
+      def initialize(arguments)
+        load_hanfile!
+
+        setup_parser
+        parser.parse!(arguments)
+
+        determine_bastion if Hansolo.gateway
+      end
+
+      # Public interface to the command to be implemented in a subclass.
+      def run
+        raise NotImplementedError
+      end
+
+      private
+
+      def exec(command)
+        Hansolo.logger.debug(command)
+        Kernel.exec(command)
+      end
+
+      def call(command)
+        Hansolo.logger.debug(command)
+        %x{#{command}}
+      end
+
+      def parser
+        @parser ||= OptionParser.new
+      end
+
+      def load_hanfile!
+        load hanfile_path if File.exists?(hanfile_path)
+      end
+
+      def hanfile_path
+        @hanfile_path ||= File.expand_path('Hanfile')
+      end
+
+      def setup_parser
+        parser.on( '-h', '--help', 'display this screen' ) do
+          puts parser
+          exit
+        end
+
+        parser.on( '-t', '--target a,b,c', Array, "comma-sep list of urls, e.g.: user@host:port/dest/path") do |option|
+          Hansolo.target = option
+        end
+
+        parser.on( '-a', '--app s', String, "the application name") do |option|
+          Hansolo.app = option
+        end
+      end
+    end
+  end
+end

data/lib/hansolo/commands/data_bag.rb

@@ -0,0 +1,82 @@
+require 'terminal-table'
+require 'hansolo/commands/base'
+require 'hansolo/providers/default/data_bags'
+
+module Hansolo
+  module Commands
+    class DataBag < Base
+      include Providers::DefaultBehavior::DataBags
+
+      attr_accessor :bag, :item, :changes
+
+      def run
+        changes.nil? ? print : write and print
+      end
+
+      def changes=(key_value_pairs)
+        @changes = key_value_pairs.inject({}) do |hash, pair|
+          key, value = pair.split('=', 2)
+          hash[key] = value
+          hash
+        end
+      end
+
+      private
+
+      def read(content = item_content)
+        JSON.parse(content)
+      end
+
+      def all
+        data_bags.map { |key, content| [key, read(content)] }
+      end
+
+      def write
+        content = read.merge(changes).delete_if { |k, v| v.nil? || v.strip.empty? }
+        content['id'] ||= item
+
+        write_to_storage(content.to_json)
+      end
+
+      def print
+        if !bag.nil? && !item.nil?
+          rows = read
+          rows.delete('id')
+
+          terminal_table = Terminal::Table.new(rows: rows, headings: ['key', 'value'])
+        else
+          terminal_table = Terminal::Table.new do |table|
+            table.headings = ['key', 'value']
+            all.each_with_index do |(bag_and_item, content), i|
+              table.add_separator if i != 0
+
+              table.add_row [{ value: ' ', colspan: 2, alignment: :center, border_y: ' ' }]
+              table.add_row [{ value: "BAG/ITEM: #{bag_and_item}", colspan: 2, alignment: :center }]
+
+              table.add_separator
+
+              content.delete('id')
+              content.each do |k, v|
+                table.add_row [k, v]
+              end
+            end
+          end
+        end
+
+        STDOUT.puts terminal_table
+      end
+
+      def setup_parser
+        super
+
+        parser.on('-b', '--data-bag-and-item BAG/ITEM', String, 'The data-bag and data-item, e.g. config/environment') do |option|
+          self.bag, self.item = option.split('/')
+        end
+
+        parser.on('--set CONFIG', Array, 'Set or unset (with an empty value) key-value pairs, e.g. foo=bar,key=value') do |option|
+          self.changes = option
+        end
+      end
+    end
+  end
+end

data/lib/hansolo/commands/solo.rb

@@ -0,0 +1,79 @@
+require 'hansolo/commands/base'
+require 'hansolo/providers/default/solo'
+
+module Hansolo
+  module Commands
+    class Solo < Base
+      include Providers::DefaultBehavior::Solo
+
+      # Puts cookbooks and data bags on the target nodes and runs `chef-solo`.
+      # Providers should implement the {#sync_data_bags} and {#sync_cookbooks}.
+      def run
+        sync_data_bags
+
+        Hansolo.librarian.install!
+        sync_cookbooks
+
+        execute_chef_solo
+      end
+
+      # SSH into each node to prepare and execute a `chef-solo` run.
+      def execute_chef_solo
+        threads = hosts.map do |host|
+          ssh = connect(host)
+
+          Thread.new do
+            ssh.exec! generate_manifest.command(manifest: manifest)
+            ssh.exec! generate_json.command(json: json)
+
+            ssh.exec! chef_solo do |channel, stream, line|
+              puts line
+            end
+
+            ssh.close
+          end
+        end
+
+        threads.map(&:join)
+      end
+
+      private
+
+      def chef_solo
+        'sudo chef-solo -c /tmp/solo.rb -j /tmp/deploy.json'
+      end
+
+      def connect(host)
+        if bastion.nil?
+          Net::SSH.new(host.host, host.user, port: host.port)
+        else
+          gateway.ssh(host.host, host.user, port: host.port)
+        end
+      end
+
+      def generate_manifest
+        Cocaine::CommandLine.new('echo', ':manifest > /tmp/solo.rb')
+      end
+
+      def generate_json
+        Cocaine::CommandLine.new('echo', ':json > /tmp/deploy.json')
+      end
+
+      def manifest
+        <<-MANIFEST
+file_cache_path '/tmp'
+cookbook_path '/tmp/cookbooks'
+data_bag_path '/tmp/data_bags'
+        MANIFEST
+      end
+
+      def json
+        { :run_list => Hansolo.runlist }.to_json
+      end
+
+      def gateway
+        @gateway ||= Net::SSH::Gateway.new(bastion.host, bastion.user, port: bastion.port)
+      end
+    end
+  end
+end

data/lib/hansolo/commands/ssh.rb

@@ -0,0 +1,58 @@
+require 'hansolo/commands/base'
+
+module Hansolo::Commands
+  class SSH < Base
+    def run
+      if bastion.nil?
+        exec(ssh.command(ssh_params))
+      else
+        exec(bastion_ssh.command(bastion_params))
+      end
+    end
+
+    private
+
+    def post_ssh_command
+      "#{Hansolo.post_ssh_command}; bash -i"
+    end
+
+    def ssh
+      Cocaine::CommandLine.new('ssh', ssh_params)
+    end
+
+    def ssh_options
+      options = ":user@:host #{Hansolo.ssh_options} -p :port"
+      options << ' -t :command' if Hansolo.post_ssh_command
+      options
+    end
+
+    def ssh_params
+      @ssh_params ||= begin
+        uri = hosts.sample
+
+        {
+          user: uri.user,
+          host: uri.host,
+          port: uri.port.to_s,
+          command: post_ssh_command
+        }
+      end
+    end
+
+    def bastion_ssh
+      Cocaine::CommandLine.new('ssh', bastion_ssh_options)
+    end
+
+    def bastion_ssh_options
+      "-A -l :bastion_user #{Hansolo.ssh_options} -p :bastion_port :bastion_host -t \"ssh #{ssh_options}\""
+    end
+
+    def bastion_params
+      @bastion_params ||= {
+        bastion_user: bastion.user,
+        bastion_port: bastion.port.to_s,
+        bastion_host: bastion.host
+      }.merge(ssh_params)
+    end
+  end
+end

data/lib/hansolo/librarians/berkshelf.rb

@@ -0,0 +1,15 @@
+module Hansolo::Librarians
+  module Berkshelf
+    module_function
+
+    def install!
+      directory = Pathname.new("tmp/cookbooks/#{Hansolo.app}")
+      FileUtils.mkdir_p(directory)
+
+      files = Dir[directory.join('*')]
+      FileUtils.rm_rf(files)
+
+      system("berks install --path #{directory}")
+    end
+  end
+end

data/lib/hansolo/librarians.rb

@@ -0,0 +1 @@
+require 'hansolo/librarians/berkshelf'

data/lib/hansolo/providers/aws/data_bags.rb

@@ -0,0 +1,25 @@
+module Hansolo::Providers::AWS
+  module DataBags
+    def data_bags
+      objects = bucket.objects.with_prefix(Hansolo.app).to_a
+      objects.map do |o|
+        key = o.key.chomp('.json').sub("#{Hansolo.app}/", '')
+        [key, o.read]
+      end
+    end
+
+    def item_key
+      @item_key ||= "#{Hansolo.app}/#{bag}/#{item}.json"
+    end
+
+    def item_content
+      bucket.objects[item_key].read
+    rescue AWS::S3::Errors::NoSuchKey
+      "{}"
+    end
+
+    def write_to_storage(content)
+      bucket.objects[item_key].write(content)
+    end
+  end
+end

data/lib/hansolo/providers/aws/discovery.rb

@@ -0,0 +1,58 @@
+module Hansolo
+  module Providers
+    module AWS
+      module Discovery
+        def ec2
+          @ec2 ||= ::AWS::EC2.new(Hansolo.aws_credentials)
+        end
+
+        def s3
+          @s3 ||= ::AWS::S3.new(Hansolo.aws_credentials)
+        end
+
+        def determine_bastion
+          @bastion = begin
+            uri = super
+
+            return uri if uri.scheme == 'ssh'
+
+            instance = instances_by_tag(uri.scheme.to_s, uri.host).first
+            raise ArgumentError, "no gateway with #{uri.scheme} #{uri.host} found" if instance.nil?
+
+            URI.parse("ssh://#{uri.user}@#{instance.public_ip_address}:#{uri.port || 22}")
+          end
+        end
+
+        def hosts
+          @hosts ||= begin
+            target = Hansolo.target
+            return super unless target.is_a?(Hash)
+
+            target_instances = instances_by_tag(target[:host].to_s, Hansolo.app)
+
+            target_instances.map do |instance|
+              ip_address = instance.ip_address || instance.private_ip_address
+              URI.parse("ssh://#{target[:user]}@#{ip_address}:#{target[:port] || 22}")
+            end
+          end
+        end
+
+        private
+
+        def bucket
+          @bucket ||= begin
+            name = Hansolo.bucket_name
+
+            bucket = s3.buckets[name]
+            bucket = s3.buckets.create(name) unless bucket.exists?
+            bucket
+          end
+        end
+
+        def instances_by_tag(tag, value)
+          ec2.instances.tagged(tag).tagged_values(value)
+        end
+      end
+    end
+  end
+end

data/lib/hansolo/providers/aws/solo.rb

@@ -0,0 +1,27 @@
+module Hansolo::Providers::AWS
+  module Solo
+    def sync_data_bags
+      threads = hosts.map do |host|
+        Thread.new do
+          ssh = connect(host)
+
+          command = data_bag_items.inject([]) do |cmd, object|
+            path = Pathname.new('/tmp/data_bags').join(object.key)
+
+            cmd << "mkdir -p #{path.dirname}"
+            cmd << "echo '#{object.read}' > #{path}"
+          end
+
+          ssh.exec! command.join('; ')
+          ssh.close
+        end
+      end
+
+      threads.map(&:join)
+    end
+
+    def data_bag_items
+      bucket.objects.select { |o| o.key =~ /\.json$/ }
+    end
+  end
+end

data/lib/hansolo/providers/aws.rb

@@ -0,0 +1,30 @@
+require 'aws-sdk'
+require 'hansolo'
+require 'hansolo/providers/aws/data_bags'
+require 'hansolo/providers/aws/discovery'
+require 'hansolo/providers/aws/solo'
+
+module Hansolo
+  class << self
+    attr_accessor :aws_access_key_id, :aws_secret_access_key, :bucket_name
+  end
+
+  def self.aws_credentials
+    @aws_credentials ||= {
+      access_key_id: aws_access_key_id,
+      secret_access_key: aws_secret_access_key
+    }
+  end
+
+  class Commands::Base
+    include Providers::AWS::Discovery
+  end
+
+  class Commands::DataBag
+    include Providers::AWS::DataBags
+  end
+
+  class Commands::Solo
+    include Providers::AWS::Solo
+  end
+end

data/lib/hansolo/providers/default/data_bags.rb

@@ -0,0 +1,29 @@
+module Hansolo::Providers::DefaultBehavior
+  module DataBags
+    # Key-value pairs of the name of the data bag item to the item's content.
+    # @return [Hash]
+    def data_bags
+      @data_bags ||= Dir[Hansolo.data_bags_path.join('*', '**')].map { |path| [path.chomp('.json'), load_content(path)] }
+    end
+
+    # Path to the
+    def item_path
+      Hansolo.data_bags_path.join(bag, "#{item}.json")
+    end
+
+    def load_content(path)
+      File.read(path)
+    end
+
+    def item_content
+      load_content(item_path)
+    rescue
+      '{}'
+    end
+
+    def write_to_storage(content)
+      FileUtils.mkdir_p(item_path.dirname)
+      File.open(item_path, 'w') { |f| f.write content }
+    end
+  end
+end

data/lib/hansolo/providers/default/solo.rb

@@ -0,0 +1,68 @@
+module Hansolo::Providers::DefaultBehavior
+  module Solo
+
+    # `rsync` data bags to the node
+    def sync_data_bags
+      rsync_resource(:data_bags)
+    end
+
+    # `rsync` cookbooks to the node
+    def sync_cookbooks
+      rsync_resource(:cookbooks)
+    end
+
+    private
+
+    def rsync_resource(resource)
+      threads = hosts.map do |host|
+        Thread.new { call rsync.command(rsync_params(host, resource)) }
+      end
+
+      threads.map(&:join)
+    end
+
+    def rsync
+      Cocaine::CommandLine.new('rsync', rsync_options)
+    end
+
+    def rsync_options
+      "--delete -av -e \"#{ssh_options}\" :source :destination"
+    end
+
+    def ssh_options
+      if !bastion.nil?
+        "ssh -A -l :bastion_user #{Hansolo.ssh_options} :bastion_host ssh -l :user #{Hansolo.ssh_options} -p :port"
+      else
+        "ssh -l :user #{Hansolo.ssh_options} -p :port"
+      end
+    end
+
+    def rsync_params(host, content)
+      params = {
+        user: host.user,
+        ssh_options: Hansolo.ssh_options,
+        port: host.port.to_s,
+        source: source(content),
+        destination: destination(host, content)
+      }
+
+      if !bastion.nil?
+        params.merge!(
+          bastion_user: bastion.user,
+          bastion_port: bastion.port.to_s,
+          bastion_host: bastion.host
+        )
+      end
+
+      params
+    end
+
+    def source(content)
+      "#{Hansolo.send("#{content}_path").join(Hansolo.app)}/"
+    end
+
+    def destination(host, content)
+      "#{host.user}@#{host.host}:/tmp/#{content}"
+    end
+  end
+end

data/lib/hansolo/providers/default.rb

@@ -0,0 +1,21 @@
+module Hansolo
+  module Providers
+    module DefaultBehavior
+      # Sets {Hansolo::Commands::Base#bastion}
+      # @return [URI, NilClass]
+      def determine_bastion
+        @bastion = case Hansolo.gateway
+                   when String then URI.parse(Hansolo.gateway)
+                   when URI then Hansolo.gateway
+                   else raise ArgumentError, 'pass in a String or URI object'
+                   end
+      end
+
+      # Builds an array of `URI` instances representing target nodes
+      # @return [Array<URI>]
+      def hosts
+        @hosts ||= Array(Hansolo.target).map { |target| URI.parse(target) }
+      end
+    end
+  end
+end

data/lib/hansolo/version.rb

@@ -1,3 +1,3 @@
 module Hansolo
-  VERSION = "0.0.1.alpha.3"
+  VERSION = "0.1.0"
 end

data/lib/hansolo.rb

@@ -1,210 +1,46 @@
-require 'net/ssh'
-require 'json'
-require 'aws-sdk'
+require 'logger'
+require "hansolo/version"
+require 'hansolo/librarians'
 
 module Hansolo
-  class Cli
-    attr_accessor :keydir, :urls, :runlist, :s3conn, :app, :stage, :aws_bucket_name, :aws_data_bag_keys
-
-    def initialize(args={})
-      @keydir                 = args[:keydir]
-      @urls                   = args[:urls]
-      @runlist                = args[:runlist]
-      @app                    = args[:app]
-      @stage                  = args[:stage]
-      @aws_bucket_name        = args[:aws_bucket_name]
-      @aws_data_bag_keys      = args[:aws_data_bag_keys]
-      @aws_secret_access_key  = args[:aws_secret_access_key]
-      @aws_access_key_id      = args[:aws_access_key_id]
-
-      if (@aws_secret_access_key && @aws_access_key_id && @aws_bucket_name && @aws_data_bag_keys)
-        @s3conn = AWS::S3.new(:access_key_id => args[:aws_access_key_id],
-                              :secret_access_key => args[:aws_secret_access_key])
-      end
-    end
-
-    def self.banner
-      "Usage: hansolo [OPTS]"
-    end
-
-    def self.help
-      DATA.read
-    end
-
-    def tmpdir
-      '/tmp'
-    end
-
-    def all!
-      vendor_berkshelf!
-      rsync_cookbooks!
-      rsync_data_bags! if s3conn
-      solo!
-    end
-
-    def username(url)
-      @username ||= Util.parse_url(url)[:username]
-    end
-
-    def dest_cookbooks_dir(url)
-      File.join("/", "home", username(url), "cookbooks")
-    end
-
-    def dest_data_bags_dir(url)
-      File.join("/", "home", username(url), "data_bags")
-    end
-
-    def local_cookbooks_tmpdir
-      File.join(tmpdir, 'cookbooks.working')
-    end
-
-    def local_data_bags_tmpdir
-      File.join(tmpdir, 'data_bags.working')
-    end
-
-    def vendor_berkshelf!
-      Util.call_vendor_berkshelf(local_cookbooks_tmpdir)
-    end
-
-    def s3_bucket
-      s3_bucket = s3conn.buckets[aws_bucket_name]
-      if s3_bucket.exists?
-        s3_bucket
-      else
-        s3conn.buckets.create(aws_bucket_name)
-      end
-    end
-
-    #def s3_key_name
-      #"#{app}/#{stage}/environment.json"
-    #end
-
-    #def s3_item
-      #s3_bucket.objects[s3_key_name]
-    #end
-
-    def rsync_cookbooks!
-      raise ArgumentError, "missing urls array and keydir"  unless (urls && keydir)
-      urls.each do |url|
-        opts = Util.parse_url(url).merge(keydir: keydir, sourcedir: local_cookbooks_tmpdir, destdir: dest_cookbooks_dir(url))
-        Util.call_rsync(opts)
-      end
-    end
-
-    def rsync_data_bags!
-      # Grab JSON file from S3, and place it into a conventional place
-      Util.call("mkdir -p #{File.join(local_data_bags_tmpdir, 'app')}")
-
-      aws_data_bag_keys.each do |key_name|
-        item = s3_bucket.objects[key_name]
-        base_key_name = File.basename(key_name)
-        File.open(File.join(local_data_bags_tmpdir, 'app', base_key_name), 'w') do |f|
-          f.write item.read
-        end if item.exists?
-      end
-
-      urls.each do |url|
-        opts = Util.parse_url(url).merge(keydir: keydir, sourcedir: local_data_bags_tmpdir, destdir: dest_data_bags_dir(url))
-        Util.call_rsync(opts)
-      end
-    end
-
-    def solo!
-      raise ArgumentError, "missing urls array and keydir"  unless (urls && keydir)
-      urls.each { |url| Util.chef_solo(Util.parse_url(url).merge(keydir: keydir, cookbooks_dir: dest_cookbooks_dir(url), data_bags_dir: dest_data_bags_dir(url), runlist: runlist)) }
-    end
+  class << self
+    attr_accessor :keydir,
+                  :gateway,
+                  :app,
+                  :target,
+                  :runlist,
+                  :cookbooks_path,
+                  :data_bags_path,
+                  :post_ssh_command,
+                  :librarian,
+                  :ssh_options
   end
 
-  module Util
-    def self.call(cmd)
-      puts "* #{cmd}"
-      %x{#{cmd}}
-    end
-
-    def self.call_vendor_berkshelf(tmpdir)
-      call("rm -rf #{tmpdir} && bundle exec berks install --path #{tmpdir}")
-    end
-
-    def self.call_rsync(args={})
-      cmd = "rsync -av -e 'ssh -l #{args[:username]} #{ssh_options(["-p #{args[:port]}", "-i #{args[:keydir]}"])}' "
-      cmd << "#{args[:sourcedir]}/ #{args[:username]}@#{args[:hostname]}:#{args[:destdir]}"
-      call cmd
-    end
-
-    def self.chef_solo(args={})
-      # on remote do:
-      # build a solo.rb
-      # build a tmp json file with the contents { "run_list": [ "recipe[my_app::default]" ] }
-      # chef-solo -c solo.rb -j tmp.json
+  LOGGER = Logger.new(STDOUT)
+  LOGGER.formatter = proc do |severity, datetime, progname, msg|
+    "* #{msg}\n"
+  end
 
-      Net::SSH.start(args[:hostname], args[:username], :port => args[:port], :keys => [ args[:keydir] ]) do |ssh|
-        puts ssh.exec! "echo \"#{solo_rb(args[:tmpdir], args[:cookbooks_dir], args[:data_bags_dir])}\" > /tmp/solo.rb"
-        puts ssh.exec! "echo '#{ { :run_list => args[:runlist] }.to_json }' > /tmp/deploy.json"
-        ssh.exec! 'PATH="$PATH:/opt/vagrant_ruby/bin" sudo chef-solo -l debug -c /tmp/solo.rb -j /tmp/deploy.json' do |ch, stream, line|
-          puts line
-        end
-      end
-    end
+  def self.configure
+    yield self
 
-    private
+    self.cookbooks_path ||= Pathname.new('tmp/cookbooks')
+    self.data_bags_path ||= Pathname.new('tmp/data_bags')
+    self.ssh_options    ||= '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
+  end
 
-    def self.solo_rb(tmpdir, cookbooks_dir, data_bags_dir)
-      [
-        "file_cache_path '#{tmpdir}'",
-        "cookbook_path '#{cookbooks_dir}'",
-        "data_bag_path '#{data_bags_dir}'"
-      ].join("\n")
-    end
+  def self.logger
+    LOGGER
+  end
 
-    def self.parse_url(url)
-      if (url =~ /^([^\@]*)@([^:]*):([0-9]*)$/)
-        return { username: $1, hostname: $2, port: $3.to_i }
-      else
-        raise ArgumentError, "Unable to parse `#{url}', should be in form `user@host:port'"
-      end
-    end
+  def self.librarians
+    {
+      berkshelf: Librarians::Berkshelf
+    }
+  end
+  private_class_method :librarians
 
-    def self.ssh_options(opts=[])
-      (
-        [
-          "-q",
-          "-o StrictHostKeyChecking=no",
-          "-o UserKnownHostsFile=/dev/null"
-      ] + opts
-      ).join(' ')
-    end
+  def self.librarian=(librarian)
+    @librarian = librarians[librarian]
   end
 end
-
-require "hansolo/version"
-
-__END__
-This is a simple cli program to automate deploy using chef-solo and
-berkshelf.
-
-If you pass a filename, put in JSON for the configuration.  So in .hansolo.json:
-
-  { "keydir": "/Applications/Vagrant/embedded/gems/gems/vagrant-1.1.4/keys/vagrant" }
-
-Then you can pass to the command as:
-
-  $ hansolo -c .hansolo.json
-
-NOTE: Command-line args trump config settings.
-
-Example Usage:
-
-  $ hansolo -s approval -t /tmp/myapp.cookbooks \
-
-      -k /Applications/Vagrant/embedded/gems/gems/vagrant-1.1.4/keys/vagrant \
-
-      -u user@host1:22/path,user@host2:22/path \
-
-      -r apt::default,myapp::deploy
-
-  $ hansolo -s approval -c .hansolo.json
-
-  $ hansolo -s approval
-
-NOTE: You don't need to pass -c if you use the filename .hansolo.json.  Passing -c
-will override reading this default.

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: hansolo
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.3
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Brian Kaney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh-gateway
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +75,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cocaine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -107,22 +155,72 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Tool to automate deployment using chef-solo and berkshelf
 email:
 - brian@vermonster.com
 executables:
 - hansolo
+- hansolo-databag
+- hansolo-ssh
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .yardopts
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/hansolo
+- bin/hansolo-databag
+- bin/hansolo-ssh
 - hansolo.gemspec
 - lib/hansolo.rb
+- lib/hansolo/commands/base.rb
+- lib/hansolo/commands/data_bag.rb
+- lib/hansolo/commands/solo.rb
+- lib/hansolo/commands/ssh.rb
+- lib/hansolo/librarians.rb
+- lib/hansolo/librarians/berkshelf.rb
+- lib/hansolo/providers/aws.rb
+- lib/hansolo/providers/aws/data_bags.rb
+- lib/hansolo/providers/aws/discovery.rb
+- lib/hansolo/providers/aws/solo.rb
+- lib/hansolo/providers/default.rb
+- lib/hansolo/providers/default/data_bags.rb
+- lib/hansolo/providers/default/solo.rb
 - lib/hansolo/version.rb
 - tests/hansolo_test.rb
 homepage: ''
@@ -141,9 +239,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23