small_wonder 0.1

data/README.md

@@ -0,0 +1,80 @@
+## Small Wonder
+
+Small Wonder is a deployment tool.
+
+Specifically it's a lightweight wrapper for Salticid, which is a tool that will run a bunch of commands on a bunch of machines for you. Kinda like capistrano. To a large extent Small Wonder is a means for using Salticid and Chef together to deploy applications. Salticid "roles" and "tasks" are Ruby code and can use the Chef Ruby APIs to search and access anything Chef Client or Knife can (by consuming your knife config). Small Wonder has a notion of an application object as well, this object contains data like the name, version, status and even the databag config data for an application. Name, version and status are saved back to the Chef node so you can use application specific details in your recipes, searches and etc.
+
+### License
+
+Apache License Version 2.0
+
+### Usage
+
+#### Configure
+
+    $ mkdir ~/.small_wonder
+    $ $EDITOR ~/.small_wonder/small_wonder.rb
+
+
+    chef_repo_path                      "/path/to/chef-repo" # the path to your chef-repo
+    ssh_user                            "user" # the ssh user you want Small Wonder and Salticid to use
+    application_deployment_attribute    "deployed_applications" # the attribute Small Wonder will save data back to chef using
+    config_template_working_directory   "/tmp/small_wonder" # the local directory temporary template work will be done in
+    remote_working_dir                  "/tmp/small_wonder_#{Time.now.to_i}" # the remote directory temporary template work will be done in
+    application_deployments_dir         "/path/to/chef-repo/application_deployments" # path to your role files
+    application_templates_dir           "/path/to/chef-repo/application_templates" # path to your template files
+    databag                             "apps" # the databag that contains application configuration data items
+
+In addition to a Small Wonder config, you need a working Knife configuration file.
+
+#### Expectations
+
+Small Wonder expects the names of things to match up. Specifically the application name should be the same as the Salticid role name, databag item and template directory. Note that if an application name has a hyphen in it Small Wonder will convert it to an underscore internally with regards to Salticid roles since they need to be legit Ruby method names.
+
+#### Roles and tasks
+
+Define "roles" using ruby code and splitting deployment operations in to "tasks".
+
+Check out the examples directory for ... well examples.
+
+#### Running small_wonder
+
+A role name should match the name of the application, Chef recipe and databag item your app uses for configuration.
+
+To run the role use:
+
+    $ small_wonder -p example
+
+If you have a specific Chef search query you want to use to as the source of nodes to deploy to:
+
+    $ small_wonder -p example -q "some:attribute"
+
+The default search query is "recipes:example".
+
+You can also specify a version number to pass to the application object:
+
+    $ small_wonder -p example -V 123
+
+#### Chef Data
+
+During the deployment Small Wonder will save data back to the Chef node. Moreover, status is updated to the task currently being run, so you can see live deployment progress in your searches.
+
+If you want to find out details about an app use a knife search like:
+
+    $ knife search node "deployed_applications:example" -a deployed_applications
+
+The output should be something like:
+
+    deployed_applications:
+      example:
+        status:   final
+        version:  851
+    id:                              your.server.com
+
+#### Templating
+
+Small wonder supports some basic erb templating just like Chef. All erb files in your 'application_templates_dir' can get populated with data from various Chef objects and attributes. Those files then get scp'd to the server and "overlayed" (read: `cp -R`) on to the installation directory of the application.
+
+Files and directories with 'VERSION' in the name will be convered to have the actual appclication.version variable in place of 'VERSION'.
+
+The examples directory has some examples.

data/bin/small_wonder

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'small_wonder'))
+
+SmallWonder.main

