singleton-client-test 0.7.7.3 → 0.7.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55ae7e69d2ec121acde618656b62f88d8376874379d3b6179b7f06d86f4a7034
-  data.tar.gz: 5b7395f4fed5d9542554a68788d4fd03e5ef7869816b868c45d34738ca58c4ab
+  metadata.gz: 3bd55bdad7f46bf9c0cffd42a710cfb6dcae97ecadbbb148af41d2b44be0afca
+  data.tar.gz: 026ef3a390e9a88691decb97b1131ac31e358c9ede7628a7b698d38899a80465
 SHA512:
-  metadata.gz: f9e93a9961f77802fbabf6c3272787dfae5a4c42ee0d6f12b315b31fe176aefd3feeadf49e611ae60c70cff3c0ba7437f829a8364ea39d0a3edfcebac2f1cef2
-  data.tar.gz: 16108cd1e8008453bc19a1c9a0a6f3fd2e5fd28e06c95894fdda341180ec21a775802554c18b8da9cc8d938bfeb379646df8651aaeae881be30f98cb68db9b80
+  metadata.gz: 5792e7d5f543603927732321cf440be37266fdc5a65fdd6075017068bb98fd9e5b8b4c52e8421fb0508166997993117d6c151921243b642ea448fb5ceea2e542
+  data.tar.gz: 7a8938ba9ffe0b6480a4b83e441b48d48eec98f5e2262019ff5db001e94fe50d404cc3c4277e464cab90ab7141076223b370d2c3a733058d95eecd940f8d8e88

data/lib/sgtn-client/api/source.rb

@@ -4,12 +4,9 @@
 require 'sgtn-client/loader/source'
 
 module SgtnClient
-  autoload :CacheUtil, 'sgtn-client/util/cache-util'
-
   class Source
     def self.loadBundles(locale)
       SgtnClient.logger.debug "[Source][loadBundles]locale=#{locale}"
-      SgtnClient::Config.configurations.default = locale
     end
   end
 end

data/lib/sgtn-client/api/t.rb

@@ -1,6 +1,8 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
+require 'request_store'
+
 module SgtnClient
   class T
     def self.s(key)

data/lib/sgtn-client/api/translation.rb

@@ -8,19 +8,19 @@ module SgtnClient
     module Implementation
       # <b>DEPRECATED:</b> Please use <tt>Sgtn:translate</tt> instead.
       def getString(component, key, locale)
-        SgtnClient.logger.debug "[Translation.getString]component: #{component}, key: #{key}, locale: #{locale}"
+        SgtnClient.logger.debug { "[Translation.getString]component: #{component}, key: #{key}, locale: #{locale}" }
         translate(key, component, locale) { nil }
       end
 
       # <b>DEPRECATED:</b> Please use <tt>Sgtn:translate</tt> instead.
       def getString_p(component, key, plural_args, locale)
-        SgtnClient.logger.debug "[Translation][getString_p]component=#{component}, key=#{key}, locale=#{locale}"
+        SgtnClient.logger.debug { "[Translation][getString_p]component=#{component}, key=#{key}, locale=#{locale}" }
         translate(key, component, locale, **plural_args) { nil }
       end
 
       # <b>DEPRECATED:</b> Please use <tt>Sgtn:translate</tt> instead.
       def getString_f(component, key, args, locale, *_optionals)
-        SgtnClient.logger.debug "[Translation][getString_f]component=#{component}, key=#{key}, locale=#{locale}"
+        SgtnClient.logger.debug { "[Translation][getString_f]component=#{component}, key=#{key}, locale=#{locale}" }
         s = translate(key, component, locale) { nil }
         return nil if s.nil?
 
@@ -39,16 +39,16 @@ module SgtnClient
         get_translations(component, locale)
       end
 
