virtualmonkey 0.0.1

data/lib/virtualmonkey/lamp_runner.rb

@@ -0,0 +1,29 @@
+module VirtualMonkey
+  class LampRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::UnifiedApplication
+    include VirtualMonkey::Mysql
+
+    # It's not that I'm a Java fundamentalist; I merely believe that mortals should
+    # not be calling the following methods directly. Instead, they should use the
+    # TestCaseInterface methods (behavior, verify, probe) to access these functions.
+    # Trust me, I know what's good for you. -- Tim R.
+    private
+
+    def run_lamp_checks
+      # check that the standard unified app is responding on port 80
+      run_unified_application_checks(@servers, 80)
+      
+      # TODO: check that running the mysql backup script succeeds
+      # server.spot_check_command("/etc/cron.daily/mysql-dump-backup.sh")
+      #
+      # TODO: run operational RightScript(s)
+      # 
+
+
+      
+    end
+
+
+  end
+end

data/lib/virtualmonkey/mysql.rb

@@ -0,0 +1,172 @@
+require 'ruby-debug'
+module VirtualMonkey
+  module Mysql
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::EBS
+    attr_accessor :scripts_to_run
+    attr_accessor :db_ebs_prefix
+
+    # sets the lineage for the deployment
+    # * kind<~String> can be "chef" or nil
+    def set_variation_lineage(kind = nil)
+      @lineage = "testlineage#{@deployment.href.split(/\//).last}"
+      if kind == "chef"
+        @deployment.set_input('db/backup/lineage', "text:#{@lineage}")
+        # unset all server level inputs in the deployment to ensure use of 
+        # the setting from the deployment level
+        @deployment.servers_no_reload.each do |s|
+          s.set_input('db/backup/lineage', "text:")
+        end
+      else
+        @deployment.set_input('DB_LINEAGE_NAME', "text:#{@lineage}")
+        # unset all server level inputs in the deployment to ensure use of 
+        # the setting from the deployment level
+        @deployment.servers_no_reload.each do |s|
+          s.set_input('DB_LINEAGE_NAME', "text:")
+        end
+      end
+    end
+
+    def set_variation_backup_prefix
+      @lineage = "text:testlineage#{rand(1000000)}"
+      @deployment.set_input('DB_EBS_PREFIX', @lineage)
+      # unset all server level inputs in the deployment to ensure use of 
+      # the setting from the deployment level
+      @deployment.servers_no_reload.each do |s|
+        s.set_input('DB_EBS_PREFIX', "text:")
+      end
+    end
+
+    def set_variation_bucket
+       bucket = "text:testingcandelete#{@deployment.href.split(/\//).last}"
+      @deployment.set_input('remote_storage/default/container', bucket)
+      # unset all server level inputs in the deployment to ensure use of 
+      # the setting from the deployment level
+      @deployment.servers_no_reload.each do |s|
+        s.set_input('remote_storage/default/container', "text:")
+      end
+    end
+
+    # creates a MySQL enabled EBS stripe on the server
+    # * server<~Server> the server to create stripe on
+    def create_stripe(server)
+      options = { "EBS_MOUNT_POINT" => "text:/mnt/mysql", 
+              "EBS_STRIPE_COUNT" => "text:#{@stripe_count}", 
+              "EBS_VOLUME_SIZE" => "text:1", 
+              "DBAPPLICATION_USER" => "text:someuser", 
+              "DB_MYSQLDUMP_BUCKET" => "ignore:$ignore",
+              "DB_MYSQLDUMP_FILENAME" => "ignore:$ignore",
+              "AWS_ACCESS_KEY_ID" => "ignore:$ignore",
+              "AWS_SECRET_ACCESS_KEY" => "ignore:$ignore",
+              "DB_SCHEMA_NAME" => "ignore:$ignore",
+              "DBAPPLICATION_PASSWORD" => "text:somepass", 
+              "EBS_TOTAL_VOLUME_GROUP_SIZE" => "text:1",
+              "EBS_LINEAGE" => "text:#{@lineage}" }
+      audit = server.run_executable(@scripts_to_run['create_mysql_ebs_stripe'], options)
+      audit.wait_for_completed
+    end
+
+    # Performs steps necessary to bootstrap a MySQL Master server from a pristine state.
+    # * server<~Server> the server to use as MASTER
+    def config_master_from_scratch(server)
+      behavior(:create_stripe, server)
+      object_behavior(server, :spot_check_command, "service mysqld start")
+#TODO the service name depends on the OS
+#      server.spot_check_command("service mysql start")
+      behavior(:run_query, "create database mynewtest", server)
+      behavior(:set_master_dns, server)
+      # This sleep is to wait for DNS to settle - must sleep
+      sleep 120
+      behavior(:run_script, "backup", server)
+    end
+
+    # Runs a mysql query on specified server.
+    # * query<~String> a SQL query string to execute
+    # * server<~Server> the server to run the query on 
+    def run_query(query, server)
+      query_command = "echo -e \"#{query}\"| mysql"
+      server.spot_check_command(query_command)
+    end
+
+    # Sets DNS record for the Master server to point at server
+    # * server<~Server> the server to use as MASTER
+    def set_master_dns(server)
+      audit = server.run_executable(@scripts_to_run['master_init'])
+      audit.wait_for_completed
+    end
+
+    # Use the termination script to stop all the servers (this cleans up the volumes)
+    def stop_all(wait=true)
+      if @scripts_to_run['terminate']
+        options = { "DB_TERMINATE_SAFETY" => "text:off" }
+        @servers.each { |s| s.run_executable(@scripts_to_run['terminate'], options) unless s.state == 'stopped' }
+      else
+        @servers.each { |s| s.stop }
+      end
+
+      wait_for_all("stopped") if wait
+      # unset dns in our local cached copy..
+      @servers.each { |s| s.params['dns-name'] = nil } 
+    end
+
+    # uses SharedDns to find an available set of DNS records and sets them on the deployment
+    def setup_dns(domain)
+# TODO should we just use the ID instead of the full href?
+      owner=@deployment.href
+      @dns = SharedDns.new(domain)
+      raise "Unable to reserve DNS" unless @dns.reserve_dns(owner)
+      @dns.set_dns_inputs(@deployment)
+    end
+
+    # releases records back into the shared DNS pool
+    def release_dns
+      @dns.release_dns
+    end
+
+    def promote_server(server)
+      run_script("promote", server)
+    end
+
+    def slave_init_server(server)
+      run_script("slave_init", server)
+    end
+
+    def restore_server(server)
+      run_script("restore", server)
+    end
+
+    def create_migration_script
+      options = { "DB_EBS_PREFIX" => "text:regmysql",
+              "DB_EBS_SIZE_MULTIPLIER" => "text:1",
+              "EBS_STRIPE_COUNT" => "text:#{@stripe_count}" }
+      s_one.run_executable(@scripts_to_run['create_migrate_script'], options)
+    end
+
+    # These are mysql specific checks (used by mysql_runner and lamp_runner)
+    def run_checks
+      # check that mysql tmpdir is custom setup on all servers
+      query = "show variables like 'tmpdir'"
+      query_command = "echo -e \"#{query}\"| mysql"
+      @servers.each do |server|
+        server.spot_check(query_command) { |result| raise "Failure: tmpdir was unset#{result}" unless result.include?("/mnt/mysqltmp") }
+      end
+    end
+
+    # check that mysql can handle 5000 concurrent connections (file limits, etc.)
+    def run_mysqlslap_check
+      @servers.each do |server|
+        result = server.spot_check_command("mysqlslap  --concurrency=5000 --iterations=10 --number-int-cols=2 --number-char-cols=3 --auto-generate-sql --csv=/tmp/mysqlslap_q1000_innodb.csv --engine=innodb --auto-generate-sql-add-autoincrement --auto-generate-sql-load-type=mixed --number-of-queries=1000 --user=root")
+        raise "FATAL: mysqlslap check failed" unless result[:output].empty?
+      end
+    end
+
+    # check that ulimit has been set correctly
+    # XXX: DEPRECATED
+    def ulimit_check
+      @servers.each do |server|
+        result = server.spot_check_command("su - mysql -s /bin/bash -c \"ulimit -n\"")
+        raise "FATAL: ulimit wasn't set correctly" unless result[:output].to_i >= 1024
+      end
+    end
+  end
+end

