rhc 0.94.8 → 0.95.13

data/features/lib/rhc_helper/commandify.rb

@@ -0,0 +1,154 @@
+require 'benchmark'
+require 'fileutils'
+
+module RHCHelper
+  module Commandify
+    # Implements a method missing approach that will convert calls
+    # like rhc_app_create into 'rhc app create' on the command line
+    def method_missing(sym, *args, &block)
+      if sym.to_s.start_with?("rhc")
+        # Build up the command
+        cmd = get_cmd(sym)
+
+        # Get any blocks that should be run after processing
+        cmd_callback = get_cmd_callback(cmd, args[0])
+
+        # Add arguments to the command
+        cmd << get_args(cmd, args[0])
+
+        # Run the command, timing it
+        time = Benchmark.realtime do
+          run(cmd, args[0], &cmd_callback).should == 0
+        end
+
+        # Log the benchmarking info
+        perf_logger.info "#{time} #{sym.to_s.upcase} #{$namespace} #{$login}"
+      else
+        super(sym, *args, &block)
+      end
+    end
+
+    # Given a method name, convert to an equivalent
+    # rhc command line string.  This method handles
+    # exceptions like converting rhc_app_add_alias
+    # to rhc app add-alias.
+    def get_cmd(method_sym)
+      cmd = method_sym.to_s.gsub('_', ' ')
+
+      # Handle parameters with a dash
+      cmd.gsub!('add alias', 'add-alias')
+      cmd.gsub!('remove alias', 'remove-alias')
+      cmd.gsub!('force stop', 'force-stop')
+
+      return cmd
+    end
+
+    # Print out the command arguments based on the state of the application instance
+    def get_args(cmd, cartridge=nil, debug=true)
+      args = " "
+      args << "-l #{$username} "
+      args << "-p #{$password} "
+      args << "-d " if debug
+
+      # Add the application name for all application commands
+      if cmd =~ /app/
+        raise "No application name" unless @name
+        args << "-a #{@name} "
+      end
+
+      # Command specific arguments
+      case cmd
+        when /domain/
+          raise "No namespace set" unless $namespace
+          args << "-n #{$namespace} "
+        when /destroy/
+          args << "-b "
+        when /snapshot/
+          args << "-f #{@snapshot} "
+        when /create/
+          args << "-r #{@repo} "
+          args << "-t #{@type} "
+        when /add-alias/
+          raise "No alias set" unless @alias
+          args << "--alias #{@alias} "
+        when /cartridge/
+          raise "No cartridge supplied" unless cartridge
+          args << "-c #{cartridge}"
+      end
+
+      args.rstrip
+    end
+
+    # This looks for a callback method that is defined for the command.
+    # For example, a command with rhc_app_create_callback will match
+    # and be returned for the 'rhc app create' command.  The most specific
+    # callback will be matched, so rhc_app_create_callback being more
+    # specific than rhc_app_callback.
+    def get_cmd_callback(cmd, cartridge=nil)
+      # Break the command up on spaces
+      cmd_parts = cmd.split
+      
+      # Drop the 'rhc' portion from the array
+      cmd_parts.shift
+
+      # Look for a method match ending in _callback
+      cmd_parts.length.times do
+        begin
+          # Look for a callback match and return on any find
+          return method((cmd_parts.join("_") + "_callback").to_sym)
+        rescue NameError
+          # Remove one of the parts to see if there is a more
+          # generic match defined
+          cmd_parts.pop
+        end
+      end
+
+      return nil
+    end
+  end
+
+  # The regex to parse the ssh output from the create app results
+  SSH_OUTPUT_PATTERN = %r|ssh://([^@]+)@([^/]+)|
+
+  #
+  # Begin Post Processing Callbacks
+  #
+  def app_create_callback(exitcode, stdout, stderr, arg)
+    match = stdout.split.map {|line| line.match(SSH_OUTPUT_PATTERN)}.compact[0]
+    @uid = match[1] if match
+    raise "UID not parsed from app create output" unless @uid
+    persist
+  end
+
+  def app_destroy_callback(exitcode, stdout, stderr, arg)
+    FileUtils.rm_rf @repo
+    FileUtils.rm_rf @file
+    @repo, @file = nil
+  end
+
+  def cartridge_add_callback(exitcode, stdout, stderr, cartridge)
+    if cartridge.start_with?('mysql-')
+      @mysql_hostname = /^Connection URL: mysql:\/\/(.*)\/$/.match(stdout)[1]
+      @mysql_user = /^ +Root User: (.*)$/.match(stdout)[1]
+      @mysql_password = /^ +Root Password: (.*)$/.match(stdout)[1]
+      @mysql_database = /^ +Database Name: (.*)$/.match(stdout)[1]
+
+      @mysql_hostname.should_not be_nil
+      @mysql_user.should_not be_nil
+      @mysql_password.should_not be_nil
+      @mysql_database.should_not be_nil
+    end
+
+    @embed << cartridge
+    persist
+  end
+
+  def cartridge_remove_callback(exitcode, stdout, stderr, cartridge)
+    @mysql_hostname = nil
+    @mysql_user = nil
+    @mysql_password = nil
+    @mysql_database = nil
+    @embed.delete(cartridge)
+    persist
+  end
+end