data/lib/small_wonder.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+
+require 'socket'
+require 'excon'
+require 'mixlib/config'
+require 'mixlib/cli'
+require 'mixlib/log'
+require 'yajl/json_gem'
+require 'salticid'
+require 'chef'
+require 'highline/import'
+require 'erb'
+require 'net/scp'
+
+__DIR__ = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift __DIR__ unless
+  $LOAD_PATH.include?(__DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__DIR__))
+
+require 'small_wonder/log'
+require 'small_wonder/cli'
+require 'small_wonder/config'
+require 'small_wonder/utils'
+require 'small_wonder/deploy'
+require 'small_wonder/application'
+require 'small_wonder/configuratorator'
+
+require 'small_wonder/salticid_monkeypatch'
+
+module SmallWonder
+  class << self
+
+    def salticid=(h)
+      @salticid = h
+    end
+
+    def salticid
+      @salticid
+    end
+
+    def main()
+
+      cli = SmallWonder::CLI.new
+      cli.parse_options
+
+      # consume small wonder config
+      SmallWonder::Utils.consume_config_file(cli, cli.config[:config_file])
+
+      unless SmallWonder::Utils.sane_working_dir?(SmallWonder::Config.remote_working_dir)
+        SmallWonder::Log.error("Your remote working dir looks strange (#{SmallWonder::Config.remote_working_dir})")
+        exit(1)
+      end
+
+      unless SmallWonder::Utils.sane_working_dir?(SmallWonder::Config.config_template_working_directory)
+        SmallWonder::Log.error("Your local working dir looks strange (#{SmallWonder::Config.config_template_working_directory})")
+        exit(1)
+      end
+
+      SmallWonder::Utils.consume_config_file(cli, cli.config[:knife_config_file])
+
+      # inintialize chef/knife config
+      Chef::Config[:node_name] = SmallWonder::Config.node_name
+      Chef::Config[:client_key] = SmallWonder::Config.client_key
+      Chef::Config[:chef_server_url] = SmallWonder::Config.chef_server_url
+
+      # Set up salticid
+      self.salticid = Salticid.new
+      self.salticid.load(File.expand_path(File.join(
+        SmallWonder::Config.application_deployments_dir, '**', '*.rb')))
+
+      case SmallWonder::Config.action
+      when "none"
+        SmallWonder::Log.info("No action specified, assuming deploy ...")
+        SmallWonder::Deploy.run
+      when "deploy"
+        SmallWonder::Deploy.run
+      when "vicki"
+        system("open http://www.youtube.com/watch?v=ukSvjqwJixw")
+      else
+        SmallWonder::Log.error("Supported action \"#{SmallWonder::Config.action}\"!")
+      end
+
+    end
+
+  end
+end

data/lib/small_wonder/application.rb

@@ -0,0 +1,109 @@
+module SmallWonder
+  class Application
+
+    ## In small wonder an application object has the following constituent parts:
+    #### node name
+    #### application name
+    #### version
+    #### status
+    #### databag-based config data
+
+    attr_accessor :version, :status
+    attr_reader :node_name, :application_name, :config_data
+
+    def initialize(node_name, application_name, opts = {})
+      @node_name = node_name
+      @application_name = application_name
+
+      @config_data = Chef::DataBagItem.load(SmallWonder::Config.databag, application_name).raw_data
+
+      data = Chef::Node.load(node_name)
+
+      unless data[SmallWonder::Config.application_deployment_attribute]
+        create_application_deployment_attribute(node_name, application_name)
+        data = Chef::Node.load(node_name)
+      end
+
+      unless data[SmallWonder::Config.application_deployment_attribute].has_key?(application_name)
+        create_application_deployment_attribute_child(node_name, application_name)
+        data = Chef::Node.load(node_name)
+      end
+
+      unless data[SmallWonder::Config.application_deployment_attribute][application_name]
+        update_application_data(node_name, application_name, "version", "0")
+        update_application_data(node_name, application_name, "status", "new")
+      end
+
+      # set version to application version if we have one
+      @version = opts[:version] || nil
+
+      # set status to status before we update for deploy
+      @status = opts[:status] || get_status(node_name, application_name)
+
+      # save the data back to the chef node
+      update_application_data(node_name, application_name, "status", "initialized")
+    end
+
+    def version=(version)
+      @version = version
+      set_version(@node_name, @application_name, version)
+    end
+
+    def status=(status)
+      @status = status
+      set_status(@node_name, @application_name, status)
+    end
+
+    private
+
+    def get_existing_version(node, application)
+      version = get_chef_data_value(node, application, "version")
+
+      unless version
+        version = "0"
+      end
+
+      version
+    end
+
+    def set_version(node, application, version)
+      update_application_data(node, application, "version", version)
+    end
+
+    def get_status(node, application)
+      get_chef_data_value(node, application, "status")
+    end
+
+    def set_status(node, application, status)
+      update_application_data(node, application, "status", status)
+    end
+
+    def get_chef_data_value(node, application, key)
+      data = Chef::Node.load(node)
+      data[SmallWonder::Config.application_deployment_attribute][application][key]
+    end
+
+    def create_application_deployment_attribute(node, application)
+      data = Chef::Node.load(node)
+      data[SmallWonder::Config.application_deployment_attribute] = {}
+      data[SmallWonder::Config.application_deployment_attribute][application] = {}
+      data.save
+    end
+
+    def create_application_deployment_attribute_child(node, application)
+      data = Chef::Node.load(node)
+      data[SmallWonder::Config.application_deployment_attribute][application] = {}
+      data.save
+    end
+
+    def update_application_data(node, application, key, value)
+      data = Chef::Node.load(node)
+      data[SmallWonder::Config.application_deployment_attribute][application][key] = value
+      data.save
+
+      #SmallWonder::Log.info("[#{node} // #{application}] #{key} was updated to #{value}")
+    end
+
+  end
+end
+

