virtualmonkey 0.0.1

data/lib/virtualmonkey/command/troop.rb

@@ -0,0 +1,146 @@
+module VirtualMonkey
+  module Command
+    # This command does all the steps create/run/conditionaly destroy
+    def self.troop
+      options = Trollop::options do
+        text "This command performs all the operations of the monkey in one execution.  Create/Run/Destroy"
+        opt :file, "troop config, see config/troop/*sample.json for example format", :type => :string, :required => true
+        opt :no_spot, "do not use spot instances"
+        opt :step, "use the troop config file to do either: create, run, or destroy", :type => :string
+        opt :tag, "add an additional tag to the deployments", :type => :string
+        opt :create, "interactive mode: create troop config"
+        opt :mci_override, "list of mcis to use instead of the ones from the server template. expects full hrefs.", :type => :string, :multi => true, :required => false
+        opt :no_delete, "only terminate, no deletion.", :short => "-d"
+      end
+
+      # PATHs SETUP
+      features_dir = File.join(File.dirname(__FILE__), "..", "..", "..", "features")
+      features_glob = Dir.glob(File.join(features_dir, "**"))
+      features_glob = features_glob.collect { |c| File.basename(c) }
+
+      config_dir = File.join(File.dirname(__FILE__), "..", "..", "..", "config")
+      cloud_variables_glob = Dir.glob(File.join(config_dir, "cloud_variables", "**"))
+      cloud_variables_glob = cloud_variables_glob.collect { |c| File.basename(c) }
+      common_inputs_glob = Dir.glob(File.join(config_dir, "common_inputs", "**"))
+      common_inputs_glob = common_inputs_glob.collect { |c| File.basename(c) }
+      global_state_dir = File.join(File.dirname(__FILE__), "..", "..", "..", "test_states")
+      options[:tag] += "-" if options[:tag]
+      options[:tag] = "" unless options[:tag]
+      
+      # CREATE NEW CONFIG
+      if options[:create]
+        troop_config = {}
+        troop_config[:tag] = ask("What tag to use for creating the deployments?")
+        troop_config[:server_template_ids] = ask("What Server Template ids would you like to use to create the deployments (comma delimited)?").split(",")
+        troop_config[:server_template_ids].each {|st| st.strip!}
+
+        troop_config[:runner] = 
+          choose do |menu|
+            menu.prompt = "What kind of deployment is this (runner type)?"
+            menu.choice("MysqlToolboxRunner")
+            menu.choice("MysqlRunner")
+            menu.choice("SimpleRunner")
+          end
+
+        troop_config[:cloud_variables] =
+          choose do |menu|
+            menu.prompt = "Which cloud_variables config file?"
+            menu.index = :number
+            menu.choices(*cloud_variables_glob)
+          end
+
+        troop_config[:common_inputs] =
+          choose do |menu|
+            menu.prompt = "Which common_inputs config file?"
+            menu.index = :number
+            menu.choices(*common_inputs_glob)
+          end
+
+        troop_config[:feature] = 
+          choose do |menu|
+            menu.prompt = "Which feature file?"
+            menu.index = :number
+            menu.choices(*features_glob)
+          end
+        
+        write_out = troop_config.to_json( :indent => "  ", 
+                                          :object_nl => "\n",
+                                          :array_nl => "\n" )
+        File.open(options[:file], "w") { |f| f.write(write_out) }
+        say("created config file #{options[:file]}")
+        say("Done.")
+      else
+        # Execute Main
+        config = JSON::parse(IO.read(options[:file]))
+        options[:step] = "all" unless options[:step]
+        tag = options[:tag] + config['tag']
+
+        # CREATE PHASE
+        if options[:step] =~ /((all)|(create))/
+          @dm = DeploymentMonk.new(tag, config['server_template_ids'])
+          @dm.variables_for_cloud = JSON::parse(IO.read(File.join(config_dir, "cloud_variables", config['cloud_variables'])))
+          config['common_inputs'].each do |cipath|
+            @dm.load_common_inputs(File.join(config_dir, "common_inputs", cipath))
+          end  
+          @dm.generate_variations(options)
+        end
+
+        # RUN PHASE
+        if options[:step] =~ /((all)|(run))/
+          @dm = DeploymentMonk.new(tag) if options[:step] =~ /run/
+          EM.run {
+            @cm = CukeMonk.new
+            @cm.options = {}
+            remaining_jobs = @cm.jobs.dup
+            @dm.deployments.each do |deploy|
+              @cm.run_test(deploy, File.join(features_dir, config['feature']))
+            end
+
+            watch = EM.add_periodic_timer(10) {
+              @cm.watch_and_report
+              if @cm.all_done?
+                watch.cancel 
+              end
+              remaining_jobs.each do |job|
+                # destroy on success only (keep failed deploys)
+                if job.status == 0 and options[:step] =~ /all/
+                  runner = eval("VirtualMonkey::#{config['runner']}.new(job.deployment.nickname)")
+                  puts "destroying successful deployment: #{runner.deployment.nickname}"
+                  runner.behavior(:stop_all, false)
+                  runner.deployment.destroy unless options[:no_delete]
+                  remaining_jobs.delete(job)
+                  if runner.respond_to?(:release_dns) and not options[:no_delete]
+                    runner.behavior(:release_dns)
+                  end
+                end
+              end
+            }
+          }
+        end
+
+        if options[:step] =~ /destroy/
+          @dm = DeploymentMonk.new(tag)
+          @dm.deployments.each do |deploy|
+            runner = eval("VirtualMonkey::#{config['runner']}.new(deploy.nickname)")
+            runner.behavior(:stop_all, false)
+            state_dir = File.join(global_state_dir, deploy.nickname)
+            if File.directory?(state_dir)
+              puts "Deleting state files for #{deploy.nickname}..."
+              Dir.new(state_dir).each do |state_file|
+                if File.extname(state_file) =~ /((rb)|(feature))/
+                   File.delete(File.join(state_dir, state_file))
+                end 
+              end 
+              Dir.rmdir(state_dir)
+            end
+            if runner.respond_to?(:release_dns) and not options[:no_delete]
+              runner.behavior(:release_dns)
+            end
+          end
+          @dm.destroy_all unless options[:no_delete]
+        end
+      end
+      puts "Troop done."
+    end
+  end
+end

