rally_api 0.6.0 → 0.7.0

data/lib/rally_api/rally_json_connection.rb

@@ -1,4 +1,4 @@
-require 'rest_client'
+require "httpclient"
 require 'json'
 
 # :stopdoc:
@@ -15,70 +15,30 @@ module RallyAPI
 
     DEFAULT_PAGE_SIZE = 200
 
-    attr_accessor :rally_headers, :retries, :retry_list, :low_debug, :logger
+    attr_accessor :rally_headers, :low_debug, :logger
 
     def initialize(headers, low_debug, proxy_info)
       @rally_headers = headers
       @low_debug = low_debug
       @logger = nil
 
-      @retries = 0
-      @retry_list = {}
+      @rally_http_client = HTTPClient.new
+      @rally_http_client.receive_timeout = 300
+      @rally_http_client.send_timeout    = 300
+      @rally_http_client.transparent_gzip_decompression = true
 
-      if (!ENV["http_proxy"].nil?) && (proxy_info.nil?)
-        RestClient.proxy = ENV['http_proxy']
+      #passed in proxy setup overrides env level proxy
+      env_proxy = ENV["http_proxy"]
+      if (!env_proxy.nil?) && (proxy_info.nil?)
+        @rally_http_client.proxy = env_proxy
       end
-
-      if !proxy_info.nil?
-        RestClient.proxy = proxy_info
-      end
-
-    end
-
-    def read_object(url, args, params = nil)
-      args[:method] = :get
-      result = send_json_request(url, args, params)
-      log_info(result) if @low_debug
-      rally_type = result.keys[0]
-      result[rally_type]
-    end
-
-    def create_object(url, args, rally_object)
-      args[:method] = :post
-      text_json = rally_object.to_json
-      args[:payload] = text_json
-      log_info("create - payload json: #{text_json}") if @low_debug
-      result = send_json_request(url, args)
-      log_info("create - result: #{result}") if @low_debug
-      result["CreateResult"]["Object"]
-    end
-
-    def update_object(url, args, rally_fields)
-      args[:method] = :post
-      text_json = rally_fields.to_json
-      args[:payload] = text_json
-      log_info("update payload json: #{text_json}") if @low_debug
-      result = send_json_request(url, args)
-      log_info("update - result: #{result}") if @low_debug
-      result["OperationResult"]
-    end
-
-    def put_object(url, args, put_params, rally_fields)
-      args[:method] = :put
-      text_json = rally_fields.to_json
-      args[:payload] = text_json
-      result = send_json_request(url, args, put_params)
-      result["OperationResult"]
+      @rally_http_client.proxy = proxy_info unless !proxy_info.nil?
     end
 
-    def delete_object(url,args)
-      args[:method] = :delete
-      result = send_json_request(url,args)
-      log_info("delete result - #{result}") if @low_debug
-      result["OperationResult"]
+    def set_client_user(base_url, user, password)
+      @rally_http_client.set_basic_auth(base_url, user, password)
     end
 
-    #---------------------------------------------
     def get_all_json_results(url, args, query_params, limit = 99999)
       all_results = []
       args[:method] = :get
@@ -87,7 +47,8 @@ module RallyAPI
       params[:start]    = 1
       params = params.merge(query_params)
 
-      query_result = send_json_request(url, args, params)
+      #query_result = send_json_request(url, args, params)
+      query_result = send_request(url, args, params)
       all_results.concat(query_result["QueryResult"]["Results"])
       totals = query_result["QueryResult"]["TotalResultCount"]
 
@@ -110,6 +71,36 @@ module RallyAPI
       query_result
     end
 
+    #args should have :method
+    def send_request(url, args, url_params = {})
+      method = args[:method]
+      req_args = { :query => url_params }
+
+      req_headers = @rally_headers.headers
+      if (args[:method] == :post) || (args[:method] == :put)
+        req_headers["Content-Type"] = "application/json"
+        req_headers["Accept"] = "application/json"
+        text_json =args[:payload].to_json
+        req_args[:body] = text_json
+      end
+      req_args[:header] = req_headers
+
+      begin
+        log_info("Rally API calling #{method} - #{url} with #{req_args}") if @low_debug
+        response = @rally_http_client.request(method, url, req_args)
+      rescue Exception => ex
+        msg =  "Rally Rest Json: - rescued exception - #{ex.message} on request to #{url} with params #{url_params}"
+        log_info(msg)
+        raise StandardError, msg
+      end
+
+      log_info("RallyAPI response was - #{response.inspect}") if @low_debug
+      json_obj = JSON.parse(response.body)   #todo handle null post error
+      errs = check_for_errors(json_obj)
+      raise StandardError, "\nError on request - #{url} - \n#{errs}" if errs[:errors].length > 0
+      json_obj
+    end
+
     private
 
     def run_threads(query_array)