-      # raise error when translation is not found
       def translate(key, component, locale = nil, **kwargs)
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] key: #{key}, component: #{component}, locale: #{locale}, args: #{kwargs}"
-
-        locale = locale.nil? ? self.locale : SgtnClient::LocaleUtil.get_best_locale(locale)
-
-        result = get_bundle(component, locale)&.fetch(key, nil)
-        if result.nil? && !LocaleUtil.is_source_locale(locale)
-          locale = LocaleUtil.get_source_locale
-          result = get_bundle(component, locale)&.fetch(key, nil)
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] key: #{key}, component: #{component}, locale: #{locale}, args: #{kwargs}" }
+
+        begin
+          best_match_locale = LocaleUtil.get_best_locale(locale || SgtnClient.locale, component)
+          messages, actual_locale = get_bundle_with_fallback(component, best_match_locale)
+          result = messages&.fetch(key, nil)
+        rescue StandardError => e
+          SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] translation is missing. {#{key}, #{component}, #{locale}}. #{e}" }
+          result = nil
         end
 
         if result.nil?
@@ -61,31 +61,21 @@ module SgtnClient
         if kwargs.empty?
           result
         else
-          locale = result.locale if result.is_a?(SgtnClient::StringUtil)
-          result.localize(locale) % kwargs
+          result.localize(actual_locale) % kwargs
         end
       end
       alias t translate
 
       def get_translations(component, locale = nil)
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] component: #{component}, locale: #{locale}"
-
-        locale = locale.nil? ? self.locale : SgtnClient::LocaleUtil.get_best_locale(locale)
-        items = get_bundle(component, locale)
-        if items.nil? && !LocaleUtil.is_source_locale(locale)
-          items = get_bundle(component, LocaleUtil.get_source_locale)
-          locale = LocaleUtil.get_source_locale
-        end
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] component: #{component}, locale: #{locale}" }
 
-        { 'component' => component, 'locale' => locale, 'messages' => items || {} } if items
-      end
-
-      def locale
-        RequestStore.store[:locale] ||= SgtnClient::LocaleUtil.get_fallback_locale
-      end
+        best_match_locale = LocaleUtil.get_best_locale(locale || SgtnClient.locale, component)
+        messages, actual_locale = get_bundle_with_fallback(component, best_match_locale)
 
-      def locale=(value)
-        RequestStore.store[:locale] = SgtnClient::LocaleUtil.get_best_locale(value)
+        { 'component' => component, 'locale' => actual_locale, 'messages' => messages } if messages
+      rescue StandardError => e
+        SgtnClient.logger.error "[#{method(__callee__).owner}.#{__callee__}] translations are missing. {#{component}, #{locale}}. #{e}"
+        nil
       end
 
       private
@@ -99,15 +89,29 @@ module SgtnClient
       end
 
       def get_bundle!(component, locale)
-        id = SgtnClient::Common::BundleID.new(component, locale)
-        bundles = SgtnClient::Config.available_bundles
-        unless bundles.nil? || bundles.empty? || bundles.include?(id)
-          raise SgtnClient::SingletonError, 'bundle is unavailable.'
-        end
+        SgtnClient.config.loader.get_bundle(component, locale)
+      rescue StandardError
+        # delete the locale from the available_bundles of component to avoid repeated calls to server
+        SgtnClient.config.available_bundles.delete(Common::BundleID.new(component, locale))
+        SgtnClient.config.available_locales(component)&.delete(locale)
+        SgtnClient.config.changed
+        SgtnClient.config.notify_observers(:available_locales, component)
+        raise
+      end
+
+      def get_bundle_with_fallback(component, locale)
+        messages = get_bundle(component, locale)
+        return messages, locale if messages
 
-        SgtnClient::Config.loader.get_bundle(component, locale)
+        LocaleUtil.locale_fallbacks.each do |l|
+          next if l == locale
+
+          messages = get_bundle(component, l)
+          return messages, l if messages
+        end
       end
     end
+
     extend Implementation
   end
 end

data/lib/sgtn-client/common/data.rb

@@ -1,9 +1,12 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
+require 'set'
+require 'time'
+
 module SgtnClient
   module Common
-    class BundleID
+    class BundleID # :nodoc:
       attr_reader :locale, :component
 
       def initialize(component, locale)
@@ -17,14 +20,48 @@ module SgtnClient
       end
 
       def ==(other)
-       (other.is_a? self.class) && @locale == other.locale && @component == other.component
+        (other.is_a? self.class) && @locale == other.locale && @component == other.component
       end
 
       alias eql? ==
 
       def to_s
-        "locale=#{@locale}, component=#{@component}}"
+        "{component: #{@component}, locale: #{@locale}}"
+      end
+    end
+
+    module DataInfo # :nodoc:
+      attr_accessor :last_update
+
+      def initialize(*)
+        @last_update = Time.now
+        super
+      end
+
+      def expired?
+        Time.now >= @last_update + DataInfo.age
       end
+
+      def self.age
+        @age ||= SgtnClient.config.cache_expiry_period * 60
+      end
+    end
+
+    class BundleData < Hash # :nodoc:
+      include DataInfo
+
+      def initialize(*args)
+        if !args.empty? && args[0].is_a?(Hash)
+          update(args[0])
+          super()
+        else
+          super
+        end
+      end
+    end
+
+    class SetData < Set # :nodoc:
+      include DataInfo
     end
   end
 end

