fmrest 0.12.0 → 0.13.0

data/lib/fmrest/token_store.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module TokenStore
-    autoload :Base,         "fmrest/token_store/base"
-    autoload :Memory,       "fmrest/token_store/memory"
-    autoload :Null,         "fmrest/token_store/null"
-    autoload :ActiveRecord, "fmrest/token_store/active_record"
-    autoload :Moneta,       "fmrest/token_store/moneta"
-    autoload :Redis,        "fmrest/token_store/redis"
-  end
-end

data/lib/fmrest/token_store/active_record.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-require "active_record"
-
-module FmRest
-  module TokenStore
-    # Heavily inspired by Moneta's ActiveRecord store:
-    #
-    #   https://github.com/minad/moneta/blob/master/lib/moneta/adapters/activerecord.rb
-    #
-    class ActiveRecord < Base
-      DEFAULT_TABLE_NAME = "fmrest_session_tokens".freeze
-
-      @connection_lock = ::Mutex.new
-      class << self
-        attr_reader :connection_lock
-      end
-
-      attr_reader :connection_pool, :model
-
-      delegate :with_connection, to: :connection_pool
-
-      def initialize(options = {})
-        super
-
-        @connection_pool = ::ActiveRecord::Base.connection_pool
-
-        create_table
-
-        @model = Class.new(::ActiveRecord::Base)
-        @model.table_name = table_name
-      end
-
-      def delete(key)
-        model.where(scope: key).delete_all
-      end
-
-      def load(key)
-        model.where(scope: key).pluck(:token).first
-      end
-
-      def store(key, value)
-        record = model.find_or_initialize_by(scope: key)
-        record.token = value
-        record.save!
-        value
-      end
-
-      private
-
-      def create_table
-        with_connection do |conn|
-          return if conn.table_exists?(table_name)
-
-          # Prevent multiple connections from attempting to create the table simultaneously.
-          self.class.connection_lock.synchronize do
-            conn.create_table(table_name, id: false) do |t|
-              t.string :scope, null: false
-              t.string :token, null: false
-              t.datetime :updated_at
-            end
-            conn.add_index(table_name, :scope, unique: true)
-            conn.add_index(table_name, [:scope, :token])
-          end
-        end
-      end
-
-      def table_name
-        options[:table_name] || DEFAULT_TABLE_NAME
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/base.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module TokenStore
-    class Base
-      attr_reader :options
-
-      def initialize(options = {})
-        @options = options
-      end
-
-      def load(key)
-        raise NotImplementedError
-      end
-
-      def store(key, value)
-        raise NotImplementedError
-      end
-
-      def delete(key)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/memory.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-
-module FmRest
-  module TokenStore
-    class Memory < Base
-      def initialize(*args)
-        super
-        @tokens = {}
-      end
-
-      def delete(key)
-        @tokens.delete(key)
-      end
-
-      def load(key)
-        @tokens[key]
-      end
-
-      def store(key, value)
-        @tokens[key] = value
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/moneta.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-require "moneta"
-
-module FmRest
-  module TokenStore
-    class Moneta < Base
-      DEFAULT_ADAPTER = :Memory
-      DEFAULT_PREFIX = "fmrest-token:".freeze
-
-      attr_reader :moneta
-
-      # @param options [Hash]
-      #   Options to pass to `Moneta.new`
-      # @option options [Symbol] :adapter (:Memory)
-      #   The Moneta adapter to use
-      # @option options [String] :prefix (DEFAULT_PREFIX)
-      #   The prefix to use for keys
-      def initialize(options = {})
-        options = options.dup
-        super(options)
-        adapter = options.delete(:adapter) || DEFAULT_ADAPTER
-        options[:prefix] ||= DEFAULT_PREFIX
-        @moneta = ::Moneta.new(adapter, options)
-      end
-
-      def load(key)
-        moneta[key]
-      end
-
-      def delete(key)
-        moneta.delete(key)
-      end
-
-      def store(key, value)
-        moneta[key] = value
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/null.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-
-module FmRest
-  module TokenStore
-    module Null < Base
-      include Singleton
-
-      def delete(key)
-      end
-
-      def load(key)
-      end
-
-      def store(key, value)
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/redis.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-require "redis" unless defined?(MockRedis)
-
-module FmRest
-  module TokenStore
-    class Redis < Base
-      DEFAULT_PREFIX = "fmrest-token:".freeze
-
-      STORE_OPTIONS = [:redis, :prefix].freeze
-
-      def initialize(options = {})
-        super
-        @redis = @options[:redis] || ::Redis.new(options_for_redis)
-        @prefix = @options[:prefix] || DEFAULT_PREFIX
-      end
-
-      def load(key)
-        @redis.get(prefix_key(key))
-      end
-
-      def store(key, value)
-        @redis.set(prefix_key(key), value)
-        value
-      end
-
-      def delete(key)
-        @redis.del(prefix_key(key))
-      end
-
-      private
-
-      def options_for_redis
-        @options.dup.tap do |options|
-          STORE_OPTIONS.each { |opt| options.delete(opt) }
-        end
-      end
-
-      def prefix_key(key)
-        "#{@prefix}#{key}"
-      end
-    end
-  end
-end