data/lib/virtualmonkey/mysql_runner.rb

@@ -0,0 +1,108 @@
+module VirtualMonkey
+  class MysqlRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::EBS
+    include VirtualMonkey::Mysql
+    attr_accessor :scripts_to_run
+    attr_accessor :db_ebs_prefix
+
+    # It's not that I'm a Java fundamentalist; I merely believe that mortals should
+    # not be calling the following methods directly. Instead, they should use the
+    # TestCaseInterface methods (behavior, verify, probe) to access these functions.
+    # Trust me, I know what's good for you. -- Tim R.
+    private
+
+    def run_promotion_operations
+      behavior(:config_master_from_scratch, s_one)
+      object_behavior(s_one, :relaunch)
+      s_one.dns_name = nil
+      behavior(:wait_for_snapshots)
+# need to wait for ebs snapshot, otherwise this could easily fail
+      behavior(:restore_server, s_two)
+      object_behavior(s_one, :wait_for_operational_with_dns)
+      behavior(:wait_for_snapshots)
+      behavior(:slave_init_server, s_one)
+      behavior(:promote_server, s_one)
+    end
+
+    def run_reboot_operations
+# Duplicate code here because we need to wait between the master and the slave time
+      #reboot_all(true) # serially_reboot = true
+      @servers.each do |s|
+        object_behavior(s, :reboot, true)
+        object_behavior(s, :wait_for_state, "operational")
+      end
+      behavior(:wait_for_all, "operational")
+      behavior(:run_reboot_checks)
+    end
+
+    # This is where we perform multiple checks on the deployment after a reboot.
+    def run_reboot_checks
+      # one simple check we can do is the backup.  Backup can fail if anything is amiss
+      @servers.each do |server|
+        behavior(:run_script, "backup", server)
+      end
+    end
+
+
+    # lookup all the RightScripts that we will want to run
+    def lookup_scripts
+#TODO fix this so epoch is not hard coded.
+puts "WE ARE HARDCODING THE TOOL BOX NAMES TO USE 11H1.b1"
+     scripts = [
+                 [ 'restore', 'restore and become' ],
+                 [ 'slave_init', 'slave init' ],
+                 [ 'promote', 'EBS promote to master' ],
+                 [ 'backup', 'EBS backup' ],
+                 [ 'terminate', 'TERMINATE SERVER' ]
+               ]
+      ebs_toolbox_scripts = [
+                              [ 'create_stripe' , 'EBS stripe volume create - 11H1.b1' ]
+                            ]
+      mysql_toolbox_scripts = [
+                              [ 'create_mysql_ebs_stripe' , 'DB Create MySQL EBS stripe volume - 11H1.b1' ],
+                              [ 'create_migrate_script' , 'DB EBS create migrate script from MySQL EBS v1' ]
+                            ]
+      st = ServerTemplate.find(s_two.server_template_href)
+      lookup_scripts_table(st,scripts)
+      @scripts_to_run['master_init'] = RightScript.new('href' => "/api/acct/2901/right_scripts/195053")
+      #This does not work - does not create the same type as call above does.
+      #@scripts_to_run['master_init'] = RightScript.find_by("name") { |n| n =~ /DB register master \-ONLY FOR TESTING/ }
+      raise "Did not find script" unless @scripts_to_run['master_init']
+
+      tbx = ServerTemplate.find_by(:nickname) { |n| n =~ /EBS Stripe Toolbox - 11H1.b1/ }
+      raise "Did not find toolbox template" unless tbx[0]
+      # Use the HEAD revision.
+      lookup_scripts_table(tbx[0],ebs_toolbox_scripts)
+#      @scripts_to_run['create_stripe'] = RightScript.new('href' => "/api/acct/2901/right_scripts/198381")
+#TODO - does not account for 5.0/5.1 toolbox differences
+puts "USING MySQL 5.0 toolbox"
+      tbx = ServerTemplate.find_by(:nickname) { |n| n =~ /Database Manager with MySQL 5.0 Toolbox - 11H1.b1/ }
+      raise "Did not find toolbox template" unless tbx[0]
+      lookup_scripts_table(tbx[0],mysql_toolbox_scripts)
+#      @scripts_to_run['create_mysql_ebs_stripe'] = RightScript.new('href' => "/api/acct/2901/right_scripts/212492")
+#      @scripts_to_run['create_migrate_script'] = tbx[0].executables.detect { |ex| ex.name =~ /DB EBS create migrate script from MySQL EBS v1 master/ }
+     raise "FATAL: Need 2 MySQL servers in the deployment" unless @servers.size == 2
+    end
+
+    def migrate_slave
+      s_one.settings
+      object_behavior(s_one, :spot_check_command, "/tmp/init_slave.sh")
+      behavior(:run_script, "backup", s_one)
+    end
+   
+    def launch_v2_slave
+      s_two.settings
+      behavior(:wait_for_snapshots)
+      behavior(:run_script, "slave_init", s_two)
+    end
+
+    def run_restore_with_timestamp_override
+      object_behavior(s_one, :relaunch)
+      s_one.dns_name = nil
+      s_one.wait_for_operational_with_dns
+      audit = object_behavior(s_one, :run_executable, @scripts_to_run['restore'], { "OPT_DB_RESTORE_TIMESTAMP_OVERRIDE" => "text:#{find_snapshot_timestamp}" } )
+      audit.wait_for_completed
+    end
+  end
+end

