DistelliClientFramework 1.0

data/lib/distelli/clientframework.rb

@@ -0,0 +1,417 @@
+#!/usr/bin/env ruby
+
+require 'set'
+require 'logger'
+require 'distelli/servicemarshallers'
+require 'securerandom'
+require 'net/http'
+require 'uri'
+require 'date'
+require 'openssl'
+require 'base64'
+
+module Distelli
+  module Logging
+    def logger
+      Logging.logger
+    end
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+
+  class ClientException < StandardError
+  end
+
+  class Credentials
+    attr_accessor :key_id, :secret_key
+    def initialize(key_id, secret_key)
+      @key_id = key_id
+      @secret_key = secret_key
+    end
+  end
+
+  class RequestSigner
+    include Distelli::Logging
+    def initialize()
+    end
+
+    def get_string_to_sign(request_info)
+      string_to_sign = Array.new
+      string_to_sign.push(request_info.http_method)
+      if request_info.contains_header(ServiceConstants::CONTENT_MD5_HEADER)
+        string_to_sign.push(request_info.headers[ServiceConstants::CONTENT_MD5_HEADER])
+      else
+        string_to_sign.push("")
+      end
+
+      if request_info.contains_header(ServiceConstants::CONTENT_TYPE_HEADER)
+        string_to_sign.push(request_info.headers[ServiceConstants::CONTENT_TYPE_HEADER])
+      else
+        string_to_sign.push("")
+      end
+
+      if request_info.contains_header(ServiceConstants::DATE_HEADER)
+        string_to_sign.push(request_info.headers[ServiceConstants::DATE_HEADER])
+      else
+        string_to_sign.push("")
+      end
+
+      sorted_headers = Array.new
+      request_info.headers.each do |header|
+        if header[0].to_s().downcase().start_with?("x-dstli")
+          sorted_headers.push(header[0])
+        end
+      end
+
+      sorted_headers.sort!()
+      sorted_headers.each do |header|
+        string_to_sign.push(header.downcase()+":"+request_info.headers[header.to_s])
+      end
+
+      # Canonicalize the resource
+      if request_info.resource_uri == nil
+        string_to_sign.push("")
+      else
+        string_to_sign.push(request_info.resource_uri)
+      end
+
+      sorted_params = Array.new
+      if request_info.query_params != nil
+        request_info.query_params.each_pair do |param, values|
+          if values == nil or values.length() == 0
+            next
+          end
+          values.sort!()
+          query_param_list = Array.new
+          values.each do |value|
+            query_param_list.push(value.to_s)
+          end
+          sorted_params.push(param+"="+query_param_list.join(','))
+        end
+      end
+
+      sorted_params.sort!()
+      string_to_sign.push(sorted_params.join('&'))
+      return string_to_sign.join("\n")
+    end
+
+    def get_signature(secret_key, request_info)
+      string_to_sign = get_string_to_sign(request_info)
+      logger.debug("StringToSign:\n"+string_to_sign)
+      return hmacsha(secret_key, string_to_sign)
+    end
+
+    def hmacsha(secret_key, string_to_sign)
+      digest = OpenSSL::Digest::Digest.new("sha256")
+      hmac = OpenSSL::HMAC.digest(digest, secret_key, string_to_sign)
+      return Base64.encode64(hmac)
+    end
+  end
+
+  class ClientBase
+    include Distelli::Logging
+    def initialize(credentials, endpoint=nil)
+      @credentials = credentials
+      @endpoint = endpoint
+      @json_marshaller = JsonMarshaller.new
+      @xml_marshaller = XmlMarshaller.new
+      @logger = nil
+    end
+
+    def set_endpoint(endpoint)
+      if endpoint == nil
+        return
+      end
+      if endpoint.start_with?("http://") or endpoint.start_with?("https://")
+        @endpoint = endpoint
+      else
+        @endpoint = "http://"+endpoint
+      end
+
+    end
+
+    def execute(request_info)
+      if @endpoint == nil
+        raise ClientException.new("Invalid endpoint: "+@endpoint.to_s)
+      end
+      logger.debug("Executing request to endpoint: "+@endpoint.to_s)
+      # uri_str = @endpoint
+      # if request_info.resource_uri != nil
+      #   uri_str = uri_str+request_info.resource_uri
+      # end
+
+      request_info.add_header(ServiceConstants::OPERATION_HEADER, request_info.operation)
+      request_info.add_header(ServiceConstants::CONTENT_TYPE_HEADER, request_info.content_type)
+
+      if not request_info.contains_header(ServiceConstants::RESPONSE_TYPE_HEADER)
+          request_info.add_header(ServiceConstants::RESPONSE_TYPE_HEADER, request_info.response_type)
+      end
+
+      request_info.remove_query_params(ServiceConstants::OPERATION_PARAM)
+      request_info.remove_query_params(ServiceConstants::RESPONSE_TYPE_PARAM)
+
+      if request_info.request_id == nil
+          request_info.request_id = SecureRandom.uuid
+      end
+
+      request_info.add_header(ServiceConstants::REQUEST_ID_HEADER, request_info.request_id)
+      request_info.remove_query_params(ServiceConstants::REQUEST_ID_PARAM)
+
+      # Set the Date header
+      cur_time = Time.now.utc
+      request_info.add_header(ServiceConstants::DATE_HEADER, cur_time.strftime("%a, %d %b %Y %H:%M:%S %z"))
+
+      # Create the URI
+      uri = URI.parse(request_info.get_uri(@endpoint))
+
+      # TODO: Set the Content-MD5 header
+
+      # Set the authentication headers
+      if @credentials != nil
+        signer = RequestSigner.new
+        signature = signer.get_signature(@credentials.secret_key, request_info)
+        request_info.add_header(ServiceConstants::AUTHORIZATION_HEADER, "DWS "+@credentials.key_id+":"+signature)
+      end
+
+      response = nil
+
+      http_method = request_info.http_method
+      http_client = Net::HTTP.new(uri.host, uri.port)
+      http_client.set_debug_output($stdout)
+      if http_method == ServiceConstants::HTTP_METHOD_GET
+        logger.debug("Executing GET: "+request_info.to_s)
+        # Create the http request with the URI, Query Params and Headers
+        http_request = Net::HTTP::Get.new(uri.request_uri, request_info.headers)
+        # Execute the request to get the response
+        response = http_client.request(http_request)
+      elsif http_method == ServiceConstants::HTTP_METHOD_POST
+        logger.debug("Executing POST: "+request_info.to_s)
+        payload = get_payload(request_info)
+        # Create the http request with the URI, Query Params and Headers
+        http_request = Net::HTTP::Post.new(uri.request_uri, request_info.headers)
+        # Set the body
+        http_request.body = payload
+        # Execute the request to get the response
+        response = http_client.request(http_request)
+      elsif http_method == ServiceConstants::HTTP_METHOD_PUT
+        logger.debug("Executing PUT: "+request_info.to_s)
+        payload = get_payload(request_info)
+        # Create the http request with the URI, Query Params and Headers
+        http_request = Net::HTTP::Put.new(uri.request_uri, request_info.headers)
+        # Set the body
+        http_request.body= payload
+        # Execute the request to get the response
+        response = http_client.request(http_request)
+      elsif http_method == ServiceConstants::HTTP_METHOD_DELETE
+        logger.debug("Executing DELETE: "+request_info.to_s)
+        # Create the http request with the URI, Query Params and Headers
+        http_request = Net::HTTP::Delete.new(uri.request_uri, request_info.headers)
+        # Execute the request to get the response
+        response = http_client.request(http_request)
+      else
+          raise ClientException.new("Invalid HTTP Method: "+http_method)
+      end
+      return handle_response(response)
+    end
+
+    private
+    def get_payload(request_info)
+      if request_info == nil
+        return nil
+      end
+      request = request_info.request
+      if request != nil
+        if request_info.content_type == nil or request_info.content_type == ServiceConstants::CONTENT_TYPE_JSON
+          marshalled_payload = @json_marshaller.marshall(request)
+          logger.debug("Marshalled Payload: "+marshalled_payload)
+          return marshalled_payload
+        elsif request_info.content_type == ServiceConstants.CONTENT_TYPE_XML
+          marshalled_payload = @xml_marshaller.marshall(request)
+          logger.debug("Marshalled Payload: "+marshalled_payload)
+          return marshalled_payload
+        end
+      end
+    end
+
+    def handle_response(response)
+      http_status_code = response.code
+      content_type = response[ServiceConstants::CONTENT_TYPE_HEADER]
+      logger.debug("Received Response "+http_status_code.to_s+", Content-Type: "+content_type.to_s+", Payload: "+response.body.to_s)
+      if http_status_code.to_i/100 != 2
+        error = nil
+        if content_type != nil
+          error = unmarshall_error(content_type, response)
+        end
+
+        if http_status_code.to_i/100 == 4
+          raise Distelli::ClientError.new("Request Failed! Client Error.",error[0], error[1], http_status_code.to_i)
+        elsif http_status_code.to_i/100 == 5
+          raise Distelli::ServerError.new("Request Failed! Server Error", error[0], error[1], http_status_code.to_i)
+        else
+          raise ClientException.new("Invalid Response Status Code: "+http_status_code)
+        end
+      end
+
+      if content_type != nil
+        return unmarshall_response(content_type, response)
+      end
+    end
+
+    def unmarshall_response(content_type, response)
+      if content_type == nil
+        raise ClientException.new("Cannot unmarshall with missing content type: "+content_type)
+      end
+      if content_type == ServiceConstants::CONTENT_TYPE_JSON
+        return @json_marshaller.unmarshall(response.body)
+      elsif content_type == ServiceConstants::CONTENT_TYPE_XML
+        return @xml_marshaller.unmarshall(response.body)
+      elsif content_type == ServiceConstants::CONTENT_TYPE_OCTET_STREAM
+        raise ClientException.new("Content-Type: "+content_type+" not supported by this client!")
+      else
+        raise ClientException.new("Invalid Content type: "+content_type)
+      end
+    end
+
+    def unmarshall_error(content_type, response)
+      if content_type == nil
+        raise ClientException.new("Invalid content type: "+content_type+" Failed to unmarshall error response: "+response.body)
+      end
+      if content_type == ServiceConstants::CONTENT_TYPE_JSON
+        return @json_marshaller.unmarshall_error(response.body)
+      elsif content_type == distelli.constants.ServiceConstants.CONTENT_TYPE_XML
+          return @xml_marshaller.unmarshall_error(response.body)
+      else
+        raise ClientException.new("Unsupported Content Type: "+content_type+" while unmarshallinge error_response: "+response.body)
+      end
+    end
+  end
+
+  class RequestInfo
+    attr_accessor :query_params, :headers, :resource_uri, :operation, :request_id, :request, :request_bytes
+    VALID_CONTENT_TYPES = Set.new [ServiceConstants::CONTENT_TYPE_JSON, ServiceConstants::CONTENT_TYPE_XML, ServiceConstants::CONTENT_TYPE_OCTET_STREAM]
+    VALID_HTTP_METHODS = Set.new [ServiceConstants::HTTP_METHOD_GET, ServiceConstants::HTTP_METHOD_PUT, ServiceConstants::HTTP_METHOD_POST, ServiceConstants::HTTP_METHOD_DELETE]
+    VALID_RESPONSE_TYPES = Set.new [ServiceConstants::RESPONSE_TYPE_XML, ServiceConstants::RESPONSE_TYPE_JSON]
+    def initialize()
+      @query_params = Hash.new
+      @headers = Hash.new
+      @resource_uri = "/"
+      @operation = nil
+      @request_id = nil
+      @content_type = ServiceConstants::CONTENT_TYPE_JSON
+      @http_method = "GET"
+      @request = nil
+      @request_bytes = nil
+      @response_type = ServiceConstants::RESPONSE_TYPE_JSON
+    end
+
+    # Returns tho fully qualified uri by concatenating the endpoint
+    # and the resource_uri and adding the query params
+    def get_uri(endpoint)
+      uriparse_result = URI.parse(endpoint)
+      uri_str = endpoint
+      resource_uri = uriparse_result.path
+      if resource_uri == nil or resource_uri.length() == 0
+        resource_uri = "/"
+        uri_str = endpoint+resource_uri
+      end
+
+      @resource_uri = resource_uri
+      # now build the query string
+      query_param_list = Array.new
+      @query_params.each_pair do |k,v|
+        v.each do |x|
+          query_param_list.push(k+'='+x)
+        end
+      end
+      return uri_str+'?'+query_param_list.join('&')
+    end
+
+    #Lets implement the to_s method of the RequestInfo
+    def to_s
+      vars = instance_variables.map do |n|
+        "#{n}=#{instance_variable_get(n).inspect}"
+      end
+      "{%s}" % [vars.join(', ')]
+    end
+
+    def content_type
+      @content_type
+    end
+
+    def content_type=(content_type)
+      if !VALID_CONTENT_TYPES.include?(content_type)
+        raise ClientException.new("Invalid content type: "+content_type)
+      end
+      @content_type = content_type
+    end
+
+    def response_type
+      @response_type
+    end
+
+    def response_type=(response_type)
+      if !VALID_RESPONSE_TYPES.include?(response_type)
+        raise ClientException.new("Invalid response type: "+response_type)
+      end
+      @response_type = response_type
+    end
+
+    def http_method
+      @http_method
+    end
+
+    def http_method=(http_method)
+      if !VALID_HTTP_METHODS.include?(http_method)
+        raise ClientException.new("Invalid http method: "+http_method)
+      end
+      @http_method = http_method
+    end
+
+    def contains_header(header)
+      return @headers.has_key?(header)
+    end
+
+    def add_header(header, value)
+      if header == nil or value == nil
+        return
+      end
+      @headers[header] = value
+    end
+
+    def remove_header(header)
+      if header == nil
+        return
+      end
+      @headers.delete(header)
+    end
+
+    def remove_query_params(key)
+      if not @query_params.has_key?(key)
+        return
+      end
+      @query_params.delete(key)
+    end
+
+    def add_query_param(key, value)
+      if value == nil
+        return
+      end
+      param_values = nil
+      if @query_params.has_key?(key)
+        param_values = @query_params[key]
+      else
+        param_values = Array.new
+        @query_params[key] = param_values
+      end
+
+      if value.instance_of?(DateTime)
+        #TODO: Check if the timezone is present. if not then set it to UTC
+        param_values.push(value.strftime("%Y-%m-%dT%H:%M:%S%z"))
+      else
+        param_values.push(value.to_s)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: DistelliClientFramework
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Rahul Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: DistelliServiceMarshallers
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Distelli Client Framework for Ruby Clients
+email: rsingh@distelli.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/distelli/clientframework.rb
+homepage: http://www.distelli.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Distelli Client classes and marshallers for Ruby Clients
+test_files: []