data/lib/fmrest/v1.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/v1/connection"
-require "fmrest/v1/paths"
-require "fmrest/v1/container_fields"
-require "fmrest/v1/utils"
-require "fmrest/v1/dates"
-require "fmrest/v1/auth"
-
-module FmRest
-  module V1
-    extend Connection
-    extend Paths
-    extend ContainerFields
-    extend Utils
-    extend Dates
-    extend Auth
-
-    autoload :TokenSession, "fmrest/v1/token_session"
-    autoload :RaiseErrors, "fmrest/v1/raise_errors"
-    autoload :TypeCoercer, "fmrest/v1/type_coercer"
-  end
-end

data/lib/fmrest/v1/auth.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module Auth
-      # Requests a token through basic auth
-      #
-      # @param connection [Faraday] the auth connection to use for
-      #   the request
-      # @return The token if successful
-      # @return `false` if authentication failed
-      def request_auth_token(connection = FmRest::V1.auth_connection)
-        request_auth_token!(connection)
-      rescue FmRest::APIError::AccountError
-        false
-      end
-
-      # Requests a token through basic auth, raising
-      # `FmRest::APIError::AccountError` if auth fails
-      #
-      # @param (see #request_auth_token)
-      # @return The token if successful
-      # @raise [FmRest::APIError::AccountError] if authentication failed
-      def request_auth_token!(connection = FmRest.V1.auth_connection)
-        resp = connection.post(V1.session_path)
-        resp.body["response"]["token"]
-      end
-    end
-  end
-end

