super_settings 1.0.2 → 2.0.0

data/lib/super_settings/storage/mongodb_storage.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "mongo"
+
+module SuperSettings
+  module Storage
+    # MongoDB implementation of the SuperSettings::Storage model.
+    #
+    # You must define the connection URL to use by setting the `url` or `mongodb` attribute on the class.
+    #
+    # @example
+    #   SuperSettings::Storage::MongoDBStorage.url = "mongodb://user:password@localhost:27017/super_settings"
+    #
+    # @example
+    #  SuperSettings::Storage::MongoDBStorage.mongodb = Mongo::Client.new("mongodb://user:password@localhost:27017/super_settings")
+    class MongoDBStorage < StorageAttributes
+      include Storage
+      include Transaction
+
+      DEFAULT_COLLECTION_NAME = "super_settings"
+
+      @mongodb = nil
+      @url = nil
+      @url_hash = @url.hash
+      @collection_name = DEFAULT_COLLECTION_NAME
+      @mutex = Mutex.new
+
+      class HistoryStorage < HistoryAttributes
+        def as_bson
+          attributes = {
+            value: value,
+            changed_by: changed_by,
+            created_at: created_at
+          }
+          attributes[:deleted] = true if deleted?
+          attributes
+        end
+      end
+
+      class << self
+        attr_writer :url, :mongodb
+        attr_accessor :collection_name
+
+        def mongodb
+          if @mongodb.nil? || @url_hash != @url.hash
+            @mutex.synchronize do
+              unless @url_hash == @url.hash
+                @url_hash = @url.hash
+                @mongodb = Mongo::Client.new(@url)
+                create_indexes!(@mongodb)
+              end
+            end
+          end
+          @mongodb
+        end
+
+        def settings_collection
+          mongodb[collection_name]
+        end
+
+        def updated_since(time)
+          time = TimePrecision.new(time, :millisecond).time
+          settings_collection.find(updated_at: {"$gt": time}).projection(history: 0).sort({updated_at: -1}).collect do |attributes|
+            record = new(attributes)
+            record.persisted = true
+            record
+          end
+        end
+
+        def all
+          settings_collection.find.projection(history: 0).collect do |attributes|
+            record = new(attributes)
+            record.persisted = true
+            record
+          end
+        end
+
+        def find_by_key(key)
+          query = {
+            key: key,
+            deleted: false
+          }
+          record = settings_collection.find(query).projection(history: 0).first
+          new(record) if record
+        end
+
+        def last_updated_at
+          last_updated_setting = settings_collection.find.projection(updated_at: 1).sort(updated_at: -1).limit(1).first
+          last_updated_setting["updated_at"] if last_updated_setting
+        end
+
+        def destroy_all
+          settings_collection.delete_many({})
+        end
+
+        def save_all(changes)
+          upserts = changes.collect { |setting| upsert(setting) }
+          changes.each { |setting| setting.new_history.clear }
+          settings_collection.bulk_write(upserts)
+          true
+        end
+
+        protected
+
+        def default_load_asynchronous?
+          true
+        end
+
+        private
+
+        def upsert(setting)
+          doc = setting.as_bson
+          history = setting.new_history.collect(&:as_bson)
+          {
+            update_one: {
+              filter: {key: setting.key},
+              update: {
+                "$set": doc.except(:key, :history),
+                "$setOnInsert": {key: setting.key},
+                "$push": {history: {"$each": history}}
+              },
+              upsert: true
+            }
+          }
+        end
+
+        def create_indexes!(client)
+          collection = client[collection_name]
+          collection_exists = client.database.collection_names.include?(collection.name)
+          existing_indexes = (collection_exists ? collection.indexes.to_a : [])
+
+          unique_key_index = {key: 1}
+          unless existing_indexes.any? { |index| index["key"] == unique_key_index }
+            collection.indexes.create_one(unique_key_index, unique: true)
+          end
+
+          updated_at_index = {updated_at: -1}
+          unless existing_indexes.any? { |index| index["key"] == updated_at_index }
+            collection.indexes.create_one(updated_at_index)
+          end
+
+          history_created_at_desc_index = {key: 1, "history.created_at": -1}
+          unless existing_indexes.any? { |index| index["key"] == history_created_at_desc_index }
+            collection.indexes.create_one(history_created_at_desc_index)
+          end
+        end
+      end
+
+      attr_reader :new_history
+
+      def initialize(*)
+        @new_history = []
+        super
+      end
+
+      def history(limit: nil, offset: 0)
+        pipeline = [
+          {
+            "$match": {key: key}
+          },
+          {
+            "$addFields": {
+              history: {
+                "$sortArray": {
+                  input: "$history",
+                  sortBy: {created_at: -1}
+                }
+              }
+            }
+          }
+        ]
+
+        if limit || offset > 0
+          pipeline << {
+            "$addFields": {
+              history: {
+                "$slice": ["$history", offset, (limit || {"$size": "$history"})]
+              }
+            }
+          }
+        end
+
+        pipeline << {
+          "$project": {
+            _id: 0,
+            history: 1
+          }
+        }
+
+        record = self.class.settings_collection.aggregate(pipeline).to_a.first
+        return [] unless record && record["history"].is_a?(Array)
+
+        record["history"].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)
+        created_at = TimePrecision.new(created_at, :millisecond).time
+        history = HistoryStorage.new(key: key, value: value, changed_by: changed_by, created_at: created_at, deleted: deleted)
+        @new_history.unshift(history)
+        history
+      end
+
+      def created_at=(val)
+        super(TimePrecision.new(val, :millisecond).time)
+      end
+
+      def updated_at=(val)
+        super(TimePrecision.new(val, :millisecond).time)
+      end
+
+      def destroy
+        settings_collection.delete_one(key: key)
+      end
+
+      def as_bson
+        {
+          key: key,
+          raw_value: raw_value,
+          value_type: value_type,
+          description: description,
+          created_at: created_at,
+          updated_at: updated_at,
+          deleted: deleted?
+        }
+      end
+    end
+
+    def created_at=(val)
+      super(TimePrecision.new(val, :millisecond).time)
+    end
+
+    def updated_at=(val)
+      super(TimePrecision.new(val, :millisecond).time)
+    end
+  end
+end

