awsome 0.0.0

data/bin/awsome

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'awsome'
+require 'optparse'
+
+requirements_file = 'requirements.yml'
+OptionParser.new do |opts|
+  opts.banner = 'Usage: awsome [options]' 
+  opts.on('-r', '--requirements [FILE]', 'Use a requirements file from another location (default is ./requirements.yml)') do |opt|
+    requirements_file = opt
+  end
+  opts.on('-v', '--verbose', 'Print commands as they are executed') do |opt|
+    Awsome.config.verbose = true
+  end
+  opts.on('-d', '--debug', 'Run ec2 commands with --debug') do |opt|
+    Awsome.config.debug = true
+  end
+  opts.on('-s', '--stacks', 'Print out full stack traces when commands are executed') do |opt|
+    Awsome.config.stacks = true
+  end
+end.parse!
+
+instances = Awsome::Ec2.describe_instances('instance-state-name' => 'running')
+requirements = Awsome::Requirements.from_yaml_file(requirements_file)
+matchmaker = Awsome::Matchmaker.new(instances, requirements)
+executor = Awsome::Executor.new(matchmaker.matches)
+
+executor.execute

data/lib/awsome.rb

@@ -0,0 +1,81 @@
+module Awsome
+  def self.config
+    @@config ||= Config.new
+  end
+
+  def self.execute(command, options={})
+    command = command.join(' ') if command.is_a?(Array)
+    if config.verbose
+      puts
+      puts command
+      puts '='*command.length
+    end
+    if options[:system]
+      result = system(command)
+    else
+      result = `#{command}`
+      result = options[:preprocess].call(result) if options[:preprocess]
+      result = map_table(result, options)
+    end
+  ensure
+    if config.verbose
+      case result
+      when String then puts result
+      else ap result
+      end
+    end
+    if config.stacks
+      ap Kernel.caller
+    end
+  end
+
+  def self.map_table(table, options)
+    return table unless options[:columns]
+    rows = table.split("\n")
+    rows.select! { |row| row =~ options[:filter] } if options[:filter]
+    rows.collect do |row|
+      properties = {}
+      values = options[:delimiter] ? row.split(options[:delimiter]) : row.split
+      values.each_with_index { |value, index| 
+        field = options[:columns][index]
+        properties[field] = value
+      }
+      properties
+    end
+  end
+
+  def self.wait_until(opts={}, &block)
+    retries = opts[:retries] || 5
+    interval = opts[:interval] || 5
+    while !yield && retries > 0
+      puts "block returned false (#{retries} more retries)..." if Awsome.config.verbose
+      sleep interval
+      retries -= 1
+    end
+  end
+
+  class Config
+    attr_accessor :region, :url, :aws_access_key, :aws_secret_key, :connection_timeout, 
+      :request_timeout, :verbose, :show_empty_fields, :debug, :show_request, :stacks
+
+    def initialize
+      @region = ENV['REGION']
+      @url = ENV['EC2_URL']
+      @aws_access_key = ENV['AWS_ACCESS_KEY']
+      @aws_secret_key = ENV['AWS_SECRET_KEY']
+      @show_empty_fields = true
+    end
+  end
+end
+
+require 'set'
+require 'awesome_print'
+require 'awsome/ec2.rb'
+require 'awsome/elb.rb'
+require 'awsome/ssh.rb'
+require 'awsome/debian.rb'
+require 'awsome/requirements.rb'
+require 'awsome/executor.rb'
+require 'awsome/matchmaker.rb'
+require 'awsome/requirements_options.rb'
+require 'awsome/instance_requirement.rb'

data/lib/awsome/debian.rb

