virtualmonkey 0.0.1

data/features/ebs_toolbox.rb

@@ -0,0 +1,62 @@
+#@ebs
+#Feature: EBS toolbox tests
+#  Tests the RightScale premium ServerTemplate
+#
+#  Scenario: Run all EBS toolbox operational scripts
+##
+## PHASE 1) Launch a toolbox server and create an EBS stripe with "interesting" data on it.
+##  How many servers do we need?  Launch them all and figure it out later.
+##
+# Given A EBS Toolbox deployment
+  @runner = VirtualMonkey::EBSRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should set a variation lineage
+  @runner.set_var(:set_variation_lineage)
+
+# Then I should set a variation stripe count of "3"
+  @runner.set_var(:set_variation_stripe_count, 3)
+
+# Then I should set a variation volume size "3"
+  @runner.set_var(:set_variation_volume_size, 3)
+
+# Then I should set a variation mount point "/mnt/ebs"
+  @runner.set_var(:set_variation_mount_point, "/mnt/ebs")
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should create a new EBS stripe
+  @runner.behavior(:create_stripe)
+
+##
+## PHASE 2) Run checks for the basic scripts
+##
+# Then I should test the backup script operations
+  @runner.behavior(:test_backup_script_operations)
+
+##
+## PHASE 3) restore the snapshot on another server
+##
+# Then I should backup the volume
+  @runner.behavior(:create_backup)
+
+# Then I should test the restore operations
+  @runner.behavior(:test_restore)
+
+##
+## PHASE 4) Do the grow EBS tests
+##
+# Then I should test the restore grow operations
+  @runner.behavior(:test_restore_grow)
+
+# Then I should test reboot operations on the deployment
+  @runner.behavior(:run_reboot_operations)
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)

data/features/lamp.rb

@@ -0,0 +1,33 @@
+#@lamp_test
+#
+#Feature: LAMP Server Template Test
+#  Tests the deployment
+#
+#Scenario: LAMP Server Template Test
+#
+# Given A LAMP deployment
+  @runner = VirtualMonkey::LampRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should run LAMP checks
+  @runner.behavior(:run_lamp_checks)
+
+# Then I should run mysql checks
+  @runner.behavior(:run_checks)
+
+## Then I should run mysqlslap stress test
+#  @runner.behavior(:run_mysqlslap_check)
+#
+# Then I should check that ulimit was set correctly
+  @runner.probe(".*", "su - mysql -s /bin/bash -c \"ulimit -n\"") { |s| s.to_i > 1024 }
+
+# Then I should check that monitoring is enabled
+  @runner.behavior(:check_monitoring)

data/features/lb-apache-haproxy.rb

@@ -0,0 +1,49 @@
+#@lb_test
+#
+#Feature: LB Server Test
+#  Tests the LB servers
+#
+#Scenario: LB server test
+#
+# Given An Apache with HAproxy deployment
+  @runner = VirtualMonkey::FeAppRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should set a variation for connecting to shared database host
+  @runner.set_var(:set_master_db_dnsname)
+
+# When I launch the "Load Balancer" servers
+  @runner.behavior(:launch_set, "Load Balancer")
+
+# Then I should wait for the state of "Load Balancer" servers to be "operational"
+  @runner.behavior(:wait_for_set, "Load Balancer", "operational")
+
+# Then I should set a variation LB_HOSTNAME
+  @runner.set_var(:set_lb_hostname)
+
+# When I launch the "App Server" servers
+  @runner.behavior(:launch_set, "App Server")
+
+# Then I should wait for the state of "App Server" servers to be "operational"
+  @runner.behavior(:wait_for_set, "App Server", "operational")
+
+# Then I should run unified application checks on app servers
+  @runner.behavior(:run_unified_application_checks, @runner.send(:app_servers))
+
+# Then I should run frontend checks
+  @runner.behavior(:frontend_checks)
+
+# Then I should run log rotation checks
+  @runner.behavior(:log_rotation_checks)
+
+## TODO?
+## When I restart apache
+#
+#
+## Then apache status should be good
+#
+#
+# Then I should test reboot operations on the deployment
+  @runner.behavior(:run_reboot_operations)

data/features/mysql_5.x_v2_v4_from_scratch.rb

