virtualmonkey 0.0.1

data/lib/virtualmonkey/rails_aio_developer_chef_runner.rb

@@ -0,0 +1,8 @@
+module VirtualMonkey
+  class RailsAioDeveloperChefRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::ApplicationFrontend
+
+  end
+end
+ 

data/lib/virtualmonkey/shared_dns.rb

@@ -0,0 +1,67 @@
+class SharedDns
+  attr_accessor :reservation
+  attr_accessor :owner
+
+  def initialize(domain = "virtualmonkey_shared_resources")
+    @sdb = Fog::AWS::SimpleDB.new(:aws_access_key_id => Fog.credentials[:aws_access_key_id_test], :aws_secret_access_key => Fog.credentials[:aws_secret_access_key_test])
+    @domain = domain
+    @reservation = nil
+  end
+
+    # set dns inputs on a deployment to match the current reservation
+  # * deployment<~Deployment> the deployment to set inputs on
+  def set_dns_inputs(deployment)
+    sdb_result = @sdb.get_attributes(@domain, @reservation)
+
+    set_these = sdb_result.body['Attributes'].reject {|k,v| k == 'owner'}
+    set_these.each do |key,val|
+      deployment.set_input(key, val.to_s)
+      deployment.servers.each { |s| s.set_input(key, "text:") }
+    end
+  end
+
+  def reserve_dns(owner, timeout = 0)
+    puts "Checking DNS reservation for #{owner}"
+    result = @sdb.select("SELECT * from #{@domain} where owner = '#{owner}'")
+    puts "Reusing DNS reservation" unless result.body["Items"].empty?
+    if result.body["Items"].empty?
+       result = @sdb.select("SELECT * from #{@domain} where owner = 'available'")
+       return false if result.body["Items"].empty?
+       puts "Aquired new DNS reservation"
+       item_name = result.body["Items"].keys.first
+       response = @sdb.put_attributes(@domain, item_name, {'owner' => owner}, :expect => {'owner' => "available"}, :replace => ['owner'])
+    end
+    @owner = owner
+    @reservation = result.body["Items"].keys.first
+  rescue Excon::Errors::ServiceUnavailable
+    puts "Resuce: ServiceUnavailable"
+    retry_reservation(owner, timeout)
+  rescue Excon::Errors::Conflict
+    puts "Resuce: Conflict"
+    retry_reservation(owner, timeout)
+  end
+
+  def retry_reservation(owner, timeout)
+    STDOUT.flush
+    if timeout > 20 
+      return false
+    end
+    sleep(5)
+    reserve_dns(owner, timeout + 1)
+  end
+
+  def release_all
+    result = @sdb.select("SELECT * from #{@domain}")
+    result.body['Items'].keys.each do |item_name|
+      @sdb.put_attributes(@domain, item_name, {"owner" => "available"}, :replace => ["owner"])
+    end
+  end
+
+  def release_dns(res = @reservation)
+    raise "FATAL: could not release dns because there was no @reservation" unless res
+    @sdb.put_attributes(@domain, res, {"owner" => "available"}, :replace => ["owner"]) 
+    @reservation = nil
+  end
+end
+
+

data/lib/virtualmonkey/simple.rb

@@ -0,0 +1,5 @@
+module VirtualMonkey
+  module Simple
+
+  end
+end

data/lib/virtualmonkey/simple_runner.rb

@@ -0,0 +1,6 @@
+module VirtualMonkey
+  class SimpleRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::Simple
+  end
+end

data/lib/virtualmonkey/test_case_interface.rb