data/features/lib/rhc_helper/domain.rb

@@ -0,0 +1,50 @@
+require 'dnsruby'
+require 'rhc-rest'
+
+module RHCHelper
+  #
+  # A class to help maintain the state from rhc calls
+  #
+  class Domain
+    extend Runnable
+    extend Commandify
+    include Dnsruby
+
+    def self.create_if_needed(prefix="test")
+      unless $namespace
+        loop do
+          # Loop until we find a unique namespace
+          chars = ("1".."9").to_a
+          namespace = prefix + Array.new(8, '').collect{chars[rand(chars.size)]}.join
+
+          # No retries on reservation check
+          unless reserved?(namespace)
+            # Set the global namespace
+            $namespace = namespace
+
+            # Create the domain
+            rhc_domain_create
+
+            # Write the new domain to a file in the temp directory
+            File.open(File.join(RHCHelper::TEMP_DIR, 'namespace'), 'w') do |f| 
+              f.write(namespace)
+            end
+
+            break
+          end
+        end
+      end
+    end
+
+    def self.reserved?(namespace=$namespace)
+      # If we get a response, then the namespace is reserved
+      # An exception means that it is available
+      begin
+        Dnsruby::Resolver.new.query("#{namespace}.#{$domain}", Dnsruby::Types::TXT)
+        return true
+      rescue
+        return false
+      end
+    end
+  end
+end

data/features/lib/rhc_helper/httpify.rb

@@ -0,0 +1,107 @@
+require 'uri'
+require 'net/https'
+require 'ostruct'
+
+module RHCHelper
+  module Httpify
+    include Loggable
+
+    # attributes that contain statistics based on calls to connect
+    attr_accessor :response_code, :response_time
+
+    def http_instance(uri, timeout=30)
+      proxy = ENV['http_proxy'] ? URI.parse(ENV['http_proxy']) : OpenStruct.new
+      http = Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port)
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      if (uri.scheme == "https")
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      return http.start
+    end
+
+    def http_get(url, timeout=30)
+      uri = URI.parse(url)
+      http = http_instance(uri, timeout)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      http.request(request)
+    end
+    
+    def http_head(url, host=nil, follow_redirects=true)
+      uri = URI.parse(url)
+      http = http_instance(uri)
+      request = Net::HTTP::Head.new(uri.request_uri)
+      request["Host"] = host if host
+      response = http.request(request)
+      
+      if follow_redirects and response.is_a?(Net::HTTPRedirection)
+        return http_head(response.header['location'])
+      else
+        return response
+      end
+    end
+
+    def is_inaccessible?(max_retries=120)
+      max_retries.times do |i|
+        begin
+          if http_head("http://#{hostname}").is_a? Net::HTTPServerError
+            return true
+          else
+            logger.info("Connection still accessible / retry #{i} / #{hostname}")
+            sleep 1
+          end
+        rescue
+          return true
+        end
+      end
+      return false
+    end
+
+    def is_accessible?(use_https=false, max_retries=120, host=nil)
+      prefix = use_https ? "https://" : "http://"
+      url = prefix + hostname
+
+      max_retries.times do |i|
+        begin
+          if http_head(url, host).is_a? Net::HTTPSuccess
+            return true
+          else
+            logger.info("Connection still inaccessible / retry #{i} / #{url}")
+            sleep 1
+          end
+        rescue SocketError
+          logger.info("Connection still inaccessible / retry #{i} / #{url}")
+          sleep 1
+        end
+      end
+
+      return false
+    end
+
+    def connect(use_https=false, max_retries=30)
+      prefix = use_https ? "https://" : "http://"
+      url = prefix + hostname
+
+      logger.info("Connecting to #{url}")
+      beginning_time = Time.now
+
+      max_retries.times do |i|
+        response = http_get(url, 1)
+
+        if response.is_a? Net::HTTPSuccess
+          @response_code = response.code
+          @response_time = Time.now - beginning_time
+          logger.info("Connection result = #{@response_code} / #{url}")
+          logger.info("Connection response time = #{@response_time} / #{url}")
+          return response.body
+        else
+          logger.info("Connection failed / retry #{i} / #{url}")
+          sleep 1
+        end
+      end
+
+      return nil
+    end
+  end
+end