@@ -0,0 +1,36 @@
+module Awsome
+  module Debian
+    def self.describe_debian_packages(hostname)
+      if Awsome::Ssh.scp("#{hostname}:/home/ubuntu/packages.csv", './packages.csv')
+        File.open('./packages.csv', 'r').read.strip.split(',')
+      else
+        []
+      end
+    end
+
+    def self.remove_debian_packages(hostname, *packages)
+      installed = describe_debian_packages(hostname)
+      remaining = installed.to_set - packages.to_set
+
+      return if packages.empty?
+
+      Awsome::Ssh.ssh hostname, "sudo apt-get update"
+      Awsome::Ssh.ssh hostname, "sudo apt-get remove -y --force-yes #{packages.join(' ')}"
+      Awsome::Ssh.ssh hostname, "echo #{remaining.to_a.join(',')} > ~/packages.csv"
+    end
+
+    def self.install_debian_packages(hostname, *packages)
+      installed = describe_debian_packages(hostname)
+      remaining = installed.to_set + packages.to_set
+
+      Awsome::Ssh.ssh hostname, "sudo apt-get update"
+
+      if packages.empty?
+        Awsome::Ssh.ssh hostname, "sudo apt-get upgrade"
+      else
+        Awsome::Ssh.ssh hostname, "sudo apt-get install -y --force-yes #{packages.join(' ')}"
+        Awsome::Ssh.ssh hostname, "echo #{remaining.to_a.join(',')} > ~/packages.csv"
+      end
+    end
+  end
+end

data/lib/awsome/ec2.rb

@@ -0,0 +1,109 @@
+module Awsome
+  module Ec2
+    def self.config
+      Awsome.config
+    end
+
+    def self.command(*cmd)
+      args = cmd.last.is_a?(Hash) && cmd.pop
+      options = cmd
+      options << "--region #{config.region}"
+      options << "--url #{config.url}"
+      options << "--aws-access-key #{config.aws_access_key}"
+      options << "--aws-secret-key #{config.aws_secret_key}"
+      options << "--connection-timeout #{config.connection_timeout}" if config.connection_timeout
+      options << "--request-timeout #{config.request_timeout}" if config.request_timeout
+      options << "--verbose" if config.verbose
+      options << "--show-empty-fields" if config.show_empty_fields
+      options << "--debug" if config.debug
+      args && args.each { |k,v| options << "--#{k} #{v}" }
+      options.join(' ')
+    end
+
+    def self.map_table(*args)
+      Awsome.map_table(*args)
+    end
+
+    @@run_instance_fields = %w(
+      instance_identifier
+      instance_id
+      ami_id
+      state
+      key
+      ami_launch_index
+      product_code
+      instance_type
+      instance_launch_time
+      availability_zone
+    )
+
+    def self.run_instance(properties)
+      cmd = command('ec2-run-instances', properties['ami_id'], 
+        :group => properties['security_group_ids'], 
+        :key => properties['key'], 
+        'instance-type'.to_sym => properties['instance_type'], 
+        'availability-zone'.to_sym => properties['availability_zone']
+      )
+      Awsome::Ec2::Instance.new(Awsome.execute(cmd, columns: @@run_instance_fields, filter: /^INSTANCE/).first)
+    end
+
+    @@describe_instance_fields = %w( 
+      reservation_identifier
+      reservation_id
+      aws_account_id
+      security_group_ids
+      instance_identifier
+      instance_id
+      ami_id
+      public_dns_name
+      private_dns_name
+      state
+      key
+      ami_launch_index
+      product_codes
+      instance_type
+      instance_launch_time
+      availability_zone
+    )
+
+    def self.describe_instances(filters={})
+      cmd = [Awsome::Ec2.command('ec2-describe-instances')]
+      cmd += filters.collect { |k,v| "--filter \"#{k}=#{v}\"" }
+      preprocess = Proc.new { |text| text.gsub("\nINSTANCE", " INSTANCE") }
+      properties = Awsome.execute(cmd, columns: @@describe_instance_fields, filter: /^RESERVATION/, preprocess: preprocess)
+      properties.collect { |p| Awsome::Ec2::Instance.new(p) }
+    end
+
+    @@describe_volumes_fields = %w(
+      attachment_identifier
+      volume_id
+      instance_id
+      device
+      state
+      date
+    )
+
+    def self.describe_volumes(filters={})
+      cmd = [Awsome::Ec2.command('ec2-describe-volumes')]
+      cmd += filters.collect { |k,v| "--filter \"#{k}=#{v}\"" }
+      Awsome.execute(cmd, columns: @@describe_volumes_fields, filter: /^ATTACHMENT/)
+    end
+
+    def self.detach_volume(volume_id)
+      cmd = Awsome::Ec2.command('ec2-detach-volume', volume_id)
+      Awsome.execute(cmd)
+    end
+
+    def self.attach_volume(volume_id, instance_id, device)
+      cmd = Awsome::Ec2.command('ec2-attach-volume', volume_id, instance: instance_id, device: device)
+      Awsome.execute(cmd)
+    end
+
+    def self.terminate_instances(*instance_ids)
+      cmd = Awsome::Ec2.command("ec2-terminate-instances #{instance_ids.join(' ')}") 
+      Awsome.execute(cmd)
+    end
+  end
+end
+
+require 'awsome/ec2/instance.rb'

