rhc 0.97.17 → 0.98.16

data/features/lib/rhc_helper/domain.rb

@@ -1,5 +1,5 @@
 require 'dnsruby'
-require 'rhc-rest'
+require 'rhc/rest'
 
 module RHCHelper
   #
@@ -38,6 +38,10 @@ module RHCHelper
       end
     end
 
+    def self.create
+      rhc_domain_create
+    end
+
     def self.delete
       rhc_domain_delete
       $namespace = nil

data/features/lib/rhc_helper/httpify.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'uri'
 require 'net/https'
 require 'ostruct'
@@ -21,62 +22,125 @@ module RHCHelper
       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
+    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(start,uri,e,options)
+        err_str = "Connection inacessible for %s (%s) - %.2f seconds"
+        logger.info(err_str % [uri,e.class,Time.now - start])
+        logger.info "Sleeping for %d seconds, retrying" % options[:sleep]
+        sleep options[:sleep]
       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
+      begin
+        timeout(options[:timeout]) do
+          loop do
+            # Send the HTTP request
+            response = begin
+                         http = http_instance(uri,options[:http_timeout])
+                         logger.debug "Requesting: #{uri}"
+                         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
+                         return e
+                       end
+            logger.debug "Received: %s" % response
+
+            case response
+            # Catch any response if we're expecting it
+            when options[:expected]
+              break
+            # Retry these responses
+            when Net::HTTPServiceUnavailable, SocketError
+              my_sleep(start,uri,response,options)
+            else
+              # Some other response
+              break
+            end
           end
-        rescue
-          return true
         end
+      rescue Timeout::Error => e
+        puts "Did not receive an acceptable response in %d seconds" % options[:timeout]
       end
-      return false
+
+      # 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_accessible?(use_https=false, max_retries=120, host=nil)
-      prefix = use_https ? "https://" : "http://"
-      url = prefix + hostname
+    def is_inaccessible?
+      check_response({
+        :expected => Net::HTTPServiceUnavailable
+      })
+    end
 
-      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
+    def is_accessible?(options = {})
+      check_response(options.merge({
+        :expected => Net::HTTPSuccess
+      }))
+    end
+
+    def doesnt_exist?
+      check_response({
+        :expected => SocketError,
+      }) do |response|
+          return !(response.is_a?(Net::HTTPSuccess))
         end
-      end
+    end
 
-      return false
+    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)
@@ -86,22 +150,22 @@ module RHCHelper
       logger.info("Connecting to #{url}")
       beginning_time = Time.now
 
-      max_retries.times do |i|
-        response = http_get(url, 1)
+      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 / retry #{i} / #{url}")
-          sleep 1
-        end
+      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
-
-      return nil
     end
   end
 end

data/features/lib/rhc_helper/loggable.rb

@@ -2,8 +2,6 @@ require 'logger'
 
 module RHCHelper
   module Loggable
-    PASSWORD_REGEX = / -p [^\s]* /
-
     def logger
       Loggable.logger
     end

data/features/lib/rhc_helper/persistable.rb

@@ -6,8 +6,18 @@ module RHCHelper
     include ActiveSupport::JSON
     include Loggable
 
-    def find_on_fs
-      Dir.glob("#{RHCHelper::TEMP_DIR}/*.json").collect {|f| App.from_file(f)}
+    def find_on_fs(options = {})
+      # Find all apps
+      apps = Dir.glob("#{RHCHelper::TEMP_DIR}/*.json").collect {|f| App.from_file(f)}
+
+      if options.empty?
+        apps.first
+      else
+        apps.find do |app|
+          # Loop through all options and then run AND on all of the results
+          options.map{|name,expected| app.send(name) == expected }.inject(&:&)
+        end
+      end
     end
 
     def from_file(filename)

data/features/lib/rhc_helper/sshkey.rb

@@ -0,0 +1,29 @@
+require "rhc/rest"
+
+module RHCHelper
+  
+  class Sshkey
+    extend Runnable
+    extend Commandify
+    
+    class << self
+      attr_accessor :sshkey_output, :exitcode
+    end
+    
+    def self.list(*args)
+      rhc_sshkey_list args
+    end
+    
+    def self.show(*args)
+      rhc_sshkey_show args
+    end
+    
+    def self.add(*args)
+      rhc_sshkey_add args
+    end
+    
+    def self.remove(*args)
+      rhc_sshkey_remove args
+    end
+  end
+end

data/features/multiple_cartridge.feature

@@ -0,0 +1,17 @@
+@multiple_cartridge @domain_required
+Feature: Multiple Cartridge Tests
+
+  @init
+  Scenario: Supporting Cartridge Added
+    Given an existing or new php-5.3 application with an embedded mysql-5.1 cartridge
+    When the phpmyadmin-3.4 cartridge is added
+    Then the phpmyadmin-3.4 cartridge should be running
+
+  Scenario: Conflicting Cartridge Fails
+    Then adding the postgresql-8.5 cartridge should fail
+
+  Scenario: Cartridge Removed
+    When the phpmyadmin-3.4 cartridge is removed
+    When the mysql-5.1 cartridge is removed
+    Then the phpmyadmin-3.4 cartridge should be removed
+    Then the mysql-5.1 cartridge should be removed

data/features/sshkey.feature

