nice_http 1.8.10 → 1.9.0

data/lib/nice_http/{manage_response.rb → manage/response.rb}

@@ -31,7 +31,7 @@ module NiceHttpManageResponse
 
       begin
         # this is to be able to access all keys as symbols on Ruby < 2.6.0
-        if RUBY_VERSION < '2.6.0'
+        if RUBY_VERSION < "2.6.0"
           new_resp = Hash.new()
           resp.each { |key, value|
             if key.kind_of?(String)
@@ -107,11 +107,11 @@ module NiceHttpManageResponse
             if key.kind_of?(Symbol)
               if key == :code or key == :data or key == :header or key == :message
                 if key == :data and !@response[:'content-type'].to_s.include?("text/html")
-                  if key == :data and 
-                    (!@response[:'content-type'].include?('text') and 
-                     !@response[:'content-type'].include?('json') and
-                     !@response[:'content-type'].include?('xml') and
-                     !@response[:'content-type'].include?('charset=utf-8'))
+                  if key == :data and
+                     (!@response[:'content-type'].include?("text") and
+                      !@response[:'content-type'].include?("json") and
+                      !@response[:'content-type'].include?("xml") and
+                      !@response[:'content-type'].include?("charset=utf-8"))
                     message += "\n data: It's not text data so won't be in the logs."
                   else
                     begin
@@ -185,6 +185,7 @@ module NiceHttpManageResponse
           end
         end
       end
+      @response = wait_async_operation() if @response[:code] == "202"
       @prev_response = @response
     rescue Exception => stack
       @logger.fatal stack
@@ -192,109 +193,4 @@ module NiceHttpManageResponse
     end
     @start_time = nil
   end
-
-  private
-
-  def set_stats(hash)
-    unless hash.key?(:num_requests)
-      # to add to the end the previous keys so num_requests and time_elapsed come first
-      keys = hash.keys
-      hash.keys.each do |k|
-        hash.delete(k)
-      end
-
-      hash[:num_requests] = 0
-      hash[:started] = @start_time
-      hash[:finished] = @start_time
-      hash[:real_time_elapsed] = 0
-      hash[:time_elapsed] = {
-        total: 0,
-        maximum: 0,
-        minimum: 100000,
-        average: 0,
-      }
-
-      # to add to the end the previous keys so num_requests and time_elapsed come first
-      keys.each do |k|
-        hash[k] = {}
-      end
-    end
-    hash[:num_requests] += 1
-    hash[:started] = hash[:finished] = @start_time if hash[:started].nil?
-
-    if @start_time < hash[:finished]
-      hash[:real_time_elapsed] += (@finish_time - hash[:finished])
-    else
-      hash[:real_time_elapsed] += (@finish_time - @start_time)
-    end
-    hash[:finished] = @finish_time
-
-    hash[:time_elapsed][:total] += @response[:time_elapsed]
-    hash[:time_elapsed][:maximum] = @response[:time_elapsed] if @response[:time_elapsed] > hash[:time_elapsed][:maximum]
-    hash[:time_elapsed][:minimum] = @response[:time_elapsed] if @response[:time_elapsed] < hash[:time_elapsed][:minimum]
-    hash[:time_elapsed][:average] = hash[:time_elapsed][:total] / hash[:num_requests]
-  end
-
-  private
-
-  def create_stats(resp)
-    # all
-    set_stats(self.class.stats[:all])
-    # all method
-    unless self.class.stats[:all][:method].key?(@prev_request[:method])
-      self.class.stats[:all][:method][@prev_request[:method]] = {
-        response: {},
-      }
-    end
-    set_stats(self.class.stats[:all][:method][@prev_request[:method]])
-    # all method response
-    unless self.class.stats[:all][:method][@prev_request[:method]][:response].key?(resp.code)
-      self.class.stats[:all][:method][@prev_request[:method]][:response][resp.code] = {}
-    end
-    set_stats(self.class.stats[:all][:method][@prev_request[:method]][:response][resp.code])
-
-    # server
-    server = "#{@host}:#{@port}"
-    unless self.class.stats[:path].key?(server)
-      self.class.stats[:path][server] = {}
-    end
-    set_stats(self.class.stats[:path][server])
-    # server path
-    unless self.class.stats[:path][server].key?(@prev_request[:path])
-      self.class.stats[:path][server][@prev_request[:path]] = { method: {} }
-    end
-    set_stats(self.class.stats[:path][server][@prev_request[:path]])
-    # server path method
-    unless self.class.stats[:path][server][@prev_request[:path]][:method].key?(@prev_request[:method])
-      self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]] = {
-        response: {},
-      }
-    end
-    set_stats(self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]])
-    # server path method response
-    unless self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response].key?(resp.code)
-      self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response][resp.code] = {}
-    end
-    set_stats(self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response][resp.code])
-
-    if @prev_request.key?(:name)
-      # name
-      unless self.class.stats[:name].key?(@prev_request[:name])
-        self.class.stats[:name][@prev_request[:name]] = { method: {} }
-      end
-      set_stats(self.class.stats[:name][@prev_request[:name]])
-      # name method
-      unless self.class.stats[:name][@prev_request[:name]][:method].key?(@prev_request[:method])
-        self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]] = {
-          response: {},
-        }
-      end
-      set_stats(self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]])
-      # name method response
-      unless self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response].key?(resp.code)
-        self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response][resp.code] = {}
-      end
-      set_stats(self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response][resp.code])
-    end
-  end
 end