data/features/lib/rhc_helper/loggable.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module RHCHelper
+  module Loggable
+    PASSWORD_REGEX = / -p [^\s]* /
+
+    def logger
+      Loggable.logger
+    end
+
+    def perf_logger
+      Loggable.perf_logger
+    end
+
+    def self.logger
+      @logger ||= Logger.new($stdout)
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+      original_formatter = Logger::Formatter.new
+      @logger.formatter = proc { |severity, datetime, progname, msg|
+        # Filter out any passwords
+        filter_msg = msg.gsub(PASSWORD_REGEX, " -p ***** ") 
+
+        # Format with the original formatter
+        original_formatter.call(severity, datetime, progname, filter_msg)
+      }
+    end
+
+    def self.perf_logger
+      @perf_logger ||= Logger.new($stdout)
+    end
+
+    def self.perf_logger=(logger)
+      @perf_logger = logger
+    end
+  end
+end

data/features/lib/rhc_helper/persistable.rb

@@ -0,0 +1,38 @@
+require 'active_support/json'
+require 'active_support/core_ext/object/to_json'
+
+module RHCHelper
+  module Persistable
+    include ActiveSupport::JSON
+    include Loggable
+
+    def find_on_fs
+      Dir.glob("#{RHCHelper::TEMP_DIR}/*.json").collect {|f| App.from_file(f)}
+    end
+
+    def from_file(filename)
+      App.from_json(ActiveSupport::JSON.decode(File.open(filename, "r") {|f| f.readlines}[0]))
+    end
+
+    def from_json(json)
+      app = App.new(json['type'], json['name'])
+      app.embed = json['embed']
+      app.mysql_user = json['mysql_user']
+      app.mysql_password = json['mysql_password']
+      app.mysql_hostname = json['mysql_hostname']
+      app.uid = json['uid']
+      return app
+    end
+  end
+
+  module Persistify
+    include ActiveSupport::JSON
+
+    attr_accessor :file
+
+    def persist
+      json = self.to_json(:except => [:logger, :perf_logger])
+      File.open(@file, "w") {|f| f.puts json}
+    end
+  end
+end

data/features/lib/rhc_helper/runnable.rb

@@ -0,0 +1,41 @@
+require 'open4'
+require 'timeout'
+
+module RHCHelper
+  module Runnable
+    include Loggable
+
+    def run(cmd, arg=nil, input=[])
+      logger.info("Running: #{cmd}")
+
+      exit_code = -1
+      output = nil
+
+      # Don't let a command run more than 5 minutes
+      Timeout::timeout(500) do
+        pid, stdin, stdout, stderr = Open4::popen4 cmd
+        input.each {|line| stdin.puts line}
+        stdin.close
+
+        # Block until the command finishes
+        ignored, status = Process::waitpid2 pid
+        out = stdout.read.strip
+        err = stderr.read.strip
+        stdout.close
+        stderr.close
+        logger.debug("Standard Output:\n#{out}")
+        logger.debug("Standard Error:\n#{err}")
+
+        # Allow a caller to pass in a block to process the output
+        yield status.exitstatus, out, err, arg if block_given?
+        exit_code = status.exitstatus
+      end
+
+      if exit_code != 0
+        logger.error("(#{$$}): Execution failed #{cmd} with exit_code: #{exit_code.to_s}")
+      end
+
+      return exit_code
+    end
+  end
+end

data/features/lib/rhc_helper.rb

@@ -0,0 +1,7 @@
+require 'rhc_helper/loggable'
+require 'rhc_helper/commandify'
+require 'rhc_helper/httpify'
+require 'rhc_helper/persistable'
+require 'rhc_helper/runnable'
+require 'rhc_helper/app'
+require 'rhc_helper/domain'

data/features/step_definitions/application_steps.rb