@@ -0,0 +1,58 @@
+@sshkey @client_tools_required
+Feature: SSH key Management
+As an OpenShift user, I want to manage SSH keys with 'rhc sshkey' commands.
+
+  @sshkey_list
+  Scenario: SSH key is listed
+    Given the SSH key "key1" already exists
+    When 'rhc sshkey list' is run
+    Then the output includes the key information
+  
+  @sshkey_show
+  Scenario: SSH key is shown individually
+    Given the SSH key "key1" already exists
+    When 'rhc sshkey show "key1"' is run
+    Then the output includes the key information for "key1"
+  
+  @sshkey_show
+  Scenario: Requested SSH key does not exist
+    Given the SSH key "key2" does not exist
+    When 'rhc sshkey show "key2"' command is run
+    Then the command exits with status code 118
+  
+  @sshkey_add
+  Scenario: SSH key is added successfully
+    Given the SSH key "key1" does not exist
+    When a new SSH key "features/support/key1.pub" is added as "key1"
+    Then the key "key1" should exist
+    And the command exits with status code 0
+  
+  @sshkey_add
+  Scenario: invalid SSH key is added
+    Given the SSH key "key1" does not exist
+    When a new SSH key "features/support/key3.pub" is added as "key3"
+    Then the command exits with status code 128
+  
+  @sshkey_add
+  Scenario: SSH key with the same name already exists
+    Given the SSH key "key1" already exists
+    When a new SSH key "features/support/key2.pub" is added as "key1"
+    Then the command exits with status code 128
+  
+  @sshkey_add
+  Scenario: SSH key with the identical content already exists
+    Given an SSH key "key2" with the same content as "key1" exists
+    And the SSH key "key1" does not exist
+    When 'rhc sshkey add "key1" "features/support/key1.pub"' is run
+    Then the command exits with status code 128
+  
+  @sshkey_remove
+  Scenario: SSH key is deleted successfully
+    When 'rhc sshkey remove "key1"' is run
+    Then the SSH key "key1" is deleted
+  
+  @sshkey_remove
+  Scenario: SSH key requested to be deleted does not exist
+    Given the SSH key "key1" does not exist
+    When 'rhc sshkey remove "key1"' is run
+    Then the command exits with status code 118

data/features/step_definitions/application_steps.rb

@@ -3,75 +3,78 @@ 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
+# This can transform any application cartridge requirements into an array
+Transform /^application with(.*)$/ do |embed_type|
+  case embed_type.strip
+  when /^out an embedded cartridge/
+    []
+  when /^an embedded (.*) cartridge$/
+    [$1]
+  when /^embedded (.*) and (.*) cartridges$/
+    [$1,$2]
   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
+# Use the transformed array so we can reuse this step for all combinations
+Given /^an existing (or new )?(.+) (application with.*)$/ do |create,type, embeds|
+  options = { :type => type }
+  options[:embed] = embeds if embeds
 
-  @app.should_not be_nil, 'No existing applications w/cartridges found.  Check the creation scenarios for failures.'
-end
+  @app = App.find_on_fs(options)
 
-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
+  if create && @app.nil?
+    step "a #{type} application is created"
+    embeds.each do |embed|
+      step "the #{embed} cartridge is added"
     end
   end
 
-  @app.should_not be_nil, 'No existing applications found.  Check the creation scenarios for failures.'
+  @app.should_not be_nil, "No existing %s applications %sfound.  Check the creation scenarios for failures." % [
+    type,
+    embeds ? '' : "w/ [#{embeds.join(',')}]"
+  ]
+end
+
+# Mark this step as pending so we make sure to explicitly require apps without embeds
+Given /^an existing (or new )?(.+) application$/ do |create,type|
+  pending
 end
 
 When /^(\d+) (.+) applications are created$/ do |app_count, type|
+  old_app = @app
   @apps = app_count.to_i.times.collect do
-    app = App.create_unique(type)
-    app.rhc_app_create
-    app
+    Then "a #{type} application is created"
+    @app
   end
+  @app = old_app
 end
 
-When /^the application is stopped$/ do
-  @app.rhc_app_stop
-end
-
-When /^the application is started$/ do
-  @app.rhc_app_start
+When /^a (.+) application is created$/ do |type|
+  @app = App.create_unique(type)
+  @app.rhc_app_create
 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 (\w+)$/ do |command|
+  # Do any pre-check setup we may need
+  case command
+  when 'snapshot'
+    @snapshot = File.join(RHCHelper::TEMP_DIR, "snapshot.tar.gz")
+    @app.snapshot = @snapshot
+  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
+  # Set up aliases for any irregular commands
+  aliases = {
+    :stopped => :stop,
+    :shown   => :show,
+    :tidied  => :tidy,
+    :snapshot => :snapshot_save
+  }
 
-When /^the application is shown$/ do
-  @app.rhc_app_show
-end
+  # Use an alias if it exists, or just remove 'ed' (like from started)
+  cmd = aliases[command.to_sym] || command.gsub(/ed$/,'').to_sym
 
-When /^the application is tidied$/ do
-  @app.rhc_app_tidy
+  # Send the specified command to the application
+  @app.send("rhc_app_#{cmd}")
 end
 
 Then /^the snapshot should be found$/ do
@@ -80,20 +83,25 @@ Then /^the snapshot should be found$/ do
 end
 
 Then /^the applications should be accessible?$/ do
+  old_app = @app
   @apps.each do |app|
-    app.is_accessible?.should be_true
-    app.is_accessible?(true).should be_true
+    Then "the application should be accessible"
   end
+  @app = old_app
 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"
+  @app.is_accessible?({:use_https => 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 /^the application should not exist$/ do
+  @app.doesnt_exist?.should be_true, "Application still exists when it shouldn't"
+end
+
 Then /^it should succeed$/ do
 end