data/lib/small_wonder/cli.rb

@@ -0,0 +1,64 @@
+module SmallWonder
+  class CLI
+    include Mixlib::CLI
+
+    option :config_file,
+      :short => "-c CONFIG",
+      :long  => "--config CONFIG",
+      :default => "#{ENV['HOME']}/.small_wonder/small_wonder.rb",
+      :description => "The configuration file to use"
+
+    option :knife_config_file,
+      :short => "-k CONFIG",
+      :long  => "--knife CONFIG",
+      :default => "#{ENV['HOME']}/.chef/knife.rb",
+      :description => "The knife configuration file to use"
+
+    option :action,
+      :short => "-a ACTION",
+      :long  => "--action ACTION",
+      :description => "The action you want small wonder to take [deploy]",
+      :default => "none"
+
+    option :app,
+      :short => "-p APP",
+      :long  => "--app APP",
+      :description => "The app you want small wonder to do something with",
+      :default => nil
+
+    option :version,
+      :short => "-V VERSION",
+      :long  => "--version VERSION",
+      :description => "The version of app you want small wonder to do something with",
+      :default => nil
+
+    option :query,
+      :short => "-q query",
+      :long  => "--query query",
+      :description => "The query you want small wonder to do something with",
+      :default => nil
+
+    option :write_node_file,
+      :short => "-w",
+      :long  => "--write",
+      :description => "true/false write the node json file to your chef-repo at end of deploy",
+      :default => false
+
+    option :log_level,
+      :short => "-l LEVEL",
+      :long  => "--log_level LEVEL",
+      :description => "Set the log level (debug, info, warn, error, fatal)",
+      :default => :info,
+      :proc => Proc.new { |l| l.to_sym }
+
+    option :help,
+      :short => "-h",
+      :long => "--help",
+      :description => "All the help you need ...",
+      :on => :tail,
+      :boolean => true,
+      :show_options => true,
+      :exit => 0
+
+  end
+end

data/lib/small_wonder/config.rb

@@ -0,0 +1,9 @@
+module SmallWonder
+  class Config
+    extend Mixlib::Config
+
+    configure do |c|
+
+    end
+  end
+end

data/lib/small_wonder/configuratorator.rb