@@ -0,0 +1,151 @@
+module VirtualMonkey
+  module TestCaseInterface
+    def set_var(sym, *args)
+      behavior(sym, *args)
+    end
+
+    def behavior(sym, *args)
+      begin
+        rerun_test
+        #pre-command
+        populate_settings unless @populated
+        #command
+        result = __send__(sym, *args)
+        #post-command
+        continue_test
+      rescue Exception => e
+        dev_mode?(e)
+      end while @rerun_last_command.pop
+      result
+    end
+
+    def verify(method, expectation, *args)
+      if expectation =~ /((exception)|(error)|(fatal)|(fail))/i
+        expect = "fail"
+        error_msg = expectation.split(":")[1..-1].join(":")
+      elsif expectation =~ /((success)|(succeed)|(pass))/i
+        expect = "pass"
+      elsif expectation =~ /nil/i
+        expect = "nil"
+      else
+        raise 'Syntax Error: verify expects a "pass", "fail", or "nil"'
+      end
+
+      begin
+        rerun_test
+        result = __send__(command, *args)
+        if expect != "pass" and not (result == nil and expect == "nil")
+          raise "FATAL: Failed verification"
+        end
+        continue_test
+      rescue Exception => e
+        if not ("#{e}" =~ /#{error_msg}/ and expect == "fail")
+          dev_mode?(e)
+        end
+      end while @rerun_last_command.pop
+    end
+
+    def probe(server, command, &block)
+      # run command on servers matching "server" over ssh
+      result = ""
+      @servers.select { |s| s.nickname =~ /#{server}/ }.each { |s|
+        begin
+          rerun_test
+          result_temp = s.spot_check_command(command)
+          if not yield(result_temp[:output])
+            raise "FATAL: Server #{s.nickname} failed probe. Got #{result_temp[:output]}"
+          end
+          continue_test
+        rescue Exception => e
+          dev_mode?(e)
+        end while @rerun_last_command.pop
+        result += result_temp[:output]
+      }
+    end
+
+    private
+
+    def dev_mode?(e)
+      if not ENV['MONKEY_NO_DEBUG'] =~ /true/i
+        puts e
+        puts "Pausing for debugging..."
+        debugger
+      else
+        exception_handle(e)
+      end
+    end
+
+    def exception_handle(e)
+      puts "ATTENTION: Using default exception_handle(e). This can be overridden in mixin classes."
+      if e.message =~ /Insufficient capacity/
+        puts "Got \"#{e.message}\". Retrying...."
+        sleep 60
+      else
+        raise e
+      end
+    end
+
+    def help
+      puts "Here are some of the wrapper methods that may be of use to you in your debugging quest:\n"
+      puts "behavior(sym, *args): Pass the method name (as a symbol or string) and the optional arguments"
+      puts "                      that you wish to pass to that method; behavior() will call that method"
+      puts "                      with those arguments while handling nested exceptions, retries, and"
+      puts "                      debugger calls.\n"
+      puts "                      Examples:"
+      puts "                        behavior(:launch_all)"
+      puts "                        behavior(:launch_set, 'Load Balancer')\n"
+      puts "verify(sym, expectation_string, *args): Pass the method name (as a symbol or string), the expected" 
+      puts "                                        result, and any arguments to pass to that method. The"
+      puts "                                        expectation_string should consist of 'Error: MyRegex',"
+      puts "                                        'Pass', or 'nil'. 'Error: MyRegex' tells verify() that it"
+      puts "                                        should expect an exception to be raised, and the message "
+      puts "                                        or exception name should match /MyRegex/. 'Pass' tells"
+      puts "                                        verify() that it should expect the method to return normally,"
+      puts "                                        and 'nil' tells verify() that it should expect the method to"
+      puts "                                        return nil.\n"
+      puts "                                        Example:"
+      puts "                                          verify(:launch_all, 'Error: execution expired')\n"
+      puts "probe(server_regex, shell_command, &block): Provides a one-line interface for running a command on"
+      puts "                                            a set of servers and verifying their output. The block"
+      puts "                                            should take one argument, the output string from one of"
+      puts "                                            the servers, and return true or false based on however"
+      puts "                                            the developer wants to verify correctness.\n"
+      puts "                                            Examples:"
+      puts "                                              probe('.*', 'ls') { |s| puts s }"
+      puts "                                              probe('.*', 'uname -a') { |s| s =~ /x64/ }\n"
+      puts "continue_test: Disables the retry loop that reruns the last command (the current command that you're"
+      puts "               debugging.\n"
+      puts "help: Prints this help message."
+    end
+
+    def populate_settings
+      @servers.each { |s| s.settings }
+      lookup_scripts
+      @populated = 1
+    end
+
+    def object_behavior(obj, sym, *args)
+      begin
+        rerun_test
+        #pre-command
+        populate_settings unless @populated
+        #command
+        result = obj.__send__(sym, *args)
+        #post-command
+        continue_test
+      rescue Exception => e
+        dev_mode?(e)
+      end while @rerun_last_command.pop
+      result
+    end
+
+    def rerun_test
+      @rerun_last_command.push(true)
+    end
+
+    def continue_test
+      @rerun_last_command.pop
+      @rerun_last_command.push(false)
+    end
+  end
+end

data/lib/virtualmonkey/unified_application.rb

@@ -0,0 +1,40 @@
+module VirtualMonkey
+  module UnifiedApplication
+    # returns true if the http response contains the expected_string
+    # * url<~String> url to perform http request
+    # * expected_string<~String> regex compatible string used to match against the response output
+    def test_http_response(expected_string, url, port)
+      cmd = "curl -s #{url} 2> /dev/null "
+      puts cmd
+      timeout=300
+      begin
+        status = Timeout::timeout(timeout) do
+          while true
+            response = `#{cmd}` 
+            break if response.include?(expected_string)
+            puts "Retrying..."
+            sleep 5
+          end
+        end
+      rescue Timeout::Error => e
+        raise "ERROR: Query failed after #{timeout/60} minutes."
+      end
+    end
+    
+    def run_unified_application_checks(run_on=@servers, port=8000)
+      run_on.each do |server| 
+        behavior(:run_unified_application_check, server.dns_name, port)
+      end
+    end
+    
+    # this is where ALL the generic application server checks live, this could get rather long but for now it's a single method with a sequence of checks
+    def run_unified_application_check(dns_name, port=8000)
+      url_base = "#{dns_name}:#{port}"
+      behavior(:test_http_response, "html serving succeeded", "#{url_base}/index.html", port) 
+      behavior(:test_http_response, "configuration=succeeded", "#{url_base}/appserver/", port) 
+      behavior(:test_http_response, "I am in the db", "#{url_base}/dbread/", port) 
+      behavior(:test_http_response, "hostname=", "#{url_base}/serverid/", port) 
+    end
+    
+  end
+end

data/spec/bug3518.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "bug #3518" do
+  before(:all) do
+    raise "for this spec to run, you must have a mysql deployment nickname in $DEPLOYMENT variable" unless ENV['DEPLOYMENT']
+    @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+    @runner.lookup_scripts
+    @runner.setup_dns
+  end
+  it "disables binlogs on the old master after promote" do
+    @runner.run_promotion_operations
+    oldmaster = @runner.servers.last 
+    oldmaster.settings
+    puts "oldmaster is #{oldmaster.dns_name}"
+  end
+end

data/spec/concurrent_writes_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require 'ruby-debug'
+
+describe SharedDns, "Using sdb to store shared resources" do
+  it "should perform concurrent reads and writes" do
+    unique_record = "blah#{rand(10000000)}"
+    
+    reservations = Array.new
+    18.times do |i|
+      reservations[i] = SharedDns.new
+    end
+
+    reservations[0].release_all
+
+    mythreads = Array.new
+    reservations.each do |x|
+      mythreads << Thread.new do
+        x.reserve_dns
+# all reservations should succeed
+        x.should_not == false
+        puts  "reserved #{x.reservation}"
+        STDOUT.flush
+      end
+    end
+  end
+end

data/spec/cuke_job_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe CukeMonk do
+  it "checks a job status" do
+    EM.run {
+      cm = CukeMonk.new
+      cm.run_test("NODEPLOY", "simple.feature")
+      cm.run_test("NODEPLOY", "simple.feature")
+      cm.run_test("NODEPLOY", "simple.feature")
+
+      EM.add_periodic_timer(1) {
+        cm.show_jobs
+      }
+
+      donetime = EM.add_periodic_timer(1) {
+        donetime.cancel
+        puts "All done? #{cm.all_done?}"
+        if cm.all_done?
+          EM.stop
+        end
+      }
+        
+
+    }
+  end
+end

data/spec/ek.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require "ruby-debug"
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Messing with spec" do
+  before(:all) do
+    raise "for this spec to run, you must have a mysql deployment nickname in $DEPLOYMENT variable" unless ENV['DEPLOYMENT']
+    @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+    @runner.lookup_scripts
+    @runner.lineage='testlineage3049'
+    @runner.stripe_count=1
+#    @runner.set_variation_lineage
+    @master = @runner.servers.first
+    @master.start
+    @master.wait_for_operational_with_dns
+    @master.settings
+    puts "master is #{@master.dns_name}"
+#    @runner.config_master_from_scratch(master)
+#    @runner.setup_dns
+
+  end
+  it "wait for master snapshot to complete - no pending snapshots for master lineage" do
+# take the lineage name, find all snapshots and verify that none are in the pending state.
+    @runner.run_script("backup", @master)
+    @runner.wait_for_snapshots
+debugger
+  end
+end

data/spec/little_ruby.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'virtualmonkey'
+
+@sdb = Fog::AWS::SimpleDB.new(:aws_access_key_id => Fog.credentials[:aws_access_key_id_test], :aws_secret_access_key => Fog.credentials[:aws_secret_access_key_test])
+
+@domain="virtualmonkey_awsdns"
+
+29.times do |num|
+  item_name="awsdns#{num}"
+  attributes=
+      {"SLAVE_DB_DNSID"=>["text:Z3AINKOIEY1X3X:testslave#{num}.aws.rightscale.com"],
+       "MASTER_DB_DNSID"=>["text:Z3AINKOIEY1X3X:test#{num}.aws.rightscale.com"],
+       "DNS_USER"=>["cred:AWS_ACCESS_KEY_ID_TEST"],
+       "DNS_PASSWORD"=>["cred:AWS_SECRET_ACCESS_KEY_TEST"],
+       "DNS_PROVIDER"=>["text:AwsDNS"],
+       "owner"=>["available"],
+       "MASTER_DB_DNSNAME"=>["text:test#{num}.aws.rightscale.com"]}
+  response = @sdb.put_attributes(@domain, item_name, attributes)
+end
+

data/spec/mini.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require "ruby-debug"
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Messing with spec" do
+  before(:all) do
+    raise "for this spec to run, you must have a mysql deployment nickname in $DEPLOYMENT variable" unless ENV['DEPLOYMENT']
+    @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+    @runner
+    @runner.lookup_scripts
+    @snapshot_lineage_prefix='testlineage3049'
+#    @runner.setup_dns
+
+  end
+  it "wait for master snapshot to complete - no pending snapshots for master lineage" do
+# take the lineage name, find all snapshots and verify that none are in the pending state.
+snapshots =Ec2EbsSnapshot.find_by_cloud_id(3).select { |n| n.nickname =~ /#{@snapshot_lineage_prefix}.*$/ }
+status= snapshots.map &:aws_status
+puts status.join ","
+puts "we got completed snapshots" if status.include?("completed") 
+puts "we got pending snapshots" if status.include?("pending") 
+debugger
+puts x
+  end
+end

data/spec/monitoring.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'rubygems'
+require 'virtualmonkey'
+
+dep=VirtualMonkey::SimpleRunner.new(ENV['DEPLOYMENT'])
+s= dep.servers.first
+s.monitoring
+mon=s.get_sketchy_data({'start'=>-180,'end'=>"-20",'plugin_name'=>"df",'plugin_type'=>"df-mnt"})
+data=mon['data']
+free=data['free']
+raise "No df free data" unless free.length > 0
+raise "DF not free" unless free[0]