@@ -0,0 +1,71 @@
+#@mysql_5.x
+#Feature: mysql 5.x v2 or v4 promote operations test
+#  Tests the RightScale premium ServerTemplate
+#
+#  Scenario: Setup 2 server deployment and run basic cluster failover operations
+#
+# PHASE 1) Bootstrap and test promote
+#
+# Given A MySQL deployment
+  @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should set a variation lineage
+  @runner.set_var(:set_variation_lineage)
+
+# Then I should set a variation stripe count of "1"
+  @runner.set_var(:set_variation_stripe_count, 1)
+
+# Then I should set a variation MySQL DNS
+  @runner.set_var(:setup_dns, "virtualmonkey_shared_resources") # DNSMadeEasy
+
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "booting"
+  @runner.behavior(:wait_for_all, "booting")
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should test promotion operations on the deployment
+  @runner.behavior(:run_promotion_operations)
+
+# Then I should run mysql checks
+  @runner.behavior(:run_checks)
+
+# Then I should run mysqlslap stress test
+#  @runner.behavior(:run_mysqlslap_check)
+
+# Then I should check that ulimit was set correctly
+#  @runner.behavior(:ulimit_check)
+  @runner.probe(".*", "su - mysql -s /bin/bash -c \"ulimit -n\"") { |s| s.to_i > 1024 }
+
+# Then I should check that monitoring is enabled
+  @runner.behavior(:check_monitoring)
+
+#
+# PHASE 2) Reboot
+#
+
+# Then I should test reboot operations on the deployment
+  @runner.behavior(:run_reboot_operations)
+
+#
+# PHASE 3) Additional Tests
+#
+
+# Then I should run a restore using OPT_DB_RESTORE_TIMESTAMP_OVERRIDE
+  @runner.behavior(:run_restore_with_timestamp_override)
+
+# 
+# PHASE 4) Terminate
+#
+
+# Then I should terminate the servers
+  @runner.behavior(:stop_all, true)
+
+# Then I should release the DNS
+  @runner.behavior(:release_dns)

data/features/mysql_5.x_v2_v4_from_scratch_awsdns.rb

@@ -0,0 +1,71 @@
+#@mysql_5.x
+#Feature: mysql 5.x v2 or v4 promote operations test
+#  Tests the RightScale premium ServerTemplate
+#
+#  Scenario: Setup 2 server deployment and run basic cluster failover operations
+#
+# PHASE 1) Bootstrap and test promote
+#
+# Given A MySQL deployment
+  @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should set a variation lineage
+  @runner.set_var(:set_variation_lineage)
+
+# Then I should set a variation stripe count of "1"
+  @runner.set_var(:set_variation_stripe_count, 1)
+
+# Then I should set a variation MySQL DNS
+  @runner.set_var(:setup_dns, "virtualmonkey_awsdns") # AWSDNS
+
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "booting"
+  @runner.behavior(:wait_for_all, "booting")
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should test promotion operations on the deployment
+  @runner.behavior(:run_promotion_operations)
+
+# Then I should run mysql checks
+  @runner.behavior(:run_checks)
+
+# Then I should run mysqlslap stress test
+#  @runner.behavior(:run_mysqlslap_check)
+
+# Then I should check that ulimit was set correctly
+#  @runner.behavior(:ulimit_check)
+  @runner.probe(".*", "su - mysql -s /bin/bash -c \"ulimit -n\"") { |s| s.to_i > 1024 }
+
+# Then I should check that monitoring is enabled
+  @runner.behavior(:check_monitoring)
+
+#
+# PHASE 2) Reboot
+#
+
+# Then I should test reboot operations on the deployment
+  @runner.behavior(:run_reboot_operations)
+
+#
+# PHASE 3) Additional Tests
+#
+
+# Then I should run a restore using OPT_DB_RESTORE_TIMESTAMP_OVERRIDE
+  @runner.behavior(:run_restore_with_timestamp_override)
+
+# 
+# PHASE 4) Terminate
+#
+
+# Then I should terminate the servers
+  @runner.behavior(:stop_all, true)
+
+# Then I should release the DNS
+  @runner.behavior(:release_dns)

data/features/mysql_5.x_v2_v4_from_scratch_dyndns.rb