data/lib/sgtn-client/common/single_operation.rb

@@ -3,25 +3,24 @@
 
 module SgtnClient
   class SingleOperation
-    def initialize(*conditions, &block)
-      raise 'no way to create a new obj' unless block
+    def initialize(*conditions, &creator)
+      raise 'no way to create a new obj' unless creator
 
       @lock = Mutex.new
       @hash = {}
 
       @conditions = conditions
-      @creator = block
+      @creator = creator
     end
 
-    # return new created object
-    def operate(id, *args)
+    # return new created object (return nil possibly)
+    def operate(id, &block)
       @lock.synchronize do
         obj = @hash[id]
         @conditions.each do |con|
-          return obj unless con.call(id, obj, *args)
+          return obj unless con.call(id, obj)
         end
-        # TODO: whatif returning nil
-        @hash[id] = @creator.call(id, obj, *args)
+        @hash[id] = @creator.call(id, &block)
       end
     end
 

data/lib/sgtn-client/common.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+#  Copyright 2022 VMware, Inc.
+#  SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  module Common # :nodoc:
+    autoload :BundleID, 'sgtn-client/common/data'
+  end
+end

data/lib/sgtn-client/core/config.rb

@@ -1,205 +1,88 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-require 'erb'
-require 'yaml'
+require 'concurrent/map'
 require 'observer'
+require 'set'
+require 'singleton'
 
 module SgtnClient
-  #include Exceptions
-
-  module TranslationLoader
-    autoload :LoaderFactory, 'sgtn-client/loader/loader_factory'
-  end
+  class Config # :nodoc:
+    include Observable
+    include Singleton
+
+    attr_accessor :product_name, :version, :vip_server, :translation_bundle, :source_bundle, :cache_expiry_period, :log_file, :log_level
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= if log_file
+                    puts "create log file: '#{log_file}', level: #{log_level}"
+                    require 'logging'
+                    logger = Logging.logger(log_file, 4, 1_048_576)
+                    logger.level = log_level
+                    logger
+                  else
+                    require 'logger'
+                    Logger.new(STDOUT, level: log_level || Logger::INFO)
+                  end
+    end
 
-  module Configuration
+    def loader
+      @loader ||= TranslationLoader::LoaderFactory.create(self)
+    end
 
-    def config
-        @config ||= Config.config
+    def available_bundles
+      loader.available_bundles
+    rescue StandardError => e
+      SgtnClient.logger.error 'failed to get available bundles'
+      SgtnClient.logger.error e
+      Set.new
     end
 
-    def set_config(env, override_configurations = {})
-      @config =
-        case env
-        when Config
-          env
-        when Hash
-          begin
-            config.dup.merge!(env)
-          rescue Errno::ENOENT => error
-            Config.new(env)
-          end
-        else
-          Config.config(env, override_configurations)
-        end
+    def available_components
+      bundles = available_bundles
+      return Set.new if bundles.nil? || bundles.empty?
+
+      define_bundles_methods(bundles) unless bundles.respond_to?(:components)
+      bundles.components
     end
 
-    alias_method :config=, :set_config
+    def available_locales(component)
+      bundles = available_bundles
+      return Set.new if bundles.nil? || bundles.empty?
 
-  end
-  
-
-  class Config
-    extend Observable
-
-    attr_accessor :username, :password, :signature, :app_id, :cert_path,
-    :token, :token_secret, :subject,
-    :http_timeout, :http_proxy,
-    :device_ipaddress, :sandbox_email_address,
-    :mode, :endpoint, :merchant_endpoint, :platform_endpoint, :ipn_endpoint,
-    :rest_endpoint, :rest_token_endpoint, :client_id, :client_secret,
-    :openid_endpoint, :openid_redirect_uri, :openid_client_id, :openid_client_secret,
-    :verbose_logging, :product_name, :version, :vip_server,
-    :translation_bundle, :source_bundle, :cache_expiry_period, :disable_cache, :default_language
-
-
-    # Create Config object
-    # === Options(Hash)
-    # * <tt>username</tt>   -- Username
-    # * <tt>password</tt>   -- Password
-    # * <tt>signature</tt> (Optional if certificate present) -- Signature
-    # * <tt>app_id</tt>     -- Application ID
-    # * <tt>cert_path</tt> (Optional if signature present)  -- Certificate file path
-    def initialize(options)
-      merge!(options)
+      define_bundles_methods(bundles) unless bundles.respond_to?(:locales)
+      bundles.locales(component)
     end
 
-    # Override configurations
-    def merge!(options)
+    def update(options)
       options.each do |key, value|
         send("#{key}=", value)
       end
