openshift-origin-console 1.3.2

data/lib/active_resource/associations/builder/association.rb

@@ -0,0 +1,35 @@
+#
+# Reproduced from https://github.com/rails/rails/pull/230/files for Association support
+#
+module ActiveResource::Associations::Builder
+  class Association #:nodoc:
+
+    # providing a Class-Variable, which will have a differend store of subclasses
+    class_attribute :valid_options
+    self.valid_options = [:class_name]
+
+    # would identify subclasses of association
+    class_attribute :macro
+
+    attr_reader :model, :name, :options, :klass
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+
+    def build
+      validate_options
+      reflection = model.create_reflection(self.class.macro, name, options)
+    end
+
+    private
+
+    def validate_options
+      options.assert_valid_keys(self.class.valid_options)
+    end
+  end
+end

data/lib/active_resource/associations/builder/belongs_to.rb

@@ -0,0 +1,5 @@
+module ActiveResource::Associations::Builder
+  class BelongsTo < Association
+    self.macro = :belongs_to
+  end
+end

data/lib/active_resource/associations/builder/has_many.rb

@@ -0,0 +1,5 @@
+module ActiveResource::Associations::Builder
+  class HasMany < Association
+    self.macro = :has_many
+  end
+end

data/lib/active_resource/associations/builder/has_one.rb

@@ -0,0 +1,5 @@
+module ActiveResource::Associations::Builder
+  class HasOne < Association
+    self.macro = :has_one
+  end
+end

data/lib/active_resource/persistent_connection.rb