@@ -0,0 +1,88 @@
+module SmallWonder
+  class Configuratorator
+
+    def self.generate_and_upload_files(application, path, opts = {})
+      config_template_dir = "#{SmallWonder::Config.application_templates_dir}/#{application.application_name}"
+
+      templates = Dir["#{config_template_dir}/**/*.erb"]
+
+      file_list = []
+
+      templates.each do |file|
+        filename = File.basename(file, '.*')
+        filename.gsub!("VERSION", application.version)
+
+        reldir = File.dirname(file).gsub("#{config_template_dir}", ".")
+        reldir.gsub!("VERSION", application.version)
+
+        file_list << "#{reldir}/#{filename}"
+
+        SmallWonder::Log.info("Generating #{reldir}/#{filename}")
+
+        generated_file = generate_file(file, application, config_template_dir, opts)
+
+        file_dir = "#{SmallWonder::Config.config_template_working_directory}/#{application.application_name}/#{reldir}"
+
+        FileUtils.mkdir_p(file_dir)
+
+        SmallWonder::Utils.write_file(generated_file, "#{file_dir}/#{filename}")
+      end
+
+      upload_files(application.node_name, application.application_name)
+      copy_files_to_install_dir(application.node_name, application.application_name, path)
+      cleanup_working_directories(application.node_name, application.application_name)
+
+      file_list
+    end
+
+    private
+
+    def self.generate_file(file, application, config_template_dir, opts)
+      @deploy_config = application.config_data
+      @options = @deploy_config
+      @node = Chef::Node.load(application.node_name)
+      node = Chef::Node.load(application.node_name)
+
+      if opts[:app_options]
+        @app_options = opts[:app_options]
+      end
+
+      template_file = File.read(file)
+
+      begin
+        template = ERB.new(template_file)
+      rescue Exception => e
+        SmallWonder::Log.error("Error generating file (#{file}).")
+        SmallWonder::Log.error(e)
+        exit(1)
+      end
+
+      template.result(binding)
+    end
+
+    def self.upload_files(node_name, application)
+      Net::SSH.start(node_name, SmallWonder::Config.ssh_user) do |ssh|
+        ssh.exec!("mkdir -p #{SmallWonder::Config.remote_working_dir}")
+      end
+
+      Net::SCP.start(node_name, SmallWonder::Config.ssh_user) do |scp|
+        scp.upload!("#{SmallWonder::Config.config_template_working_directory}/#{application}", SmallWonder::Config.remote_working_dir, {:recursive => true})
+      end
+    end
+
+    def self.copy_files_to_install_dir(node_name, application, path)
+      Net::SSH.start(node_name, SmallWonder::Config.ssh_user) do |ssh|
+        ssh.exec!("echo \"#{@sudo_password}\n\" | sudo -S cp -R #{SmallWonder::Config.remote_working_dir}/#{application}/* /#{path}/")
+      end
+    end
+
+    def self.cleanup_working_directories(node_name, application)
+      FileUtils.rm_rf("#{SmallWonder::Config.config_template_working_directory}/#{application}")
+
+      Net::SSH.start(node_name, SmallWonder::Config.ssh_user) do |ssh|
+        ssh.exec!("rm -rf #{SmallWonder::Config.remote_working_dir}")
+      end
+    end
+
+  end
+end

data/lib/small_wonder/deploy.rb

@@ -0,0 +1,100 @@
+module SmallWonder
+  class Deploy
+    def self.run()
+      if SmallWonder::Config.app
+        nodes = SmallWonder::Deploy.node_query()
+        SmallWonder::Deploy.deploy(SmallWonder::Config.app, nodes)
+      else
+        SmallWonder::Log.error("No application was specified for your deploy, use the '-p' switch.")
+      end
+    end
+
+    private
+
+    def self.node_query()
+      nodes = []
+
+      if SmallWonder::Config.query
+        query = SmallWonder::Config.query
+      else
+        query = "recipes:#{SmallWonder::Config.app}"
+      end
+
+      Chef::Search::Query.new.search(:node, "#{query}") do |n|
+        nodes << n[:fqdn]
+      end
+
+      nodes
+    end
+
+    def self.deploy(application_name, nodes)
+      if nodes.length > 0
+        SmallWonder::Log.info("Found the following nodes via your search.")
+
+        nodes.each do |node|
+          SmallWonder::Log.info("*  #{node}")
+        end
+
+        input = ::HighLine.agree("Are you sure you want to deploy to these nodes [yes|no]?")
+
+        if input
+          SmallWonder::Log.info("Commencing deployment.")
+
+          nodes.each do |node|
+            if SmallWonder::Config.version
+              SmallWonder::Log.info("Got version #{SmallWonder::Config.version} from a command line option, using it as the current version for #{SmallWonder::Config.app}.")
+              application = SmallWonder::Application.new(node, application_name, {:version => SmallWonder::Config.version})
+            else
+              SmallWonder::Log.info("Did not get a app version to deploy on the command line, assuming you will set it during the deploy.")
+              application = SmallWonder::Application.new(node, application_name)
+            end
+
+            deploy_application(application)
+          end
+        end
+      else
+        SmallWonder::Log.info("No nodes found for your search.")
+      end
+    end
+
+    def self.deploy_application(application)
+      run_salticid_task(application)
+
+      if SmallWonder::Config.write_node_file
+        SmallWonder::Utils.write_node_data_file(application.node_name)
+      end
+    end
+
+    ## deploy step
+    # Creates a new salticid host for node, and calls <app>.deploy on it.
+    def self.run_salticid_task(application)
+      host = SmallWonder.salticid.host application.node_name
+      host.on_log do |message|
+        begin
+          level = {'stderr' => 'fatal', nil => 'info'}
+          level.default = 'info'
+          severity = message.severity || 'info'
+          SmallWonder::Log.send(level[message.severity], message.text)
+        rescue => e
+          p e
+        end
+      end
+
+      host.application = application
+
+      host.user SmallWonder::Config.ssh_user
+      @sudo_password = ::HighLine.ask("Your sudo password please:  ") { |q| q.echo = false }
+      host.password = @sudo_password
+
+      # sub hyphens for underscores to work around having hyphens in method names
+
+      host.role application.application_name.gsub("-", "_")
+
+      host.send(application.application_name.gsub("-", "_")).deploy
+
+      # set the application status to final since the deploy is done
+      application.status = "final"
+    end
+
+  end
+end

