gooddata 0.6.7 → 0.6.8

data/lib/gooddata/rest/client.rb

@@ -0,0 +1,318 @@
+# encoding: utf-8
+
+require 'rest-client'
+
+require_relative '../helpers/auth_helpers'
+
+require_relative 'connections/connections'
+require_relative 'object_factory'
+
+require_relative '../mixins/inspector'
+
+module GoodData
+  module Rest
+    # User's interface to GoodData Platform.
+    #
+    # MUST provide way to use - DELETE, GET, POST, PUT
+    # SHOULD provide way to use - HEAD, Bulk GET ...
+    class Client
+      #################################
+      # Constants
+      #################################
+      DEFAULT_CONNECTION_IMPLEMENTATION = Connections::RestClientConnection
+
+      #################################
+      # Class variables
+      #################################
+      @@instance = nil # rubocop:disable ClassVars
+
+      #################################
+      # Getters/Setters
+      #################################
+
+      # Decide if we need provide direct access to connection
+      attr_reader :connection
+
+      # TODO: Decide if we need provide direct access to factory
+      attr_reader :factory
+
+      include Mixin::Inspector
+      inspector :object_id
+
+      #################################
+      # Class methods
+      #################################
+      class << self
+        # Globally available way to connect (and create client and set global instance)
+        #
+        # ## HACK
+        # To make transition from old implementation to new one following HACK IS TEMPORARILY ENGAGED!
+        #
+        # 1. First call of #connect sets the GoodData::Rest::Client.instance (static, singleton instance)
+        # 2. There are METHOD functions with same signature as their CLASS counterparts using singleton instance
+        #
+        # ## Example
+        #
+        # client = GoodData.connect('jon.smith@goodddata.com', 's3cr3tp4sw0rd')
+        #
+        # @param username [String] Username to be used for authentication
+        # @param password [String] Password to be used for authentication
+        # @return [GoodData::Rest::Client] Client
+        def connect(username, password, opts = {})
+          new_opts = opts.dup
+          if username.is_a?(Hash) && username.key?(:sst_token)
+            new_opts[:sst_token] = username[:sst_token]
+          elsif username.is_a? Hash
+            new_opts[:username] = username[:login] || username[:user] || username[:username]
+            new_opts[:password] = username[:password]
+          elsif username.nil? && password.nil? && (opts.nil? || opts.empty?)
+            new_opts = Helpers::AuthHelper.read_credentials
+          else
+            new_opts[:username] = username
+            new_opts[:password] = password
+          end
+          unless new_opts[:sst_token]
+            fail ArgumentError, 'No username specified' if new_opts[:username].nil?
+            fail ArgumentError, 'No password specified' if new_opts[:password].nil?
+          end
+
+          client = Client.new(new_opts)
+
+          if client
+            at_exit do
+              # puts client.connection.stats_table if client && client.connection
+            end
+          end
+
+          # HACK: This line assigns class instance # if not done yet
+          @@instance = client # rubocop:disable ClassVars
+          client
+        end
+
+        def disconnect
+          if @@instance # rubocop:disable ClassVars
+            @@instance.disconnect # rubocop:disable ClassVars
+            @@instance = nil # rubocop:disable ClassVars
+          end
+        end
+
+        def connection
+          @@instance # rubocop:disable ClassVars
+        end
+
+        alias_method :client, :connection
+      end
+
+      # Constructor of client
+      # @param opts [Hash] Client options
+      # @option opts [String] :username Username used for authentication
+      # @option opts [String] :password Password used for authentication
+      # @option opts :connection_factory Object able to create new instances of GoodData::Rest::Connection
+      # @option opts [GoodData::Rest::Connection] :connection Existing GoodData::Rest::Connection
+      def initialize(opts)
+        # TODO: Decide if we want to pass the options directly or not
+        @opts = opts
+
+        @connection_factory = @opts[:connection_factory] || DEFAULT_CONNECTION_IMPLEMENTATION
+
+        # TODO: See previous TODO
+        # Create connection
+        @connection = opts[:connection] || @connection_factory.new(opts)
+
+        # Connect
+        connect
+
+        # Create factory bound to previously created connection
+        @factory = ObjectFactory.new(self)
+      end
+
+      def domain(domain_name)
+        GoodData::Domain[domain_name, :client => self]
+      end
+
+      def projects(id = :all)
+        GoodData::Project[id, client: self]
+      end
+
+      def processes(id = :all)
+        GoodData::Process[id, client: self]
+      end
+
+      def connect
+        username = @opts[:username]
+        password = @opts[:password]
+
+        @connection.connect(username, password, @opts)
+      end
+
+      def disconnect
+        @connection.disconnect
+      end
+
+      #######################
+      # Factory stuff
+      ######################
+      def create(klass, data = {}, opts = {})
+        @factory.create(klass, data, opts)
+      end
+
+      def find(klass, opts = {})
+        @factory.find(klass, opts)
+      end
+
+      # Gets resource by name
+      def resource(res_name)
+        puts "Getting resource '#{res_name}'"
+        nil
+      end
+
+      def user
+        create(GoodData::Profile, @connection.user)
+      end
+
+      #######################
+      # Rest
+      #######################
+      # HTTP DELETE
+      #
+      # @param uri [String] Target URI
+      def delete(uri, opts = {})
+        @connection.delete uri, opts
+      end
+
+      # HTTP GET
+      #
+      # @param uri [String] Target URI
+      def get(uri, opts = {})
+        @connection.get uri, opts
+      end
+
+      # FIXME: Invstigate _file argument
+      def get_project_webdav_path(_file, opts = { :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        u = URI(project.links['uploads'])
+        URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{project.pid}/")
+      end
+
+      # FIXME: Invstigate _file argument
+      def get_user_webdav_path(_file, opts = { :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        u = URI(project.links['uploads'])
+        URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
+      end
+
+      # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+      # this is a helper that should help you with resources where the information about "Are we done"
+      # is the http code of response. By default we repeat as long as the code == 202. You can
+      # change the code if necessary. It expects the URI as an input where it can poll. It returns the
+      # value of last poll. In majority of cases these are the data that you need.
+      #
+      # @param link [String] Link for polling
+      # @param options [Hash] Options
+      # @return [Hash] Result of polling
+      def poll_on_code(link, options = {})
+        code = options[:code] || 202
+        sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
+        response = get(link, :process => false)
+
+        while response.code == code
+          sleep sleep_interval
+          retryable(:tries => 3, :on => RestClient::InternalServerError) do
+            sleep sleep_interval
+            response = get(link, :process => false)
+          end
+        end
+        if options[:process] == false
+          response
+        else
+          get(link)
+        end
+      end
+
+      # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
+      # this is a helper that should help you with resources where the information about "Are we done"
+      # is inside the response. It expects the URI as an input where it can poll and a block that should
+      # return either true -> 'meaning we are done' or false -> meaning sleep and repeat. It returns the
+      # value of last poll. In majority of cases these are the data that you need
+      #
+      # @param link [String] Link for polling
+      # @param options [Hash] Options
+      # @return [Hash] Result of polling
+      def poll_on_response(link, options = {}, &bl)
+        sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
+        response = get(link)
+        while bl.call(response)
+          sleep sleep_interval
+          retryable(:tries => 3, :on => RestClient::InternalServerError) do
+            sleep sleep_interval
+            response = get(link)
+          end
+        end
+        response
+      end
+
+      # HTTP PUT
+      #
+      # @param uri [String] Target URI
+      def put(uri, data, opts = {})
+        @connection.put uri, data, opts
+      end
+
+      # HTTP POST
+      #
+      # @param uri [String] Target URI
+      def post(uri, data, opts = {})
+        @connection.post uri, data, opts
+      end
+
+      # Retry blok if exception thrown
+      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
+      end
+
+      # Uploads file
+      def upload(file, options = {})
+        @connection.upload file, options
+      end
+
+      def upload_to_user_webdav(file, options = {})
+        p = options[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, options]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        u = URI(project.links['uploads'])
+        url = URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
+        upload(file, options.merge(
+          :directory => options[:directory],
+          :staging_url => url
+        ))
+      end
+
+      def with_project(pid, &block)
+        GoodData.with_project(pid, client: self, &block)
+      end
+    end
+  end
+end

data/lib/gooddata/rest/connection.rb

@@ -0,0 +1,235 @@
+# encoding: utf-8
+
+require 'terminal-table'
+
+require_relative '../version'
+require_relative '../exceptions/exceptions'
+
+module GoodData
+  module Rest
+    # Wrapper of low-level HTTP/REST client/library
+    class Connection
+      DEFAULT_URL = 'https://secure.gooddata.com'
+      LOGIN_PATH = '/gdc/account/login'
+      TOKEN_PATH = '/gdc/account/token'
+
+      DEFAULT_HEADERS = {
+        :content_type => :json,
+        :accept => [:json, :zip],
+        :user_agent => GoodData.gem_version_string
+      }
+
+      DEFAULT_LOGIN_PAYLOAD = {
+        :headers => DEFAULT_HEADERS
+      }
+
+      class << self
+        def construct_login_payload(username, password)
+          res = {
+            'postUserLogin' => {
+              'login' => username,
+              'password' => password,
+              'remember' => 1
+            }
+          }
+          res
+        end
+      end
+
+      attr_reader :cookies
+      attr_reader :stats
+      attr_reader :user
+
+      def initialize(opts)
+        @user = nil
+
+        @stats = {}
+        @opts = opts
+
+        # Initialize cookies
+        reset_cookies!
+      end
+
+      # Connect using username and password
+      def connect(username, password, options = {})
+        # Reset old cookies first
+        if options[:sst_token]
+          merge_cookies!('GDCAuthSST' => options[:sst_token])
+          @user = get(get('/gdc/app/account/bootstrap')['bootstrapResource']['accountSetting']['links']['self'])
+          @auth = {}
+          refresh_token :dont_reauth => true
+        else
+          credentials = Connection.construct_login_payload(username, password)
+          @auth = post(LOGIN_PATH, credentials, :dont_reauth => true)['userLogin']
+
+          @user = get(@auth['profile'])
+          refresh_token :dont_reauth => true
+        end
+      end
+
+      # Disconnect
+      def disconnect
+        # TODO: Wrap somehow
+        url = @auth['state']
+        delete url if url
+
+        @auth = nil
+        @server = nil
+        @user = nil
+
+        reset_cookies!
+      end
+
+      def refresh_token(options = {})
+        begin # rubocop:disable RedundantBegin
+          get TOKEN_PATH, :dont_reauth => true # avoid infinite loop GET fails with 401
+        rescue Exception => e # rubocop:disable RescueException
+          puts e.message
+          raise e
+        end
+      end
+
+      # Returns server URI
+      #
+      # @return [String] server uri
+      def server_url
+        @server && @server.url
+      end
+
+      # HTTP DELETE
+      #
+      # @param uri [String] Target URI
+      def delete(uri, options = {})
+        fail NotImplementedError "DELETE #{uri}"
+      end
+
+      # HTTP GET
+      #
+      # @param uri [String] Target URI
+      def get(uri, options = {})
+        fail NotImplementedError "GET #{uri}"
+      end
+
+      # HTTP PUT
+      #
+      # @param uri [String] Target URI
+      def put(uri, data, options = {})
+        fail NotImplementedError "PUT #{uri}"
+      end
+
+      # HTTP POST
+      #
+      # @param uri [String] Target URI
+      def post(uri, data, options = {})
+        fail NotImplementedError "POST #{uri}"
+      end
+
+      # Reader method for SST token
+      #
+      # @return uri [String] SST token
+      def sst_token
+        cookies[:cookies]['GDCAuthSST']
+      end
+
+      def stats_table(values = stats)
+        sorted = values.sort_by { |k, v| v[:avg] }
+        Terminal::Table.new :headings => %w(title avg min max total calls) do |t|
+          sorted.each do |l|
+            row = [
+              l[0],
+              sprintf('%.3f', l[1][:avg]),
+              sprintf('%.3f', l[1][:min]),
+              sprintf('%.3f', l[1][:max]),
+              sprintf('%.3f', l[1][:total]),
+              l[1][:calls]
+            ]
+            t.add_row row
+          end
+        end
+      end
+
+      # Reader method for TT token
+      #
+      # @return uri [String] TT token
+      def tt_token
+        cookies[:cookies]['GDCAuthTT']
+      end
+
+      private
+
+      def merge_cookies!(cookies)
+        @cookies[:cookies].merge! cookies
+      end
+
+      def profile(title, &block)
+        t1 = Time.now
+        res = block.call
+        t2 = Time.now
+        delta = t2 - t1
+
+        update_stats title, delta
+        res
+      end
+
+      def reset_cookies!
+        @cookies = { :cookies => {} }
+      end
+
+      # TODO: Store PH_MAP for wildcarding of URLs in reports in separate file
+      PH_MAP = [
+        ['/gdc/projects/{id}/users/{id}/permissions', %r{/gdc/projects/[\w]+/users/[\w]+/permissions}],
+        ['/gdc/projects/{id}/roles/{id}', %r{/gdc/projects/[\w]+/roles/[\d]+}],
+        ['/gdc/projects/{id}/model/diff/{id}', %r{/gdc/projects/[\w]+/model/diff/[\w]+}],
+        ['/gdc/projects/{id}/', %r{/gdc/projects/[\w]+/}],
+        ['/gdc/projects/{id}', %r{/gdc/projects/[\w]+}],
+        ['/gdc/md/{id}/using2/{id}/{id}', %r{/gdc/md/[\w]+/using2/[\d]+/[\d]+}],
+        ['/gdc/md/{id}/usedby2/{id}/{id}', %r{/gdc/md/[\w]+/usedby2/[\d]+/[\d]+}],
+        ['/gdc/md/{id}/tasks/{id}/status', %r{/gdc/md/[\w]+/tasks/[\w]+/status}],
+        ['/gdc/md/{id}/obj/{id}/validElements', %r{/gdc/md/[\w]+/obj/[\d]+/validElements(/)?(\?.*)?}],
+        ['/gdc/md/{id}/obj/{id}/elements', %r{/gdc/md/[\w]+/obj/[\d]+/elements(/)?(\?.*)?}],
+        ['/gdc/md/{id}/obj/{id}', %r{/gdc/md/[\w]+/obj/[\d]+}],
+        ['/gdc/md/{id}/etl/task/{id}', %r{/gdc/md/[\w]+/etl/task/[\d]+}],
+        ['/gdc/md/{id}/dataResult/{id}', %r{/gdc/md/[\w]+/dataResult/[\d]+}],
+        ['/gdc/md/{id}', %r{/gdc/md/[\w]+}],
+        ['/gdc/app/projects/{id}/execute', %r{/gdc/app/projects/[\w]+/execute}],
+        ['/gdc/account/profile/{id}', %r{/gdc/account/profile/[\w]+}],
+        ['/gdc/account/login/{id}', %r{/gdc/account/login/[\w]+}],
+        ['/gdc/account/domains/{id}', %r{/gdc/account/domains/[\w\d-]+}]
+      ]
+
+      def update_stats(title, delta)
+        orig_title = title
+
+        placeholders = true
+
+        if placeholders
+          PH_MAP.each do |pm|
+            break if title.gsub!(pm[1], pm[0])
+          end
+        end
+
+        stat = stats[title]
+        if stat.nil?
+          stat = {
+            :min => delta,
+            :max => delta,
+            :total => 0,
+            :avg => 0,
+            :calls => 0,
+            :entries => []
+          }
+        end
+
+        stat[:min] = delta if delta < stat[:min]
+        stat[:max] = delta if delta > stat[:max]
+        stat[:total] += delta
+        stat[:calls] += 1
+        stat[:avg] = stat[:total] / stat[:calls]
+
+        stat[:entries] << orig_title if placeholders
+
+        stats[title] = stat
+      end
+    end
+  end
+end