@@ -0,0 +1,71 @@
+#@mysql_5.x
+#Feature: mysql 5.x v2 or v4 promote operations test
+#  Tests the RightScale premium ServerTemplate
+#
+#  Scenario: Setup 2 server deployment and run basic cluster failover operations
+#
+# PHASE 1) Bootstrap and test promote
+#
+# Given A MySQL deployment
+  @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should set a variation lineage
+  @runner.set_var(:set_variation_lineage)
+
+# Then I should set a variation stripe count of "1"
+  @runner.set_var(:set_variation_stripe_count, 1)
+
+# Then I should set a variation MySQL DNS
+  @runner.set_var(:setup_dns, "virtualmonkey_awsdns") # DNSMadeEasy
+
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "booting"
+  @runner.behavior(:wait_for_all, "booting")
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should test promotion operations on the deployment
+  @runner.behavior(:run_promotion_operations)
+
+# Then I should run mysql checks
+  @runner.behavior(:run_checks)
+
+# Then I should run mysqlslap stress test
+#  @runner.behavior(:run_mysqlslap_check)
+
+# Then I should check that ulimit was set correctly
+#  @runner.behavior(:ulimit_check)
+  @runner.probe(".*", "su - mysql -s /bin/bash -c \"ulimit -n\"") { |s| s.to_i > 1024 }
+
+# Then I should check that monitoring is enabled
+  @runner.behavior(:check_monitoring)
+
+#
+# PHASE 2) Reboot
+#
+
+# Then I should test reboot operations on the deployment
+  @runner.behavior(:run_reboot_operations)
+
+#
+# PHASE 3) Additional Tests
+#
+
+# Then I should run a restore using OPT_DB_RESTORE_TIMESTAMP_OVERRIDE
+  @runner.behavior(:run_restore_with_timestamp_override)
+
+# 
+# PHASE 4) Terminate
+#
+
+# Then I should terminate the servers
+  @runner.behavior(:stop_all, true)
+
+# Then I should release the DNS
+  @runner.behavior(:release_dns)

data/features/mysql_v1_upgrade_v2.rb

@@ -0,0 +1,54 @@
+#@mysql_5.x
+#Feature: mysql 5.x v1 to v2 upgrade tests
+#  Tests the RightScale premium ServerTemplate
+#
+#  Scenario: Follow the steps in the v1 to v2 upgrade guide. Then run the mysql checks.
+# http://support.rightscale.com/03-Tutorials/02-AWS/02-Website_Edition/2.1_MySQL_Setup/MySQL_Setup_Migration%3a__EBS_to_EBS_Stripe
+#
+# PHASE 1) Launch a v1 master from a known hardcoded snapshot.
+#  TODO - add the steps to create the v1 master from scratch.  The upgrade is the major
+#         concern so lets get that done first.
+#  Prerequisite: A Deployment with a running MySQL EBS Master-DB server 
+#  (launched using a revision of the "MySQL EBS v1" ServerTemplate)
+# Old school hand crafted deployment: https://my.rightscale.com/deployments/49925.  Make sure
+# The one server is still up and running as master DB.
+#
+# Given A MySQL deployment
+  @runner = VirtualMonkey::MysqlRunner.new(ENV['DEPLOYMENT'])
+
+# Then I should stop the servers
+  @runner.behavior(:stop_all)
+
+# Then I should set a variation lineage
+  @runner.behavior(:set_variation_lineage)
+
+# Then I should set a variation stripe count of "3"
+  @runner.behavior(:set_variation_stripe_count, 3)
+
+#
+# PHASE 2) Launch a new v2 server and migrate from v1
+#
+# Then I should launch all servers
+  @runner.behavior(:launch_all)
+
+# Then I should wait for the state of "all" servers to be "operational"
+  @runner.behavior(:wait_for_all, "operational")
+
+# Then I should create the migration script
+  @runner.behavior(:create_migration_script)
+
+# Then I should migrate a new slave
+  @runner.behavior(:migrate_slave)
+
+#
+# PHASE 3) Initialize additional slave from v2 snapshots
+#
+# Then I should init a new v2 slave
+  @runner.behavior(:launch_v2_slave)
+
+# Then I should test the new v2 slave
+  @runner.behavior(:run_checks)
+
+# Then I should check that ulimit was set correctly
+  @runner.behavior(:ulimit_check)
+

data/features/old_cuke_features/Rakefile