data/lib/virtualmonkey/cuke_monk.rb

@@ -0,0 +1,184 @@
+require 'rubygems'
+require 'erb'
+require 'fog'
+require 'eventmachine'
+require 'right_popen'
+
+class CukeJob
+  attr_accessor :status, :output, :logfile, :deployment, :rest_log, :no_resume
+
+  def link_to_rightscale
+    i = deployment.href.split(/\//).last
+    d = deployment.href.split(/\./).first.split(/\//).last
+    "https://#{d}.rightscale.com/deployments/#{i}#auditentries"
+  end
+
+  def on_read_stdout(data)
+#    @output ||= ""
+#    @output << data
+    File.open(@logfile, "a") { |f| f.write(data) }
+  end
+
+  def on_read_stderr(data)
+#    @output ||= ""
+#    @output << data
+    File.open(@logfile, "a") { |f| f.write(data) }
+  end
+    
+  def receive_data data
+#    @output += data
+    File.open(@logfile, "a") { |f| f.write(data) }
+  end
+
+  def unbind
+    @status = get_status.exitstatus
+  end
+
+  def on_exit(status)
+    @status = status.exitstatus
+#    File.open(@logfile, "a") { |f| f.write(@output) }
+  end
+
+  def run(deployment, cmd)
+    RightScale.popen3(:command        => cmd,
+                        :target         => self,
+                        :environment    => {"DEPLOYMENT" => deployment.nickname,
+                                            "AWS_ACCESS_KEY_ID" => Fog.credentials[:aws_access_key_id],
+                                            "AWS_SECRET_ACCESS_KEY" => Fog.credentials[:aws_secret_access_key],
+                                            "REST_CONNECTION_LOG" => @rest_log,
+                                            "MONKEY_NO_RESUME" => "#{@no_resume}",
+                                            "MONKEY_NO_DEBUG" => "true"},
+                        :stdout_handler => :on_read_stdout,
+                        :stderr_handler => :on_read_stderr,
+                        :exit_handler   => :on_exit)
+  end
+end
+
+class CukeMonk
+  attr_accessor :jobs
+  attr_accessor :options
+  # Runs a cucumber test on a single Deployment
+  # * deployment<~String> the nickname of the deployment
+  # * feature<~String> the feature filename 
+  def run_test(deployment, feature, break_point = 1000000)
+    new_job = CukeJob.new
+    new_job.logfile = File.join(@log_dir, "#{deployment.nickname}.log")
+    new_job.rest_log = "#{@log_dir}/#{deployment.nickname}.rest_connection.log"
+    new_job.deployment = deployment
+    new_job.no_resume = "true" if @options[:no_resume]
+    break_point = @options[:breakpoint] if @options[:breakpoint]
+    cmd = "bin/grinder #{feature} #{break_point}"
+    @jobs << new_job
+    puts "running #{cmd}"
+    new_job.run(deployment, cmd)
+  end
+
+  def initialize()
+    @jobs = []
+    @passed = []
+    @failed = []
+    @running = []
+    dirname = Time.now.strftime("%Y/%m/%d/%H-%M-%S")
+    @log_dir = File.join("log", dirname)
+    @log_started = dirname
+    FileUtils.mkdir_p(@log_dir)
+    @feature_dir = File.join(File.dirname(__FILE__), '..', '..', 'features')
+  end
+ 
+  # runs a feature on an array of deployments
+  # * deployments<~Array> array of strings containing the nicknames of the deployments
+  # * feature_name<~String> the feature filename 
+  def run_tests(deployments,cmd)
+    deployments.each { |d| run_test(d,cmd) }
+  end
+
+  def watch_and_report
+    old_passed = @passed
+    old_failed = @failed
+    old_running = @running
+    old_sum = old_passed.size + old_failed.size + old_running.size
+    @passed = @jobs.select { |s| s.status == 0 }
+    @failed = @jobs.select { |s| s.status == 1 }
+    @running = @jobs.select { |s| s.status == nil }
+    new_sum = @passed.size + @failed.size + @running.size
+    puts "#{@passed.size} features passed.  #{@failed.size} features failed.  #{@running.size} features running."
+    if new_sum < old_sum and new_sum < @jobs.size
+      puts "WARNING: Jobs Lost! Finding..."
+      report_lost_deployments({ :old_passed => old_passed, :passed => @passed,
+                                :old_failed => old_failed, :failed => @failed,
+                                :old_running => old_running, :running => @running })
+    end
+    if old_passed != @passed || old_failed != @failed
+      status_change_hook
+    end
+  end
+
+  def status_change_hook
+    generate_reports
+    if all_done?
+      puts "monkey done."
+      EM.stop
+    end
+  end
+
+  def all_done?
+    running = @jobs.select { |s| s.status == nil }
+    running.size == 0 && @jobs.size > 0
+  end
+
+  def generate_reports
+    passed = @jobs.select { |s| s.status == 0 }
+    failed = @jobs.select { |s| s.status == 1 }
+    running = @jobs.select { |s| s.status == nil }
+    report_on = @jobs.select { |s| s.status == 0 || s.status == 1 }
+    index = ERB.new  File.read(File.dirname(__FILE__)+"/index.html.erb")
+    bucket_name = "virtual_monkey"
+
+    ## upload to s3
+    # setup credentials in ~/.fog
+    s3 = Fog::AWS::Storage.new(:aws_access_key_id => Fog.credentials[:aws_access_key_id_test], :aws_secret_access_key => Fog.credentials[:aws_secret_access_key_test])
+    if directory = s3.directories.detect { |d| d.key == bucket_name } 
+      puts "found directory, re-using"
+    else
+      directory = s3.directories.create(:key => bucket_name)
+    end
+    raise 'could not create directory' unless directory
+    s3.put_object(bucket_name, "#{@log_started}/index.html", index.result(binding), 'x-amz-acl' => 'public-read', 'Content-Type' => 'text/html')
+ 
+    report_on.each do |j|
+      begin
+        done = 0
+        s3.put_object(bucket_name, "#{@log_started}/#{File.basename(j.logfile)}", IO.read(j.logfile), 'Content-Type' => 'text/plain', 'x-amz-acl' => 'public-read')
+        s3.put_object(bucket_name, "#{@log_started}/#{File.basename(j.rest_log)}", IO.read(j.rest_log), 'Content-Type' => 'text/plain', 'x-amz-acl' => 'public-read')
+        done = 1
+      rescue Exception => e
+        unless e.message =~ /Bad file descriptor/i
+          raise e
+        end
+        sleep 1
+      end while not done
+    end
+    
+    msg = <<END_OF_MESSAGE
+    new results avilable at http://s3.amazonaws.com/#{bucket_name}/#{@log_started}/index.html\n-OR-\nin #{@log_dir}/index.html"
+END_OF_MESSAGE
+    puts msg
+  end
+  
+  def report_lost_deployments(jobs = {})
+    running_change = jobs[:old_running] - jobs[:running]
+    passed_change = jobs[:passed] - jobs[:old_passed]
+    failed_change = jobs[:failed] - jobs[:old_failed]
+    lost_jobs = running_change - passed_change - failed_change
+    lost_jobs.each do |j|
+      puts "LOST JOB---------------------------------"
+      puts "Deployment Name: #{j.deployment.nickname}"
+      puts "Status Code: #{j.status}"
+      puts "Audit Entries: #{j.link_to_rightscale}"
+      puts "Log File: #{j.logfile}"
+      puts "Rest_Connection Log File: #{j.rest_log}"
+      puts "-----------------------------------------"
+    end
+  end
+end
+

data/lib/virtualmonkey/deployment_monk.rb

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'rest_connection'
+
+class DeploymentMonk
+  attr_accessor :common_inputs
+  attr_accessor :variables_for_cloud
+  attr_accessor :deployments
+  attr_reader :tag
+
+  def from_tag
+    variations = Deployment.find_by(:nickname) {|n| n =~ /^#{@tag}/ }
+    puts "loading #{variations.size} deployments matching your tag"
+    return variations
+  end
+
+  def initialize(tag, server_templates = [], extra_images = [])
+    @clouds = ["1","2","3","4", "232"]
+    @cloud_names = { "1" => "ec2-east", "2" => "ec2-eu", "3" => "ec2-west", "4" => "ec2-ap", "232" => "rackspace"}
+    @tag = tag
+    @deployments = from_tag
+    @server_templates = []
+    @common_inputs = {}
+    @variables_for_cloud = {}
+    raise "Need either populated deployments or passed in server_template ids" if server_templates.empty? && @deployments.empty?
+    if server_templates.empty?
+      puts "loading server templates from servers in the first deployment"
+      @deployments.first.servers.each do |s|
+        server_templates << s.server_template_href.split(/\//).last.to_i
+      end
+    end
+    server_templates.each do |st|
+      @server_templates << ServerTemplate.find(st.to_i)
+    end
+
+    @image_count = 0
+    @server_templates.each do |st|
+      new_st = ServerTemplateInternal.new(:href => st.href)
+      st.multi_cloud_images = new_st.multi_cloud_images
+      @image_count = st.multi_cloud_images.size if st.multi_cloud_images.size > @image_count
+    end
+  end
+
+  def generate_variations(options = {})
+    if options[:mci_override] && !options[:mci_override].empty?
+      @image_count = options[:mci_override].size
+    end
+    @image_count.times do |index|
+      @clouds.each do |cloud|
+        if @variables_for_cloud[cloud] == nil
+          puts "variables not found for cloud #{cloud} skipping.."
+          next
+        end
+        dep_tempname = "#{@tag}-#{@cloud_names[cloud]}-#{rand(1000000)}-"
+        dep_image_list = []
+        new_deploy = Deployment.create(:nickname => dep_tempname)
+        @deployments << new_deploy
+        @server_templates.each do |st|
+          server_params = { :nickname => "tempserver-#{rand(1000000)}-#{st.nickname}", 
+                            :deployment_href => new_deploy.href, 
+                            :server_template_href => st.href, 
+                            :cloud_id => cloud
+                            #:ec2_image_href => image['image_href'], 
+                            #:instance_type => image['aws_instance_type'] 
+                          }
+          
+          server = Server.create(server_params.merge(@variables_for_cloud[cloud]))
+          # since the create call does not set the parameters, we need to set them separate
+          if server.respond_to?(:set_inputs)
+            server.set_inputs(@variables_for_cloud[cloud]['parameters'])
+          else
+            @variables_for_cloud[cloud]['parameters'].each do |key,val|
+              server.set_input(key,val)
+            end
+          end
+         
+          # uses a special internal call for setting the MCI on the server
+          if options[:mci_override] && !options[:mci_override].empty?
+            use_this_image = options[:mci_override][index]
+            dep_image_list << MultiCloudImage.find(options[:mci_override][index]).name.gsub(/ /,'_')
+          elsif st.multi_cloud_images[index]
+            dep_image_list << st.multi_cloud_images[index]['name'].gsub(/ /,'_')
+            use_this_image = st.multi_cloud_images[index]['href']
+          else
+            use_this_image = st.multi_cloud_images[0]['href']
+          end
+          #RsInternal.set_server_multi_cloud_image(server.href, use_this_image)
+          sint = ServerInternal.new(:href => server.href)
+          sint.set_multi_cloud_image(use_this_image)
+
+          # finally, set the spot price
+          unless options[:no_spot]
+            server.reload
+            server.settings
+            if server.ec2_instance_type =~ /small/ 
+              server.max_spot_price = "0.085"
+            elsif server.ec2_instance_type =~ /large/
+              server.max_spot_price = "0.38"
+            end
+            server.pricing = "spot"
+            server.parameters = {}
+            server.save
+          end
+        end
+        new_deploy.nickname = dep_tempname + dep_image_list.uniq.join("_AND_")
+        new_deploy.save
+        @common_inputs.each do |key,val|
+          new_deploy.set_input(key,val)
+        end
+      end
+    end
+  end
+
+  def load_common_inputs(file)
+    @common_inputs.merge! JSON.parse(IO.read(file))
+  end
+
+  def destroy_all
+    @deployments.each do |v|
+      v.reload
+      v.servers.each { |s| s.stop }
+    end 
+    @deployments.each { |v| v.destroy }
+    @deployments = []
+  end
+
+  def get_deployments
+    deployments = []
+    @deployments.each { |v| deployments << v.nickname }
+    deployments 
+  end
+
+end