kinetic_sdk 0.1.1

data/lib/kinetic_sdk/task/lib/trees.rb

@@ -0,0 +1,274 @@
+module KineticSdk
+  class Task
+
+    # Delete a tree.
+    #
+    # @param tree [String|Hash] either the tree title, or a hash consisting of component names
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     delete_tree("Kinetic Request CE :: Win a Car :: Complete")
+    #
+    # Example
+    #
+    #     delete_tree({
+    #       "source_name" => "Kinetic Request CE",
+    #       "group_name" => "Win a Car",
+    #       "tree_name" => "Complete"
+    #     })
+    #
+    def delete_tree(tree, headers=header_basic_auth)
+      if tree.is_a? Hash
+        title = "#{tree['source_name']} :: #{tree['group_name']} :: #{tree['tree_name']}"
+      else
+        title = "#{tree.to_s}"
+      end
+      info("Deleting Tree \"#{title}\"")
+      delete("#{@api_url}/trees/#{encode(title)}", headers)
+    end
+
+    # Delete trees.
+    #
+    # If the source_name is provided, only trees that belong to the source
+    # will be deleted, otherwise all trees will be deleted.
+    #
+    # @param source_name [String] the name of the source, or nil to delete all trees
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     delete_trees("Kinetic Request CE")
+    #
+    def delete_trees(source_name=nil, headers=header_basic_auth)
+      if source_name.nil?
+        info("Deleting all trees")
+        params = {}
+      else
+        info("Deleting trees for Source \"#{source_name}\"")
+        params = { "source" => source_name }
+      end
+
+      (find_trees(params, headers).content['trees'] || []).each do |tree|
+        info("Deleting tree \"#{tree['title']}\"")
+        delete("#{@api_url}/trees/#{encode(tree['title'])}", headers)
+      end
+    end
+
+
+    # Find trees.
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     find_trees({ "source" => "Kinetic Request CE" })
+    #
+    # Example
+    # 
+    #     find_trees({ "include" => "details" })
+    #
+    # Example
+    #
+    #     find_trees({ "source" => "Kinetic Request CE", "include" => "details" })
+    #
+    def find_trees(params={}, headers=header_basic_auth)
+      info("Finding Trees")
+      get("#{@api_url}/trees", params, headers)
+    end
+
+    # Find routines.
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     find_routines({ "source" => "Kinetic Request CE" })
+    #
+    # Example
+    #
+    #     find_routines({ "include" => "details" })
+    #
+    # Example
+    #
+    #     find_routines({ "source" => "Kinetic Request CE", "include" => "details" })
+    #
+    def find_routines(params={}, headers=header_basic_auth)
+      info("Finding Routines")
+      response = get("#{@api_url}/trees", params, headers)
+
+      routines = []
+      (response.content["trees"] || []).each do |tree|
+        routines.push(tree) unless tree['definitionId'].nil?
+      end
+      final_content = { "trees" => routines }
+      response.content= final_content
+      response.content_string= final_content.to_json
+      response
+    end
+
+    # Import a tree
+    #
+    # If the tree already exists on the server, this will fail unless forced
+    # to overwrite.
+    #
+    # The source named in the tree content must also exist on the server, or
+    # the import will fail.
+    #
+    # @param tree [String] content from tree file
+    # @param force_overwrite [Boolean] whether to overwrite a tree if it exists, default is false
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def import_tree(tree, force_overwrite=false, headers=header_basic_auth)
+      body = { "content" => tree }
+      info("Importing Tree #{File.basename(tree)}")
+      post_multipart("#{@api_url}/trees?force=#{force_overwrite}", body, headers)
+    end
+
+    # Import a routine
+    #
+    # If the routine already exists on the server, this will fail unless
+    # forced to overwrite.
+    #
+    # @param routine [String] content from routine file
+    # @param force_overwrite [Boolean] whether to overwrite a routine if it exists, default is false
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def import_routine(routine, force_overwrite=false, headers=header_basic_auth)
+      body = { "content" => routine }
+      info("Importing Routine #{File.basename(routine)}")
+      post_multipart("#{@api_url}/trees?force=#{force_overwrite}", body, headers)
+    end
+
+    # Find a single tree by title (Source Name :: Group Name :: Tree Name)
+    #
+    # @param title [String] The tree title
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     find_tree(
+    #       "Kinetic Request CE :: Win a Car :: Complete",
+    #       { "include" => "details" }
+    #     )
+    #
+    def find_tree(title, params={}, headers=header_basic_auth)
+      info("Finding the \"#{title}\" Tree")
+      get("#{@api_url}/trees/#{encode(title)}", params, headers)
+    end
+
+    # Export a single tree or routine
+    #
+    # @param title [String] the title of the tree or routine
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    def export_tree(title, headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export a tree." if @options[:export_directory].nil?
+      info("Exporting tree \"#{title}\" to #{@options[:export_directory]}.")
+      # Get the tree
+      response = find_tree(title, { "include" => "export" })
+      # Parse the response and export the tree
+      tree = response.content
+
+      # determine which directory to write the file to
+      if tree['sourceGroup'] == "-"
+        # Create the directory if it doesn't yet exist
+        routine_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "routines"))
+        tree_file = File.join(routine_dir, "#{tree['name'].slugify}.xml")
+      else
+        # Create the directory if it doesn't yet exist
+        tree_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "trees", tree['sourceName'].slugify))
+        tree_file = File.join(tree_dir, "#{tree['sourceName'].slugify}.#{tree['sourceGroup'].slugify}.#{tree['name'].slugify}.xml")
+      end
+      # write the file
+      File.write(tree_file, tree['export'])
+      info("Exported #{tree['type']}: #{tree['title']} to #{tree_file}")
+    end
+
+    # Export all trees and local routines for a source, and global routines
+    #
+    # @param source_name [String] Name of the source to export trees and local routines
+    #   - Leave blank or pass nil to export all trees and global routines
+    #   - Pass "-" to export only global routines
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_trees(source_name=nil, headers=header_basic_auth)
+      raise StandardError.new "An export directory must be defined to export trees." if @options[:export_directory].nil?
+      if source_name.nil?
+        info("Exporting all trees and routines to #{@options[:export_directory]}.")
+        (find_sources.content["sourceRoots"] || []).each do |sourceRoot|
+          export_trees(sourceRoot['name'])
+        end
+        return
+      elsif source_name == "-"
+        info("Exporting global routines to #{@options[:export_directory]}.")
+      else
+        info("Exporting trees and routines for source \"#{source_name}\" to #{@options[:export_directory]}.")
+      end
+
+      # Get all the trees and routines for the source
+      response = find_trees({ "source" => source_name, "include" => "export" })
+      # Parse the response and export each tree
+      (response.content["trees"] || []).each do |tree|
+        # determine which directory to write the file to
+        if tree['sourceGroup'] == "-"
+          # create the directory if it doesn't yet exist
+          routine_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "routines"))
+          tree_file = File.join(routine_dir, "#{tree['name'].slugify}.xml")
+        else
+          # create the directory if it doesn't yet exist
+          tree_dir = FileUtils::mkdir_p(File.join(@options[:export_directory], "trees", source_name.slugify))
+          tree_file = File.join(tree_dir, "#{source_name.slugify}.#{tree['sourceGroup'].slugify}.#{tree['name'].slugify}.xml")
+        end
+        # write the file
+        File.write(tree_file, tree['export'])
+        info("Exported #{tree['type']}: #{tree['title']} to #{tree_file}")
+      end
+    end
+
+
+    # Export all global routines
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def export_routines(headers=header_basic_auth)
+      export_trees("-", headers)
+    end
+
+    # Create a new run of a tree
+    #
+    # @param title [String] title of the tree: Source Name, Group Name, Tree Name
+    # @param body [Hash] properties to pass to the tree, what can be used/accepted
+    #   depends on the source.
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def run_tree(title, body={}, headers=default_headers)
+      info("Running tree #{title}")
+      parts = title.split(" :: ")
+      raise StandardError.new "Title is invalid: #{title}" if parts.size != 3
+      url = "#{@api_v1_url}/run-tree/#{encode(parts[0])}/#{encode(parts[1])}/#{encode(parts[2])}"
+      post(url, body, headers)
+    end
+
+    # Update a tree
+    #
+    # @param title [String] title of the tree: Source Name, Group Name, Tree Name
+    # @param body [Hash] properties to pass to the tree
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def update_tree(title, body={}, headers=default_headers)
+      info("Updating the \"#{title}\" Tree")
+      put("#{@api_url}/trees/#{encode(title)}", body, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/lib/users.rb

@@ -0,0 +1,75 @@
+module KineticSdk
+  class Task
+
+    # Add a user
+    #
+    # @param user [Hash] user properties
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     add_user({
+    #       "loginId" => "foo",
+    #       "password" => "bar",
+    #       "email" => "foo@bar.com"
+    #     })
+    #
+    def add_user(user, headers=default_headers)
+      info("Add user \"#{user['loginId']}\"")
+      post("#{@api_url}/users", user, headers)
+    end
+
+    # Delete a User
+    #
+    # @param login_id [String] login id of the user
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_user(login_id, headers=header_basic_auth)
+      info("Deleting User \"#{login_id}\"")
+      delete("#{@api_url}/users/#{encode(login_id)}", headers)
+    end
+
+    # Delete all Users
+    #
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def delete_users(headers=header_basic_auth)
+      info("Deleting all users")
+      (find_users(headers).content["users"] || []).each do |user|
+        delete("#{@api_url}/users/#{encode(user['login_id'])}", headers)
+      end
+    end
+
+    # Find all users
+    #
+    # @param params [Hash] Query parameters that are added to the URL, such as +include+
+    # @param headers [Hash] hash of headers to send, default is basic authentication
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    def find_users(params={}, headers=header_basic_auth)
+      info("Finding all users")
+      get("#{@api_url}/users", params, headers)
+    end
+
+    # Update a user
+    #
+    # @param login_id [String] Login Id for the user
+    # @param user [Hash] updated properties of the user
+    # @param headers [Hash] hash of headers to send, default is basic authentication and accept JSON content type
+    # @return [KineticSdk::Utils::KineticHttpResponse] object, with +code+, +message+, +content_string+, and +content+ properties
+    #
+    # Example
+    #
+    #     update_user({
+    #       "loginId" => "foo",
+    #       "password" => "bar",
+    #       "email" => "foo@bar.com"
+    #     })
+    #
+    def update_user(login_id, user, headers=default_headers)
+      info("Updating user \"#{login_id}\"")
+      put("#{@api_url}/users/#{encode(login_id)}", user, headers)
+    end
+
+  end
+end

data/lib/kinetic_sdk/task/task-sdk.rb

@@ -0,0 +1,92 @@
+Dir[File.join(File.dirname(File.expand_path(__FILE__)), "lib", "**", "*.rb")].each {|file| require file }
+
+module KineticSdk
+
+  # Task is a Ruby class that acts as a wrapper for the Kinetic Task REST API
+  # without having to make explicit HTTP requests.
+  #
+  class Task
+
+    # Include the KineticHttpUtils module
+    include KineticSdk::Utils::KineticHttpUtils
+
+    attr_reader :api_url, :api_v1_url, :config_user, :options, :server, :version, :username, :password
+
+    # Initalize the Task SDK with the web server URL and user credentials,
+    # along with any custom option values.
+    #
+    # @param [Hash] opts Kinetic Task properties
+    # @option opts [String] :config_file optional - path to the YAML configuration file
+    #
+    #   * Ex: /opt/config/task-configuration1.yaml
+    #
+    # @option opts [String] :app_server_url the URL to the Kinetic Task web application.
+    #
+    #   * Ex: <http://192.168.0.1:8080/kinetic-task>
+    #
+    # @option opts [String] :username the username for the user
+    # @option opts [String] :password the password for the user
+    # @option opts [Hash<Symbol, Object>] :options ({}) optional settings
+    #
+    #   * :export_directory (String) (_example: /opt/exports/kinetic-task) directory to write files when exporting,
+    #   * :log_level (String) (_defaults to: off_) level of logging - off | info | debug | trace
+    #   * :max_redirects (Fixnum) (_defaults to: 10_) maximum number of redirects to follow
+    #   * :ssl_ca_file (String) full path to PEM certificate used to verify the server
+    #   * :ssl_verify_mode (String) (_defaults to: none_) - none | peer
+    #
+    # Example: using a configuration file
+    #
+    #     KineticSdk::Task.new({
+    #       config_file: "/opt/config1.yaml"
+    #     })
+    #
+    # Example: using a properties hash
+    #
+    #     KineticSdk::Task.new({
+    #       app_server_url: "http://localhost:8080/kinetic-task",
+    #       username: "admin",
+    #       password: "admin",
+    #       options: {
+    #         log_level: "debug",
+    #         export_directory: "/opt/exports/task-server-a",
+    #         ssl_verify_mode: "peer",
+    #         ssl_ca_file: "/usr/local/self_signing_ca.pem"
+    #       }
+    #     })
+    #
+    # If the +config_file+ option is present, it will be loaded first, and any additional
+    # options will overwrite any values in the config file
+    #
+    def initialize(opts)
+      # initialize any variables
+      options = {}
+      @config_user = {}
+      @server = nil
+
+      # process the configuration file if it was provided
+      unless opts[:config_file].nil?
+        options.merge!(YAML::load_file opts[:config_file])
+      end
+
+      # process the configuration hash if it was provided
+      options.merge!(opts)
+
+      # process any individual options
+      @options = options.delete(:options) || {}
+      @config_user[:username] = options[:username]
+      @config_user[:password] = options[:password]
+      @server = options[:app_server_url].chomp('/')
+      @username = @config_user[:username]
+      @password = @config_user[:password]
+
+      # TODO: Better separation of APIv1 and APIv2
+      @api_v1_url = "#{@server}/app/api/v1"
+      @api_v2_url = "#{@server}/app/api/v2"
+
+      # set any constants or calculated values
+      @api_url = @api_v2_url
+      @version = 2
+    end
+
+  end
+end

data/lib/kinetic_sdk/utils/kinetic-http-headers.rb

@@ -0,0 +1,150 @@
+module KineticSdk
+  module Utils
+    module KineticHttpUtils
+
+      #-------------------------------------------------------------------------
+      # Instance methods that are duplicated as module/class methods
+      #-------------------------------------------------------------------------
+
+      # Provides an Accept header set to application/json
+      #
+      # @return [Hash] Accept header set to application/json
+      def header_accept_json
+        { "Accept" => "application/json" }
+      end
+
+      # Provides a basic authentication header
+      # 
+      # @param username [String] username to authenticate
+      # @param password [String] password associated to the username
+      # @return [Hash] Authorization: Basic base64 hash of username and password
+      def header_basic_auth(username=@username, password=@password)
+        { "Authorization" => "Basic #{Base64.encode64(username.to_s + ":" + password.to_s).gsub("\n", "")}" }
+      end
+
+      # Provides a Bearer authentication header
+      # 
+      # @param token [String] JSON Web Token (jwt)
+      # @return [Hash] Authorization: Bearer jwt
+      def header_bearer_auth(token=@jwt)
+        { "Authorization" => "Bearer #{token}" }
+      end
+
+      # Provides a content-type header set to application/json
+      #
+      # @return [Hash] Content-Type header set to application/json
+      def header_content_json
+        { "Content-Type" => "application/json" }
+      end
+
+      # Provides a user-agent header set to Kinetic Ruby SDK
+      #
+      # @return [Hash] User-Agent header set to Kinetic Reuby SDK
+      def header_user_agent
+        { "User-Agent" => "Kinetic Ruby SDK #{KineticSdk::VERSION}" }
+      end
+
+      # Provides a hash of default headers
+      #
+      # @param username [String] username to authenticate
+      # @param password [String] password associated to the username
+      # @return [Hash] Hash of headers
+      #   - Accepts: application/json
+      #   - Authorization: Basic base64 hash of username and password if username is provided
+      #   - Content-Type: application/json
+      #   - User-Agent: Kinetic Ruby SDK {KineticSdk::VERSION}
+      def default_headers(username=@username, password=@password)
+        headers = header_accept_json.merge(header_content_json).merge(header_user_agent)
+        headers.merge!(header_basic_auth(username, password)) unless username.nil?
+        headers
+      end
+
+      # Provides a hash of default headers with bearer auth instead of basic auth
+      #
+      # @param token [String] JSON Web Token (jwt)
+      # @return [Hash] Hash of headers
+      #   - Accepts: application/json
+      #   - Authorization: Bearer jwt
+      #   - Content-Type: application/json
+      #   - User-Agent: Kinetic Ruby SDK {KineticSdk::VERSION}
+      def default_jwt_headers(token=@jwt)
+        headers = header_accept_json.merge(header_content_json).merge(header_user_agent)
+        headers.merge!(header_bearer_auth(token)) unless token.nil?
+        headers
+      end
+
+
+      #------------------------------------------
+      # Class methods
+      #------------------------------------------
+
+      # Provides a accepts header set to application/json
+      #
+      # @return [Hash] Accepts header set to application/json
+      def self.header_accept_json
+        { "Accepts" => "application/json" }
+      end
+
+      # Provides a basic authentication header
+      # 
+      # @param username [String] username to authenticate
+      # @param password [String] password associated to the username
+      # @return [Hash] Authorization: Basic base64 hash of username and password
+      def self.header_basic_auth(username=@username, password=@password)
+        { "Authorization" => "Basic #{Base64.encode64(username.to_s + ":" + password.to_s).gsub("\n", "")}" }
+      end
+
+      # Provides a Bearer authentication header
+      # 
+      # @param token [String] JSON Web Token (jwt)
+      # @return [Hash] Authorization: Bearer jwt
+      def self.header_bearer_auth(token=@jwt)
+        { "Authorization" => "Bearer #{token}" }
+      end
+
+      # Provides a content-type header set to application/json
+      #
+      # @return [Hash] Content-Type header set to application/json
+      def self.header_content_json
+        { "Content-Type" => "application/json" }
+      end
+
+      # Provides a user-agent header set to Kinetic Ruby SDK
+      #
+      # @return [Hash] User-Agent header set to Kinetic Reuby SDK
+      def self.header_user_agent
+        { "User-Agent" => "Kinetic Ruby SDK #{KineticSdk::VERSION}" }
+      end
+
+      # Provides a hash of default headers
+      #
+      # @param username [String] username to authenticate
+      # @param password [String] password associated to the username
+      # @return [Hash] Hash of headers
+      #   - Accept: application/json
+      #   - Authorization: Basic base64 hash of username and password if username is provided
+      #   - Content-Type: application/json
+      #   - User-Agent: Kinetic Ruby SDK {KineticSdk::VERSION}
+      def self.default_headers(username=@username, password=@password)
+        headers = self.header_accept_json.merge(self.header_content_json).merge(self.header_user_agent)
+        headers.merge!(self.header_basic_auth(username, password)) unless username.nil?
+        headers
+      end
+
+      # Provides a hash of default headers with bearer auth instead of basic auth
+      #
+      # @param token [String] JSON Web Token (jwt)
+      # @return [Hash] Hash of headers
+      #   - Accepts: application/json
+      #   - Authorization: Bearer jwt
+      #   - Content-Type: application/json
+      #   - User-Agent: Kinetic Ruby SDK {KineticSdk::VERSION}
+      def self.default_jwt_headers(token=@jwt)
+        headers = self.header_accept_json.merge(self.header_content_json).merge(self.header_user_agent)
+        headers.merge!(self.header_bearer_auth(token)) unless token.nil?
+        headers
+      end
+
+    end
+  end
+end

data/lib/kinetic_sdk/utils/kinetic-http-response.rb

@@ -0,0 +1,75 @@
+module KineticSdk
+  module Utils
+
+    # The KineticHttpResponse object normalizes the Net::HTTPResponse object
+    # properties so they are always consistent.
+    #
+    # If the object passed in the constructor is a StandardError, the status code is
+    # set to 0, and the {#exception} and {#backtrace} methods can be used to get the 
+    # details.
+    #
+    # Regardless of whether a Net::HTTPResponse object or a StandardError object was 
+    # passed in the constructor, the {#code} and {#message} methods will give information
+    # about the response.
+    class KineticHttpResponse
+      # response code [String] - always '0' if constructor object is a StandardError
+      attr_reader :code
+      # the parsed JSON response body if content-type is application/json
+      attr_accessor :content
+      # the raw response body string
+      attr_accessor :content_string
+      # the response content-type
+      attr_reader :content_type
+      # the resonse headers
+      attr_reader :headers
+      # response status message
+      attr_reader :message
+      # the raw response object
+      attr_reader :response
+      # response code [Fixnum] - always 0 if constructor object is a StandardError
+      attr_reader :status
+      
+      # the StandardError backtrace if constructor object is a StandardError
+      attr_reader :backtrace
+      # the raw StandardError if constructor object is a StandardError
+      attr_reader :exception
+
+      # Constructor
+      #
+      # @param object [Net::HTTPResponse | StandardError] either a Net::HTTPResponse or a StandardError
+      def initialize(object)
+        case object
+        when Net::HTTPResponse then
+          @code = object.code
+          @content_string = object.body
+          @content_type = object.content_type
+          @headers = object.each_header.inject({}) { |h,(k,v)| h[k] = v; h }
+          @message = object.message
+          @response = object
+          @status = @code.to_i
+
+          # if content type is json, try to parse the content string
+          @content = case @content_type
+            when "application/json" then
+              # will raise an exception if content_string is not valid json
+              JSON.parse(@content_string)
+            else
+              {}
+            end
+        when StandardError then
+          @code = "0"
+          @content = {}
+          @content_string = nil
+          @content_type = nil
+          @backtrace = object.backtrace
+          @exception = object.exception
+          @message = object.message
+          @status = @code.to_i
+        else
+          raise StandardError.new("Invalid response object: #{object.class}")
+        end
+      end
+    end
+
+  end
+end