-      self
     end
-    
-    class << self
-
-        @@config_cache = {}
-        def load(file_name, default_env = default_environment)
-          @@config_cache        = {}
-          @@configurations      = read_configurations(file_name)
-          @@default_environment = default_env
-          config
-        end
 
+    private
 
-        # Get default environment name
-        def default_environment
-          @@default_environment ||= ENV['SGTN_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || "development"
-        end
-
+    def define_bundles_methods(bundles)
+      bundles.instance_eval do |_|
+        @component_locales ||= Concurrent::Map.new
 
-        # Set default environment
-        def default_environment=(env)
-          @@default_environment = env.to_s
+        def components
+          @components ||= reduce(Set.new) { |components, id| components << id.component }
         end
 
-        def configure(options = {}, &block)
-          begin
-            self.config.merge!(options)
-          rescue Errno::ENOENT
-            self.configurations = { default_environment => options }
-          end
-          block.call(self.config) if block
-          self.config
-        end
-        alias_method :set_config, :configure
-
-        # Create or Load Config object based on given environment and configurations.
-        # === Attributes
-        # * <tt>env</tt> (Optional) -- Environment name
-        # * <tt>override_configuration</tt> (Optional) -- Override the configuration given in file.
-        # === Example
-        #   Config.config
-        #   Config.config(:development)
-        #   Config.config(:development, { :app_id => "XYZ" })
-        def config(env = default_environment, override_configuration = {})
-          if env.is_a? Hash
-            override_configuration = env
-            env = default_environment
-          end
-          if override_configuration.nil? or override_configuration.empty?
-            default_config(env)
-          else
-            default_config(env).dup.merge!(override_configuration)
-          end
-        end
-  
-        def default_config(env = nil)
-          env = (env || default_environment).to_s
-          if configurations[env]
-            @@config_cache[env] ||= new(configurations[env])
-          else
-            raise SgtnClient::Exceptions::MissingConfig.new("Configuration[#{env}] NotFound")
-          end
-        end
-        
-        # Get raw configurations in Hash format.
-        def configurations
-          @@configurations ||= read_configurations
-        end
-  
-        # Set configuration
-        def configurations=(configs)
-          @@config_cache   = {}
-          @@configurations = configs && Hash[configs.map{|k,v| [k.to_s, v] }]
-        end
+        def locales(component)
+          @component_locales[component] ||= begin
+            return Set.new unless components.include?(component)
 
-        # Set logger
-        def logger=(logger)
-          Logging.logger = logger
-        end
-
-        # Get logger
-        def logger
-          if @@configurations[:mode] == 'live' and Logging.logger.level == Logger::DEBUG
-            Logging.logger.warn "DEBUG log level not allowed in live mode for security of confidential information. Changing log level to INFO..."
-            Logging.logger.level = Logger::INFO
+            each_with_object(Set.new) { |id, locales| locales << id.locale if id.component == component }
           end
-          Logging.logger
         end
+      end
 
-
-        def loader
-          @loader ||= begin
-            config = SgtnClient::Config.configurations[SgtnClient::Config.default_environment]
-            SgtnClient::TranslationLoader::LoaderFactory.create(config)
-          end
-        end
-
-        def available_bundles
-          loader.available_bundles
-        rescue StandardError => e
-          SgtnClient.logger.error 'failed to get available bundles'
-          SgtnClient.logger.error e
-          Set.new
-        end
-
-        def available_locales
-          bundles = available_bundles
-          return Set.new if bundles.nil? || bundles.empty?
-
-          unless bundles.respond_to?(:locales)
-            def bundles.locales
-              @locales ||= reduce(Set.new) { |locales, id| locales << id.locale }
-            end
-            changed
-            notify_observers(:available_locales)
-          end
-          bundles.locales
-        end
-
-        private
-        # Read configurations from the given file name
-        # === Arguments
-        # * <tt>file_name</tt> (Optional) -- Configuration file path
-        def read_configurations(file_name = "config/sgtnclient.yml")
-          erb = ERB.new(File.read(file_name))
-          erb.filename = file_name
-          YAML.load(erb.result)
-        end       
-
+      changed
+      notify_observers(:available_locales)
     end
   end
-
 end

data/lib/sgtn-client/i18n_backend.rb

@@ -0,0 +1,48 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require 'i18n'
+
+module SgtnClient # :nodoc:
+  # When integrating Singleton in a client application that is already using [I18n::Backend (https://www.rubydoc.info/github/svenfuchs/i18n/master/I18n/Backend/), it would be useful to have Singleton override the said module in order to minimize necessary changes. Here is a common usage:
+  #
+  #   I18n::Backend::Simple.include(I18n::Backend::Fallbacks) # add fallbacks behavior to current backend
+  #   I18n.backend = I18n::Backend::Chain.new(Sgtn::I18nBackend.new(component_name), I18n.backend)
+  #   I18n.enforce_available_locales=false # disable available locales check
+  #   I18n.default_locale = :en
+  class I18nBackend
+    def initialize(component)
+      @component = component
+    end
+
+    def initialized?
+      @initialized ||= true
+    end
+
+    def load_translations(*) end
+
+    def store_translations(*) end
+
+    def available_locales
+      SgtnClient.config.available_locales(@component).to_a
+    end
+
+    def reload!; end
+
+    def eager_load!; end
+
+    def translations; end
+
+    def exists?(locale, key, options)
+      !!(translate(locale, key, options) { nil })
+    end
+
+    def translate(locale, key, options)
+      flat_key = I18n::Backend::Flatten.normalize_flat_keys(locale, key, options[:scope], '.')
+      values = options.except(*I18n::RESERVED_KEYS)
+      Translation.translate(flat_key, @component, locale, **values) { nil }
+    end
+
+    def localize(locale, object, format, options) end
+  end
+end

data/lib/sgtn-client/loader/cache.rb

@@ -3,68 +3,52 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-module SgtnClient
-  autoload :CacheUtil, 'sgtn-client/util/cache-util'
+require 'concurrent/map'
 
+module SgtnClient
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
     module Cache # :nodoc:
+      def initialize(*)
+        @cache_hash = Concurrent::Map.new
+        super
+      end
+
       # get from cache, return expired data immediately
       def get_bundle(component, locale)
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}"
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}" }
 