data/lib/virtualmonkey/mysql_toolbox_runner.rb

@@ -0,0 +1,51 @@
+module VirtualMonkey
+  class MysqlToolboxRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::EBS
+    include VirtualMonkey::Mysql
+    attr_accessor :scripts_to_run
+
+    # It's not that I'm a Java fundamentalist; I merely believe that mortals should
+    # not be calling the following methods directly. Instead, they should use the
+    # TestCaseInterface methods (behavior, verify, probe) to access these functions.
+    # Trust me, I know what's good for you. -- Tim R.
+    private
+
+    def lookup_scripts
+      scripts_mysql = [
+                         [ 'promote', 'EBS promote to master' ],
+                         [ 'backup', 'EBS backup' ],
+                         [ 'terminate', 'TERMINATE SERVER' ]
+                       ]
+      scripts_my_toolbox = [
+                              [ 'create_backup_scripts', 'EBS create backup scripts' ],
+                              [ 'enable_network', 'DB MySQL Enable Networking' ],
+                              [ 'create_migrate_script', 'DB EBS create migrate script from MySQL EBS v1' ],
+                              [ 'create_mysql_ebs_stripe', 'DB Create MySQL EBS stripe' ],
+                              [ 'grow_volume', 'DB EBS slave init and grow stripe volume' ],
+                              [ 'restore', 'DB EBS restore stripe volume' ]
+                            ]
+      st = ServerTemplate.find(s_one.server_template_href)
+      lookup_scripts_table(st,scripts_mysql)
+      # hardwired script! (this is an 'anyscript' that users typically use to setup the master dns)
+      # This a special version of the register that uses MASTER_DB_DNSID instead of a test DNSID
+      # This is identical to "DB register master" However it is not part of the template.
+#      @scripts_to_run['master_init'] = RightScript.find_by("name") { |n| n =~ /DB register master \-ONLY FOR TESTING/ }
+      @scripts_to_run['master_init'] = RightScript.new('href' => "/api/acct/2901/right_scripts/195053")
+      raise "Did not find script" unless @scripts_to_run['master_init']
+
+#      @scripts_to_run['master_init'] = RightScript.new('href' => "/api/acct/2901/right_scripts/195053")
+#TODO - this is hardcoded for 5.0 toolbox - need to deal with issue that we have two
+#toolboxes and their names are going to change
+      tbx = ServerTemplate.find_by(:nickname) { |n| n =~ /Database Manager with MySQL 5.0 Toolbox - 11H1.b1/ }
+      raise "FATAL: could not find toolbox" unless tbx
+      # Use the HEAD revision.
+      st = tbx[0]
+      lookup_scripts_table(st,scripts_my_toolbox)
+    end
+
+    def create_master
+      config_master_from_scratch(s_one)
+    end
+  end
+end

