nice_http 1.8.10 → 1.9.0

data/lib/nice_http/methods/post.rb

@@ -0,0 +1,122 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Post data to path
+  # @param arguments [Hash] containing at least keys :data and :path.
+  #   In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
+  # @param arguments [Array<path, data, additional_headers>]
+  #   path (string).
+  #   data (json data for example).
+  #   additional_headers (Hash key=>value).
+  # @return [Hash] response
+  #   Including at least the symbol keys:
+  #     :data = the response data body.
+  #     :message = plain text response.
+  #     :code = code response (200=ok,500=wrong...).
+  #   All keys in response are lowercase.
+  #   data, message and code can also be accessed as attributes like .message .code .data.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  # @example
+  #   resp = @http.post(Requests::Customer.update_customer)
+  #   assert resp.code == 201
+  # @example
+  #   resp = http.post( {
+  #                       path: "/api/users",
+  #                       data: {name: "morpheus", job: "leader"}
+  #                      } )
+  #   pp resp.data.json
+  ######################################################
+  def post(*arguments)
+    begin
+      path, data, headers_t = manage_request(*arguments)
+      @start_time = Time.now if @start_time.nil?
+      if arguments.size > 0 and arguments[0].kind_of?(Hash)
+        arg = arguments[0]
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        if headers_t["Content-Type"] == "multipart/form-data"
+          require "net/http/post/multipart"
+          headers_t.each { |key, value|
+            arguments[0][:data].add_field(key, value) #add to Headers
+          }
+          resp = @http.request(arguments[0][:data])
+        elsif headers_t["Content-Type"].to_s.include?("application/x-www-form-urlencoded")
+          encoded_form = URI.encode_www_form(arguments[0][:data])
+          resp = @http.request_post(path, encoded_form, headers_t)
+          data = resp.body
+        else
+          resp = @http.post(path, data, headers_t)
+          #todo: do it also for forms and multipart
+          if (resp.code == 401 or resp.code == 408) and @headers_orig.values.map(&:class).include?(Proc)
+            try = false
+            @headers_orig.each do |k, v|
+              if v.is_a?(Proc) and headers_t.key?(k)
+                try = true
+                headers_t[k] = v.call
+              end
+            end
+            if try
+              @logger.warn "Not authorized. Trying to generate a new token."
+              resp = @http.post(path, data, headers_t)
+            end
+          end
+          data = resp.body
+        end
+      rescue Exception => stack
+        @logger.warn stack
+        if !@timeout.nil? and (Time.now - @start_time_net) > @timeout
+          @logger.warn "The connection seems to be closed in the host machine. Timeout."
+          return { fatal_error: "Net::ReadTimeout", code: nil, message: nil, data: "" }
+        else
+          @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+          @http.finish()
+          @http.start()
+          @start_time_net = Time.now if @start_time_net.nil?
+          @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
+          resp, data = @http.post(path, data, headers_t)
+        end
+      end
+      manage_response(resp, data)
+      if @auto_redirect and @response[:code].to_i >= 300 and @response[:code].to_i < 400 and @response.include?(:location)
+        if @num_redirects <= 30
+          @num_redirects += 1
+          current_server = "http"
+          current_server += "s" if @ssl == true
+          current_server += "://#{@host}"
+          location = @response[:location].gsub(current_server, "")
+          @logger.info "(#{@num_redirects}) Redirecting NiceHttp to #{location}"
+          get(location)
+        else
+          @logger.fatal "(#{@num_redirects}) Maximum number of redirections for a single request reached. Be sure everything is correct, it seems there is a non ending loop"
+          @num_redirects = 0
+        end
+      else
+        @num_redirects = 0
+      end
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return { fatal_error: stack.to_s, code: nil, message: nil, data: "" }
+    end
+  end
+end

data/lib/nice_http/methods/put.rb