@@ -132,57 +123,13 @@ module RallyAPI
       Thread.new do
         thread_results = []
         request_array.each do |req|
-            page_res = send_json_request(req[:url], req[:args], req[:params])
+            page_res = send_request(req[:url], req[:args], req[:params])
             thread_results.push({:page_num => req[:page_num], :results => page_res})
         end
         thread_results
       end
     end
 
-    def send_json_request(url, args, url_params = nil)
-      request_args = {}
-      request_args[:url]      = url
-      request_args[:user]     = args[:user]
-      request_args[:password] = args[:password]
-      request_args[:method]   = args[:method]
-      request_args[:timeout]  = 120
-      request_args[:open_timeout] = 120
-
-      r_headers = @rally_headers.headers
-      r_headers[:params] = url_params
-
-      if (args[:method] == :post) || (args[:method] == :put)
-        r_headers[:content_type] = :json
-        r_headers[:accept] = :json
-        request_args[:payload] = args[:payload]
-      end
-
-      request_args[:headers] = r_headers
-
-      begin
-        req = RestClient::Request.new(request_args)
-        log_info(req.url) if @low_debug
-        response = req.execute
-      rescue => ex
-        msg =  "Rally Rest Json: - rescued exception - #{ex.message} on request to #{url} with params #{url_params}"
-        log_info(msg)
-        if !@retry_list.has_key?(req.url)
-          @retry_list[req.url] = 0
-        end
-        if (@retries > 0) && (retry_list[req.url] < @retries)
-          @retry_list[req.url] += 1
-          retry
-        end
-        raise StandardError, msg
-      end
-      @retry_list.delete(req.url)
-      log_info(response) if @low_debug
-      json_obj = JSON.parse(response.body)   #todo handle null post error
-      errs = check_for_errors(json_obj)
-      raise StandardError, "\nError on request - #{url} - \n#{errs}" if errs[:errors].length > 0
-      json_obj
-    end
-
     def log_info(message)
       puts message if @logger.nil?
       @logger.debug(message) unless @logger.nil?

data/lib/rally_api/rally_object.rb

@@ -72,7 +72,7 @@ module RallyAPI
     def method_missing(sym, *args)
       ret_val = get_val(sym.to_s)
       if @rally_rest.rally_rest_api_compat && ret_val.nil?
-        ret_val = get_val(camel_case_word(:sym))
+        ret_val = get_val(camel_case_word(sym))
       end
       ret_val
     end

data/lib/rally_api/rally_rest_json.rb

@@ -68,6 +68,7 @@ module RallyAPI
       @logger    = args[:logger] || nil    #assumes this is an instance of Logger
 
       @rally_connection = RallyJsonConnection.new(@rally_headers, @low_debug, @proxy_info)
+      @rally_connection.set_client_user(@rally_url, @rally_user, @rally_password)
       @rally_connection.logger  = @logger unless @logger.nil?
       @rally_connection.retries = @retries if @retries > 0
 
@@ -128,9 +129,10 @@ module RallyAPI
     end
 
     def user
-      args = {:user => @rally_user, :password => @rally_password}
-      json_response = @rally_connection.read_object(make_get_url(@rally_objects[:user]), args)
-      RallyObject.new(self, json_response)
+      args = { :method => :get }
+      json_response = @rally_connection.send_request(make_get_url(@rally_objects[:user]), args)
+      rally_type = json_response.keys[0]
+      RallyObject.new(self, json_response[rally_type])
     end
 
 
@@ -142,29 +144,38 @@ module RallyAPI
         fields["Project"] = @rally_default_project._ref unless @rally_default_project.nil?
       end
 
-      args = {:user => @rally_user, :password => @rally_password }
       object2create = { rally_type => make_ref_fields(fields) }
-      json_response = @rally_connection.create_object(make_create_url(rally_type), args, object2create)
-      RallyObject.new(self, json_response).read()
+      args = { :method => :post, :payload => object2create }
+      #json_response = @rally_connection.create_object(make_create_url(rally_type), args, object2create)
+      json_response = @rally_connection.send_request(make_create_url(rally_type), args, object2create)
+      #todo - check for warnings
+      RallyObject.new(self, json_response["CreateResult"]["Object"]).read()
     end
 
 
     def read(type, obj_id, params = nil)
       rally_type = check_type(type)
       ref = check_id(rally_type, obj_id)
