fmrest-core 0.13.0

data/lib/fmrest/token_store/base.rb

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,41 @@
+# 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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module FmRest
+  module V1
+    module Connection
+      BASE_PATH = "/fmi/data/v1"
+      DATABASES_PATH = "#{BASE_PATH}/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 = V1.url_encode(settings.database!)
+
+        Faraday.new(
+          "#{scheme}://#{host}#{DATABASES_PATH}/#{database}/".freeze,
+          faraday_options,
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/fmrest/v1/container_fields.rb

@@ -0,0 +1,114 @@
+# 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