data/lib/small_wonder/log.rb

@@ -0,0 +1,30 @@
+module SmallWonder
+  require 'colorize'
+
+  class Log
+    COLORS = {
+      'FATAL' => :light_red,
+      'ERROR' => :light_red,
+      'WARN' => :light_yellow,
+      'INFO' => nil,
+      'DEBUG' => :light_blue
+    }
+
+    class Formatter < Mixlib::Log::Formatter
+      def call(severity, time, progname, msg)
+        str = format("[%s] %s\n",
+                     time.strftime("%H:%M:%S"),
+                     msg).colorize(COLORS[severity])
+      end
+    end
+
+    extend Mixlib::Log
+
+    def self.init(*opts)
+      super *opts
+
+      @logger.formatter = Formatter.new() if @logger.respond_to?(:formatter=)
+      @logger
+    end
+  end
+end

data/lib/small_wonder/salticid_monkeypatch.rb

@@ -0,0 +1,22 @@
+class ::Salticid::Host
+  def application
+    @application
+  end
+
+  def application=(app)
+    @application = app
+  end
+end
+
+class Salticid::Task
+  alias_method :stock_run, :run
+
+  def run(context = nil, *args)
+    if context.respond_to? :application
+      context.application.status = name
+    end
+
+    SmallWonder::Log.info("Running task: #{name}")
+    stock_run(context, *args)
+  end
+end

data/lib/small_wonder/utils.rb

@@ -0,0 +1,62 @@
+module SmallWonder
+  class Utils
+
+    def self.consume_config_file(cli, file)
+      if File.exists?(file)
+        SmallWonder::Config.from_file(file)
+        SmallWonder::Config.merge!(cli.config)
+
+        SmallWonder::Log.level(SmallWonder::Config.log_level)
+      else
+        SmallWonder::Log.error("#{file} doesn't exist!")
+        exit(1)
+      end
+    end
+
+    def self.write_node_data_file(node)
+      data = Chef::Node.load(node)
+
+      file = "#{SmallWonder::Config.chef_repo_path}/nodes/#{node}.json"
+
+      SmallWonder::Log.info("Writing node file (#{file}).")
+
+      write_file(JSON.pretty_generate(data), file)
+    end
+
+    def self.write_file(data, path)
+      begin
+        file = File.new(path,"w")
+        file.puts data
+      rescue Exception => e
+        SmallWonder::Log.error("Error writing file (#{path}).")
+        SmallWonder::Log.error(e)
+        exit(1)
+      ensure
+        file.close
+      end
+    end
+
+    def self.sane_working_dir?(dir)
+      sane = []
+      sane << starts_with?(dir, "/tmp/small_wonder")
+
+      if dir.include?("..")
+        sane << false
+      else
+        sane << true
+      end
+
+      if sane.include?(false)
+        false
+      else
+        true
+      end
+    end
+
+    def self.starts_with?(string, prefix)
+      prefix = prefix.to_s
+      string[0, prefix.length] == prefix
+    end
+
+  end
+end

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification 
+name: small_wonder
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Joe Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mixlib-config
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mixlib-cli
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mixlib-log
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: excon
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: chef
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: salticid
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id010
+description: 
+email: j@boundary.com
+executables: 
+- small_wonder
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- bin/small_wonder
+- lib/small_wonder/application.rb
+- lib/small_wonder/cli.rb
+- lib/small_wonder/config.rb
+- lib/small_wonder/configuratorator.rb
+- lib/small_wonder/deploy.rb
+- lib/small_wonder/log.rb
+- lib/small_wonder/salticid_monkeypatch.rb
+- lib/small_wonder/utils.rb
+- lib/small_wonder.rb
+- README.md
+homepage: https://github.com/boundary/small_wonder
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Deployment Tool
+test_files: []
+