data/lib/fmrest/v1/connection.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module FmRest
-  module V1
-    module Connection
-      BASE_PATH = "/fmi/data/v1/databases"
-
-      AUTH_HEADERS = { "Content-Type" => "application/json" }.freeze
-
-      # Builds a complete DAPI Faraday connection with middleware already
-      # configured to handle authentication, JSON parsing, logging and DAPI
-      # error handling. A block can be optionally given for additional
-      # middleware configuration
-      #
-      # @option (see #base_connection)
-      # @return (see #base_connection)
-      def build_connection(settings = FmRest.default_connection_settings, &block)
-        settings = ConnectionSettings.wrap(settings)
-
-        base_connection(settings) do |conn|
-          conn.use RaiseErrors
-          conn.use TokenSession, settings
-
-          # The EncodeJson and Multipart middlewares only encode the request
-          # when the content type matches, so we can have them both here and
-          # still play nice with each other, we just need to set the content
-          # type to multipart/form-data when we want to submit a container
-          # field
-          conn.request :multipart
-          conn.request :json
-
-          # Allow overriding the default response middleware
-          if block_given?
-            yield conn, settings
-          else
-            conn.use TypeCoercer, settings
-            conn.response :json
-          end
-
-          if settings.log
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          conn.adapter Faraday.default_adapter
-        end
-      end
-
-      # Builds a Faraday connection to use for DAPI basic auth login
-      #
-      # @option (see #base_connection)
-      # @return (see #base_connection)
-      def auth_connection(settings = FmRest.default_connection_settings)
-        settings = ConnectionSettings.wrap(settings)
-
-        base_connection(settings, { headers: AUTH_HEADERS }) do |conn|
-          conn.use RaiseErrors
-
-          conn.basic_auth settings.username!, settings.password!
-
-          if settings.log
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          conn.response :json
-          conn.adapter Faraday.default_adapter
-        end
-      end
-
-      # Builds a base Faraday connection with base URL constructed from
-      # connection settings and passes it the given block
-      #
-      # @option settings [String] :host The hostname for the FM server
-      # @option settings [String] :database The FM database name
-      # @option settings [String] :username The username for DAPI authentication
-      # @option settings [String] :account_name Alias of :username for
-      #   compatibility with Rfm gem
-      # @option settings [String] :password The password for DAPI authentication
-      # @option settings [String] :ssl SSL settings to forward to the Faraday
-      #   connection
-      # @option settings [String] :proxy Proxy options to forward to the Faraday
-      #   connection
-      # @param faraday_options [Hash] additional options for Faraday object
-      # @return [Faraday] The new Faraday connection
-      def base_connection(settings = FmRest.default_connection_settings, faraday_options = nil, &block)
-        settings = ConnectionSettings.wrap(settings)
-
-        host = settings.host!
-
-        # Default to HTTPS
-        scheme = "https"
-
-        if host.match(/\Ahttps?:\/\//)
-          uri = URI(host)
-          host = uri.hostname
-          host += ":#{uri.port}" if uri.port != uri.default_port
-          scheme = uri.scheme
-        end
-
-        faraday_options = (faraday_options || {}).dup
-        faraday_options[:ssl] = settings.ssl if settings.ssl?
-        faraday_options[:proxy] = settings.proxy if settings.proxy?
-
-        database = URI.encode_www_form_component(settings.database!)
-
-        Faraday.new(
-          "#{scheme}://#{host}#{BASE_PATH}/#{database}/".freeze,
-          faraday_options,
-          &block
-        )
-      end
-    end
-  end
-end

data/lib/fmrest/v1/container_fields.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module ContainerFields
-      DEFAULT_UPLOAD_CONTENT_TYPE = "application/octet-stream".freeze
-
-      # Given a container field URL it tries to fetch it and returns an IO
-      # object with its body content (see Ruby's OpenURI for how the IO object
-      # is extended with useful HTTP response information).
-      #
-      # This method uses OpenURI instead of Faraday for fetching the actual
-      # container file.
-      #
-      # @raise [FmRest::ContainerFieldError] if any step fails
-      # @param container_field_url [String] The URL to the container to
-      #   download
-      # @param base_connection [Faraday::Connection] An optional Faraday
-      #   connection to use as base settings for the container requests, useful
-      #   if you need to set SSL or proxy settings. If given, this connection
-      #   will not be used directly, but rather a new one with copied SSL and
-      #   proxy options. If omitted, `FmRest.default_connection_settings`'s
-      #   `:ssl` and `:proxy` options will be used instead (if available)
-      # @return [IO] The contents of the container
-      def fetch_container_data(container_field_url, base_connection = nil)
-        require "open-uri"
-
-        begin
-          url = URI(container_field_url)
-        rescue ::URI::InvalidURIError
-          raise FmRest::ContainerFieldError, "Invalid container field URL `#{container_field_url}'"
-        end
-
-        # Make sure we don't try to open anything on the file:/ URI scheme
-        unless url.scheme.match(/\Ahttps?\Z/)
-          raise FmRest::ContainerFieldError, "Container URL is not HTTP (#{container_field_url})"
-        end
-
-        ssl_options = base_connection && base_connection.ssl && base_connection.ssl.to_hash
-        proxy_options = base_connection && base_connection.proxy && base_connection.proxy.to_hash
-
-        conn =
-          Faraday.new(nil,
-            ssl:   ssl_options || FmRest.default_connection_settings[:ssl],
-            proxy: proxy_options || FmRest.default_connection_settings[:proxy]
-          )
-
-        # Requesting the container URL with no cookie set will respond with a
-        # redirect and a session cookie
-        cookie_response = conn.get url
-
-        unless cookie = cookie_response.headers["Set-Cookie"]
-          raise FmRest::ContainerFieldError, "Container field's initial request didn't return a session cookie, the URL may be stale (try downloading it again immediately after retrieving the record)"
-        end
-
-        # Now request the URL again with the proper session cookie using
-        # OpenURI, which wraps the response in an IO object which also responds
-        # to #content_type
-        url.open(faraday_connection_to_openuri_options(conn).merge("Cookie" => cookie))
-      end
-
-      # Handles the core logic of uploading a file into a container field
-      #
-      # @param connection [Faraday::Connection] the Faraday connection to use
-      # @param container_path [String] the path to the container
-      # @param filename_or_io [String, IO] a path to the file to upload or an
-      #   IO object
-      # @param options [Hash]
-      # @option options [String] :content_type (DEFAULT_UPLOAD_CONTENT_TYPE)
-      #   The content type for the uploaded file
-      # @option options [String] :filename The filename to use for the uploaded
-      #   file, defaults to `filename_or_io.original_filename` if available
-      def upload_container_data(connection, container_path, filename_or_io, options = {})
-        content_type = options[:content_type] || DEFAULT_UPLOAD_CONTENT_TYPE
-
-        connection.post do |request|
-          request.url container_path
-          request.headers['Content-Type'] = ::Faraday::Request::Multipart.mime_type
-
-          filename = options[:filename] || filename_or_io.try(:original_filename)
-
-          request.body = { upload: Faraday::UploadIO.new(filename_or_io, content_type, filename) }
-        end
-      end
-
-      private
-
-      # Copies a Faraday::Connection's relevant options to
-      # OpenURI::OpenRead#open format
-      #
-      def faraday_connection_to_openuri_options(conn)
-        openuri_opts = {}
-
-        if !conn.ssl.empty?
-          openuri_opts[:ssl_verify_mode] =
-            conn.ssl.fetch(:verify, true) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-
-          openuri_opts[:ssl_ca_cert] = conn.ssl.cert_store if conn.ssl.cert_store
-        end
-
-        if conn.proxy && !conn.proxy.empty?
-          if conn.proxy.user && conn.proxy.password
-            openuri_opts[:proxy_http_basic_authentication] =
-              [conn.proxy.uri.tap { |u| u.userinfo = ""}, conn.proxy.user, conn.proxy.password]
-          else
-            openuri_opts[:proxy] = conn.proxy.uri
-          end
-        end
-
-        openuri_opts
-      end
-    end
-  end
-end