rhc 1.14.7 → 1.15.6

data/features/lib/rhc_helper/cartridge.rb

@@ -1,97 +0,0 @@
-require 'rhc/rest'
-
-module RHCHelper
-  #
-  # A class to help maintain the state from rhc calls and helper
-  # methods around cartridge management.
-  #
-  class Cartridge
-    extend Runnable
-    extend Commandify
-    extend Persistable
-    include Loggable
-    include Runnable
-    include Httpify
-    include Persistify
-
-    # attributes to represent the general information of the cartridge
-    attr_accessor :name
-
-    # Create the data structure for a test cartridge
-    def initialize(app, name)
-      @name = name
-      @app_name = app.name unless app.nil?
-      @hostname = "#{@app_name}-#{$namespace}.#{$domain}"
-      @file = "#{TEMP_DIR}/#{$namespace}.json"
-    end
-
-    def rhc_cartridge(cmd)
-      full_cmd = "rhc cartridge #{cmd} -l #{$username} -p #{$password} #{@app_name ? "-a #{@app_name}" : ""}"
-      full_cmd += " #{@name}" if cmd != "list"
-      run(full_cmd, nil) do |exitstatus, out, err, arg|
-        yield exitstatus, out, err, arg if block_given?
-      end
-    end
-
-    def self.list
-      rhc_cartridge_list do |exitstatus, out, err, arg|
-        return [exitstatus, out, err, arg]
-      end
-    end
-
-    def add
-      rhc_cartridge('add') do |exitstatus, out, err, arg|
-        yield exitstatus, out, err, arg if block_given?
-      end
-    end
-
-    def status
-      result = ""
-      rhc_cartridge('status') do |exitstatus, out, err, arg|
-        result = out
-      end
-
-      result
-    end
-
-    def start
-      rhc_cartridge('start')
-    end
-
-    def stop
-      rhc_cartridge('stop')
-    end
-
-    def restart
-      rhc_cartridge('restart')
-    end
-
-    def remove
-      rhc_cartridge('remove --confirm')
-    end
-
-    def scale(values)
-      status = nil
-      rhc_cartridge("scale #{values}") do |exitstatus, out, err, arg|
-        status = exitstatus
-      end
-      status
-    end
-
-    def storage(cartridge, args)
-      output = nil
-      rhc_cartridge("storage #{cartridge} #{args}") do |exitstatus, out, err, arg|
-        output = out.split(" ")[-1]
-      end
-      output
-    end
-
-    def show
-      result = ""
-      rhc_cartridge('show') do |exitstatus, out, err, arg|
-        result = out
-      end
-      result
-    end
-  end
-end

data/features/lib/rhc_helper/commandify.rb