data/lib/awsome/ec2/instance.rb

@@ -0,0 +1,76 @@
+module Awsome
+  module Ec2
+    class Instance
+      attr_reader :properties
+
+      def initialize(property_hash)
+        raise 'properties must be a hash' unless property_hash.is_a?(Hash)
+        @properties = property_hash.clone
+      end
+
+      def packages
+        Awsome::Debian.describe_debian_packages(@properties['public_dns_name']).to_set
+      end
+
+      def volumes
+        Awsome::Ec2.describe_volumes('attachment.instance-id' => @properties['instance_id']).collect do |p| 
+          p['volume_id'] 
+        end.to_set
+      end
+
+      def wait_until_running!
+        Awsome.wait_until(interval: 10) do
+          reload! 
+          @properties['state'] =~ /^running/
+        end
+      end
+
+      def wait_for_ssh!
+        Awsome.wait_until(interval: 10) { has_ssh? }
+      end
+
+      def reattach_volumes(*volumes)
+        volumes.each do |info| 
+          Awsome::Ec2.detach_volume(info['id'])
+          Awsome::Ec2.attach_volume(info['id'], @properties['instance_id'], info['device']) 
+        end
+      end
+
+      def deregister_from_elbs
+        elbs.each { |elb| elb.deregister(@properties['instance_id']) }
+      end
+
+      def register_with_elbs(*load_balancer_names)
+        Awsome::Elb.describe_lbs(*load_balancer_names).each { |elb| elb.register(@properties['instance_id']) }
+      end
+
+      def remove_packages(*packages)
+        Awsome::Debian.remove_debian_packages(@properties['public_dns_name'], *packages)
+      end
+
+      def install_packages(*packages)
+        Awsome::Debian.install_debian_packages(@properties['public_dns_name'], *packages)
+      end
+
+      def terminate
+        Awsome::Ec2.terminate_instances(@properties['instance_id'])
+      end
+
+      private 
+        def reload!
+          instance = Awsome::Ec2.describe_instances('instance-id' => @properties['instance_id']).first
+          raise "instance #{@properties['instance_id']} not found" if instance.nil?
+          @properties = instance.properties.clone
+        end
+
+        def has_ssh?
+          Awsome::Ssh.has_ssh?(@properties['public_dns_name'])
+        end
+
+        def elbs
+          Awsome::Elb.describe_lbs.select { |elb| elb.instances.include?(@properties['instance_id']) }
+        end
+
+    end
+  end
+end

data/lib/awsome/elb.rb