data/lib/super_settings/storage/redis_storage.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require "redis"
 
 module SuperSettings
@@ -23,20 +22,15 @@ module SuperSettings
     #
     # @example
     #   SuperSettings::Storage::RedisStorage.redis = ConnectionPool.new(size: 5) { Redis.new(url: ENV["REDIS_URL"]) }
-    class RedisStorage
-      include Storage
+    class RedisStorage < StorageAttributes
+      include Transaction
 
       SETTINGS_KEY = "SuperSettings.settings"
       UPDATED_KEY = "SuperSettings.order_by_updated_at"
 
-      class HistoryStorage
+      class HistoryStorage < HistoryAttributes
         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)
@@ -55,10 +49,8 @@ module SuperSettings
             record
           end
 
-          def destroy_all_by_key(key)
-            RedisStorage.transaction do |redis|
-              redis.del("#{HISTORY_KEY_PREFIX}.#{key}")
-            end
+          def destroy_all_by_key(key, redis)
+            redis.del("#{HISTORY_KEY_PREFIX}.#{key}")
           end
 
           def redis_key(key)
@@ -66,24 +58,20 @@ module SuperSettings
           end
         end
 
-        def initialize(*)
-          @deleted = false
-          super
-        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)
+
+          RedisStorage.transaction do |changes|
+            changes << self
           end
         end
 
-        def deleted?
-          !!@deleted
+        def save_to_redis(redis)
+          redis.lpush(self.class.redis_key(key), payload_json.to_json)
+        end
+
+        def created_at
+          SuperSettings::Storage::RedisStorage.time_at_microseconds(super)
         end
 
         private
@@ -92,16 +80,13 @@ module SuperSettings
           payload = {
             value: value,
             changed_by: changed_by,
-            created_at: created_at.to_f
+            created_at: SuperSettings::Storage::RedisStorage.microseconds(created_at)
           }
           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|
@@ -110,15 +95,15 @@ module SuperSettings
         end
 
         def updated_since(time)
-          time = SuperSettings::Coerce.time(time)
+          min_score = microseconds(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
+              setting = load_from_json(json) if json
+              settings << setting if setting && setting.updated_at > time
             end
             settings
           end
@@ -134,7 +119,7 @@ module SuperSettings
         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])