@@ -0,0 +1,341 @@
+require 'active_support/core_ext/benchmark'
+require 'net/https'
+require 'date'
+require 'time'
+require 'uri'
+require 'net/http/persistent'
+
+# Derived from ActiveResource::Connection
+module ActiveResource
+  # Class to handle connections to remote web services.
+  # This class is used by ActiveResource::Base to interface with REST
+  # services.
+  class PersistentConnection
+
+    HTTP_FORMAT_HEADER_NAMES = {  :get => 'Accept',
+      :put => 'Content-Type',
+      :post => 'Content-Type',
+      :patch => 'Content-Type',
+      :delete => 'Accept',
+      :head => 'Accept'
+    }
+
+    class ServerRefusedConnection < Errno::ECONNREFUSED
+      def initialize(site,path=nil)
+        @site, @path = site, path
+      end
+
+      def message
+        "Connection refused to #{@site}#{@path}"
+      end
+    end
+
+    attr_reader :site, :user, :password, :auth_type, :timeout, :proxy, :ssl_options, :connection_name
+    attr_accessor :format
+
+    class << self
+      def requests
+        @@requests ||= []
+      end
+    end
+
+    # Override to change the Persistent slot
+    def connection_name
+      @connection_name || 'active_resource'
+    end
+
+    # The +site+ parameter is required and will set the +site+
+    # attribute to the URI for the remote resource service.
+    def initialize(site, format = ActiveResource::Formats::XmlFormat)
+      raise ArgumentError, 'Missing site URI' unless site
+      @user = @password = nil
+      @uri_parser = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+      self.site = site
+      self.format = format
+    end
+
+    # Set URI for remote service.
+    def site=(site)
+      @site = site.is_a?(URI) ? site : @uri_parser.parse(site)
+      @user = @uri_parser.unescape(@site.user) if @site.user
+      @password = @uri_parser.unescape(@site.password) if @site.password
+    end
+
+    # Set the proxy for remote service.
+    def proxy=(proxy)
+      @proxy = proxy.is_a?(URI) ? proxy : @uri_parser.parse(proxy)
+    end
+
+    # Sets the user for remote service.
+    def user=(user)
+      @user = user
+    end
+
+    # Sets the password for remote service.
+    def password=(password)
+      @password = password
+    end
+
+    # Sets the auth type for remote service.
+    def auth_type=(auth_type)
+      @auth_type = legitimize_auth_type(auth_type)
+    end
+
+    # Sets the debug output stream for HTTP requests
+    def debug_output=(debug_output)
+      @debug_output = debug_output
+    end
+
+    [:idle_timeout, :read_timeout, :open_timeout, :timeout].each do |sym|
+      define_method :"#{sym}=" do |value|
+        instance_variable_set(:"@#{sym}", value)
+      end
+    end
+
+    # Hash of options applied to Net::HTTP instance when +site+ protocol is 'https'.
+    def ssl_options=(opts={})
+      @ssl_options = opts
+    end
+
+    # Name for this group of requests, passed to Net::HTTP::Persistent
+    def connection_name=(name)
+      @connection_name = name
+    end
+
+    # Executes a GET request.
+    # Used to get (find) resources.
+    # Note; removed format.decode wrapper and .get method call
+    def get(path, headers = {})
+      with_auth { request(:get, path, build_request_headers(headers, :get, self.site.merge(path))) }
+    end
+
+    # Executes a DELETE request (see HTTP protocol documentation if unfamiliar).
+    # Used to delete resources.
+    def delete(path, headers = {})
+      with_auth { request(:delete, path, build_request_headers(headers, :delete, self.site.merge(path))) }
+    end
+
+    # Executes a PUT request (see HTTP protocol documentation if unfamiliar).
+    # Used to update resources.
+    def put(path, body = '', headers = {})
+      with_auth { request(:put, path, body.to_s, build_request_headers(headers, :put, self.site.merge(path))) }
+    end
+
+    # Executes a POST request.
+    # Used to create new resources.
+    def post(path, body = '', headers = {})
+      with_auth { request(:post, path, body.to_s, build_request_headers(headers, :post, self.site.merge(path))) }
+    end
+
+    # Executes a PATCH request.
+    # Used to create new resources.
+    def patch(path, body = '', headers = {})
+      with_auth { request(:patch, path, body.to_s, build_request_headers(headers, :patch, self.site.merge(path))) }
+    end
+
+    # Executes a HEAD request.
+    # Used to obtain meta-information about resources, such as whether they exist and their size (via response headers).
+    def head(path, headers = {})
+      with_auth { request(:head, path, build_request_headers(headers, :head, self.site.merge(path))) }
+    end
+
+    private
+      # Makes a request to the remote service.
+      def request(method, path, *arguments)
+        req = case method
+          when :get
+            req = Net::HTTP::Get.new path, arguments[0]
+          when :head
+            req = Net::HTTP::Head.new path, arguments[0]
+          when :delete
+            req = Net::HTTP::Delete.new path, arguments[0]
+          when :put
+            req = Net::HTTP::Put.new path, arguments[1]
+            req.body = arguments[0]
+            req
+          when :patch
+            req = Net::HTTP::Patch.new path, arguments[1]
+            req.body = arguments[0]
+            req
+          when :post
+            req = Net::HTTP::Post.new path, arguments[1]
+            req.body = arguments[0]
+            req
+          else
+            raise StandardError, "Method not recognized #{method}"
+          end
+        result = ActiveSupport::Notifications.instrument("request.active_resource") do |payload|
+          payload[:method]      = method
+          payload[:request_uri] = "#{site.scheme}://#{site.host}:#{site.port}#{path}"
+          payload[:result] = http.request site, req
+        end
+        handle_response(result)
+      rescue Timeout::Error => e
+        raise TimeoutError.new(e.message)
+      rescue OpenSSL::SSL::SSLError => e
+        raise SSLError.new(e.message)
+      rescue Net::HTTP::Persistent::Error => e
+        raise ConnectionError.new(e.message)
+      rescue Errno::ECONNREFUSED => e
+        raise ServerRefusedConnection.new(site, req.path)
+      end
+
+      # Handles response and error codes from the remote service.
+      def handle_response(response)
+        case response.code.to_i
+          when 301,302
+            raise(Redirection.new(response))
+          when 200...400
+            response
+          when 400
+            raise(BadRequest.new(response))
+          when 401
+            raise(UnauthorizedAccess.new(response))
+          when 403
+            raise(ForbiddenAccess.new(response))
+          when 404
+            raise(ResourceNotFound.new(response))
+          when 405
+            raise(MethodNotAllowed.new(response))
+          when 409
+            raise(ResourceConflict.new(response))
+          when 410
+            raise(ResourceGone.new(response))
+          when 422
+            raise(ResourceInvalid.new(response))
+          when 401...500
+            raise(ClientError.new(response))
+          when 500...600
+            raise(ServerError.new(response))
+          else
+            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+        end
+      end
+
+      # Get or create Net::HTTP::Persistent instance for communication with the
+      # remote service and resources.
+      def http
+        @http ||= configure_http(new_http)
+      end
+
+      def new_http
+        http = Net::HTTP::Persistent.new connection_name
+        http.proxy = @proxy if @proxy
+        http
+      end
+
+      def configure_http(http)
+        http = apply_ssl_options(http)
+
+        # Net::HTTP timeouts default to 60 seconds.
+        if @timeout
+          http.open_timeout = @timeout
+          http.read_timeout = @timeout
+        end
+
+        [:read_timeout, :open_timeout, :idle_timeout].each do |sym|
+          http.send(:"#{sym}=", instance_variable_get(:"@#{sym}")) if instance_variable_get(:"@#{sym}")
+        end
+
+        http
+      end
+
+      def apply_ssl_options(http)
+        return http unless @site.is_a?(URI::HTTPS)
+
+        #http.ssl(true) #changed
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        return http unless defined?(@ssl_options)
+
+        [:ca_path, :ca_file,
+         :cert, :key, :cert_store, :ssl_timeout, :ssl_version,
+         :verify_mode, :verify_callback, :verify_depth
+        ].each do |sym|
+          http.send(:"#{sym}=", @ssl_options[sym]) if @ssl_options[sym]
+        end
+
+        http
+      end
+
+      def default_header
+        @default_header ||= {}
+      end
+
+      # Builds headers for request to remote service.
+      def build_request_headers(headers, http_method, uri)
+        authorization_header(http_method, uri).update(default_header).update(http_format_header(http_method)).update(headers)
+      end
+
+      def response_auth_header
+        @response_auth_header ||= ""
+      end
+
+      def with_auth
+        retried ||= false
+        yield
+      rescue UnauthorizedAccess => e
+        raise if retried || auth_type != :digest
+        @response_auth_header = e.response['WWW-Authenticate']
+        retried = true
+        retry
+      end
+
+      def authorization_header(http_method, uri)
+        if @user || @password
+          if auth_type == :digest
+            { 'Authorization' => digest_auth_header(http_method, uri) }
+          else
+            { 'Authorization' => 'Basic ' + ["#{@user}:#{@password}"].pack('m').delete("\r\n") }
+          end
+        else
+          {}
+        end
+      end
+
+      def digest_auth_header(http_method, uri)
+        params = extract_params_from_response
+
+        ha1 = Digest::MD5.hexdigest("#{@user}:#{params['realm']}:#{@password}")
+        ha2 = Digest::MD5.hexdigest("#{http_method.to_s.upcase}:#{uri.path}")
+
+        params.merge!('cnonce' => client_nonce)
+        request_digest = Digest::MD5.hexdigest([ha1, params['nonce'], "0", params['cnonce'], params['qop'], ha2].join(":"))
+        "Digest #{auth_attributes_for(uri, request_digest, params)}"
+      end
+
+      def client_nonce
+        Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
+      end
+
+      def extract_params_from_response
+        params = {}
+        if response_auth_header =~ /^(\w+) (.*)/
+          $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        end
+        params
+      end
+
+      def auth_attributes_for(uri, request_digest, params)
+        [
+          %Q(username="#{@user}"),
+          %Q(realm="#{params['realm']}"),
+          %Q(qop="#{params['qop']}"),
+          %Q(uri="#{uri.path}"),
+          %Q(nonce="#{params['nonce']}"),
+          %Q(nc="0"),
+          %Q(cnonce="#{params['cnonce']}"),
+          %Q(opaque="#{params['opaque']}"),
+          %Q(response="#{request_digest}")].join(", ")
+      end
+
+      def http_format_header(http_method)
+        {HTTP_FORMAT_HEADER_NAMES[http_method] => format.mime_type}
+      end
+
+      def legitimize_auth_type(auth_type)
+        return :basic if auth_type.nil?
+        auth_type = auth_type.to_sym
+        [:basic, :digest].include?(auth_type) ? auth_type : :basic
+      end
+  end
+end

