super_settings 0.0.0.rc1

data/lib/super_settings/storage/http_storage.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+
+# SuperSettings::Storage model that reads from a remote service running the SuperSettings REST API.
+# This storage engine is read only. It is intended to allow microservices to read settings from a
+# central application that exposes the SuperSettings::RestAPI.
+module SuperSettings
+  module Storage
+    class HttpStorage
+      include Storage
+
+      DEFAULT_HEADERS = {"Accept" => "application/json"}.freeze
+      DEFAULT_TIMEOUT = 5.0
+
+      attr_reader :key, :raw_value, :description, :value_type, :updated_at, :created_at
+
+      class Error < StandardError
+      end
+
+      class NotFoundError < Error
+      end
+
+      class InvalidRecordError < Error
+        attr_reader :errors
+
+        def initialize(message, errors:)
+          super(message)
+          @errors = errors
+        end
+      end
+
+      class HistoryStorage
+        include SuperSettings::Attributes
+
+        attr_accessor :key, :value, :changed_by, :deleted
+
+        def created_at=(val)
+          @created_at = SuperSettings::Coerce.time(val)
+        end
+
+        def deleted?
+          !!(defined?(@deleted) && @deleted)
+        end
+      end
+
+      class << self
+        def all
+          call_api(:get, "/settings")["settings"].collect do |attributes|
+            new(attributes)
+          end
+        end
+
+        def updated_since(time)
+          call_api(:get, "/settings/updated_since", time: time)["settings"].collect do |attributes|
+            new(attributes)
+          end
+        end
+
+        def find_by_key(key)
+          record = new(call_api(:get, "/setting", key: key))
+          record.send(:set_persisted!)
+          record
+        rescue NotFoundError
+          nil
+        end
+
+        def last_updated_at
+          value = call_api(:get, "/settings/last_updated_at")["last_updated_at"]
+          SuperSettings::Coerce.time(value)
+        end
+
+        attr_accessor :base_url
+
+        attr_accessor :timeout
+
+        def headers
+          @headers ||= {}
+        end
+
+        def query_params
+          @query_params ||= {}
+        end
+
+        protected
+
+        def default_load_asynchronous?
+          true
+        end
+
+        private
+
+        def call_api(method, path, params = {})
+          url_params = (method == :get ? query_params.merge(params) : query_params)
+          uri = api_uri(path, url_params)
+
+          body = nil
+          request_headers = DEFAULT_HEADERS.merge(headers)
+          if method == :post && !params&.empty?
+            body = params.to_json
+            request_headers["Content-Type"] = "application/json; charset=utf8-"
+          end
+
+          response = http_request(method: method, uri: uri, headers: request_headers, body: body)
+
+          begin
+            response.value # raises exception unless response is a success
+            JSON.parse(response.body)
+          rescue Net::ProtocolError
+            if [404, 410].include?(response.code.to_i)
+              raise NotFoundError.new("#{response.code} #{response.message}")
+            elsif response.code.to_i == 422
+              raise InvalidRecordError.new("#{response.code} #{response.message}", errors: JSON.parse(response.body)["errors"])
+            else
+              raise Error.new("#{response.code} #{response.message}")
+            end
+          rescue JSON::JSONError => e
+            raise Error.new(e.message)
+          end
+        end
+
+        def http_request(method:, uri:, headers: {}, body: nil, redirect_count: 0)
+          response = nil
+          http = Net::HTTP.new(uri.host, uri.port || uri.inferred_port)
+          begin
+            http.read_timeout = (timeout || DEFAULT_TIMEOUT)
+            http.open_timeout = (timeout || DEFAULT_TIMEOUT)
+            if uri.scheme == "https"
+              http.use_ssl = true
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            end
+
+            request = (method == :post ? Net::HTTP::Post.new(uri.request_uri) : Net::HTTP::Get.new(uri.request_uri))
+            set_headers(request, headers)
+            request.body = body if body
+
+            response = http.request(request)
+          ensure
+            begin
+              http.finish if http.started?
+            rescue IOError
+            end
+          end
+
+          if response.is_a?(Net::HTTPRedirection)
+            location = resp["Location"]
+            if redirect_count < 5 && SuperSettings::Coerce.present?(location)
+              return http_request(method: :get, uri: URI(location), headers: headers, body: body, redirect_count: redirect_count + 1)
+            end
+          end
+
+          response
+        end
+
+        def api_uri(path, params)
+          uri = URI("#{base_url.chomp("/")}#{path}")
+          if params && !params.empty?
+            q = []
+            q << uri.query unless uri.query.to_s.empty?
+            params.each do |name, value|
+              q << "#{URI.encode_www_form_component(name.to_s)}=#{URI.encode_www_form_component(value.to_s)}"
+            end
+            uri.query = q.join("&")
+          end
+          uri
+        end
+
+        def set_headers(request, headers)
+          headers.each do |name, value|
+            name = name.to_s
+            values = Array(value)
+            request[name] = values[0].to_s
+            values[1, values.length].each do |val|
+              request.add_field(name, val.to_s)
+            end
+          end
+        end
+      end
+
+      def save!
+        payload = {key: key}
+        if deleted?
+          payload[:deleted] = true
+        else
+          payload[:value] = value
+          payload[:value_type] = value_type
+          payload[:description] = description
+        end
+
+        begin
+          call_api(:post, "/settings", settings: [payload])
+          set_persisted!
+        rescue InvalidRecordError
+          return false
+        end
+        true
+      end
+
+      def history(limit: nil, offset: 0)
+        params = {key: key}
+        params[:offset] = offset if offset > 0
+        params[:limit] = limit if limit
+        history = call_api(:get, "/setting/history", params)
+        history["histories"].collect do |attributes|
+          HistoryItem.new(key: key, value: attributes["value"], changed_by: attributes["changed_by"], created_at: attributes["created_at"], deleted: attributes["deleted"])
+        end
+      end
+
+      def create_history(changed_by:, created_at:, value: nil, deleted: false)
+        # No-op since history is maintained by the source system.
+      end
+
+      def reload
+        self.class.find_by_key(key)
+        self.attributes = self.class.find_by_key(key).attributes
+        self
+      end
+
+      def key=(value)
+        @key = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def raw_value=(value)
+        @raw_value = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+      alias_method :value=, :raw_value=
+      alias_method :value, :raw_value
+
+      def value_type=(value)
+        @value_type = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def description=(value)
+        @description = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def deleted=(value)
+        @deleted = Coerce.boolean(value)
+      end
+
+      def created_at=(value)
+        @created_at = SuperSettings::Coerce.time(value)
+      end
+
+      def updated_at=(value)
+        @updated_at = SuperSettings::Coerce.time(value)
+      end
+
+      def deleted?
+        !!(defined?(@deleted) && @deleted)
+      end
+
+      def persisted?
+        !!(defined?(@persisted) && @persisted)
+      end
+
+      protected
+
+      def redact_history!
+        # No-op since history is maintained by the source system.
+      end
+
+      private
+
+      def set_persisted!
+        @persisted = true
+      end
+
+      def call_api(method, path, params = {})
+        self.class.send(:call_api, method, path, params)
+      end
+
+      def encrypted=(value)
+        # No op; needed for API compatibility
+      end
+    end
+  end
+end