@@ -0,0 +1,66 @@
+module Awsome
+  module Elb
+    @@delimiter = " OH YEAH BANANAS "
+
+    def self.config
+      Awsome.config
+    end
+
+    def self.command(*cmd)
+      args = cmd.last.is_a?(Hash) && cmd.pop
+      options = cmd
+      options << "--region #{config.region}"
+      # options << "--url #{config.url}" # explicitly setting the url this way breaks the elb tools
+      options << "--access-key-id #{config.aws_access_key}"
+      options << "--secret-key #{config.aws_secret_key}"
+      options << "--show-long"
+      options << "--delimiter \"#{@@delimiter}\""
+      options << "--show-request" if config.show_request
+      options << "--show-empty-fields" if config.show_empty_fields
+      options << "--connection-timeout #{config.connection_timeout}" if config.connection_timeout
+      args && args.each { |k,v| options << "--#{k} #{v}" }
+      options.join(' ')
+    end
+
+    @@describe_lbs_columns = %w(
+      identifier
+      name
+      dns_name
+      canonical_hosted_zone_name
+      canonical_hosted_zone_name_id
+      health_check
+      availability_zones
+      subnets
+      vpc_id
+      instance_ids
+      listener_descriptions
+      backend_server_descriptions
+      app_cookie_stickiness_policies
+      lb_cookie_stickiness_policies
+      other_policies
+      source_security_group
+      security_groups
+      created_time
+      scheme
+      pagination_marker
+    )
+
+    def self.describe_lbs(*load_balancer_names)
+      cmd = Awsome::Elb.command("elb-describe-lbs #{load_balancer_names.join(' ')}")
+      properties = Awsome.execute(cmd, columns: @@describe_lbs_columns, delimiter: @@delimiter)
+      properties.collect { |p| Awsome::Elb::LoadBalancer.new(p) }
+    end
+
+    def self.deregister_instance_from_lb(load_balancer_name, instance_id)
+      cmd = Awsome::Elb.command('elb-deregister-instances-from-lb', load_balancer_name, instances: instance_id, delimiter: @@delimiter)
+      Awsome.execute(cmd)
+    end
+
+    def self.register_instance_with_lb(load_balancer_name, instance_id)
+      cmd = Awsome::Elb.command('elb-register-instances-with-lb', load_balancer_name, instances: instance_id, delimiter: @@delimiter)
+      Awsome.execute(cmd)
+    end
+  end
+end
+
+require 'awsome/elb/load_balancer.rb'

data/lib/awsome/elb/load_balancer.rb

@@ -0,0 +1,30 @@
+module Awsome
+  module Elb
+    class LoadBalancer
+      attr_reader :properties
+      
+      def initialize(property_hash)
+        @properties = property_hash.clone
+      end
+
+      def instances
+        @properties['instance_ids'].gsub('"', '').split(',').collect(&:strip).to_set
+      end
+
+      def deregister(instance_id)
+        Awsome::Elb.deregister_instance_from_lb(@properties['name'], instance_id)
+      end
+
+      def register(instance_id)
+        Awsome::Elb.register_instance_with_lb(@properties['name'], instance_id)
+      end
+
+      private
+        def reload!
+          elb = Awsome::Elb.describe_lbs(@properties['name']).first
+          raise "elb #{@properties['name']} not found" if elb.nil?
+          @properties = elb.properties.clone
+        end
+    end
+  end
+end

data/lib/awsome/executor.rb

@@ -0,0 +1,66 @@
+module Awsome
+  class Executor
+    def initialize(matches)
+      @matches = matches
+    end
+
+    def execute
+      @matches.each { |s, m| execute_match(s, m) }
+    end
+
+    private
+
+      def execute_match(signature, match)
+        @i_pool = match[:i_pool]
+        @r_pool = match[:r_pool]
+
+        puts "instance pool:"
+        ap @i_pool
+
+        puts "requirement pool:"
+        ap @r_pool
+
+        run
+        wait_for_ssh
+        reattach_volumes
+        deploy
+        terminate
+      end
+
+      def run
+        @i_pool.each_with_index do |instance, i|
+          @i_pool[i] = Awsome::Ec2.run_instance(@r_pool[i].properties) if instance.nil?
+        end
+      end
+
+      def wait_for_ssh
+        @i_pool.each do |i|
+          i.wait_until_running!
+          i.wait_for_ssh!
+        end
+      end
+
+      def reattach_volumes
+        @i_pool.each_with_index do |instance, i|
+          instance.reattach_volumes(*@r_pool[i].volumes_to_attach(instance))
+        end
+      end
+
+      def deploy
+        @i_pool.each_with_index do |instance, i|
+          instance.deregister_from_elbs
+          instance.remove_packages(*@r_pool[i].packages_to_remove(instance))
+          instance.install_packages(*@r_pool[i].packages_to_install(instance))
+          instance.register_with_elbs(*@r_pool[i].elbs)
+        end
+      end
+
+      def terminate
+        @i_pool.each_with_index do |instance, i|
+          next if i < @r_pool.length
+          instance.deregister_from_elbs
+          instance.terminate
+        end
+      end
+    end
+end

