ey_stonith 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Engine Yard Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+== ey_stonith
+
+Shoot The Other Instance In The Head
+
+= Development
+
+You need to have gem bundler install
+
+    gem install bundler
+
+Then bundle everything up: 
+
+    bundle install
+
+To run the specs copy the example file to spec/config.yml and run:
+
+    bundle exec spec -c spec

data/bin/ey-monitor

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib/', __FILE__))
+require 'ey_stonith'
+
+EY::Stonith::CLI.new(:start, ARGV)

data/bin/ey-monitor-reset

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib/', __FILE__))
+require 'ey_stonith'
+
+EY::Stonith::CLI.new(:reset, ARGV)

data/bin/ey-monitor-resume

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib/', __FILE__))
+require 'ey_stonith'
+
+EY::Stonith::CLI.new(:resume, ARGV)

data/bin/ey-monitor-status

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib/', __FILE__))
+require 'ey_stonith'
+
+EY::Stonith::CLI.new(:status, ARGV)

data/bin/ey-monitor-stop

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib/', __FILE__))
+require 'ey_stonith'
+
+EY::Stonith::CLI.new(:stop, ARGV)

data/lib/ey_stonith/abstract_master.rb

@@ -0,0 +1,15 @@
+require 'json'
+require 'json/ext'
+module EY
+  module Stonith
+    class AbstractMaster
+      private
+
+      # ips are elastic, do not cache!
+      def public_ip() meta_data('public-ipv4') end
+      def local_hostname() @local_hostname ||= meta_data("local-hostname") end
+
+      def meta_data(key) EY::Stonith.meta_data[key] end
+    end
+  end
+end

data/lib/ey_stonith/address_stealer.rb

@@ -0,0 +1,45 @@
+require 'fog'
+
+module EY
+  module Stonith
+    class AddressStealer
+      def self.fog(credentials)
+        Fog::AWS::EC2.new(
+          :aws_access_key_id     => credentials[:aws_secret_id],
+          :aws_secret_access_key => credentials[:aws_secret_key]
+        )
+      end
+
+      def initialize(server_id, ip, credentials)
+        @fog         = self.class.fog(credentials)
+        server       = @fog.servers.get(server_id)
+        main_address = @fog.addresses.get(ip)
+
+        @address = if !main_address.server_id
+          main_address
+        elsif server
+          address_for(server)
+        end
+      end
+
+      def associate(server_id)
+        server = @fog.servers.get(server_id)
+        #TODO: handle error
+        raise "Don't have any IPs to use!" unless @address
+        raise "Already have an IP" if address_for(server)
+        @address.server = server
+      end
+
+      def ip
+        @address.public_ip
+      end
+
+      private
+
+      def address_for(server)
+        @fog.addresses.detect{|addr| addr.server_id == server.id }
+      end
+    end
+  end
+end
+

data/lib/ey_stonith/awsm_notifier.rb