data/lib/active_resource/persistent_http_mock.rb

@@ -0,0 +1,68 @@
+#
+# When this module is included it will prevent normal ActiveResource calls from being made.  Be sure to
+# use ActiveSupport::Testing::Isolation and require this module in the setup method if you want to use
+# ActiveResource::HttpMock in the same test suite that hits the server.
+#
+require 'active_resource/http_mock'
+
+# Duplicate of ActiveResource::HttpMock method
+class ActiveResource::PersistentConnection
+  private
+    silence_warnings do
+      alias_method :http_without_mock, :http
+      # changes behavior, will not cache http object
+      def http
+        if ActiveResource::HttpMock.enabled?
+          ActiveResource::HttpMock.new(@site)
+        else
+          http_without_mock
+        end
+      end
+    end
+end
+
+class ActiveResource::HttpMock
+  def self.enabled=(bool)
+    @enabled = bool
+  end
+  def self.enabled?
+    @enabled
+  end
+  def request(uri, req)
+    headers = {}
+    req.each_capitalized{ |k,v| headers[k] = v unless k == 'Accept' && v == '*/*' }
+    request = ActiveResource::Request.new(req.method.downcase.to_sym, req.path, req.request_body_permitted? ? req.body : nil, headers)
+    self.class.requests << request
+    if response = self.class.responses.assoc(request)
+      response[1]
+    else
+      raise ActiveResource::InvalidRequestError.new("Could not find a response recorded for\n  #{request.inspect}\n - Responses recorded are:\n  #{self.class.responses.map{|r| r.inspect}.join("\n  ")}")
+    end
+  end
+end
+
+# Add PATCH support
+class ActiveResource::HttpMock::Responder
+  def patch(path, request_headers = {}, body = nil, status = 200, response_headers = {})
+    request  = ActiveResource::Request.new(:patch, path, nil, request_headers)
+    response = ActiveResource::Response.new(body || "", status, response_headers)
+
+    delete_duplicate_responses(request)
+
+    @responses << [request, response]
+  end
+end
+class ActiveResource::HttpMock
+  class << self 
+    def patch(path, body, headers)
+      request = ActiveResource::Request.new(:patch, path, body, headers)
+      self.class.requests << request
+      if response = self.class.responses.assoc(request)
+        response[1]
+      else
+        raise InvalidRequestError.new("Could not find a response recorded for \#{request.to_s} - Responses recorded are: \#{inspect_responses}")
+      end
+    end
+  end
+end
+