data/lib/awsome/instance_requirement.rb

@@ -0,0 +1,56 @@
+module Awsome
+  class InstanceRequirement
+
+    attr_reader :properties
+
+    def initialize(properties, options)
+      @properties = properties.clone
+      @options = options
+    end
+
+    def elbs
+      @properties['elbs']
+    end
+
+    def volumes_to_attach(instance)
+      (volumes - volumes_attached_to(instance)).collect { |v| @options.find_volume(v) }
+    end
+
+    def volumes_to_detach(instance)
+      (volumes_attached_to(instance) - volumes).collect { |v| @options.find_volume(v) }
+    end
+
+    def volume_change_count(instance)
+      volumes_to_attach(instance).size + volumes_to_detach(instance).size
+    end
+
+    def packages_to_install(instance)
+      packages - packages_installed_on(instance)
+    end
+
+    def packages_to_remove(instance)
+      packages_installed_on(instance) - packages
+    end
+
+    def package_change_count(instance)
+      packages_to_install(instance).size + packages_to_remove(instance).size
+    end
+
+    private 
+      def packages
+        @properties['packages'].to_set
+      end
+
+      def volumes
+        @options.filter_volume_ids(@properties['volumes'])
+      end
+
+      def packages_installed_on(instance)
+        instance ? instance.packages : Set[]
+      end
+
+      def volumes_attached_to(instance)
+        instance ? @options.filter_volume_ids(instance.volumes) : Set[]
+      end
+  end
+end

data/lib/awsome/matchmaker.rb

@@ -0,0 +1,96 @@
+module Awsome
+  class Matchmaker
+    def initialize(instances, requirements)
+      @requirement_pools = requirements.instances.reject do |i| 
+        requirements.options.except_instance_ids.include?(i.properties['instance_id']) 
+      end.group_by { |i| signature_for(i) }
+
+      @instance_pools = instances.reject do |i| 
+        requirements.options.except_instance_ids.include?(i.properties['instance_id']) 
+      end.group_by { |i| signature_for(i) }
+
+      @signatures = @requirement_pools.keys.to_set + @instance_pools.keys.to_set
+
+      @signatures.each do |s|
+        @requirement_pools[s] ||= []
+        @instance_pools[s] ||= []
+
+        # nil indicates new instance will be brought up
+        shortage = @requirement_pools[s].size - @instance_pools[s].size
+        @instance_pools[s] += [nil]*shortage if shortage > 0
+      end
+    end
+
+    @@signature_fields = %w( ami_id key instance_type availability_zone security_group_ids )
+
+    def signature_for(instance)
+      @@signature_fields.collect { |k| instance.properties[k] }.join(',')
+    end
+
+    def matches
+      @signatures.reduce({}) { |memo, s| memo.merge(s => best_match(s)) }
+    end
+
+    private
+
+      def best_match(signature)
+        i_pool = @instance_pools[signature]
+        r_pool = @requirement_pools[signature]
+
+        best = nil
+
+        permute i_pool do |i_pool_perm|
+          best = score_match(i_pool_perm, r_pool, best)
+        end
+
+        best
+      end
+
+      def score_match(i_pool, r_pool, best)
+        v_delta = 0
+        p_delta = 0
+
+        i_pool.each_with_index do |i, index| 
+          r = r_pool[index]
+          if r
+            v_delta += r.volume_change_count(i) 
+            p_delta += r.package_change_count(i)
+          end
+        end
+
+        top_score({ 
+          v_delta: v_delta,
+          p_delta: p_delta,
+          i_pool: i_pool,
+          r_pool: r_pool
+        }, best)
+      end
+
+      def top_score(*scores)
+        scores.sort_by do |s1, s2| 
+          case
+          when s1.nil? && s2.nil? then 0
+          when s2.nil? then -1
+          when s1.nil? then 1
+          when s1[:v_delta] < s2[:v_delta] then -1
+          when s1[:v_delta] > s2[:v_delta] then 1
+          when s1[:p_delta] < s2[:p_delta] then -1
+          when s1[:p_delta] > s2[:p_delta] then 1
+          else 0
+          end
+        end.first
+      end
+
+      def permute(array, permutation=[], &block)
+        if array.empty?
+          yield(permutation.clone)
+        else
+          0.upto(array.length - 1) do |i| 
+            permutation << array.slice!(i)
+            permute(array, permutation, &block)
+            array.insert(i, permutation.pop)
+          end
+        end
+      end
+  end
+end

