looker-sdk 0.0.5

data/lib/looker-sdk/client/dynamic.rb

@@ -0,0 +1,107 @@
+module LookerSDK
+  class Client
+
+    module Dynamic
+
+      attr_accessor :dynamic
+
+      def try_load_swagger
+        resp = get('swagger.json') rescue nil
+        resp && last_response && last_response.status == 200 && last_response.data && last_response.data.to_attrs
+      end
+
+      # If a given client is created with ':shared_swagger => true' then it will try to
+      # use a globally sharable @@operations hash built from one fetch of the swagger.json for the
+      # given api_endpoint. This is an optimization for the cases where many sdk clients get created and
+      # destroyed (perhaps with different access tokens) while all talking to the same endpoints. This cuts
+      # down overhead for such cases considerably.
+
+      @@sharable_operations = Hash.new
+
+      def clear_swagger
+        @swagger = @operations = nil
+      end
+
+      def load_swagger
+        # We only need the swagger if we are going to be building our own 'operations' hash
+        return if shared_swagger && @@sharable_operations[api_endpoint]
+        # Try to load w/o authenticating. Else, authenticate and try again.
+        @swagger ||= without_authentication {try_load_swagger} || try_load_swagger
+      end
+
+      def operations
+        return @@sharable_operations[api_endpoint] if shared_swagger && @@sharable_operations[api_endpoint]
+
+        return nil unless @swagger
+        @operations ||= Hash[
+          @swagger[:paths].map do |path_name, path_info|
+            path_info.map do |method, route_info|
+              route = @swagger[:basePath].to_s + path_name.to_s
+              [route_info[:operationId], {:route => route, :method => method, :info => route_info}]
+            end
+          end.reduce(:+)
+        ].freeze
+
+        shared_swagger ? (@@sharable_operations[api_endpoint] = @operations) : @operations
+      end
+
+      def method_link(entry)
+        uri = URI.parse(api_endpoint)
+        "#{uri.scheme}://#{uri.host}:#{uri.port}/api-docs/index.html#!/#{entry[:info][:tags].first}/#{entry[:info][:operationId]}" rescue "http://docs.looker.com/"
+      end
+
+      # Callers can explicitly 'invoke' remote methods or let 'method_missing' do the trick.
+      # If nothing else, this gives clients a way to deal with potential conflicts between remote method
+      # names and names of methods on client itself.
+      def invoke(method_name, *args, &block)
+        entry = find_entry(method_name) || raise(NameError, "undefined remote method '#{method_name}'")
+        invoke_remote(entry, method_name, *args, &block)
+      end
+
+      def method_missing(method_name, *args, &block)
+        entry = find_entry(method_name) || (return super)
+        invoke_remote(entry, method_name, *args, &block)
+      end
+
+      def respond_to?(method_name, include_private=false)
+        !!find_entry(method_name) || super
+      end
+
+      private
+
+      def find_entry(method_name)
+        operations && operations[method_name.to_s] if dynamic
+      end
+
+      def invoke_remote(entry, method_name, *args, &block)
+        args = (args || []).dup
+        route = entry[:route].to_s.dup
+        params = (entry[:info][:parameters] || []).select {|param| param[:in] == 'path'}
+        body_param = (entry[:info][:parameters] || []).select {|param| param[:in] == 'body'}.first
+
+        params_passed = args.length
+        params_required = params.length + (body_param && body_param[:required] ? 1 : 0)
+        unless params_passed >= params_required
+          raise ArgumentError.new("wrong number of arguments (#{params_passed} for #{params_required}) in call to '#{method_name}'. See '#{method_link(entry)}'")
+        end
+
+        # substitute the actual params into the route template
+        params.each {|param| route.sub!("{#{param[:name]}}", args.shift.to_s) }
+
+        a = args.length > 0 ? args[0] : {}
+        b = args.length > 1 ? args[1] : {}
+
+        method = entry[:method].to_sym
+        case method
+        when :get     then get(route, a, &block)
+        when :post    then post(route, a, merge_content_type_if_body(a, b), &block)
+        when :put     then put(route, a, merge_content_type_if_body(a, b), &block)
+        when :patch   then patch(route, a, merge_content_type_if_body(a, b), &block)
+        when :delete  then delete(route, a) ; @raw_responses ? last_response : delete_succeeded?
+        else raise "unsupported method '#{method}' in call to '#{method_name}'. See '#{method_link(entry)}'"
+        end
+      end
+
+    end
+  end
+end

data/lib/looker-sdk/configurable.rb