+          time_at_microseconds(result[1])
         end
 
         def destroy_all
@@ -152,26 +137,23 @@ module SuperSettings
           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)
+        def save_all(changes)
+          with_redis do |redis|
+            redis.multi do |multi_redis|
+              changes.each do |object|
+                object.save_to_redis(multi_redis)
               end
-            ensure
-              Thread.current[:super_settings_transaction_redis] = nil
-              Thread.current[:super_settings_transaction_after_commit] = nil
             end
           end
+          true
+        end
+
+        def time_at_microseconds(time)
+          TimePrecision.new(time, :microsecond).time
+        end
+
+        def microseconds(time)
+          TimePrecision.new(time, :microsecond).to_f
         end
 
         protected
@@ -185,7 +167,7 @@ module SuperSettings
         def load_from_json(json)
           attributes = JSON.parse(json)
           setting = new(attributes)
-          setting.send(:set_persisted!)
+          setting.persisted = true
           setting
         end
       end
@@ -206,83 +188,39 @@ module SuperSettings
         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
+      def save_to_redis(redis)
+        redis.hset(SETTINGS_KEY, key, payload_json)
+        redis.zadd(UPDATED_KEY, self.class.microseconds(updated_at), key)
       end
 
       def destroy
-        self.class.transaction do |redis|
-          redis.hdel(SETTINGS_KEY, key)
-          redis.zrem(UPDATED_KEY, key)
-          HistoryStorage.destroy_all_by_key(key)
+        self.class.with_redis do |redis|
+          redis.multi do |multi_redis|
+            multi_redis.hdel(SETTINGS_KEY, key)
+            multi_redis.zrem(UPDATED_KEY, key)
+            HistoryStorage.destroy_all_by_key(key, multi_redis)
+          end
         end
       end
 
-      def key=(value)
-        @key = (Coerce.blank?(value) ? nil : value.to_s)
+      def created_at
+        self.class.time_at_microseconds(super)
       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?
-        !!@deleted
-      end
-
-      def persisted?
-        !!@persisted
+      def updated_at
+        self.class.time_at_microseconds(super)
       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
+          created_at: self.class.microseconds(created_at),
+          updated_at: self.class.microseconds(updated_at)
         }
         payload[:deleted] = true if deleted?
         payload.to_json