data/lib/virtualmonkey/patch_runner.rb

@@ -0,0 +1,46 @@
+require "rubygems"
+require "right_aws"
+
+module VirtualMonkey
+  class PatchRunner
+    include VirtualMonkey::DeploymentRunner
+    
+    
+    # It's not that I'm a Java fundamentalist; I merely believe that mortals should
+    # not be calling the following methods directly. Instead, they should use the
+    # TestCaseInterface methods (behavior, verify, probe) to access these functions.
+    # Trust me, I know what's good for you. -- Tim R.
+    private
+
+    def initialize(args)
+      super(args)
+    end
+    
+    # Grab the scripts we plan to excersize
+    def lookup_scripts
+      scripts = [
+                 [ 'test_patch', 'TEST' ]
+               ]
+      server = @servers.first
+      server.settings 
+      st = ServerTemplate.find(server.server_template_href)
+      lookup_scripts_table(st,scripts)
+    end 
+
+    def set_user_data(value)
+        @servers.each do |server|
+	    server.settings
+	    server.ec2_user_data = value
+	    server.save
+        end
+    end 
+    
+    # run the patch test script
+    def run_patch_test
+	@servers.each do |server|	
+	  run_script('test_patch', server)
+	end
+    end
+
+   end
+end

data/lib/virtualmonkey/php_aio_trial_chef_runner.rb

