gooddata 0.6.43 → 0.6.44

data/lib/gooddata/models/report_data_result.rb

@@ -94,7 +94,7 @@ module GoodData
     #
     # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
     def left_headers
-      return nil if @left_headers_cols_nums == 0
+      return nil if @left_headers_cols_nums.zero?
       top = @left_headers_cols_nums - 1
       without_top_headers.slice(0, [0, top]).to_a
     end
@@ -103,7 +103,7 @@ module GoodData
     #
     # @return [Array] Return top headers as Array of Arrays. The notation is of a matrix. First rows then cols.
     def top_headers
-      return nil if @top_headers_rows_nums == 0
+      return nil if @top_headers_rows_nums.zero?
       top = @top_headers_rows_nums - 1
       without_left_headers.slice([0, top], 0).to_a
     end
@@ -175,7 +175,7 @@ module GoodData
     # @return [Array] Returns true if data result is empty
     def empty?
       row, cols = size
-      row == 0 && cols == 0
+      row.zero? && cols.zero?
     end
 
     # Allows you to test if a report contains a row.

data/lib/gooddata/rest/client.rb

@@ -367,7 +367,7 @@ module GoodData
         @connection.download source_relative_path, target_file_path, options
       end
 
-      def download_from_user_webdav(source_relative_path, target_file_path, options = { client: GoodData.client, project: project })
+      def download_from_user_webdav(source_relative_path, target_file_path, options = { client: GoodData.client })
         download(source_relative_path, target_file_path, options.merge(:directory => options[:directory],
                                                                        :staging_url => user_webdav_path))
       end

data/lib/gooddata/rest/connection.rb

@@ -19,9 +19,6 @@ module RestClient
     def follow_redirection(request = nil, result = nil, &block)
       fail 'Using monkey patched version of RestClient::AbstractResponse#follow_redirection which is guaranteed to be compatible only with RestClient 1.8.0' if RestClient::VERSION != '1.8.0'
 
-      # @args[:cookies] = request.cookies
-      # old_follow_redirection(request, result, &block)
-
       new_args = @args.dup
 
       url = headers[:location]
@@ -29,7 +26,7 @@ module RestClient
 
       new_args[:url] = url
       if request
-        fail MaxRedirectsReached if request.max_redirects == 0
+        fail MaxRedirectsReached if request.max_redirects.zero?
         new_args[:password] = request.password
         new_args[:user] = request.user
         new_args[:headers] = request.headers
@@ -101,7 +98,8 @@ module GoodData
             'postUserLogin' => {
               'login' => username,
               'password' => password,
-              'remember' => 1
+              'remember' => 1,
+              'verify_level' => 2
             }
           }
           res
@@ -154,9 +152,11 @@ module GoodData
 
       # backward compatibility
       alias_method :cookies, :request_params
+      alias_method :headers, :request_params
       attr_reader :server
       attr_reader :stats
       attr_reader :user
+      attr_reader :verify_ssl
 
       def initialize(opts)
         super()
@@ -168,9 +168,10 @@ module GoodData
         @user = nil
         @server = nil
         @opts = opts