data/lib/super_settings/storage/s3_storage.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "aws-sdk-s3"
+
+module SuperSettings
+  module Storage
+    # Storage backend for storing the settings in an S3 object. This should work with any S3-compatible
+    # storage service.
+    class S3Storage < JSONStorage
+      SETTINGS_FILE = "settings.json"
+      HISTORY_FILE_SUFFIX = ".history.json"
+      DEFAULT_PATH = "super_settings"
+
+      # Configuration for the S3 storage backend.
+      #
+      # * access_key_id - The AWS access key ID. Defaults to the SUPER_SETTINGS_AWS_ACCESS_KEY_ID
+      #   or AWS_ACCESS_KEY_ID environment variable or whatever is set in the `Aws.config` object.
+      # * secret_access_key - The AWS secret access key. Defaults to the SUPER_SETTINGS_AWS_SECRET_ACCESS_KEY
+      #  or AWS_SECRET_ACCESS_KEY environment variable or whatever is set in the `Aws.config` object.
+      # * region - The AWS region. Defaults to the SUPER_SETTINGS_AWS_REGION or AWS_REGION environment variable.
+      #   This is required for AWS S3 but may be optional for S3-compatible services.
+      # * endpoint - The S3 endpoint URL. This is optional and should only be used for S3-compatible services.
+      #   Defaults to the SUPER_SETTINGS_AWS_ENDPOINT or AWS_ENDPOINT environment variable.
+      # * bucket - The S3 bucket name. Defaults to the SUPER_SETTINGS_S3_BUCKET or AWS_S3_BUCKET
+      #   environment variable.
+      # * object - The S3 object key. Defaults to "super_settings.json.gz" or the value set in the
+      #   SUPER_SETTINGS_S3_OBJECT environment variable.
+      #
+      # You can also specify the configuration using a URL in the format using the SUPER_SETTINGS_S3_URL
+      # environment variable. The URL should be in the format:
+      #
+      # ```
+      #   s3://access_key_id:secret_access_key@region/bucket/object
+      # ```
+      class Configuration
+        attr_accessor :access_key_id, :secret_access_key, :region, :endpoint, :bucket
+        attr_reader :path
+
+        def initialize
+          @access_key_id ||= ENV.fetch("SUPER_SETTINGS_AWS_ACCESS_KEY_ID", ENV["AWS_ACCESS_KEY_ID"])
+          @secret_access_key ||= ENV.fetch("SUPER_SETTINGS_AWS_SECRET_ACCESS_KEY", ENV["AWS_SECRET_ACCESS_KEY"])
+          @region ||= ENV.fetch("SUPER_SETTINGS_AWS_REGION", ENV["AWS_REGION"])
+          @endpoint ||= ENV.fetch("SUPER_SETTINGS_AWS_ENDPOINT", ENV["AWS_ENDPOINT"])
+          @bucket ||= ENV.fetch("SUPER_SETTINGS_S3_BUCKET", ENV["AWS_S3_BUCKET"])
+          @path ||= ENV.fetch("SUPER_SETTINGS_S3_OBJECT", DEFAULT_PATH)
+          self.url = ENV["SUPER_SETTINGS_S3_URL"] unless ENV["SUPER_SETTINGS_S3_URL"].to_s.empty?
+        end
+
+        def url=(url)
+          return if url.to_s.empty?
+
+          uri = URI.parse(url)
+          raise ArgumentError, "Invalid S3 URL" unless uri.scheme == "s3"
+
+          self.access_key_id = uri.user if uri.user
+          self.secret_access_key = uri.password if uri.password
+          self.region = uri.host if uri.host
+          _, bucket, path = uri.path.split("/", 3) if uri.path
+          self.bucket = bucket if bucket
+          self.path = path if path
+        end
+
+        def path=(value)
+          @path = "#{value}.chomp('/')/"
+        end
+
+        def hash
+          [self.class, access_key_id, secret_access_key, region, endpoint, bucket, path].hash
+        end
+      end
+
+      @bucket = nil
+      @bucket_hash = nil
+
+      class << self
+        def last_updated_at
+          all.collect(&:updated_at).compact.max
+        end
+
+        def configuration
+          @config ||= Configuration.new
+        end
+
+        def destroy_all
+          s3_bucket.objects(prefix: configuration.path).each do |object|
+            if object.key == file_path(SETTINGS_FILE) || object.key.end_with?(HISTORY_FILE_SUFFIX)
+              object.delete
+            end
+          end
+        end
+
+        protected
+
+        def default_load_asynchronous?
+          true
+        end
+
+        def settings_json_payload
+          object = settings_object
+          return nil unless object.exists?
+
+          object.get.body.read
+        end
+
+        def save_settings_json(json)
+          object = settings_object
+          object.put(body: json)
+        end
+
+        def save_history_json(key, json)
+          object = history_object(key)
+          object.put(body: json)
+        end
+
+        private
+
+        def s3_bucket
+          if configuration.hash != @bucket_hash
+            @bucket_hash = configuration.hash
+            options = {
+              endpoint: configuration.endpoint,
+              access_key_id: configuration.access_key_id,
+              secret_access_key: configuration.secret_access_key,
+              region: configuration.region
+            }
+            options[:force_path_style] = true if configuration.endpoint
+            options.compact!
+
+            @bucket = Aws::S3::Resource.new(options).bucket(configuration.bucket)
+          end
+          @bucket
+        end
+
+        def s3_object(filename)
+          s3_bucket.object(file_path(filename))
+        end
+
+        def file_path(filename)
+          "#{configuration.path}#{filename}"
+        end
+
+        def settings_object
+          s3_object(SETTINGS_FILE)
+        end
+
+        def history_object(key)
+          s3_object("#{key}#{HISTORY_FILE_SUFFIX}")
+        end
+
+        def history_json(key)
+          object = history_object(key)
+          return nil unless object.exists?
+
+          object.get.body.read
+        end
+      end
+
+      protected
+
+      def fetch_history_json
+        self.class.send(:history_json, key)
+      end
+    end
+  end
+end