@@ -0,0 +1,87 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Put data to path
+  # @param arguments [Hash] containing at least keys :data and :path.
+  #   In case :data not supplied and :data_examples array supplied, it will be taken the first example as :data.
+  # @param arguments [Array<path, data, additional_headers>]
+  #   path (string).
+  #   data (json data for example).
+  #   additional_headers (Hash key=>value).
+  # @return [Hash] response
+  #   Including at least the symbol keys:
+  #     :data = the response data body.
+  #     :message = plain text response.
+  #     :code = code response (200=ok,500=wrong...).
+  #   All keys in response are lowercase.
+  #   data, message and code can also be accessed as attributes like .message .code .data.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  # @example
+  #   resp = @http.put(Requests::Customer.remove_phone)
+  ######################################################
+  def put(*arguments)
+    begin
+      path, data, headers_t = manage_request(*arguments)
+      @start_time = Time.now if @start_time.nil?
+      if arguments.size > 0 and arguments[0].kind_of?(Hash)
+        arg = arguments[0]
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          data = ""
+          if arg[:mock_response].keys.include?(:data)
+            data = arg[:mock_response][:data]
+            if data.kind_of?(Hash) #to json
+              begin
+                require "json"
+                data = data.to_json
+              rescue
+                @logger.fatal "There was a problem converting to json: #{data}"
+              end
+            end
+          end
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], data.to_s)
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.send_request("PUT", path, data, headers_t)
+        if (resp.code == 401 or resp.code == 408) and @headers_orig.values.map(&:class).include?(Proc)
+          try = false
+          @headers_orig.each do |k, v|
+            if v.is_a?(Proc) and headers_t.key?(k)
+              try = true
+              headers_t[k] = v.call
+            end
+          end
+          if try
+            @logger.warn "Not authorized. Trying to generate a new token."
+            resp = @http.send_request("PUT", path, data, headers_t)
+          end
+        end
+        data = resp.body
+      rescue Exception => stack
+        @logger.warn stack
+        if !@timeout.nil? and (Time.now - @start_time_net) > @timeout
+          @logger.warn "The connection seems to be closed in the host machine. Timeout."
+          return { fatal_error: "Net::ReadTimeout", code: nil, message: nil, data: "" }
+        else
+          @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
+          @http.finish()
+          @http.start()
+          @headers_orig.each { |k, v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k) }
+          @start_time_net = Time.now if @start_time_net.nil?
+          resp, data = @http.send_request("PUT", path, data, headers_t)
+        end
+      end
+      manage_response(resp, data)
+
+      return @response
+    rescue Exception => stack
+      @logger.fatal stack
+      return { fatal_error: stack.to_s, code: nil, message: nil, data: "" }
+    end
+  end
+end

data/lib/nice_http/methods/send_request.rb

@@ -0,0 +1,47 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # It will send the request depending on the :method declared on the request hash
+  # Take a look at https://github.com/MarioRuiz/Request-Hash
+  #
+  # @param request_hash [Hash] containing at least key :path and :method. The methods that are accepted are: :get, :head, :post, :put, :delete, :patch
+  #
+  # @return [Hash] response
+  #   Including at least the symbol keys:
+  #     :data = the response data body.
+  #     :message = plain text response.
+  #     :code = code response (200=ok,500=wrong...).
+  #   All keys in response are lowercase.
+  #   data, message and code can also be accessed as attributes like .message .code .data.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil, data: '' }
+  # @example
+  #   resp = @http.send_request Requests::Customer.remove_session
+  #   assert resp.code == 204
+  ######################################################
+  def send_request(request_hash)
+    unless request_hash.is_a?(Hash) and request_hash.key?(:method) and request_hash.key?(:path) and
+           request_hash[:method].is_a?(Symbol) and
+           [:get, :head, :post, :put, :delete, :patch].include?(request_hash[:method])
+      message = "send_request: it needs to be supplied a Request Hash that includes a :method and :path. "
+      message += "Supported methods: :get, :head, :post, :put, :delete, :patch"
+      @logger.fatal message
+      return { fatal_error: message, code: nil, message: nil }
+    else
+      case request_hash[:method]
+      when :get
+        resp = get request_hash
+      when :post
+        resp = post request_hash
+      when :head
+        resp = head request_hash
+      when :put
+        resp = put request_hash
+      when :delete
+        resp = delete request_hash
+      when :patch
+        resp = patch request_hash
+      end
+      return resp
+    end
+  end
+end

data/lib/nice_http/reset.rb

@@ -0,0 +1,54 @@
+class NiceHttp
+  ######################################################
+  # to reset to the original defaults
+  ######################################################
+  def self.reset!
+    @host = nil
+    @port = 80
+    @ssl = false
+    @timeout = nil
+    @headers = {}
+    @values_for = {}
+    @debug = false
+    @log = :fix_file
+    @log_path = ""
+    @log_headers = :all
+    @proxy_host = nil
+    @proxy_port = nil
+    @last_request = nil
+    @request = nil
+    @requests = nil
+    @last_response = nil
+    @request_id = ""
+    @use_mocks = false
+    @connections = []
+    @active = 0
+    @auto_redirect = true
+    @log_files = {}
+    @create_stats = false
+    @stats = {
+      all: {
+        num_requests: 0,
+        started: nil,
+        finished: nil,
+        real_time_elapsed: 0,
+        time_elapsed: {
+          total: 0,
+          maximum: 0,
+          minimum: 1000000,
+          average: 0,
+        },
+        method: {},
+      },
+      path: {},
+      name: {},
+    }
+    @capture = false
+    @captured = []
+    @async_wait_seconds = 0
+    @async_header = "location"
+    @async_completed = ""
+    @async_resource = ""
+    @async_status = ""
+  end
+end

data/lib/nice_http/save_stats.rb