-      args = {:user => @rally_user, :password => @rally_password}
-      json_response = @rally_connection.read_object(ref, args, params)
-      RallyObject.new(self, json_response)
+      args = { :method => :get }
+      #json_response = @rally_connection.read_object(ref, args, params)
+      json_response = @rally_connection.send_request(ref, args, params)
+      rally_type = json_response.keys[0]
+      RallyObject.new(self, json_response[rally_type])
     end
 
     def delete(ref_to_delete)
-      args = {:user => @rally_user, :password => @rally_password}
-      @rally_connection.delete_object(ref_to_delete, args)
+      args = { :method => :delete }
+      #json_response = @rally_connection.delete_object(ref_to_delete, args)
+      json_response = @rally_connection.send_request(ref_to_delete, args)
+      json_response["OperationResult"]
     end
 
     def reread(json_object, params = nil)
-      args = {:user => @rally_user, :password => @rally_password}
-      @rally_connection.read_object(json_object["_ref"], args, params)
+      args = { :method => :get }
+      #json_response = @rally_connection.read_object(json_object["_ref"], args, params)
+      json_response = @rally_connection.send_request(json_object["_ref"], args, params)
+      rally_type = json_response.keys[0]
+      json_response[rally_type]
     end
 
 
@@ -172,8 +183,10 @@ module RallyAPI
       rally_type = check_type(type)
       ref = check_id(rally_type, obj_id)
       json_update = { rally_type => make_ref_fields(fields) }
-      args = {:user => @rally_user, :password => @rally_password}
-      @rally_connection.update_object(ref, args, json_update)
+      args = { :method => :post, :payload => json_update }
+      #json_response = @rally_connection.update_object(ref, args, json_update)
+      json_response = @rally_connection.send_request(ref, args)
+      #todo check for warnings on json_response["OperationResult"]
       RallyObject.new(self, reread({"_ref" => ref}))
     end
 
@@ -228,9 +241,10 @@ module RallyAPI
       params[:rankAbove] = short_ref(relative_ref)
       params[:fetch] = "true"
       json_update = { get_type_from_ref(ref_to_rank) => {"_ref" => ref_to_rank} }
-      args = {:user => @rally_user, :password => @rally_password}
-      update = @rally_connection.put_object(ref, args, params, json_update)
-      RallyObject.new(self, update["Object"])
+      args = { :method => :put, :payload => json_update }
+      #update = @rally_connection.put_object(ref, args, params, json_update)
+      update = @rally_connection.send_request(ref, args, params)
+      RallyObject.new(self, update["OperationResult"]["Object"])
     end
 
     #ref to object.js? rankBelow=%2Fhierarchicalrequirement%2F4624552599
@@ -240,11 +254,13 @@ module RallyAPI
       params[:rankBelow] = short_ref(relative_ref)
       params[:fetch] = "true"
       json_update = { get_type_from_ref(ref_to_rank) => {"_ref" => ref_to_rank} }
-      args = {:user => @rally_user, :password => @rally_password}
-      update = @rally_connection.put_object(ref, args, params, json_update)
-      RallyObject.new(self, update["Object"])
+      args = { :method => :put, :payload => json_update }
+      #update = @rally_connection.put_object(ref, args, params, json_update)
+      update = @rally_connection.send_request(ref, args, params)
+      RallyObject.new(self, update["OperationResult"]["Object"])
     end
 
+    #todo - check support for portfolio item fields
     def allowed_values(type, field)
       if type.class == Symbol
         query_type = @rally_objects[type]

data/lib/rally_api/version.rb

@@ -4,5 +4,5 @@
 #of the applicable Subscription Agreement between your company and
 #Rally Software Development Corp.
 module RallyAPI
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rally_api
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,19 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-17 00:00:00.000000000Z
+date: 2012-10-12 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rest-client
-  requirement: &70337979348020 !ruby/object:Gem::Requirement
+  name: httpclient
+  requirement: &70172871514240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.6.7
+        version: 2.2.4
   type: :runtime
   prerelease: false
-  version_requirements: *70337979348020
+  version_requirements: *70172871514240
 description: API wrapper for Rally's JSON REST web services api
 email:
 - dsmith@rallydev.com