@@ -1,251 +0,0 @@
-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]) || block
-
-        # Add arguments to the command
-        cmd << get_args(cmd, args[0])
-
-        exitcode = nil
-        # Run the command, timing it
-        time = Benchmark.realtime do
-          exitcode = run(cmd, args[0], &cmd_callback)
-        end
-
-        # if there is a callback let it take care of validating the results
-        exitcode.should == 0 unless cmd_callback
-
-        # 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')
-      cmd.gsub!('show gears', 'show --gears')
-
-      cmd
-    end
-
-    # Print out the command arguments based on the state of the application instance
-    def get_args(cmd, arg0=nil, debug=true)
-      args = " "
-      args << "-l #{$username} "
-      args << "-p \"#{$password}\" "
-      args << "--debug " 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 /app delete/
-          args << "--confirm "
-        when /domain list/
-          # domain list doesn't take arguments
-        when /domain show/
-          # domain show doesn't take arguments
-        when /domain update/
-          args << "#{$old_namespace} #{$namespace}"
-        when /domain /
-          raise "No namespace set" unless $namespace
-          # use legacy switch for specifying namespace to verify older interface
-          # should switch to using argument once all commands are moved over
-          args << "#{$namespace} "
-        when /snapshot/
-          args << "-f #{@snapshot} "
-        when /create/
-          args << "-r #{@repo} "
-          args << "-t #{@type} "
-          args << "-s " unless @scalable.nil?
-          args << "-g #{@gear_profile} " unless @gear_profile.nil?
-          args << "--noprompt "
-        when /add-alias/
-          raise "No alias set" unless @alias
-          args << "--alias #{@alias} "
-        when /cartridge/
-          args << "-c #{arg0}" if arg0
-        when /sshkey/
-          # in RHCHelper::Sshkey, we pass *args to method_missing here, so that
-          # we _know_ that arg0 is an Array.
-          args << arg0.first if arg0.first
-        when /env/
-          args << arg0.first if arg0.first
-      end
-
-      args.rstrip.gsub(/([\\\$])/, "\\\\\\1")
-    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 UUID output from the create app results
-  UUID_OUTPUT_PATTERN = /UUID\s*(?:\:|=)\s*(.+)/i unless const_defined?(:UUID_OUTPUT_PATTERN)
-  # The regex to parse the Gear Profile output from the create app results
-  GEAR_PROFILE_OUTPUT_PATTERN = /Gear Size\s*(?:\:|=)\s*(\w+)/m unless const_defined?(:GEAR_PROFILE_OUTPUT_PATTERN)
-
-  #
-  # Begin Post Processing Callbacks
-  #
-  def app_create_callback(exitcode, stdout, stderr, arg)
-    stdout.should =~ /Your application '([^']+)' is now available./
-
-    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
-
-  def domain_callback(exitcode, stdout, stderr, arg)
-    @domain_output = stdout
-  end
-
-  def domain_list_callback(exitcode, stdout, stderr, arg)
-    @domain_list_output = stdout
-  end
-
-  def domain_show_callback(exitcode, stdout, stderr, arg)
-    @domain_show_output = stdout
-  end
-
-  def domain_create_callback(exitcode, stdout, stderr, arg)
-    @exitcode = exitcode
-  end
-
-  def domain_update_callback(exitcode, stdout, stderr, arg)
-    @exitcode = exitcode
-  end
-
-  def domain_delete_callback(exitcode, stdout, stderr, arg)
-    @exitcode = exitcode
-  end
-
-  def sshkey_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def sshkey_add_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def sshkey_list_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def sshkey_show_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def sshkey_update_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def sshkey_delete_callback(exitcode, stdout, stderr, arg)
-    @sshkey_output = stdout
-    @exitcode = exitcode
-  end
-
-  def env_list_callback(exitcode, stdout, stderr, arg)
-    @env_output = stdout
-    @exitcode = exitcode
-  end
-
-  def env_show_callback(exitcode, stdout, stderr, arg)
-    @env_output = stdout
-    @exitcode = exitcode
-  end
-
-  def env_set_callback(exitcode, stdout, stderr, arg)
-    @env_output = stdout
-    @exitcode = exitcode
-  end
-
-  def env_unset_callback(exitcode, stdout, stderr, arg)
-    @env_output = stdout
-    @exitcode = exitcode
-  end
-
-end

data/features/lib/rhc_helper/domain.rb

@@ -1,65 +0,0 @@
-require 'rhc/rest'
-
-module RHCHelper
-  #
-  # A class to help maintain the state from rhc calls
-  #
-  class Domain
-    extend Runnable
-    extend Commandify
-    extend API
-
-    class << self
-      attr_reader :domain_output, :domain_list_output, :domain_show_output, :exitcode
-    end
-
-    def self.unique_namespace(prefix)
-      # TODO:  Due to DNS changes with the model refactor,
-      #        the namespace is not checked here - see #reserved?
-      chars = ("1".."9").to_a
-      prefix + Array.new(8, '').collect{chars[rand(chars.size)]}.join
-    end
-
-    def self.create_if_needed(prefix="test")
-      unless $namespace
-        client = new_client
-        domain = client.domains.first
-        if domain
-          $namespace = domain.id
-        else
-          $namespace = unique_namespace(prefix)
-          # Create the domain
-          rhc_domain_create
-        end
-      end
-    end
-
-    def self.create
-      rhc_domain_create
-    end
-
-    def self.delete
-      rhc_domain_delete
-      $namespace = nil
-    end
-
-    def self.update(prefix="update")
-      $old_namespace = $namespace
-      $namespace = unique_namespace(prefix)
-      rhc_domain_update
-
-      if @exitcode == 0
-      else
-        $namespace = $old_namespace
-      end
-    end
-
-    def self.reserved?(namespace=$namespace)
-      # With the recent model refactoring, we no longer create
-      # TXT DNS records.
-      # Here, we return 'true', since this is the only code that is
-      # used in 'Then' clauses of 2 Cucumber scenarios.
-      true
-    end
-  end
-end

data/features/lib/rhc_helper/env.rb

@@ -1,29 +0,0 @@
-require "rhc/rest"
-
-module RHCHelper
-
-  class Env
-    extend Runnable
-    extend Commandify
-
-    class << self
-      attr_accessor :env_output, :exitcode
-    end
-
-    def self.list(*args)
-      rhc_env_list args
-    end
-
-    def self.show(*args)
-      rhc_env_show args
-    end
-
-    def self.set(*args)
-      rhc_env_set args
-    end
-
-    def self.unset(*args)
-      rhc_env_unset args
-    end
-  end
-end