+        @verify_ssl = @opts[:verify_ssl] == false || @opts[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
 
-        # Initialize cookies
-        reset_cookies!
+        # Initialize headers
+        reset_headers!
 
         @at_exit_handler_installed = nil
       end
@@ -197,7 +198,7 @@ module GoodData
 
         # Reset old cookies first
         if options[:sst_token]
-          merge_cookies!('GDCAuthSST' => options[:sst_token])
+          merge_headers!(:x_gdc_authsst => options[:sst_token])
           get('/gdc/account/token', @request_params)
 
           @user = get(get('/gdc/app/account/bootstrap')['bootstrapResource']['accountSetting']['links']['self'])
@@ -230,7 +231,7 @@ module GoodData
 
         begin
           clear_session_id
-          delete url if url
+          delete(url, :x_gdc_authsst => sst_token) if url
         rescue RestClient::Unauthorized
           GoodData.logger.info 'Already disconnected'
         end
@@ -239,7 +240,7 @@ module GoodData
         @server = nil
         @user = nil
 
-        reset_cookies!
+        reset_headers!
       end
 
       def download(what, where, options = {})
@@ -272,46 +273,39 @@ module GoodData
         base_url = dir.empty? ? staging_uri : URI.join(staging_uri, "#{dir}/").to_s
         url = URI.join(base_url, CGI.escape(what)).to_s
 
-        b = proc do
+        b = proc do |f|
           raw = {
-            :headers => {
-              :user_agent => GoodData.gem_version_string
-            },
+            :headers => @webdav_headers.merge(:x_gdc_authtt => headers[:x_gdc_authtt]),
             :method => :get,
             :url => url,
-            :verify_ssl => (@opts[:verify_ssl] == false || @opts[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE) ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-          }.merge(cookies)
+            :verify_ssl => verify_ssl
+          }
+          RestClient::Request.execute(raw) do |chunk, _x, response|
+            if response.code.to_s != '200'
+              fail ArgumentError, "Error downloading #{url}. Got response: #{response.code} #{response} #{response.body}"
+            end
+            f.write chunk
+          end
+        end
 
+        GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
           if where.is_a?(IO) || where.is_a?(StringIO)
-            RestClient::Request.execute(raw) do |chunk, _x, response|
-              if response.code.to_s != '200'
-                fail ArgumentError, "Error downloading #{url}. Got response: #{response.code} #{response} #{response.body}"
-              end
-              where.write chunk
-            end
+            b.call(where)
           else
             # Assume it is a string or file
             File.open(where, 'w') do |f|
-              RestClient::Request.execute(raw) do |chunk, _x, response|
-                if response.code.to_s != '200'
-                  fail ArgumentError, "Error downloading #{url}. Got response: #{response.code} #{response} #{response.body}"
-                end
-                f.write chunk
-              end
+              b.call(f)
             end
           end
         end
-
-        res = nil
-        GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
-          res = b.call
-        end
-        res
       end
 
       def refresh_token(_options = {})
         begin # rubocop:disable RedundantBegin
-          get TOKEN_PATH, :dont_reauth => true # avoid infinite loop GET fails with 401
+          # avoid infinite loop GET fails with 401
+          response = get(TOKEN_PATH, :x_gdc_authsst => sst_token, :dont_reauth => true)
+          # Remove when TT sent in headers. Currently we need to parse from body
+          merge_headers!(:x_gdc_authtt => GoodData::Helpers.get_path(response, %w(userToken token)))
         rescue Exception => e # rubocop:disable RescueException
           puts e.message
           raise e
@@ -329,21 +323,7 @@ module GoodData
       #
       # @param uri [String] Target URI
       def delete(uri, options = {})
-        options = log_info(options)
-        GoodData.rest_logger.info "DELETE: #{@server.url}#{uri}"
-        profile "DELETE #{uri}" do
-          b = proc do
-            params = fresh_request_params(options[:request_id])
-            begin
-              @server[uri].delete(params)
-            rescue RestClient::Exception => e
-              # log the error if it happens
-              log_error(e, uri, params, options)
-              raise e
-            end
-          end
-          process_response(options, &b)
-        end
+        request(:delete, uri, nil, options)
       end
 
       # Helper for logging error
@@ -359,17 +339,26 @@ module GoodData
         end
       end
 
-      # HTTP GET
-      #
-      # @param uri [String] Target URI
-      def get(uri, options = {}, &user_block)
-        options = log_info(options)
-        GoodData.rest_logger.info "GET: #{@server.url}#{uri}, #{options}"
-        profile "GET #{uri}" do
+      def request(method, uri, data, options = {}, &user_block)
+        request_id = options[:request_id] || generate_request_id
+        log_info(options.merge(request_id: request_id))
+        payload = data.is_a?(Hash) ? data.to_json : data
+
+        GoodData.rest_logger.info "#{method.to_s.upcase}: #{@server.url}#{uri}, #{scrub_params(data, KEYS_TO_SCRUB)}"
+        profile "#{method.to_s.upcase} #{uri}" do
           b = proc do
-            params = fresh_request_params(options[:request_id]).merge(options)
+            params = fresh_request_params(request_id).merge(options)
             begin
-              @server[uri].get(params, &user_block)
+              case method
+              when :get
+                @server[uri].get(params, &user_block)
+              when :put
+                @server[uri].put(payload, params)
+              when :delete
+                @server[uri].delete(params)
+              when :post
+                @server[uri].post(payload, params)
+              end
             rescue RestClient::Exception => e
               # log the error if it happens
               log_error(e, uri, params, options)
@@ -380,55 +369,32 @@ module GoodData
         end
       end
 
+      # HTTP GET
+      #
+      # @param uri [String] Target URI
+      def get(uri, options = {}, &user_block)
+        request(:get, uri, nil, options, &user_block)
+      end
+
       # HTTP PUT
       #
       # @param uri [String] Target URI
       def put(uri, data, options = {})
-        options = log_info(options)
-        payload = data.is_a?(Hash) ? data.to_json : data
-        GoodData.rest_logger.info "PUT: #{@server.url}#{uri}, #{scrub_params(data, KEYS_TO_SCRUB)}"
-        profile "PUT #{uri}" do
-          b = proc do
-            params = fresh_request_params(options[:request_id])
-            begin
-              @server[uri].put(payload, params)
-            rescue RestClient::Exception => e
-              # log the error if it happens
-              log_error(e, uri, params, options)
-              raise e
-            end
-          end
-          process_response(options, &b)
-        end
+        request(:put, uri, data, options)
       end
 
       # HTTP POST
       #
       # @param uri [String] Target URI
       def post(uri, data = nil, options = {})
-        options = log_info(options)
-        GoodData.rest_logger.info "POST: #{@server.url}#{uri}, #{scrub_params(data, KEYS_TO_SCRUB)}"
-        profile "POST #{uri}" do
-          payload = data.is_a?(Hash) ? data.to_json : data
-          b = proc do
-            params = fresh_request_params(options[:request_id])
-            begin
-              @server[uri].post(payload, params)
-            rescue RestClient::Exception => e
-              # log the error if it happens
-              log_error(e, uri, params, options)
-              raise e
-            end
-          end
-          process_response(options, &b)
-        end
+        request(:post, uri, data, options)
       end
 
       # Reader method for SST token
       #
       # @return uri [String] SST token
       def sst_token
-        request_params[:cookies]['GDCAuthSST']
+        request_params[:x_gdc_authsst]
       end
 
       def stats_table(values = stats)
@@ -484,7 +450,7 @@ module GoodData
       #
       # @return uri [String] TT token
       def tt_token
-        request_params[:cookies]['GDCAuthTT']
+        request_params[:x_gdc_authtt]
       end
 
       # Uploads a file to GoodData server
@@ -514,9 +480,9 @@ module GoodData
           raw = {
             :method => method,
             :url => url,
-            :headers => @webdav_headers,
-            :verify_ssl => (@opts[:verify_ssl] == false || @opts[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE) ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-          }.merge(cookies)
+            :headers => @webdav_headers.merge(:x_gdc_authtt => headers[:x_gdc_authtt]),
+            :verify_ssl => verify_ssl
+          }
           RestClient::Request.execute(raw)
         end
 
@@ -528,20 +494,12 @@ module GoodData
       def do_stream_file(uri, filename, _options = {})
         GoodData.logger.info "Uploading file user storage #{uri}"
 
-        to_upload = File.new(filename)
-        cookies_str = request_params[:cookies].map { |cookie| "#{cookie[0]}=#{cookie[1]}" }.join(';')
-        req = Net::HTTP::Put.new(uri.path, 'User-Agent' => GoodData.gem_version_string, 'Cookie' => cookies_str)
-        req.content_length = to_upload.size
-        req.body_stream = to_upload
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.verify_mode = (@opts[:verify_ssl] == false || @opts[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE) ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-
-        response = nil
-        GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
-          response = http.start { |client| client.request(req) }
-        end
-        response
+        request = RestClient::Request.new(:method => :put,
+                                          :url => uri.to_s,
+                                          :verify_ssl => verify_ssl,
+                                          :headers => @webdav_headers.merge(:x_gdc_authtt => headers[:x_gdc_authtt]),
+                                          :payload => File.new(filename, 'rb'))
+        request.execute
       end
 
       def format_error(e, params)
@@ -570,31 +528,32 @@ module GoodData
       def log_info(options)
         # if info_message given, log it with request_id (given or generated)
         if options[:info_message]
-          request_id = options[:request_id] || generate_request_id
-          GoodData.logger.info "#{options[:info_message]} Request id: #{request_id}"
+          GoodData.logger.info "#{options[:info_message]} Request id: #{options[:request_id]}"
         end
-        options
       end
 
       # request heders with freshly generated request id
       def fresh_request_params(request_id = nil)
-        @request_params.merge(:x_gdc_request => request_id || generate_request_id)
+        tt = { :x_gdc_authtt => tt_token }
+        tt.merge(:x_gdc_request => request_id || generate_request_id)
       end
 
-      def merge_cookies!(cookies)
-        @request_params[:cookies].merge! cookies
+      def merge_headers!(headers)
+        @request_params.merge! headers.slice(:x_gdc_authtt, :x_gdc_authsst)
       end
 
       def process_response(options = {}, &block)
         retries = options[:tries] || 3
-        opts = { tries: retries, refresh_token: proc { refresh_token unless options[:dont_reauth] } }.merge(options)
+        process = options[:process]
+        dont_reauth = options[:dont_reauth]
+        options = options.reject { |k, _| [:process, :dont_reauth].include?(k) }
+        opts = { tries: retries, refresh_token: proc { refresh_token unless dont_reauth } }.merge(options)
         response = GoodData::Rest::Connection.retryable(opts) do
           block.call
         end
-
-        merge_cookies! response.cookies
+        merge_headers! response.headers
         content_type = response.headers[:content_type]
-        return response if options[:process] == false
+        return response if process == false
 
         if content_type == 'application/json' || content_type == 'application/json;charset=UTF-8'
           result = response.to_str == '""' ? {} : MultiJson.load(response.to_str)
@@ -630,8 +589,8 @@ module GoodData
         res
       end
 
-      def reset_cookies!
-        @request_params = { :cookies => {} }
+      def reset_headers!
+        @request_params = {}
       end
 
       def scrub_params(params, keys)
@@ -741,25 +700,19 @@ module GoodData
         method = :get
         GoodData.logger.debug "#{method}: #{url}"
 
-        b = proc do
+        GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
           raw = {
             :method => method,
             :url => url,
-            :headers => @webdav_headers,
-            :verify_ssl => (@opts[:verify_ssl] == false || @opts[:verify_ssl] == OpenSSL::SSL::VERIFY_NONE) ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-          }.merge(cookies)
+            :headers => @webdav_headers.merge(:x_gdc_authtt => headers[:x_gdc_authtt]),
+            :verify_ssl => verify_ssl
+          }.merge(headers)
           begin
             RestClient::Request.execute(raw)
           rescue RestClient::Exception => e
             false if e.http_code == 404
           end
         end
-
-        res = nil
-        GoodData::Rest::Connection.retryable(:tries => 2, :refresh_token => proc { refresh_token }) do
-          res = b.call
-        end
-        res
       end
     end
   end

data/lib/gooddata/version.rb

@@ -6,7 +6,7 @@
 
 # GoodData Module
 module GoodData
-  VERSION = '0.6.43'
+  VERSION = '0.6.44'
 
   class << self
     # Version

data/spec/environment/develop.rb

@@ -13,19 +13,19 @@ module GoodData
     end
 
     module ProcessHelper
-      set_const :PROCESS_ID, '6829c82d-d8cc-4589-90c4-f31eec2a6797'
-      set_const :DEPLOY_NAME, 'hello_world.rb'
+      set_const :PROCESS_ID, '98c836cf-bdf6-405e-bb8a-f4dc201588dd'
+      set_const :DEPLOY_NAME, 'gooddata_version.rb'
     end
 
     module ProjectHelper
-      set_const :PROJECT_ID, 'augu8cqwzim37c7bzf7dhufw6b8rs4go'
+      set_const :PROJECT_ID, 'l11tat2c0v4ae6mtxjv74jk8c37xz5ra'
       set_const :PROJECT_URL, "/gdc/projects/#{PROJECT_ID}"
       set_const :PROJECT_TITLE, 'GoodTravis'
       set_const :PROJECT_SUMMARY, 'No summary'
     end
 
     module ScheduleHelper
-      set_const :SCHEDULE_ID, '5784e409e4b0020189b279df'
+      set_const :SCHEDULE_ID, '57f42cfae4b041699a8eb52a'
     end
   end
 end