@@ -0,0 +1,116 @@
+module LookerSDK
+
+  # Configuration options for {Client}, defaulting to values
+  # in {Default}
+  module Configurable
+    # @!attribute [w] access_token
+    # @see look TODO docs link
+    #   @return [String] OAuth2 access token for authentication
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for API requests. default: https://api.looker.com/ look TODO: this is the wrong url... what's the right one?  Also update all other references to "api.looker.com"
+    # @!attribute auto_paginate
+    #   @return [Boolean] Auto fetch next page of results until rate limit reached
+    # @!attribute client_id
+    # @see look TODO docs link
+    #   @return [String] Configure OAuth app key
+    # @!attribute [w] client_secret
+    # @see look TODO docs link
+    #   @return [String] Configure OAuth app secret
+    # @!attribute default_media_type
+    # @see look TODO docs link
+    #   @return [String] Configure preferred media type (for API versioning, for example)
+    # @!attribute connection_options
+    #   @see https://github.com/lostisland/faraday
+    #   @return [Hash] Configure connection options for Faraday
+    # @!attribute middleware
+    #   @see https://github.com/lostisland/faraday
+    #   @return [Faraday::Builder or Faraday::RackBuilder] Configure middleware for Faraday
+    # @!attribute netrc
+    #   @return [Boolean] Instruct Looker to get credentials from .netrc file
+    # @!attribute netrc_file
+    #   @return [String] Path to .netrc file. default: ~/.netrc
+    # @!attribute per_page
+    #   @return [String] Configure page size for paginated results. API default: 30
+    # @!attribute proxy
+    #   @see https://github.com/lostisland/faraday
+    #   @return [String] URI for proxy server
+    # @!attribute user_agent
+    #   @return [String] Configure User-Agent header for requests.
+    # @!attribute web_endpoint
+    #   @return [String] Base URL for web URLs. default: https://<client>.looker.com/ look TODO is this correct?
+
+    attr_accessor :access_token, :auto_paginate, :client_id,
+                  :client_secret, :default_media_type, :connection_options,
+                  :middleware, :netrc, :netrc_file,
+                  :per_page, :proxy, :user_agent, :faraday, :swagger, :shared_swagger, :raw_responses
+    attr_writer :web_endpoint, :api_endpoint
+
+    class << self
+
+      # List of configurable keys for {LookerSDK::Client}
+      # @return [Array] of option keys
+      def keys
+        @keys ||= [
+          :access_token,
+          :api_endpoint,
+          :auto_paginate,
+          :client_id,
+          :client_secret,
+          :connection_options,
+          :default_media_type,
+          :middleware,
+          :netrc,
+          :netrc_file,
+          :per_page,
+          :proxy,
+          :user_agent,
+          :faraday,
+          :shared_swagger,
+          :swagger,
+          :raw_responses,
+          :web_endpoint
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      LookerSDK::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", LookerSDK::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
+
+    # Base URL for generated web URLs
+    #
+    # @return [String] Default: https://<client>.looker.com/ look TODO is this correct?
+    def web_endpoint
+      File.join(@web_endpoint, "")
+    end
+
+    def netrc?
+      !!@netrc
+    end
+
+    private
+
+    def options
+      Hash[LookerSDK::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+    def fetch_client_id_and_secret(overrides = {})
+      opts = options.merge(overrides)
+      opts.values_at :client_id, :client_secret
+    end
+  end
+end

data/lib/looker-sdk/default.rb

@@ -0,0 +1,148 @@
+require 'looker-sdk/response/raise_error'
+require 'looker-sdk/version'
+
+module LookerSDK
+
+  # Default configuration options for {Client}
+  module Default
+
+    # Default API endpoint look TODO update this as needed
+    API_ENDPOINT = "https://localhost:19999/api/3.0/".freeze
+
+    # Default User Agent header string
+    USER_AGENT   = "Looker Ruby Gem #{LookerSDK::VERSION}".freeze
+
+    # Default media type
+    MEDIA_TYPE   = "application/json"
+
+    # Default WEB endpoint
+    WEB_ENDPOINT = "https://localhost:9999".freeze # look TODO update this
+
+    # In Faraday 0.9, Faraday::Builder was renamed to Faraday::RackBuilder
+    RACK_BUILDER_CLASS = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+
+    # Default Faraday middleware stack
+    MIDDLEWARE = RACK_BUILDER_CLASS.new do |builder|
+      builder.use LookerSDK::Response::RaiseError
+      builder.adapter Faraday.default_adapter
+    end
+
+    class << self
+
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[LookerSDK::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      # Default access token from ENV
+      # @return [String]
+      def access_token
+        ENV['LOOKER_ACCESS_TOKEN']
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV['LOOKER_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      # Default pagination preference from ENV
+      # @return [String]
+      def auto_paginate
+        ENV['LOOKER_AUTO_PAGINATE']
+      end
+
+      # Default OAuth app key from ENV
+      # @return [String]
+      def client_id
+        ENV['LOOKER_CLIENT_ID']
+      end
+
+      # Default OAuth app secret from ENV
+      # @return [String]
+      def client_secret
+        ENV['LOOKER_SECRET']
+      end
+
+      # Default options for Faraday::Connection
+      # @return [Hash]
+      def connection_options
+        {
+          :headers => {
+            :accept => default_media_type,
+            :user_agent => user_agent
+          }
+        }
+      end
+
+      # Default media type from ENV or {MEDIA_TYPE}
+      # @return [String]
+      def default_media_type
+        ENV['LOOKER_DEFAULT_MEDIA_TYPE'] || MEDIA_TYPE
+      end
+
+      # Default middleware stack for Faraday::Connection
+      # from {MIDDLEWARE}
+      # @return [String]
+      def middleware
+        MIDDLEWARE
+      end
+
+      def faraday
+        nil
+      end
+
+      def swagger
+        nil
+      end
+
+      def shared_swagger
+        false
+      end
+
+      def raw_responses
+        false
+      end
+
+      # Default pagination page size from ENV
+      # @return [Fixnum] Page size
+      def per_page
+        page_size = ENV['LOOKER_PER_PAGE']
+
+        page_size.to_i if page_size
+      end
+
+      # Default proxy server URI for Faraday connection from ENV
+      # @return [String]
+      def proxy
+        ENV['LOOKER_PROXY']
+      end
+
+      # Default User-Agent header string from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV['LOOKER_USER_AGENT'] || USER_AGENT
+      end
+
+      # Default web endpoint from ENV or {WEB_ENDPOINT}
+      # @return [String]
+      def web_endpoint
+        ENV['LOOKER_WEB_ENDPOINT'] || WEB_ENDPOINT
+      end
+
+      # Default behavior for reading .netrc file
+      # @return [Boolean]
+      def netrc
+        ENV['LOOKER_NETRC'] || false
+      end
+
+      # Default path for .netrc file
+      # @return [String]
+      def netrc_file
+        ENV['LOOKER_NETRC_FILE'] || File.join(ENV['HOME'].to_s, '.netrc')
+      end
+
+    end
+  end
+end

data/lib/looker-sdk/error.rb

@@ -0,0 +1,235 @@
+module LookerSDK
+  class Error < StandardError
+
+    # Returns the appropriate LookerSDK::Error sublcass based
+    # on status and response message
+    #
+    # @param [Hash] response HTTP response
+    # @return [LookerSDK::Error]
+    def self.from_response(response)
+      status  = response[:status].to_i
+      body    = response[:body].to_s
+      headers = response[:response_headers]
+
+      if klass =  case status
+                  when 400      then LookerSDK::BadRequest
+                  when 401      then error_for_401(headers)
+                  when 403      then error_for_403(body)
+                  when 404      then LookerSDK::NotFound
+                  when 405      then LookerSDK::MethodNotAllowed
+                  when 406      then LookerSDK::NotAcceptable
+                  when 409      then LookerSDK::Conflict
+                  when 415      then LookerSDK::UnsupportedMediaType
+                  when 422      then LookerSDK::UnprocessableEntity
+                  when 400..499 then LookerSDK::ClientError
+                  when 500      then LookerSDK::InternalServerError
+                  when 501      then LookerSDK::NotImplemented
+                  when 502      then LookerSDK::BadGateway
+                  when 503      then LookerSDK::ServiceUnavailable
+                  when 500..599 then LookerSDK::ServerError
+                  end
+        klass.new(response)
+      end
+    end
+
+    def initialize(response=nil)
+      @response = response
+      super(build_error_message)
+    end
+
+    # Documentation URL returned by the API for some errors
+    #
+    # @return [String]
+    def documentation_url
+      data[:documentation_url] if data.is_a? Hash
+    end
+
+    # Message string returned by the API for some errors
+    #
+    # @return [String]
+    def message
+      response_message
+    end
+
+    # Returns most appropriate error for 401 HTTP status code
+    # @private
+    def self.error_for_401(headers)
+      if LookerSDK::OneTimePasswordRequired.required_header(headers)
+        LookerSDK::OneTimePasswordRequired
+      else
+        LookerSDK::Unauthorized
+      end
+    end
+
+    # Returns most appropriate error for 403 HTTP status code
+    # @private
+    def self.error_for_403(body)
+      if body =~ /rate limit exceeded/i
+        LookerSDK::TooManyRequests
+      elsif body =~ /login attempts exceeded/i
+        LookerSDK::TooManyLoginAttempts
+      else
+        LookerSDK::Forbidden
+      end
+    end
+
+    # Array of validation errors
+    # @return [Array<Hash>] Error info
+    def errors
+      if data && data.is_a?(Hash)
+        data[:errors] || []
+      else
+        []
+      end
+    end
+
+    private
+
+    def data
+      @data ||=
+        if (body = @response[:body]) && !body.empty?
+          if body.is_a?(String) &&
+            @response[:response_headers] &&
+            @response[:response_headers][:content_type] =~ /json/
+
+            Sawyer::Agent.serializer.decode(body)
+          else
+            body
+          end
+        else
+          nil
+        end
+    end
+
+    def response_message
+      case data
+      when Hash
+        data[:message]
+      when String
+        data
+      end
+    end
+
+    def response_error
+      "Error: #{data[:error]}" if data.is_a?(Hash) && data[:error]
+    end
+
+    def response_error_summary
+      return nil unless data.is_a?(Hash) && !Array(data[:errors]).empty?
+
+      summary = "\nError summary:\n"
+      summary << data[:errors].map do |hash|
+        hash.map { |k,v| "  #{k}: #{v}" }
+      end.join("\n")
+
+      summary
+    end
+
+    def build_error_message
+      return nil if @response.nil?
+
+      message =  "#{@response[:method].to_s.upcase} "
+      message << redact_url(@response[:url].to_s) + ": "
+      message << "#{@response[:status]} - "
+      message << "#{response_message}" unless response_message.nil?
+      message << "#{response_error}" unless response_error.nil?
+      message << "#{response_error_summary}" unless response_error_summary.nil?
+      message << " // See: #{documentation_url}" unless documentation_url.nil?
+      message
+    end
+
+    def redact_url(url_string)
+      %w[client_secret access_token].each do |token|
+        url_string.gsub!(/#{token}=\S+/, "#{token}=(redacted)") if url_string.include? token
+      end
+      url_string
+    end
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when API returns a 400 HTTP status code
+  class BadRequest < ClientError; end
+
+  # Raised when API returns a 401 HTTP status code
+  class Unauthorized < ClientError; end
+
+  # Raised when API returns a 401 HTTP status code
+  # and headers include "X-Looker-OTP" look TODO do we want to support this?
+  class OneTimePasswordRequired < ClientError
+    #@private
+    OTP_DELIVERY_PATTERN = /required; (\w+)/i
+
+    #@private
+    def self.required_header(headers)
+      OTP_DELIVERY_PATTERN.match headers['X-Looker-OTP'].to_s
+    end
+
+    # Delivery method for the user's OTP
+    #
+    # @return [String]
+    def password_delivery
+      @password_delivery ||= delivery_method_from_header
+    end
+
+    private
+
+    def delivery_method_from_header
+      if match = self.class.required_header(@response[:response_headers])
+        match[1]
+      end
+    end
+  end
+
+  # Raised when Looker returns a 403 HTTP status code
+  class Forbidden < ClientError; end
+
+  # Raised when Looker returns a 403 HTTP status code
+  # and body matches 'rate limit exceeded'
+  class TooManyRequests < Forbidden; end
+
+  # Raised when Looker returns a 403 HTTP status code
+  # and body matches 'login attempts exceeded'
+  class TooManyLoginAttempts < Forbidden; end
+
+  # Raised when Looker returns a 404 HTTP status code
+  class NotFound < ClientError; end
+
+  # Raised when Looker returns a 405 HTTP status code
+  class MethodNotAllowed < ClientError; end
+
+  # Raised when Looker returns a 406 HTTP status code
+  class NotAcceptable < ClientError; end
+
+  # Raised when Looker returns a 409 HTTP status code
+  class Conflict < ClientError; end
+
+  # Raised when Looker returns a 414 HTTP status code
+  class UnsupportedMediaType < ClientError; end
+
+  # Raised when Looker returns a 422 HTTP status code
+  class UnprocessableEntity < ClientError; end
+
+  # Raised on errors in the 500-599 range
+  class ServerError < Error; end
+
+  # Raised when Looker returns a 500 HTTP status code
+  class InternalServerError < ServerError; end
+
+  # Raised when Looker returns a 501 HTTP status code
+  class NotImplemented < ServerError; end
+
+  # Raised when Looker returns a 502 HTTP status code
+  class BadGateway < ServerError; end
+
+  # Raised when Looker returns a 503 HTTP status code
+  class ServiceUnavailable < ServerError; end
+
+  # Raised when client fails to provide valid Content-Type
+  class MissingContentType < ArgumentError; end
+
+  # Raised when a method requires an application client_id
+  # and secret but none is provided
+  class ApplicationCredentialsRequired < StandardError; end
+end