gooddata 0.6.0 → 0.6.2

data/lib/gooddata/commands/projects.rb

@@ -1,109 +1,15 @@
 # encoding: UTF-8
 
-module GoodData::Command
-  class Projects
-    class << self
-      def list
-        GoodData::Project.all
-      end
-
-      # Create new project based on options supplied
-      def create(options={})
-        title = options[:title]
-        summary = options[:summary]
-        template = options[:template]
-        token = options[:token]
-
-        GoodData::Project.create(:title => title, :summary => summary, :template => template, :auth_token => token)
-      end
-
-      # Show existing project
-      def show(id)
-        GoodData::Project[id]
-      end
-
-      # Clone existing project
-      def clone(project_id, options)
-        with_data = options[:with_data]
-        with_users = options[:with_users]
-        title = options[:title]
-
-        export = {
-          :exportProject => {
-            :exportUsers => with_users ? 1 : 0,
-            :exportData => with_data ? 1 : 0
-          }
-        }
-
-        result = GoodData.post("/gdc/md/#{project_id}/maintenance/export", export)
-        export_token = result['exportArtifact']['token']
-        status_url = result['exportArtifact']['status']['uri']
-
-        state = GoodData.get(status_url)['taskState']['status']
-        while state == 'RUNNING'
-          sleep 5
-          result = GoodData.get(status_url)
-          state = result['taskState']['status']
-        end
-
-        old_project = GoodData::Project[project_id]
-        project_uri = self.create(options.merge({:title => "Clone of #{old_project.title}"}))
-        new_project = GoodData::Project[project_uri]
-
-        import = {
-          :importProject => {
-            :token => export_token
-          }
-        }
-        result = GoodData.post("/gdc/md/#{new_project.obj_id}/maintenance/import", import)
-        status_url = result['uri']
-        state = GoodData.get(status_url)['taskState']['status']
-        while state == 'RUNNING'
-          sleep 5
-          result = GoodData.get(status_url)
-          state = result['taskState']['status']
+require 'pathname'
+
+module GoodData
+  module Command
+    class Projects
+      class << self
+        def list
+          GoodData::Project.all
         end
-        true
-      end
-
-      # Delete existing project
-      def delete(project_id)
-        p = GoodData::Project[project_id]
-        p.delete
-      end
-
-      # Get Spec and ID (of project)
-      def get_spec_and_project_id(base_path)
-        goodfile_path = GoodData::Helpers.find_goodfile(Pathname(base_path))
-        fail 'Goodfile could not be located in any parent directory. Please make sure you are inside a gooddata project folder.' if goodfile_path.nil?
-        goodfile = MultiJson.load(File.read(goodfile_path), :symbolize_keys => true)
-        spec_path = goodfile[:model] || fail('You need to specify the path of the build spec')
-        fail "Model path provided in Goodfile \"#{spec_path}\" does not exist" unless File.exist?(spec_path) && !File.directory?(spec_path)
-
-        spec_path = Pathname(spec_path)
-
-        content = File.read(spec_path)
-        spec = if (spec_path.extname == '.rb')
-                 eval(content)
-               elsif (spec_path.extname == '.json')
-                 MultiJson.load(spec_path, :symbolize_keys => true)
-               end
-        [spec, goodfile[:project_id]]
-      end
-
-      # Update project
-      def update(options={})
-        project = options[:project]
-        project_id = project && project.pid
-        fail 'You have to provide "project_id". You can either provide it through -p flag or even better way is to fill it in in your Goodfile under key "project_id". If you just started a project you have to create it first. One way might be through "gooddata project build"' if project_id.nil? || project_id.empty?
-        GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :project => project_id)
-      end
-
-      # Build project
-      def build(options={})
-        GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :token => options[:token])
       end
     end
   end
 end
-

data/lib/gooddata/commands/role.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require_relative '../core/core'
+
+module GoodData
+  module Command
+    class Role
+      class << self
+        def list(pid)
+          roles_response = GoodData.get("/gdc/projects/#{pid}/roles")
+
+          roles = {}
+          roles_response['projectRoles']['roles'].each do |role_uri|
+            r = GoodData.get(role_uri)
+            identifier = r['projectRole']['meta']['identifier']
+            roles[identifier] = {
+              :user_uri => r['projectRole']['links']['roleUsers'],
+              :uri => role_uri
+            }
+          end
+          roles
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/commands/runners.rb