@@ -0,0 +1,61 @@
+require 'em-http'
+
+module EY
+  module Stonith
+    class AwsmNotifier
+      def initialize(instance_id, notify_uri, opts, heartbeat = 5)
+        @instance_id, @notify_uri, @opts, @heartbeat = instance_id, notify_uri, opts, heartbeat
+        call_api
+      end
+
+      private
+
+      def try_again
+        EM.add_timer(@heartbeat) { call_api }
+      end
+
+      def call_api
+        Stonith.logger.info("Notifying awsm that I did a takeover")
+        http = EM::HttpRequest.new(@notify_uri).post :body => body, :head => head, :timeout => 10
+        http.callback {
+          ok = (200...300).include?(http.response_header.status)
+          if ok && JSON.parse(http.response)['status'] == 'ok'
+            Stonith.logger.info("Notified awsm!")
+          else
+            try_again
+          end
+        }
+        http.errback { try_again }
+      end
+
+      def head
+        {"Content-Type" => "application/x-www-form-urlencoded", "Accept" => "application/json"}
+      end
+
+      def body
+        process_payload(payload)
+      end
+
+      def payload
+        {
+          'instance_id'    => @instance_id,
+          'aws_secret_id'  => @opts[:aws_secret_id],
+          'aws_secret_key' => @opts[:aws_secret_key],
+        }
+      end
+
+      # ripped from restclient so we can use eventmachine
+      def process_payload(p = nil, parent_key = nil)
+        p.keys.map do |k|
+          key = parent_key ? "#{parent_key}[#{k}]" : k
+          if p[k].is_a? Hash
+            process_payload(p[k], key)
+          else
+            value = URI.escape(p[k].to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+            "#{key}=#{value}"
+          end
+        end.join("&")
+      end
+    end
+  end
+end

data/lib/ey_stonith/box.rb

@@ -0,0 +1,57 @@
+module EY
+  module Stonith
+    class Box
+      def initialize(config, history)
+        EY::Stonith.logger.info "Booting Stonith"
+
+        @config, @history = config, history
+        database = Database.new(@config)
+        @master  = Master.new(database, @config.master_hostname_from_dna)
+
+        trap("HUP") { stop }
+        trap("USR1") do
+          stop
+          EM.next_tick { start }
+        end
+      end
+
+      def start
+        if @master.local?
+          @local_master = LocalMaster.new(@config.notify_uri, @config.cloud_credentials)
+          @master.update @local_master.data
+          @history << :claim
+        else
+          @slave = Slave.new(self, @config.monitor_heartbeat)
+          @slave.monitor!(@master)
+          @history << :monitor
+        end
+      end
+
+      def try_takeover(master_unchanged)
+        @master.with_locked_data do |data|
+          if master_unchanged.call(data.key)
+            Stonith.logger.info("Locked! Taking over.")
+            @slave = nil
+            @history << :takeover
+            @local_master = LocalMaster.new(@config.notify_uri, @config.cloud_credentials)
+            new_data = @local_master.takeover!(data.instance_id, data.ip)
+            @master.update new_data
+          else
+            Stonith.logger.info("Failed to grab lock, relenting.")
+            @slave.start!
+            @history << :relent
+          end
+        end
+      end
+
+      private
+
+      def stop
+        EM.next_tick {
+          @slave.stop! if @slave
+          @history << :stop
+        }
+      end
+    end
+  end
+end

data/lib/ey_stonith/check_recorder.rb

@@ -0,0 +1,53 @@
+module EY
+  module Stonith
+    class CheckRecorder
+      BAD_CHECK_MAX = 5
+
+      def initialize
+        reset
+      end
+      
+      def bad_check!(key)
+        reset_on_key_change(key)
+        log_bad_check
+        @bad += 1 if @seen_good
+      end
+
+      def good_check!(key)
+        @key = key
+        @bad = 0
+        @seen_good = true
+      end
+
+      def seen_good?
+        @seen_good
+      end
+
+      def limit_exceeded?
+        seen_good? && @bad > BAD_CHECK_MAX
+      end
+
+      def checking_key?(key)
+        @key == key
+      end
+
+      protected
+
+      def reset
+        @bad = 0
+        @seen_good = false
+      end
+
+      def reset_on_key_change(key)
+        unless checking_key?(key)
+          reset
+          @key = key
+        end
+      end
+
+      def log_bad_check
+        Stonith.logger.info("Bad check against #{@key}. Seen good? #{@seen_good}")
+      end
+    end
+  end
+end

data/lib/ey_stonith/cli.rb

@@ -0,0 +1,127 @@
+require 'eventmachine'
+require 'optparse'
+require 'pathname'
+
+module EY
+  module Stonith
+    class CLI
+      DEFAULT_FILES = {
+        :ey       => "/etc/.ey-cloud.yml",
+        :redis    => "/etc/redis.yml",
+        :dna      => "/etc/chef/dna.json",
+        :history  => "/var/run/ey-monitor.history",
+        :pid_path => "/var/run/ey-monitor.pid",
+      }
+
+      def self.commands
+        @commands ||= Hash.new do |commands, command|
+          lambda {
+            puts "Command not found: #{command}"
+            puts @parser
+            exit(1)
+          }
+        end
+      end
+
+      def self.command(cmd,&block)
+        commands[cmd.to_sym] = block
+      end
+
+      command :start do
+        with_pid do
+          EY::Stonith.meta_data = @options[:meta_data] if @options[:meta_data]
+          EM.run { Box.new(@config, @history).start }
+        end
+      end
+
+      command :stop do
+        system("kill -HUP #{get_pid}")
+        sleep(1) until @history.last == "stop"
+        puts "takeover" if @history.include?(:takeover)
+      end
+
+      command :resume do
+        system("kill -USR1 #{get_pid}")
+      end
+
+      command :status do
+        puts @history
+      end
+
+      command :reset do
+        Database.new(@config).reset
+        @history.reset
+      end
+
+      def initialize(command, argv)
+        parse!(argv)
+        @config = Config.new(@options[:ey], @options[:redis], @options[:dna], @options[:history], @options[:pid_path])
+        cmd = command.to_sym || :start
+        @history = History.new(@config.history_path)
+        instance_eval(&self.class.commands[cmd.to_sym])
+      end
+
+      def with_pid
+        @config.pid_path.open('w') { |file| file << $$ }
+        yield
+        @config.pid_path.delete
+      end
+
+      def get_pid
+        @config.pid_path.read
+      end
+
+      def parse!(argv)
+        @options = DEFAULT_FILES
+        parser.parse!(argv)
+      end
+
+      def parser
+        @parser ||= OptionParser.new do |parser|
+          parser.banner = <<-USAGE
+Usage: ey-monitor [FLAGS] [COMMAND]
+
+COMMANDS
+  start  Begin monitoring (default).
+  stop   Safely stop running ey-monitor agents.
+         Reports shutdown status to stdout.
+         Exits with non-zero status if there is a problem.
+
+        USAGE
+
+          parser.separator "FLAGS"
+
+          parser.on('-e', '--ey [FILE]', "Path to the ey-cloud.yml file (default #{@options[:ey]})") do |ey|
+            @options[:ey] = Pathname.new(ey)
+          end
+
+          parser.on('-r', '--redis [FILE]', "Path to the redis.yml file (default #{@options[:redis]})") do |redis|
+            @options[:redis] = Pathname.new(redis)
+          end
+
+          parser.on('-d', '--dna [FILE]', "Path to the chef/dna.json file (default #{@options[:dna]})") do |dna|
+            @options[:dna] = Pathname.new(dna)
+          end
+
+          parser.on('-m', '--meta-data [FILE]', "Mocked AWS meta_data yaml file") do |path|
+            @options[:meta_data] = YAML.load_file(Pathname.new(path))
+          end
+
+          parser.on('-t', '--history [FILE]', "Location of stonith history file (default #{@options[:history]}") do |path|
+            @options[:history] = Pathname.new(path)
+          end          
+
+          parser.on('-p', '--pid [FILE]', "Location of stonith pid file (default #{@options[:pid_path]}") do |path|
+            @options[:pid_path] = Pathname.new(path)
+          end          
+
+          parser.on_tail("-h", "--help", "Show this message") do
+            puts parser
+            exit
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ey_stonith/config.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+require 'json'
+
+module EY
+  module Stonith
+    class Config < Struct.new(:ey_cloud, :redis_yml, :dna_json, :history_path, :pid_path)
+      def initialize(*args)
+        super *args.map { |arg| arg && Pathname.new(arg) }
+      end
+      
+      def cloud_credentials() YAML::load_file(ey_cloud) end
+      def notify_uri() "#{cloud_credentials[:api]}/api/promote_instance_to_master" end
+
+      def monitor_heartbeat() 10 end
+      def redis_key() 'ey:stonith' end
+      def redis_db() 15 end
+      def redis_host() redis[:host] end # support sometimes changes this, do not cache!
+      def redis_port() redis[:port] end
+      def master_hostname_from_dna() dna['master_app_server']['private_dns_name'] end
+
+      private
+      def dna() JSON.parse(dna_json.read) end
+      def redis() YAML::load_file(redis_yml) end
+    end
+  end
+end

data/lib/ey_stonith/data.rb

@@ -0,0 +1,7 @@
+module EY
+  module Stonith
+    class Data < Struct.new(:hostname, :instance_id, :ip)
+      def key() instance_id end
+    end
+  end
+end

data/lib/ey_stonith/database.rb

@@ -0,0 +1,56 @@
+require 'redis'
+
+module EY
+  module Stonith
+    class Database
+      def initialize(config)
+        @config = config
+      end
+
+      def with_locked_data
+        raise "Already locked!" if @locked
+        @locked = true
+        data = locked_get
+        yield data
+      ensure
+        set(data) if @locked
+      end
+
+      def with_data
+        raise "Locked!" if @locked
+        data = get
+        yield data if data
+      end
+
+      def set(data)
+        unless get
+          redis.lpush(master_key, Marshal.dump(data))
+          @locked = false
+        end
+      end
+
+      def reset
+        redis.ltrim master_key, 1, 0
+      end
+
+      private
+      
+      def get
+        result = redis.lindex(master_key, 0) # index 0
+        result && Marshal.load(result)
+      end
+
+      def locked_get
+        Marshal.load redis.blpop(master_key, 0).last # don't timeout (this number gets passed to the actual redis command)
+      end
+
+      def master_key
+        @config.redis_key
+      end
+      
+      def redis
+        @redis ||= Redis.new(:host => @config.redis_host, :port => @config.redis_port, :db => @config.redis_db, :timeout => 0)
+      end
+    end
+  end
+end

data/lib/ey_stonith/history.rb

@@ -0,0 +1,36 @@
+require 'pathname'
+
+module EY
+  module Stonith
+    class History
+      SEPARATOR = ' -> '
+
+      def initialize(path, length = 2)
+        raise ArgumentError, "Hey, I need at least 2 history lengthinesses to be a history object." if length < 2
+        @length = length
+        @path = Pathname.new(path)
+        @path.dirname.mkpath
+        FileUtils.touch(@path)
+      end
+
+      def <<(status)
+        write(status) unless last == status
+        self
+      end
+
+      def include?(status)
+        read.include?(status.to_s)
+      end
+
+      def to_s() read.join(SEPARATOR) end
+      def reset() @path.truncate(0) end
+      def write(current)
+        last_status = last
+        @path.open('w') { |file| file << [last_status, current].compact.join(SEPARATOR); file.close }
+      end
+
+      def last() read.last end
+      def read() @path.read.to_s.split(SEPARATOR) end
+    end
+  end
+end

data/lib/ey_stonith/local_master.rb

@@ -0,0 +1,28 @@
+require 'open-uri'
+require 'fog'
+
+module EY
+  module Stonith
+    class LocalMaster < AbstractMaster
+      def initialize(notify_uri, cloud_credentials)
+        @notify_uri, @cloud_credentials = notify_uri, cloud_credentials
+      end
+      alias hostname local_hostname
+
+      def takeover!(master_instance_id, master_ip)
+        address = AddressStealer.new(master_instance_id, master_ip, @cloud_credentials)
+        address.associate(instance_id)
+        AwsmNotifier.new(instance_id, @notify_uri, @cloud_credentials)
+        data(address.ip)
+      end
+
+      def data(ip = public_ip)
+        Data.new(hostname, instance_id, ip)
+      end
+
+      private
+
+      def instance_id() @instance_id ||= EY::Stonith.meta_data["instance-id"] end
+    end
+  end
+end

data/lib/ey_stonith/master.rb

@@ -0,0 +1,37 @@
+require 'ey_stonith'
+require 'eventmachine'
+require 'em-http'
+
+module EY
+  module Stonith
+    class Master < AbstractMaster
+      def initialize(database, hostname_from_dna)
+        @database, @hostname_from_dna = database, hostname_from_dna
+      end
+
+      def check(good, bad)
+        @database.with_data do |data|
+          http = EM::HttpRequest.new("http://#{data.hostname}/haproxy/monitor").get :timeout => 10
+          http.callback {
+            unless http.response_header.status == 200
+              bad.call data.key
+            else
+              good.call data.key
+            end
+          }
+          http.errback { bad.call data.key }
+        end
+      end
+
+      def local?() hostname == local_hostname end
+      def hostname() hostname_from_db || hostname_from_dna end
+      def with_locked_data(&block) @database.with_locked_data(&block) end
+      def update(data) @database.set(data) end
+
+      private
+
+      attr_reader :hostname_from_dna
+      def hostname_from_db() @database.with_data { |data| data.hostname } end
+    end
+  end
+end

data/lib/ey_stonith/meta_data.rb

@@ -0,0 +1,11 @@
+require 'open-uri'
+
+module EY
+  module Stonith
+    module MetaData
+      def self.[](key)
+        open("http://169.254.169.254/latest/meta-data/#{key}").read
+      end
+    end
+  end
+end

data/lib/ey_stonith/slave.rb

@@ -0,0 +1,41 @@
+module EY
+  module Stonith
+    class Slave
+      def initialize(box, heartbeat)
+        @box, @heartbeat = box, heartbeat
+      end
+
+      def monitor!(master)
+        return if @checking
+        Stonith.logger.info "Monitoring started"
+        @check_recorder = CheckRecorder.new
+        @checking = EM.add_periodic_timer(@heartbeat) { check(master) }
+      end
+
+      def stop!
+        if @checking
+          Stonith.logger.info "Stopped: Not monitoring until SIGUSR1 received"
+          @checking.cancel
+          @checking = nil
+        end
+      end
+
+      private
+
+      def check(master)
+        good = lambda { |master_key| @check_recorder.good_check!(master_key) }
+        bad  = lambda { |master_key|
+          @check_recorder.bad_check!(master_key)
+          takeover! if @check_recorder.limit_exceeded?
+        }
+        master.check(good, bad)
+      end
+
+      def takeover!
+        Stonith.logger.info("Trying to grab the lock for takeover")
+        stop!
+        @box.try_takeover(@check_recorder.method(:checking_key?))
+      end
+    end
+  end
+end

data/lib/ey_stonith.rb

@@ -0,0 +1,34 @@
+require 'logger'
+
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+module EY
+  module Stonith
+    class Error < StandardError; end
+
+    autoload :AbstractMaster, 'ey_stonith/abstract_master'
+    autoload :AwsmNotifier,   'ey_stonith/awsm_notifier'
+    autoload :AddressStealer, 'ey_stonith/address_stealer'
+    autoload :Box,            'ey_stonith/box'
+    autoload :CheckRecorder,  'ey_stonith/check_recorder'
+    autoload :CLI,            'ey_stonith/cli'
+    autoload :Config,         'ey_stonith/config'
+    autoload :Data,           'ey_stonith/data'
+    autoload :Database,       'ey_stonith/database'
+    autoload :History,        'ey_stonith/history'
+    autoload :LocalMaster,    'ey_stonith/local_master'
+    autoload :Master,         'ey_stonith/master'
+    autoload :MetaData,       'ey_stonith/meta_data'
+    autoload :Slave,          'ey_stonith/slave'
+
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::INFO
+    def self.logger() @@logger end
+
+    def self.meta_data() @@meta_data end
+    def self.meta_data=(meta) @@meta_data = meta end
+    def self.reset_meta_data() @@meta_data = MetaData end
+    reset_meta_data
+  end
+end
+

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: ey_stonith
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ezra Zygmuntowicz
+- Larry Diehl
+- Martin Emde
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 56
+        version: 0.0.56
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 7
+        version: 0.2.7
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id005
+description: Shoot The Other Node In The Head
+email: awsmdev@engineyard.com
+executables: 
+- ey-monitor
+- ey-monitor-stop
+- ey-monitor-status
+- ey-monitor-resume
+- ey-monitor-reset
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- lib/ey_stonith/abstract_master.rb
+- lib/ey_stonith/address_stealer.rb
+- lib/ey_stonith/awsm_notifier.rb
+- lib/ey_stonith/box.rb
+- lib/ey_stonith/check_recorder.rb
+- lib/ey_stonith/cli.rb
+- lib/ey_stonith/config.rb
+- lib/ey_stonith/data.rb
+- lib/ey_stonith/database.rb
+- lib/ey_stonith/history.rb
+- lib/ey_stonith/local_master.rb
+- lib/ey_stonith/master.rb
+- lib/ey_stonith/meta_data.rb
+- lib/ey_stonith/slave.rb
+- lib/ey_stonith.rb
+- bin/ey-monitor
+- bin/ey-monitor-reset
+- bin/ey-monitor-resume
+- bin/ey-monitor-status
+- bin/ey-monitor-stop
+- README.rdoc
+- LICENSE
+has_rdoc: true
+homepage: http://engineyard.com/cloud
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Shoot The Other Node In The Head
+test_files: []
+