@@ -0,0 +1,37 @@
+class NiceHttp
+  ######################################################
+  # It will save the NiceHttp.stats on different files, each key of the hash in a different file.
+  #
+  # @param file_name [String] path and file name to be used to store the stats.
+  #   In case no one supplied it will be used the value in NiceHttp.log and it will be saved on YAML format.
+  #   In case extension is .yaml will be saved on YAML format.
+  #   In case extension is .json will be saved on JSON format.
+  #
+  # @example
+  #    NiceHttp.save_stats
+  #    NiceHttp.save_stats('./stats/my_stats.yaml')
+  #    NiceHttp.save_stats('./stats/my_stats.json')
+  ######################################################
+  def self.save_stats(file_name = "")
+    if file_name == ""
+      if self.log.is_a?(String)
+        file_name = self.log
+      else
+        file_name = "./#{self.log_path}nice_http.log"
+      end
+    end
+    require "fileutils"
+    FileUtils.mkdir_p File.dirname(file_name)
+    if file_name.match?(/\.json$/)
+      require "json"
+      self.stats.keys.each do |key|
+        File.open("#{file_name.gsub(/.json$/, "_stats_")}#{key}.json", "w") { |file| file.write(self.stats[key].to_json) }
+      end
+    else
+      require "yaml"
+      self.stats.keys.each do |key|
+        File.open("#{file_name.gsub(/.\w+$/, "_stats_")}#{key}.yaml", "w") { |file| file.write(self.stats[key].to_yaml) }
+      end
+    end
+  end
+end

data/lib/nice_http/utils/basic_authentication.rb

@@ -0,0 +1,18 @@
+module NiceHttpUtils
+  ##################################################
+  # returns the seed for Basic authentication
+  # @param user [String]
+  # @param password [String]
+  # @param strict [Boolean] (default: false) use strict_encode64 if true, if not encode64
+  # @return [String] seed string to be used on Authorization key header on a get request
+  ####################################################
+  def self.basic_authentication(user:, password:, strict: false)
+    require "base64"
+    if strict
+      seed = "Basic " + Base64.strict_encode64(user + ":" + password)
+    else
+      seed = "Basic " + Base64.encode64(user + ":" + password)
+    end
+    return seed
+  end
+end

data/lib/nice_http/{utils.rb → utils/get_value_xml_tag.rb}

@@ -60,49 +60,4 @@ module NiceHttpUtils
       return ret
     end
   end
-
-  ##################################################
-  # set a value on xml tag
-  # @param tag_name [String]
-  # @param xml_string [String]
-  # @param value [String]
-  # @param take_off_prefix [Boolean] (optional). true, false(default)
-  # @return [String] with the new value
-  ####################################################
-  def self.set_value_xml_tag(tag_name, xml_string, value, take_off_prefix = false)
-    tag_name = tag_name.to_s
-    if take_off_prefix
-      i = tag_name.index(":")
-      tag_name = tag_name[i + 1..tag_name.length] unless i.nil?
-    end
-    if xml_string.to_s != ""
-      if take_off_prefix
-        old_value = NiceHttpUtils.get_value_xml_tag(tag_name, xml_string.dup, true)
-        xml_string.gsub!(/:#{tag_name}>#{Regexp.escape(old_value)}<\//i, ":" + tag_name + ">" + value + "</")
-        xml_string.gsub!(/<#{tag_name}>#{Regexp.escape(old_value)}<\//i, "<" + tag_name + ">" + value + "</")
-      else
-        xml_string.gsub!(/<#{tag_name}>.*<\/#{tag_name}>/i, "<" + tag_name + ">" + value + "</" + tag_name + ">")
-      end
-      return xml_string
-    else
-      return ""
-    end
-  end
-
-  ##################################################
-  # returns the seed for Basic authentication
-  # @param user [String]
-  # @param password [String]
-  # @param strict [Boolean] (default: false) use strict_encode64 if true, if not encode64
-  # @return [String] seed string to be used on Authorization key header on a get request
-  ####################################################
-  def self.basic_authentication(user:, password:, strict: false)
-    require "base64"
-    if strict
-      seed = "Basic " + Base64.strict_encode64(user + ":" + password)
-    else
-      seed = "Basic " + Base64.encode64(user + ":" + password)
-    end
-    return seed
-  end
 end

data/lib/nice_http/utils/set_value_xml_tag.rb

@@ -0,0 +1,30 @@
+module NiceHttpUtils
+
+  ##################################################
+  # set a value on xml tag
+  # @param tag_name [String]
+  # @param xml_string [String]
+  # @param value [String]
+  # @param take_off_prefix [Boolean] (optional). true, false(default)
+  # @return [String] with the new value
+  ####################################################
+  def self.set_value_xml_tag(tag_name, xml_string, value, take_off_prefix = false)
+    tag_name = tag_name.to_s
+    if take_off_prefix
+      i = tag_name.index(":")
+      tag_name = tag_name[i + 1..tag_name.length] unless i.nil?
+    end
+    if xml_string.to_s != ""
+      if take_off_prefix
+        old_value = NiceHttpUtils.get_value_xml_tag(tag_name, xml_string.dup, true)
+        xml_string.gsub!(/:#{tag_name}>#{Regexp.escape(old_value)}<\//i, ":" + tag_name + ">" + value + "</")
+        xml_string.gsub!(/<#{tag_name}>#{Regexp.escape(old_value)}<\//i, "<" + tag_name + ">" + value + "</")
+      else
+        xml_string.gsub!(/<#{tag_name}>.*<\/#{tag_name}>/i, "<" + tag_name + ">" + value + "</" + tag_name + ">")
+      end
+      return xml_string
+    else
+      return ""
+    end
+  end
+end