data/lib/nice_http/manage/set_stats.rb

@@ -0,0 +1,43 @@
+module NiceHttpManageResponse
+  private
+
+  def set_stats(hash)
+    unless hash.key?(:num_requests)
+      # to add to the end the previous keys so num_requests and time_elapsed come first
+      keys = hash.keys
+      hash.keys.each do |k|
+        hash.delete(k)
+      end
+
+      hash[:num_requests] = 0
+      hash[:started] = @start_time
+      hash[:finished] = @start_time
+      hash[:real_time_elapsed] = 0
+      hash[:time_elapsed] = {
+        total: 0,
+        maximum: 0,
+        minimum: 100000,
+        average: 0,
+      }
+
+      # to add to the end the previous keys so num_requests and time_elapsed come first
+      keys.each do |k|
+        hash[k] = {}
+      end
+    end
+    hash[:num_requests] += 1
+    hash[:started] = hash[:finished] = @start_time if hash[:started].nil?
+
+    if @start_time < hash[:finished]
+      hash[:real_time_elapsed] += (@finish_time - hash[:finished])
+    else
+      hash[:real_time_elapsed] += (@finish_time - @start_time)
+    end
+    hash[:finished] = @finish_time
+
+    hash[:time_elapsed][:total] += @response[:time_elapsed]
+    hash[:time_elapsed][:maximum] = @response[:time_elapsed] if @response[:time_elapsed] > hash[:time_elapsed][:maximum]
+    hash[:time_elapsed][:minimum] = @response[:time_elapsed] if @response[:time_elapsed] < hash[:time_elapsed][:minimum]
+    hash[:time_elapsed][:average] = hash[:time_elapsed][:total] / hash[:num_requests]
+  end
+end

data/lib/nice_http/manage/wait_async_operation.rb

@@ -0,0 +1,43 @@
+module NiceHttpManageResponse
+  def wait_async_operation(response: @response, async_wait_seconds: @async_wait_seconds, async_header: @async_header, async_completed: @async_completed, async_resource: @async_resource, async_status: @async_status)
+    resp_orig = response.deep_copy
+    if async_wait_seconds.to_i > 0 and !async_header.empty? and !async_completed.empty?
+      if response.code == 202 and response.key?(async_header.to_sym)
+        begin
+          location = response[async_header.to_sym]
+          time_elapsed = 0
+          resp_async = {body: ''}
+          while time_elapsed <= async_wait_seconds
+            path, data, headers_t = manage_request({ path: location })
+            resp_async = @http.get path
+            completed = resp_async.body.json(async_completed.to_sym)
+            break if completed.to_i == 100 or time_elapsed >= async_wait_seconds
+            time_elapsed += 1
+            sleep 1
+          end
+          resp_orig.async = {}
+          resp_orig.async.seconds = time_elapsed
+          resp_orig.async.data = resp_async.body
+          if resp_async.body.json.key?(async_status.to_sym)
+            resp_orig.async.status = resp_async.body.json(async_status.to_sym) 
+          else
+            resp_orig.async.status = ''
+          end
+          unless async_resource.empty?
+            location = resp_async.body.json(async_resource.to_sym)
+            if location.empty?
+                resp_orig.async.resource = {}
+            else
+              path, data, headers_t = manage_request({ path: location })
+              resp_async = @http.get path
+              resp_orig.async.resource = {data: resp_async.body}
+            end
+          end
+        rescue Exception => stack
+          @logger.warn stack
+        end
+      end
+    end
+    return resp_orig
+  end
+end

data/lib/nice_http/methods/delete.rb