data/features/lib/rhc_helper/httpify.rb

@@ -1,186 +0,0 @@
-require 'rubygems'
-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 do_http(options)
-      # Generate the URL if it doesn't exist
-      options[:url] ||= "http%s://%s" % [options[:use_https] ? 's' : '', hostname]
-
-      # Set some default options
-      http_defaults = {
-        :method   => :head,
-        :host     => nil,
-        :expected => Net::HTTPSuccess,
-        :sleep    => 5,
-        :timeout  => 1200,
-        :http_timeout => 30,
-        :follow_redirects => true,
-        :redirects => 0,
-        :max_redirects => 10
-      }
-      options = http_defaults.merge(options)
-
-      # Parse the URI
-      uri = URI.parse(options[:url])
-      # Start with a nil response
-      response = nil
-
-      # Set some headers
-      headers = {}
-      headers['Host'] = host if options[:host]
-
-      # Keep retrying, and let Ruby handle the timeout
-      start   = Time.now
-
-      # Helper function to log message and sleep
-      def my_sleep(status,expected,start,options)
-        [
-          ["Expecting", expected.class],
-          ["Received", status.class ],
-          ["Elapsed", Time.now - start ],
-        ].each do |values|
-            logger.info "%10s: %s" % values
-          end
-        sleep options[:sleep]
-      end
-
-      expected = options[:expected]
-      expected = (expected.to_s =~ /^Net/) ? expected.new(nil,nil,nil) : expected.new
-
-      begin
-        timeout(options[:timeout]) do
-          loop do
-            logger.debug "HTTP_CHECK: Requesting: #{uri}"
-            # Send the HTTP request
-            response = begin
-                         http = http_instance(uri,options[:http_timeout])
-                         http.send_request(
-                           options[:method].to_s.upcase, # Allow options to be a symbol
-                           uri.request_uri, nil, headers
-                         )
-                       rescue Exception => e
-                         # Pass these up so we can check them
-                         e
-                       end
-            logger.debug "HTTP_CHECK: Response: #{response.class}"
-            case response
-              # Catch any response if we're expecting it or redirection
-            when expected.class, Net::HTTPRedirection
-              break
-              # Retry these responses
-            when Net::HTTPServiceUnavailable, SocketError, Timeout::Error
-              logger.debug "HTTP_CHECK: Error #{response.message}"
-              my_sleep(response,expected,start,options)
-            else
-              case expected
-              when Net::HTTPServiceUnavailable
-                my_sleep(response,expected,start,options)
-              else
-                break
-              end
-            end
-          end
-        end
-      rescue Timeout::Error => e
-        puts "Did not receive an acceptable response in %d seconds" % options[:timeout]
-      end
-
-      # Test to see if we should follow redirect
-      if options[:follow_redirects] && response.is_a?(Net::HTTPRedirection) && !(response.is_a?(options[:expected]))
-        logger.debug "Response was a redirect, we will attempt to follow"
-        logger.debug "We've been redirected #{options[:redirects]} times"
-        if options[:redirects] < options[:max_redirects]
-          options[:redirects] += 1
-          response = do_http(options.merge({
-            :url => response.header['location']
-          }))
-        else
-          logger.debug "Too many redirects"
-        end
-      end
-
-      return response
-    end
-
-    def is_inaccessible?(options = {})
-      check_response(options.merge({
-        :expected => Net::HTTPServiceUnavailable,
-        :http_timeout => 2,
-        :timeout => 60,
-      }))
-    end
-
-    def is_accessible?(options = {})
-      check_response(options.merge({
-        :expected => Net::HTTPSuccess,
-        :http_timeout => 20,
-        :timeout => 180,
-      }))
-    end
-
-    def doesnt_exist?
-      check_response({
-        :expected => SocketError,
-      }) do |response|
-          return !(response.is_a?(Net::HTTPSuccess))
-        end
-    end
-
-    def check_response(options)
-      response = do_http(options)
-
-      if block_given?
-        # Use the custom check for this response
-        yield response
-      else
-        # Compare the response against :expected or Net::HTTPSuccess
-        response.is_a?(options[:expected] || Net::HTTPSuccess)
-      end
-    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
-
-      response = do_http({
-        :method => :get,
-        :url => url,
-        :http_timeout => 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 / #{url}")
-        return nil
-      end
-    end
-  end
-end