@@ -0,0 +1,99 @@
+require 'fileutils'
+require 'rhc/config'
+
+include RHCHelper
+
+Given /^an existing (.+) application with an embedded (.*) cartridge$/ do |type, embed|
+  App.find_on_fs.each do |app|
+    if app.type == type and app.embed.include?(embed)
+      @app = app
+      break
+    end
+  end
+
+  @app.should_not be_nil, 'No existing applications w/cartridges found.  Check the creation scenarios for failures.'
+end
+
+Given /^an existing (.+) application with embedded (.*) and (.*) cartridges$/ do |type, embed_1, embed_2|
+  App.find_on_fs.each do |app|
+    if app.type == type and app.embed.include?(embed_1) and app.embed.include?(embed_2)
+      @app = app
+      break
+    end
+  end
+
+  @app.should_not be_nil, 'No existing applications w/cartridges found.  Check the creation scenarios for failures.'
+end
+
+Given /^an existing (.+) application( without an embedded cartridge)?$/ do |type, ignore|
+  App.find_on_fs.each do |app|
+    if app.type == type and app.embed.empty?
+      @app = app
+      break
+    end
+  end
+
+  @app.should_not be_nil, 'No existing applications found.  Check the creation scenarios for failures.'
+end
+
+When /^(\d+) (.+) applications are created$/ do |app_count, type|
+  @apps = app_count.to_i.times.collect do
+    app = App.create_unique(type)
+    app.rhc_app_create
+    app
+  end
+end
+
+When /^the application is stopped$/ do
+  @app.rhc_app_stop
+end
+
+When /^the application is started$/ do
+  @app.rhc_app_start
+end
+
+When /^the application is restarted$/ do
+  @app.rhc_app_restart
+end
+
+When /^the application is destroyed$/ do
+  @app.rhc_app_destroy
+end
+
+When /^the application is snapshot$/ do
+  @snapshot = File.join(RHCHelper::TEMP_DIR, "snapshot.tar.gz")
+  @app.snapshot = @snapshot
+  @app.rhc_app_snapshot_save
+end
+
+When /^the application is shown$/ do
+  @app.rhc_app_show
+end
+
+When /^the application is tidied$/ do
+  @app.rhc_app_tidy
+end
+
+Then /^the snapshot should be found$/ do
+  File.exist?(@snapshot).should be_true
+  (File.size(@snapshot) > 0).should be_true
+end
+
+Then /^the applications should be accessible?$/ do
+  @apps.each do |app|
+    app.is_accessible?.should be_true
+    app.is_accessible?(true).should be_true
+  end
+end
+
+Then /^the application should be accessible$/ do
+  @app.is_accessible?.should be_true
+  @app.is_accessible?(true).should be_true, "Application was not accessible and should be"
+end
+
+Then /^the application should not be accessible$/ do
+  @app.is_inaccessible?.should be_true, "Application was still accessible when it shouldn't be"
+end
+
+Then /^it should succeed$/ do
+end

data/features/step_definitions/cartridge_steps.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require 'rhc/config'
+
+include RHCHelper
+
+When /^the (.+) cartridge is added$/ do |name|
+  @app.add_cartridge name
+end
+
+When /^the (.+) cartridge is stopped$/ do |name|
+  @app.cartridge(name).stop
+end
+
+When /^the (.+) cartridge is restarted$/ do |name|
+  @app.cartridge(name).restart
+end
+
+When /^the (.+) cartridge is started$/ do |name|
+  @app.cartridge(name).start
+end
+
+When /^the (.+) cartridge is removed$/ do |name|
+  @app.remove_cartridge name
+end
+
+Then /^the (.+) cartridge should be running$/ do |name|
+  @app.cartridge(name).status.should match("RESULT:\n(.+) is running|RESULT:\n(\n|.)+Uptime:")
+end
+
+Then /^the (.+) cartridge should be stopped$/ do |name|
+  @app.cartridge(name).status.should match("RESULT:\n(.+) stopped")
+end
+
+Then /^the (.+) cartridge should be removed$/ do |name|
+  # for some reason the server returns Success when cart does not exist
+  @app.cartridge(name).status.should match("RESULT:\n(.*)Success")
+end
+
+
+Then /^adding the (.+) cartridge should fail$/ do |name|
+  @app.add_cartridge(name).should == 1
+end

data/features/step_definitions/client_steps.rb

@@ -0,0 +1,32 @@
+# Cross-platform way of finding an executable in the $PATH.
+#
+#   which('ruby') #=> /usr/bin/ruby
+#
+#   Solution found at: http://bit.ly/8dKQsa
+#
+def which(cmd)
+  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+    exts.each { |ext|
+      exe = "#{path}/#{cmd}#{ext}"
+      return exe if File.executable? exe
+    }
+  end
+  return nil
+end
+
+Given /^the libra client tools$/ do
+  which('rhc').should_not be_nil
+end
+
+When /^the setup wizard is run$/ do
+  RHCHelper::App.rhc_setup
+
+  # Force a refresh of the loaded RHC state
+  RHC::Config.initialize
+end
+
+Then /^the client tools should be setup$/ do
+  RHC::Config.should_run_wizard?.should be_false, "Wizard still thinks it needs to be run"
+end
+

data/features/step_definitions/domain_steps.rb

@@ -0,0 +1,19 @@
+include RHCHelper
+When /^a new domain is needed and created$/ do
+  Domain.create_if_needed
+end
+
+Then /^the domain should be reserved?$/ do
+  # Sleep to allow DNS to propogate
+  sleep 5
+
+  # Check for up to a minute
+  resolved = false
+  120.times do
+    resolved = Domain.reserved?
+    break if resolved
+    sleep 1
+  end
+
+  resolved.should be_true, 'Not able to lookup DNS TXT record in time.'
+end