data/lib/awsome/requirements.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+
+module Awsome
+  class Requirements
+    attr_reader :options
+    def initialize(requirements_hash)
+      @requirements = requirements_hash.clone
+      @options = Awsome::RequirementsOptions.new(@requirements)
+    end
+    def self.from_yaml_file(filename)
+      new(YAML::load(File.open(filename, 'r').read))
+    end
+    def instances
+      @requirements['instances'].collect do |instance_req| 
+        Awsome::InstanceRequirement.new(instance_req, @options) 
+      end
+    end
+  end
+end
+

data/lib/awsome/requirements_options.rb

@@ -0,0 +1,20 @@
+module Awsome
+  class RequirementsOptions
+    def initialize(requirements)
+      @options = (requirements['options'] || {}).clone
+    end
+    def only_volume_ids
+      @options['volumes'].collect { |v| v['id'] }.to_set
+    end
+    def except_instance_ids
+      (@options['except_instance_ids'] || []).to_set
+    end
+    def filter_volume_ids(ids)
+      ids = ids.to_set unless ids.is_a?(Set)
+      only_volume_ids.any? ? only_volume_ids & ids : ids
+    end
+    def find_volume(volume_id)
+      @options['volumes'].find { |v| v['id'] == volume_id }
+    end
+  end
+end

data/lib/awsome/ssh.rb

@@ -0,0 +1,27 @@
+module Awsome
+  module Ssh
+    def self.ensure_ssh_env_vars!
+      raise 'SSH_KEY environment variable not set' if ENV['SSH_KEY'].nil?
+      raise 'SSH_USER environment varibale not set' if ENV['SSH_USER'].nil?
+    end
+
+    def self.ssh(host, *scripts)
+      ensure_ssh_env_vars!
+      Awsome.execute("ssh -i #{ENV['SSH_KEY']} #{ENV['SSH_USER']}@#{host} \"#{scripts.join(' && ')}\"")
+    end
+
+    def self.scp(from, to)
+      ensure_ssh_env_vars!
+      if File.exists?(from)
+        to = "#{ENV['SSH_USER']}@#{to}" 
+      else
+        from = "#{ENV['SSH_USER']}@#{from}"
+      end
+      Awsome.execute("scp -i #{ENV['SSH_KEY']} #{from} #{to}", system: true)
+    end
+
+    def self.has_ssh?(host)
+      Awsome.execute("nc -zw 2 #{host} 22 < /dev/null", system: true)
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: awsome
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sebastian Goodman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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'
+description: AWS library targeted specifically for continuous integration.
+email: sebastian@foodocs.com
+executables:
+- awsome
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/awsome.rb
+- lib/awsome/matchmaker.rb
+- lib/awsome/elb/load_balancer.rb
+- lib/awsome/requirements.rb
+- lib/awsome/ec2.rb
+- lib/awsome/executor.rb
+- lib/awsome/ssh.rb
+- lib/awsome/requirements_options.rb
+- lib/awsome/elb.rb
+- lib/awsome/debian.rb
+- lib/awsome/ec2/instance.rb
+- lib/awsome/instance_requirement.rb
+- bin/awsome
+homepage: http://github.com/0x0539/awsome
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Intelligently plan automated, incremental deployments.
+test_files: []