data/lib/super_settings/storage/redis_storage.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "json"
+
+# Redis implementation of the SuperSettings::Storage model.
+#
+# You must define the redis connection to use by setting the redis attribute on the class.
+# This can either be a `Redis` object or a block that yields a `Redis` object. You can use the
+# block form if you need to get the `Redis` object at runtime instead of having a static object.
+#
+# ```ruby
+# SuperSettings::Storage::RedisStorage.redis = Redis.new(url: ENV["REDIS_URL"])
+#
+# SuperSettings::Storage::RedisStorage.redis = lambda { RedisClient.get(:settings) }
+# ```
+#
+# You can also use the [connection_pool]() gem to provide a pool of Redis connecions for
+# a multi-threaded application. The connection_pool gem is not a dependency of this gem,
+# so you would need to add it to your application dependencies to use it.
+#
+# ```ruby
+# SuperSettings::Storage::RedisStorage.redis = ConnectionPool.new(size: 5) { Redis.new(url: ENV["REDIS_URL"]) }
+# ```
+module SuperSettings
+  module Storage
+    class RedisStorage
+      include Storage
+
+      SETTINGS_KEY = "SuperSettings.settings"
+      UPDATED_KEY = "SuperSettings.order_by_updated_at"
+
+      class HistoryStorage
+        HISTORY_KEY_PREFIX = "SuperSettings.history"
+
+        include SuperSettings::Attributes
+
+        attr_accessor :key, :value, :changed_by, :deleted
+        attr_reader :created_at
+
+        class << self
+          def find_all_by_key(key:, offset: 0, limit: nil)
+            end_index = (limit.nil? ? -1 : offset + limit - 1)
+            return [] unless end_index >= -1
+            payloads = RedisStorage.with_redis { |redis| redis.lrange("#{HISTORY_KEY_PREFIX}.#{key}", offset, end_index) }
+            payloads.collect do |json|
+              record = new(JSON.parse(json))
+              record.key = key.to_s
+              record
+            end
+          end
+
+          def create!(attributes)
+            record = new(attributes)
+            record.save!
+            record
+          end
+
+          def destroy_all_by_key(key)
+            RedisStorage.transaction do |redis|
+              redis.del("#{HISTORY_KEY_PREFIX}.#{key}")
+            end
+          end
+
+          def redis_key(key)
+            "#{HISTORY_KEY_PREFIX}.#{key}"
+          end
+        end
+
+        def created_at=(val)
+          @created_at = SuperSettings::Coerce.time(val)
+        end
+
+        def save!
+          raise ArgumentError.new("Missing key") if Coerce.blank?(key)
+          RedisStorage.transaction do |redis|
+            redis.lpush(self.class.redis_key(key), payload_json.to_json)
+          end
+        end
+
+        def deleted?
+          !!(defined?(@deleted) && @deleted)
+        end
+
+        private
+
+        def payload_json
+          payload = {
+            value: value,
+            changed_by: changed_by,
+            created_at: created_at.to_f
+          }
+          payload[:deleted] = true if deleted?
+          payload
+        end
+      end
+
+      attr_reader :key, :raw_value, :description, :value_type, :updated_at, :created_at
+      attr_accessor :changed_by
+
+      class << self
+        def all
+          with_redis do |redis|
+            redis.hgetall(SETTINGS_KEY).values.collect { |json| load_from_json(json) }
+          end
+        end
+
+        def updated_since(time)
+          time = SuperSettings::Coerce.time(time)
+          with_redis do |redis|
+            min_score = time.to_f
+            keys = redis.zrangebyscore(UPDATED_KEY, min_score, "+inf")
+            return [] if keys.empty?
+
+            settings = []
+            redis.hmget(SETTINGS_KEY, *keys).each do |json|
+              settings << load_from_json(json) if json
+            end
+            settings
+          end
+        end
+
+        def find_by_key(key)
+          json = with_redis { |redis| redis.hget(SETTINGS_KEY, key) }
+          return nil unless json
+          load_from_json(json)
+        end
+
+        def last_updated_at
+          result = with_redis { |redis| redis.zrevrange(UPDATED_KEY, 0, 1, withscores: true).first }
+          return nil unless result
+          Time.at(result[1])
+        end
+
+        def destroy_all
+          all.each(&:destroy)
+        end
+
+        attr_writer :redis
+
+        def with_redis(&block)
+          connection = (@redis.is_a?(Proc) ? @redis.call : @redis)
+          if defined?(ConnectionPool) && connection.is_a?(ConnectionPool)
+            connection.with(&block)
+          else
+            block.call(connection)
+          end
+        end
+
+        def transaction(&block)
+          if Thread.current[:super_settings_transaction_redis]
+            block.call(Thread.current[:super_settings_transaction_redis])
+          else
+            begin
+              with_redis do |redis|
+                redis.multi do |multi_redis|
+                  Thread.current[:super_settings_transaction_redis] = multi_redis
+                  Thread.current[:super_settings_transaction_after_commit] = []
+                  block.call(multi_redis)
+                end
+                after_commits = Thread.current[:super_settings_transaction_after_commit]
+                Thread.current[:super_settings_transaction_after_commit] = nil
+                after_commits.each(&:call)
+              end
+            ensure
+              Thread.current[:super_settings_transaction_redis] = nil
+              Thread.current[:super_settings_transaction_after_commit] = nil
+            end
+          end
+        end
+
+        protected
+
+        def default_load_asynchronous?
+          true
+        end
+
+        private
+
+        def load_from_json(json)
+          attributes = JSON.parse(json)
+          setting = new(attributes)
+          setting.send(:set_persisted!)
+          setting
+        end
+      end
+
+      def history(limit: nil, offset: 0)
+        HistoryStorage.find_all_by_key(key: key, limit: limit, offset: offset).collect do |record|
+          HistoryItem.new(key: key, value: record.value, changed_by: record.changed_by, created_at: record.created_at, deleted: record.deleted?)
+        end
+      end
+
+      def create_history(changed_by:, created_at:, value: nil, deleted: false)
+        HistoryStorage.create!(key: key, value: value, deleted: deleted, changed_by: changed_by, created_at: created_at)
+      end
+
+      def save!
+        self.updated_at ||= Time.now
+        self.created_at ||= updated_at
+        self.class.transaction do |redis|
+          redis.hset(SETTINGS_KEY, key, payload_json)
+          redis.zadd(UPDATED_KEY, updated_at.to_f, key)
+          set_persisted!
+        end
+        true
+      end
+
+      def destroy
+        self.class.transaction do |redis|
+          redis.hdel(SETTINGS_KEY, key)
+          redis.zrem(UPDATED_KEY, key)
+          HistoryStorage.destroy_all_by_key(key)
+        end
+      end
+
+      def key=(value)
+        @key = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def raw_value=(value)
+        @raw_value = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def value_type=(value)
+        @value_type = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def description=(value)
+        @description = (Coerce.blank?(value) ? nil : value.to_s)
+      end
+
+      def deleted=(value)
+        @deleted = Coerce.boolean(value)
+      end
+
+      def created_at=(value)
+        @created_at = SuperSettings::Coerce.time(value)
+      end
+
+      def updated_at=(value)
+        @updated_at = SuperSettings::Coerce.time(value)
+      end
+
+      def deleted?
+        !!(defined?(@deleted) && @deleted)
+      end
+
+      def persisted?
+        !!(defined?(@persisted) && @persisted)
+      end
+
+      protected
+
+      def redact_history!
+        after_commit do
+          histories = HistoryStorage.find_all_by_key(key: key)
+          histories.each { |item| item.value = nil }
+          self.class.transaction do
+            HistoryStorage.destroy_all_by_key(key)
+            histories.reverse.each(&:save!)
+          end
+        end
+      end
+
+      private
+
+      def after_commit(&block)
+        if Thread.current[:super_settings_transaction_after_commit]
+          Thread.current[:super_settings_transaction_after_commit] << block
+        else
+          block.call
+        end
+      end
+
+      def set_persisted!
+        @persisted = true
+      end
+
+      def payload_json
+        payload = {
+          key: key,
+          raw_value: raw_value,
+          value_type: value_type,
+          description: description,
+          created_at: created_at.to_f,
+          updated_at: updated_at.to_f
+        }
+        payload[:deleted] = true if deleted?
+        payload.to_json
+      end
+    end
+  end
+end