@@ -0,0 +1,6 @@
+module VirtualMonkey
+  class PhpAioTrialChefRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::ApplicationFrontend
+  end
+end

data/lib/virtualmonkey/php_chef_runner.rb

@@ -0,0 +1,69 @@
+module VirtualMonkey
+  class PhpChefRunner
+    include VirtualMonkey::DeploymentRunner
+    include VirtualMonkey::ApplicationFrontend
+
+    # It's not that I'm a Java fundamentalist; I merely believe that mortals should
+    # not be calling the following methods directly. Instead, they should use the
+    # TestCaseInterface methods (behavior, verify, probe) to access these functions.
+    # Trust me, I know what's good for you. -- Tim R.
+    private
+
+    def set_lb_hostname
+      @deployment.set_input("lb_haproxy/host", get_lb_hostname_input)
+    end
+
+    # sets the MASTER_DB_DNSNAME to this machine's ip address
+    def set_master_db_dnsname
+      the_name = get_tester_ip_addr
+      @deployment.set_input("php/db_dns_name", the_name) 
+    end
+ 
+    def frontend_checks
+      behavior(:detect_os)
+
+      behavior(:run_unified_application_checks, fe_servers, 80)
+
+      # check that all application servers exist in the haproxy config file on all fe_servers
+      server_ips = Array.new
+      app_servers.each { |app| server_ips << app['private-ip-address'] }
+      fe_servers.each do |fe|
+        fe.settings
+        haproxy_config = object_behavior(fe, :spot_check_command, 'cat /home/haproxy/rightscale_lb.cfg | grep server')
+        server_ips.each { |ip|  haproxy_config.to_s.include?(ip).should == true }
+      end
+
+      # restart haproxy and check that it succeeds
+      fe_servers.each_with_index do |server,i|
+        response = object_behavior(server, :spot_check_command?, 'service haproxy stop')
+        raise "Haproxy stop command failed" unless response
+
+        stopped = false
+        count = 0
+        until response || count > 3 do
+          response = object_behavior(server, :spot_check_command, server.haproxy_check)
+          stopped = response.include?("not running")
+          break if stopped
+          count += 1
+          sleep 10
+        end
+
+        response = object_behavior(server, :spot_check_command?, 'service haproxy start')
+        raise "Haproxy start failed" unless response
+      end
+    end
+
+    def lookup_scripts
+      @scripts_to_run = {}
+      st = ServerTemplate.find(fe_servers.first.server_template_href)
+      @scripts_to_run["attach"] = st.executables.detect { |d| d.recipe == "lb_haproxy::do_attach_request" }
+    end
+
+    def cross_connect_frontends
+      statuses = Array.new 
+      @servers.each { |s| statuses << s.run_executable(@scripts_to_run['attach']) }
+      statuses.each_with_index { |s,i| s.wait_for_completed }
+    end
+    
+  end
+end