@@ -0,0 +1,108 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Delete an existing resource
+  # @param argument [Hash, String]  hash containing at least key :path or a string with the path
+  #
+  # @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.delete(Requests::Customer.remove_session)
+  #   assert resp.code == 204
+  ######################################################
+  def delete(argument)
+    begin
+      if argument.kind_of?(String)
+        argument = { :path => argument }
+      end
+      path, data, headers_t = manage_request(argument)
+      @start_time = Time.now if @start_time.nil?
+      if argument.kind_of?(Hash)
+        arg = argument
+        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 data.to_s == ""
+          resp = @http.delete(path, 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.delete(path, headers_t)
+            end
+          end
+        else
+          request = Net::HTTP::Delete.new(path, headers_t)
+          request.body = data
+          resp = @http.request(request)
+          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."
+              request = Net::HTTP::Delete.new(path, headers_t)
+              request.body = data
+              resp = @http.request(request)
+            end
+          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.delete(path, 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/get.rb

@@ -0,0 +1,159 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Get data from path
+  #
+  # @param arg [Hash, String] hash containing at least key :path or a string with the path
+  # @param save_data [String] the path or path and file name where we want to save the response data
+  #
+  # @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.get(Requests::Customer.get_profile)
+  #   assert resp.code == 200
+  # @example
+  #   resp = @http.get("/customers/1223")
+  #   assert resp.message == "OK"
+  # @example
+  #   resp = @http.get("/assets/images/logo.png", save_data: './tmp/')
+  # @example
+  #   resp = @http.get("/assets/images/logo.png", save_data: './tmp/example.png')
+  ######################################################
+  def get(arg, save_data: "")
+    begin
+      path, data, headers_t = manage_request(arg)
+
+      @start_time = Time.now if @start_time.nil?
+      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
+      begin
+        if path.start_with?("http:") or path.start_with?("https:") #server included on path problably because of a redirection to a different server
+          require "uri"
+          uri = URI.parse(path)
+          ssl = false
+          ssl = true if path.include?("https:")
+
+          server = "http://"
+          server = "https://" if path.start_with?("https:")
+          if uri.port != 443
+            server += "#{uri.host}:#{uri.port}"
+          else
+            server += "#{uri.host}"
+          end
+
+          http_redir = nil
+          self.class.connections.each { |conn|
+            if conn.host == uri.host and conn.port == uri.port
+              http_redir = conn
+              break
+            end
+          }
+
+          if !http_redir.nil?
+            path, data, headers_t = manage_request(arg)
+            http_redir.cookies.merge!(@cookies)
+            http_redir.headers.merge!(headers_t)
+            #todo: remove only the server at the begining in case in query is the server it will be replaced when it should not be
+            resp = http_redir.get(path.gsub(server, ""))
+            @response = http_redir.response
+          else
+            @logger.warn "It seems like the http connection cannot redirect to #{server} because there is no active connection for that server. You need to create previously one."
+          end
+        else
+          @start_time_net = Time.now if @start_time_net.nil?
+          resp = @http.get(path, 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.get(path, headers_t)
+            end
+          end
+          data = resp.body
+          manage_response(resp, data)
+        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 = @http.get(path, headers_t)
+          data = resp.body
+          manage_response(resp, data)
+        end
+      end
+      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
+      if save_data != ""
+        require "pathname"
+        pn_get = Pathname.new(path)
+
+        if Dir.exist?(save_data)
+          save = save_data + "/" + pn_get.basename.to_s
+        elsif save_data[-1] == "/"
+          save = save_data + pn_get.basename.to_s
+        else
+          save = save_data
+        end
+        if Dir.exist?(Pathname.new(save).dirname)
+          File.open(save, "wb") { |fp| fp.write(@response.data) }
+        else
+          @logger.fatal "The folder #{Pathname.new(save).dirname} doesn't exist"
+        end
+      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/head.rb

@@ -0,0 +1,72 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Implementation of the http HEAD method.
+  # Asks for the response identical to the one that would correspond to a GET request, but without the response body.
+  # This is useful for retrieving meta-information written in response headers, without having to transport the entire content.
+  # @param argument [Hash, String] hash containing at least key :path or directly an string with the path
+  #
+  # @return [Hash] response
+  #   Including at least the symbol keys:
+  #     :message = plain text response.
+  #     :code = code response (200=ok,500=wrong...).
+  #   All keys in response are lowercase.
+  #   message and code can also be accessed as attributes like .message .code.
+  #   In case of fatal error returns { fatal_error: "the error description", code: nil, message: nil }
+  ######################################################
+  def head(argument)
+    begin
+      if argument.kind_of?(String)
+        argument = { :path => argument }
+      end
+      path, data, headers_t = manage_request(argument)
+      @start_time = Time.now if @start_time.nil?
+      if argument.kind_of?(Hash)
+        arg = argument
+        if @use_mocks and arg.kind_of?(Hash) and arg.keys.include?(:mock_response)
+          @logger.warn "Pay attention!!! This is a mock response:"
+          @start_time_net = Time.now if @start_time_net.nil?
+          manage_response(arg[:mock_response], "")
+          return @response
+        end
+      end
+
+      begin
+        @start_time_net = Time.now if @start_time_net.nil?
+        resp = @http.head(path, 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.head(path, 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.head(path, 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 }
+    end
+  end
+end

data/lib/nice_http/methods/patch.rb

@@ -0,0 +1,103 @@
+module NiceHttpHttpMethods
+
+  ######################################################
+  # Patch 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.patch(Requests::Customer.unrelease_account)
+  ######################################################
+  def patch(*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.patch(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.patch(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.patch(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