@@ -0,0 +1,121 @@
+require 'rubygems'
+require 'rest_connection'
+require 'yaml'
+require 'fileutils'
+require 'sqlite3'
+require File.join(File.dirname(__FILE__), "..", "vmonk", "lib", "cuke_monk")
+
+def cached_deployments()
+  if File.exists?("deployments.cache.yaml")
+    puts "Loading deployments from cache.."
+    deployments = YAML::load(IO.read("deployments.cache.yaml"))
+  else
+    deployments = Deployment.find_by(:nickname) { |nick| nick.include?(ENV['DEPLOYMENTS_TAG']) }
+    File.open("deployments.cache.yaml", "w") {|f| f.write(deployments.to_yaml)}
+  end
+  deployments
+end
+
+desc "Release MySQL DNS records for reuse"
+task :release_dns do
+  raise "Please setup DEPLOYMENT environment variable" unless ENV['DEPLOYMENT']
+  SQLite3::Database.new("shared.db") do |db|
+    q = db.query("UPDATE mysql_dns SET owner=NULL where owner='#{ENV['DEPLOYMENT']}'")
+    q.close
+    db.query("SELECT * FROM mysql_dns") do |result|
+      puts result.entries
+    end
+  end
+end
+
+desc "Release ALL MySQL DNS records for reuse"
+task :release_all_dns do
+  SQLite3::Database.new("shared.db") do |db|
+    q = db.query("UPDATE mysql_dns SET owner=NULL")
+    q.close
+    db.query("SELECT * FROM mysql_dns") do |result|
+      puts result.entries
+    end
+  end
+end
+
+desc "Run Parallel Cucumber Features and post results"
+task :run_parallel_features do
+  raise "FATAL: please setup $FEATURE environment variable with the filename of Cuke feature test." unless ENV['FEATURE']
+  raise "FATAL: please setup DEPLOYMENTS_TAG environment variable, for finding your set of deployments" unless ENV['DEPLOYMENTS_TAG']
+
+  cm = CukeMonk.new
+  set = Deployment.find_by(:nickname) { |nick| nick.include?(ENV['DEPLOYMENTS_TAG']) }
+  puts "Found: #{set.size} deployments matching #{ENV['DEPLOYMENTS_TAG']}"
+  feature_name = ENV["FEATURE"]
+  FileUtils.mkdir_p("log")
+  ENV['REST_CONNECTION_LOG'] = "log/rest_connection.log"
+  deployment_nicknames = set.map &:nickname
+  cm.run_tests(deployment_nicknames, feature_name)
+  cm.generate_reports
+end
+
+desc "Parallel Cuke test on a set of deployments"
+task :run_parallel_features_old do
+  raise "FATAL: please setup $FEATURE environment variable with the filename of Cuke feature test." unless ENV['FEATURE']
+  raise "FATAL: please setup DEPLOYMENTS_TAG environment variable, for finding your set of deployments" unless ENV['DEPLOYMENTS_TAG']
+  set = Deployment.find_by(:nickname) { |nick| nick.include?(ENV['DEPLOYMENTS_TAG']) }
+  puts "Found: #{set.size} deployments matching #{ENV['DEPLOYMENTS_TAG']}"
+  feature_name = ENV["FEATURE"]
+  FileUtils.mkdir_p("log")
+  children = []
+  set.each do |dep|
+    ENV['DEPLOYMENT'] = dep.nickname
+    ENV['REST_CONNECTION_LOG'] = "log/rest_connection.#{ENV['DEPLOYMENT']}-#{dep.nickname}.log"
+    children << Process.fork {
+      cmd = "cucumber #{feature_name} --out 'log/#{ENV['DEPLOYMENT']}-#{dep.nickname}.log'"
+      puts "RUNNING: #{cmd}"
+      success = system(cmd)
+      if success
+        FileUtils.mv("log/#{ENV['DEPLOYMENT']}-#{dep.nickname}.log","log/COMPLETED-#{ENV['DEPLOYMENT']}-#{dep.nickname}.log")
+      else
+        FileUtils.mv("log/#{ENV['DEPLOYMENT']}-#{dep.nickname}.log","log/FAILED-#{ENV['DEPLOYMENT']}-#{dep.nickname}.log")
+      end
+    }
+  end
+
+  Signal.trap("SIGINT") do
+    puts "Caught CTRL-C, killing children.."
+    children.each {|c| Process.kill("INT", c)}
+    sleep 1
+    children.each {|c| Process.kill("INT", c)}
+  end
+
+  children.each {|c| Process.wait2(c)}
+  puts "Run finished"
+  
+end
+
+desc "TERMINATE all servers in all deployments specified by DEPLOYMENTS_TAG"
+task :kill_all do
+  raise "FATAL: please setup DEPLOYMENTS_TAG environment variable, for finding your set of deployments" unless ENV['DEPLOYMENTS_TAG']
+  set = cached_deployments 
+  set.each {|n| STDOUT.puts n.nickname}
+  STDOUT.puts "10 seconds till ..TERMINATING all servers in these deployments ^^^^. CTRL-C to abort."
+  sleep 10
+  set.each do |deploy|
+    servers = deploy.servers
+    servers.each { |s| s.stop }
+  end
+end
+
+desc "RELAUNCH all *running servers in deployments specified by DEPLOYMENTS_TAG"
+task :relaunch_all do
+  raise "FATAL: please setup DEPLOYMENTS_TAG environment variable, for finding your set of deployments" unless ENV['DEPLOYMENTS_TAG']
+  set = cached_deployments 
+  set.each {|n| STDOUT.puts n.nickname}
+  STDOUT.puts "10 seconds till ..RELAUNCHING all servers in these deployments ^^^^. CTRL-C to abort."
+  sleep 10
+  set.each do |deploy|
+    my_servers = deploy.servers
+    my_servers.each do |s| 
+      s.relaunch
+    end
+  end
+end
+