-        key = SgtnClient::CacheUtil.get_cachekey(component, locale)
-        cache_item = SgtnClient::CacheUtil.get_cache(key)
-        if cache_item
-          if SgtnClient::CacheUtil.is_expired(cache_item)
-            Thread.new do # TODO: Use one thread # refresh in background
-              begin
-                load_bundle(component, locale)
-              rescue StandardError => e
-                SgtnClient.logger.error "an error occured while loading bundle: component=#{component}, locale=#{locale}"
-                SgtnClient.logger.error e
-              end
-            end
-          end
-          return cache_item.dig(:items)
-        end
+        result = @cache_hash[Common::BundleID.new(component, locale)] || load_bundle(component, locale)
+      ensure
+        load_bundle(component, locale, sync: false) if result&.expired?
+      end
 
-        load_bundle(component, locale) # refresh synchronously if not in cache
+      def available_bundles
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}]" }
+
+        result = @cache_hash[CONSTS::AVAILABLE_BUNDLES_KEY] || super
+      ensure
+        super(sync: false) if result&.expired?
       end
+    end
 
-      # load and save to cache
+    module CacheFiller # :nodoc:
       def load_bundle(component, locale)
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}"
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}] CacheFiller, component=#{component}, locale=#{locale}" }
 
-        key = SgtnClient::CacheUtil.get_cachekey(component, locale)
-        item = super
-        SgtnClient::CacheUtil.write_cache(key, item) if item
-        item
+        @cache_hash[Common::BundleID.new(component, locale)] = Common::BundleData.new(super)
       end
 
       def available_bundles
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}]"
-
-        cache_item = SgtnClient::CacheUtil.get_cache(CONSTS::AVAILABLE_BUNDLES_KEY)
-        if cache_item
-          if SgtnClient::CacheUtil.is_expired(cache_item)
-            Thread.new do # TODO: Use one thread
-              begin
-                item = super
-                SgtnClient::CacheUtil.write_cache(CONSTS::AVAILABLE_BUNDLES_KEY, item) if item
-              rescue StandardError => e
-                SgtnClient.logger.error 'an error occured while loading available bundles.'
-                SgtnClient.logger.error e
-              end
-            end
-          end
-          return cache_item.dig(:items)
-        end
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}] CacheFiller" }
 
         item = super
-        SgtnClient::CacheUtil.write_cache(CONSTS::AVAILABLE_BUNDLES_KEY, item) if item
-        item
+        old_item = @cache_hash[CONSTS::AVAILABLE_BUNDLES_KEY]
+        if item != old_item # only update if different
+          @cache_hash[CONSTS::AVAILABLE_BUNDLES_KEY] = Common::SetData.new(item)
+        else # if same, don't need to update the data, but update last_update
+          old_item.last_update = Time.now
+          old_item
+        end
       end
     end
   end