@@ -1,44 +1,47 @@
 # encoding: UTF-8
 
-module GoodData::Command
-  class Runners
-    def self.run_ruby_locally(brick_dir, options={})
-      pid = options[:project_id]
-      fail 'You have to specify a project ID' if pid.nil?
-      fail 'You have to specify directory of the brick run' if brick_dir.nil?
-      fail 'You specified file as a birck run directory. You have to specify directory.' if File.exist?(brick_dir) && !File.directory?(brick_dir)
-
-      params = options[:expanded_params] || {}
-
-      GoodData.connection.connect!
-      sst = GoodData.connection.cookies[:cookies]['GDCAuthSST']
-      pwd = Pathname.new(Dir.pwd)
-      logger_stream = STDOUT
-
-      server_uri = URI(options[:server]) unless options[:server].nil?
-      scheme = server_uri.nil? ? '' : server_uri.scheme
-      hostname = server_uri.nil? ? '' : server_uri.host
-
-      script_body = <<-script_body
-      require 'fileutils'
-      FileUtils::cd(\"#{pwd+brick_dir}\") do\
-        require 'bundler/setup'
-
-        $SCRIPT_PARAMS = {
-          "GDC_SST" => \"#{sst}\",
-          "GDC_PROJECT_ID" => \"#{pid}\",
-          "GDC_PROTOCOL" => \"#{scheme}\",
-          "GDC_HOSTNAME" => \"#{hostname}\",
-          "GDC_LOGGER_FILE" => STDOUT,
-          "GDC_ENV_LOCAL" => true
-        }.merge(#{params})
-        eval(File.read(\"./main.rb\"))
-      end
-      script_body
+require 'pathname'
+
+module GoodData
+  module Command
+    class Runners
+      def self.run_ruby_locally(brick_dir, options = {})
+        pid = options[:project_id]
+        fail 'You have to specify a project ID' if pid.nil?
+        fail 'You have to specify directory of the brick run' if brick_dir.nil?
+        fail 'You specified file as a birck run directory. You have to specify directory.' if File.exist?(brick_dir) && !File.directory?(brick_dir)
+
+        params = options[:expanded_params] || {}
+
+        GoodData.connection.connect!
+        sst = GoodData.connection.cookies[:cookies]['GDCAuthSST']
+        pwd = Pathname.new(Dir.pwd)
+
+        server_uri = URI(options[:server]) unless options[:server].nil?
+        scheme = server_uri.nil? ? '' : server_uri.scheme
+        hostname = server_uri.nil? ? '' : server_uri.host
+
+        script_body = <<-script_body
+        require 'fileutils'
+        FileUtils::cd(\"#{pwd + brick_dir}\") do\
+          require 'bundler/setup'
+
+          $SCRIPT_PARAMS = {
+            "GDC_SST" => \"#{sst}\",
+            "GDC_PROJECT_ID" => \"#{pid}\",
+            "GDC_PROTOCOL" => \"#{scheme}\",
+            "GDC_HOSTNAME" => \"#{hostname}\",
+            "GDC_LOGGER_FILE" => STDOUT,
+            "GDC_ENV_LOCAL" => true
+          }.merge(#{params})
+          eval(File.read(\"./main.rb\"))
+        end
+        script_body
 
-      Bundler.with_clean_env do
-        system('ruby', '-e', script_body)
+        Bundler.with_clean_env do
+          system('ruby', '-e', script_body)
+        end
       end
     end
   end
-end
+end

data/lib/gooddata/commands/scaffold.rb

@@ -2,62 +2,65 @@
 
 require 'erubis'
 require 'fileutils'
+require 'pathname'
 
-module GoodData::Command
-  class Scaffold
-    TEMPLATES_PATH = Pathname(__FILE__) + '../../../templates'
+module GoodData
+  module Command
+    class Scaffold
+      TEMPLATES_PATH = Pathname(__FILE__) + '../../../templates'
 
-    class << self
-      # Scaffolds new project
-      # TODO: Add option for custom output dir
-      def project(name)
-        fail ArgumentError, 'No name specified' if name.nil?
+      class << self
+        # Scaffolds new project
+        # TODO: Add option for custom output dir
+        def project(name)
+          fail ArgumentError, 'No name specified' if name.nil?
 
-        FileUtils.mkdir(name)
-        FileUtils.cd(name) do
+          FileUtils.mkdir(name)
+          FileUtils.cd(name) do
 
-          FileUtils.mkdir('model')
-          FileUtils.cd('model') do
-            input = File.read(TEMPLATES_PATH + 'project/model/model.rb.erb')
-            eruby = Erubis::Eruby.new(input)
-            File.open('model.rb', 'w') do |f|
-              f.write(eruby.result(:name => name))
+            FileUtils.mkdir('model')
+            FileUtils.cd('model') do
+              input = File.read(TEMPLATES_PATH + 'project/model/model.rb.erb')
+              eruby = Erubis::Eruby.new(input)
+              File.open('model.rb', 'w') do |f|
+                f.write(eruby.result(:name => name))
+              end
             end
-          end
 
-          FileUtils.mkdir('data')
-          FileUtils.cd('data') do
-            FileUtils.cp(Dir.glob(TEMPLATES_PATH + 'project/data/*.csv'), '.')
-          end
+            FileUtils.mkdir('data')
+            FileUtils.cd('data') do
+              FileUtils.cp(Dir.glob(TEMPLATES_PATH + 'project/data/*.csv'), '.')
+            end
 
-          input = File.read(TEMPLATES_PATH + 'project/Goodfile.erb')
-          eruby = Erubis::Eruby.new(input)
-          File.open('Goodfile', 'w') do |f|
-            f.write(eruby.result())
+            input = File.read(TEMPLATES_PATH + 'project/Goodfile.erb')
+            eruby = Erubis::Eruby.new(input)
+            File.open('Goodfile', 'w') do |f|
+              f.write(eruby.result)
+            end
           end
         end
-      end
 
-      # Scaffolds new brick
-      # TODO: Add option for custom output dir
-      def brick(name)
-        fail ArgumentError, 'No name specified' if name.nil?
-
-        FileUtils.mkdir(name)
-        FileUtils.cd(name) do
-          input = File.read(TEMPLATES_PATH + 'bricks/brick.rb.erb')
-          eruby = Erubis::Eruby.new(input)
-          File.open('brick.rb', 'w') do |f|
-            f.write(eruby.result())
-          end
+        # Scaffolds new brick
+        # TODO: Add option for custom output dir
+        def brick(name)
+          fail ArgumentError, 'No name specified' if name.nil?
+
+          FileUtils.mkdir(name)
+          FileUtils.cd(name) do
+            input = File.read(TEMPLATES_PATH + 'bricks/brick.rb.erb')
+            eruby = Erubis::Eruby.new(input)
+            File.open('brick.rb', 'w') do |f|
+              f.write(eruby.result)
+            end
 
-          input = File.read(TEMPLATES_PATH + 'bricks/main.rb.erb')
-          eruby = Erubis::Eruby.new(input)
-          File.open('main.rb', 'w') do |f|
-            f.write(eruby.result())
+            input = File.read(TEMPLATES_PATH + 'bricks/main.rb.erb')
+            eruby = Erubis::Eruby.new(input)
+            File.open('main.rb', 'w') do |f|
+              f.write(eruby.result)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/gooddata/commands/user.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require_relative '../core/core'
+
+require 'highline/import'
+require 'multi_json'
+
+module GoodData
+  module Command
+    class User
+      class << self
+        def roles(pid)
+          roles_response = GoodData.get("/gdc/projects/#{pid}/roles")
+
+          roles = {}
+          roles_response['projectRoles']['roles'].each do |role_uri|
+            r = GoodData.get(role_uri)
+            identifier = r['projectRole']['meta']['identifier']
+            roles[identifier] = {
+              :user_uri => r['projectRole']['links']['roleUsers'],
+              :uri => role_uri
+            }
+          end
+          roles
+        end
+
+        def show
+          GoodData.profile.to_json
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/connection.rb

@@ -1,378 +1,68 @@
 # encoding: UTF-8
 
-require 'multi_json'
-require 'rest-client'
-
-require_relative 'version'
+require_relative 'core/connection'
+require_relative 'core/logging'
+require_relative 'core/threaded'
 
 module GoodData
-  # # GoodData HTTP wrapper
-  #
-  # Provides a convenient HTTP wrapper for talking with the GoodData API.
-  #
-  # Remember that the connection is shared amongst the entire application.
-  # Therefore you can't be logged in to more than _one_ GoodData account.
-  # per session. Simultaneous connections to multiple GoodData accounts is not
-  # supported at this time.
-  #
-  # The GoodData API is a RESTful API that communicates using JSON. This wrapper
-  # makes sure that the session is stored between requests and that the JSON is
-  # parsed both when sending and receiving.
-  #
-  # ## Usage
-  #
-  # Before a connection can be made to the GoodData API, you have to supply the user credentials like this:
-  #
-  #   Connection.new(username, password)
-  #
-  # To send a HTTP request use either the get, post or delete methods documented below.
-  #
-  class Connection
-    DEFAULT_URL = 'https://secure.gooddata.com'
-    LOGIN_PATH = '/gdc/account/login'
-    TOKEN_PATH = '/gdc/account/token'
-
-    attr_reader(:auth_token, :url)
-    attr_accessor :status, :options
-
-    # Options:
-    # * :tries - Number of retries to perform. Defaults to 1.
-    # * :on - The Exception on which a retry will be performed. Defaults to Exception, which retries on any Exception.
-    #
-    # ### Example
-    #
-    #     retryable(:tries => 1, :on => OpenURI::HTTPError) do
-    #       # your code here
-    #     end
+  class << self
+    # Returns the active GoodData connection earlier initialized via GoodData.connect call
     #
-    def retryable(options = {}, &block)
-      opts = {:tries => 1, :on => Exception}.merge(options)
-
-      retry_exception, retries = opts[:on], opts[:tries]
-
-      begin
-        return yield
-      rescue retry_exception
-        retry if (retries -= 1) > 0
-      end
-
-      yield
+    # @see GoodData.connect
+    def connection
+      threaded[:connection] || fail('Please authenticate with GoodData.connect first')
     end
 
-    # Set the GoodData account credentials.
-    #
-    # This have to be performed before any calls to the API.
+    # Connect to the GoodData API
     #
-    # @param username The GoodData account username
-    # @param password The GoodData account password
+    # @param options
+    # @param second_options
+    # @param third_options
     #
-    def initialize(username, password, options = {})
-      @status = :not_connected
-      @username = username
-      @password = password
-      @url = options[:server] || DEFAULT_URL
-      @auth_token = options[:gdc_temporary_token]
-      @options = options
+    def connect(options = nil, second_options = nil, third_options = {})
+      GoodData.logger.debug 'GoodData#connect'
 
-      @server = create_server_connection(@url, @options)
-    end
+      if options.is_a? Hash
+        fail 'You have to provide login and password' if (options[:login].nil? || options[:login].empty?) && (options[:password].nil? || options[:password].empty?)
+        threaded[:connection] = Connection.new(options[:login], options[:password], options)
+        GoodData.project = options[:project] if options[:project]
+      elsif options.is_a?(String) && second_options.is_a?(String)
+        fail 'You have to provide login and password' if (options.nil? || options.empty?) && (second_options.nil? || second_options.empty?)
+        threaded[:connection] = Connection.new(options, second_options, third_options)
+      end
 
-    # Returns the user JSON object of the currently logged in GoodData user account.
-    def user
-      ensure_connection
-      @user
+      threaded[:connection]
     end
 
-    # Performs a HTTP GET request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).get '/gdc/projects'
-    #
-    def get(path, options = {})
-      GoodData.logger.debug "GET #{@server}#{path}"
-      ensure_connection
-      b = Proc.new { @server[path].get cookies }
-      process_response(options, &b)
-    end
+    # Disconnect (logout) if logged in
+    def disconnect
+      GoodData.logger.debug 'GoodData#disconnect'
 
-    # Performs a HTTP POST request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).post '/gdc/projects', { ... }
-    #
-    def post(path, data, options = {})
-      GoodData.logger.debug("POST #{@server}#{path}, payload: #{scrub_params(data, [:password, :login, :authorizationToken])}")
-      ensure_connection
-      payload = data.is_a?(Hash) ? data.to_json : data
-      b = Proc.new { @server[path].post payload, cookies }
-      process_response(options, &b)
+      if threaded[:connection]
+        threaded[:connection].disconnect
+        threaded[:connection] = nil
+      end
     end
 
-    # Performs a HTTP PUT request.
+    # Hepler for starting with SST easier
     #
-    # Retuns the JSON response formatted as a Hash object.
+    # @param token SST token
+    # @param options Options get routed to connect eventually so everything that you can use there should be possible to use here.
     #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).put '/gdc/projects', { ... }
-    #
-    def put(path, data, options = {})
-      payload = data.is_a?(Hash) ? data.to_json : data
-      GoodData.logger.debug "PUT #{@server}#{path}, payload: #{payload}"
-      ensure_connection
-      b = Proc.new { @server[path].put payload, cookies }
-      process_response(options, &b)
+    def connect_with_sst(token, options = {})
+      create_authenticated_connection(options.merge(:cookies => { 'GDCAuthSST' => token }))
     end
 
-    # Performs a HTTP DELETE request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    # This method is aimed at creating an authenticated connection in case you do not hae pass/login but you have SST
     #
-    # ### Examples
+    # @param options :server => optional GD server uri, If nil it secure will be used. :cookies => you can specify a hash of cookies
     #
-    #     Connection.new(username, password).delete '/gdc/project/1'
-    #
-    def delete(path, options = {})
-      GoodData.logger.debug "DELETE #{@server}#{path}"
-      ensure_connection
-      b = Proc.new { @server[path].delete cookies }
-      process_response(options, &b)
-    end
-
-    # Get the cookies associated with the current connection.
-    def cookies
-      @cookies ||= {:cookies => {}}
-    end
-
-    # Set the cookies used when communicating with the GoodData API.
-    def merge_cookies!(cookies)
-      self.cookies
-      @cookies[:cookies].merge! cookies
-    end
-
-    # Returns true if a connection have been established to the GoodData API
-    # and the login was successful.
-    def logged_in?
-      @status == :logged_in
-    end
-
-    def url=(url=nil)
-      @url = url || DEFAULT_URL
-      @server = create_server_connection(@url, @options)
-    end
-
-    # The connection will automatically be established once it's needed, which it
-    # usually is when either the user, get, post or delete method is called. If you
-    # want to force a connection (or a re-connect) you can use this method.
-    def connect!
-      connect
-    end
-
-    # Uploads a file to GoodData server
-    # /uploads/ resources are special in that they use a different
-    # host and a basic authentication.
-    def upload(file, options={})
-      ensure_connection
-
-      dir = options[:directory] || ''
-      staging_uri = options[:staging_url].to_s
-      url = dir.empty? ? staging_uri : URI.join(staging_uri, "#{dir}/").to_s
-
-      # Make a directory, if needed
-      unless dir.empty? then
-        method = :get
-        GoodData.logger.debug "#{method}: #{url}"
-        begin
-          # first check if it does exits
-          RestClient::Request.execute({
-                                        :method => method,
-                                        :url => url,
-                                        :timeout => @options[:timeout],
-                                        :headers => {
-                                          :user_agent => GoodData.gem_version_string
-                                        }}.merge(cookies)
-          )
-        rescue RestClient::Exception => e
-          if e.http_code == 404 then
-            method = :mkcol
-            GoodData.logger.debug "#{method}: #{url}"
-            RestClient::Request.execute({
-                                          :method => method,
-                                          :url => url,
-                                          :timeout => @options[:timeout],
-                                          :headers => {
-                                            :user_agent => GoodData.gem_version_string
-                                          }}.merge(cookies)
-            )
-          end
-        end
-      end
-
-      payload = options[:stream] ? 'file' : File.read(file)
-      filename = options[:filename] || options[:stream] ? 'randome-filename.txt' : File.basename(file)
-
-      # Upload the file
-      # puts "uploading the file #{URI.join(url, filename).to_s}"
-      req = RestClient::Request.new({
-                                      :method => :put,
-                                      :url => URI.join(url, filename).to_s,
-                                      :timeout => @options[:timeout],
-                                      :headers => {
-                                        :user_agent => GoodData.gem_version_string,
-                                      },
-                                      :payload => payload,
-                                      :raw_response => true,
-                                      :user => @username,
-                                      :password => @password
-                                    })
-      # .merge(cookies))
-      resp = req.execute
-      true
-    end
-
-    def download(what, where, options={})
-      staging_uri = options[:staging_url].to_s
-      url = staging_uri + what
-      req = RestClient::Request.new({
-                                      :method => 'GET',
-                                      :url => url,
-                                      :user => @username,
-                                      :password => @password
-                                    })
-
-      if where.is_a?(String)
-        File.open(where, 'w') do |f|
-          req.execute do |chunk, x, y|
-            f.write chunk
-          end
-        end
-      else
-        # Assume it is a IO stream
-        req.execute do |chunk, x, y|
-          where.write chunk
-        end
-      end
-    end
-
-    def connected?
-      @status == :logged_in
-    end
-
-    def disconnect
-      if connected? && GoodData.connection.user['state']
-        GoodData.delete(GoodData.connection.user['state'])
-        @status = :not_connected
-      end
-    end
-
-    private
-
-    def create_server_connection(url, options)
-      RestClient::Resource.new url,
-                               :timeout => options[:timeout],
-                               :headers => {
-                                 :content_type => :json,
-                                 :accept => [:json, :zip],
-                                 :user_agent => GoodData::gem_version_string,
-                               }
-    end
-
-    def ensure_connection
-      connect if @status == :not_connected
-    end
-
-    def connect
-      GoodData.logger.info 'Connecting to GoodData...'
-      @status = :connecting
-      authenticate
-    end
-
-    def authenticate
-      credentials = {
-        'postUserLogin' => {
-          'login' => @username,
-          'password' => @password,
-          'remember' => 1
-        }
-      }
-      GoodData.logger.debug 'Logging in...'
-      @user = post(LOGIN_PATH, credentials, :dont_reauth => true)['userLogin']
-      refresh_token :dont_reauth => true # avoid infinite loop if refresh_token fails with 401
-
-      @status = :logged_in
-    end
-
-    def process_response(options = {}, &block)
-      begin
-        begin
-          response = block.call
-        rescue RestClient::Unauthorized
-          raise $! if options[:dont_reauth]
-          refresh_token
-          response = block.call
-        end
-        merge_cookies! response.cookies
-        content_type = response.headers[:content_type]
-        return response if options[:process] == false
-
-        if content_type == "application/json" || content_type == "application/json;charset=UTF-8" then
-          result = response.to_str == '""' ? {} : MultiJson.load(response.to_str)
-          GoodData.logger.debug "Response: #{result.inspect}"
-        elsif content_type == 'application/zip' then
-          result = response
-          GoodData.logger.debug 'Response: a zipped stream'
-        elsif response.headers[:content_length].to_s == '0'
-          result = nil
-          GoodData.logger.debug 'Response: Empty response possibly 204'
-        elsif response.code == 204
-          result = nil
-          GoodData.logger.debug 'Response: 204 no content'
-        else
-          raise "Unsupported response content type '%s':\n%s" % [content_type, response.to_str[0..127]]
-        end
-        result
-      rescue RestClient::Exception => e
-        GoodData.logger.debug "Response: #{e.response}"
-        raise $!
-      end
-    end
-
-    def refresh_token(options = {})
-      GoodData.logger.debug 'Getting authentication token...'
-      begin
-        get TOKEN_PATH, :dont_reauth => true # avoid infinite loop GET fails with 401
-      rescue RestClient::Unauthorized
-        raise $! if options[:dont_reauth]
-        authenticate
-      end
-    end
-
-    def scrub_params(params, keys)
-      keys = keys.reduce([]) { |memo, k| memo.concat([k.to_s, k.to_sym]) }
-
-      new_params = Marshal.load(Marshal.dump(params))
-      GoodData::Helpers.hash_dfs(new_params) do |k, key|
-        keys.each do |key_to_scrub|
-          k[key_to_scrub] = ('*' * k[key_to_scrub].length) if k && k.has_key?(key_to_scrub) && k[key_to_scrub]
-        end
-      end
-      new_params
+    def create_authenticated_connection(options = {})
+      connect(options)
+      server_cookies = options[:cookies]
+      connection.merge_cookies!(server_cookies)
+      connection.status = :logged_in
+      connection
     end
   end
 end