singleton-client-test 0.7.7.3 → 0.7.7.6

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

@@ -1,6 +1,8 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
+require 'set'
+
 module SgtnClient
   module TranslationLoader
     class Chain
@@ -23,7 +25,7 @@ module SgtnClient
           end
         end
 
-        raise exception || SgtnClient::SingletonError.new("can't load component: #{component}, locale: #{locale}")
+        raise exception || SingletonError.new("can't load component: #{component}, locale: #{locale}")
       end
 
       def available_bundles

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

@@ -3,26 +3,19 @@
 
 module SgtnClient
   module TranslationLoader
-    autoload :Source, 'sgtn-client/loader/source'
-    autoload :SgtnServer, 'sgtn-client/loader/server'
-    autoload :LocalTranslation, 'sgtn-client/loader/local_translation'
-    autoload :Chain, 'sgtn-client/loader/chain_loader'
-    autoload :SourceComparer, 'sgtn-client/loader/source_comparer'
-    autoload :SingleLoader, 'sgtn-client/loader/single_loader'
-    autoload :Cache, 'sgtn-client/loader/cache'
-
     module LoaderFactory
       def self.create(config)
-        SgtnClient.logger.info "[#{method(__callee__).owner}.#{__callee__}] config=#{config}"
+        SgtnClient.logger.info "[#{method(__callee__).owner}.#{__callee__}] config=#{config.inspect}"
 
         loaders = []
-        loaders << Source.new(config) if config['source_bundle']
-        loaders << SgtnServer.new(config) if config['vip_server']
-        loaders << LocalTranslation.new(config) if config['translation_bundle']
-        raise SgtnClient::SingletonError, 'no translation is available!' if loaders.empty?
+        loaders << Source.new(config) if config.source_bundle
+        loaders << SgtnServer.new(config) if config.vip_server
+        loaders << LocalTranslation.new(config) if config.translation_bundle
+        raise SingletonError, 'no translation is available!' if loaders.empty?
 
         chain_loader = Class.new(Chain)
         chain_loader.include SourceComparer
+        chain_loader.include CacheFiller
         chain_loader.include SingleLoader
         chain_loader.include Cache
 

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

@@ -3,25 +3,20 @@
 
 require 'json'
 require 'pathname'
+require 'set'
 
 module SgtnClient
-  module Common
-    autoload :BundleID, 'sgtn-client/common/data'
-  end
-
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
     class LocalTranslation
       BUNDLE_PREFIX = 'messages_'.freeze
       BUNDLE_SUFFIX = '.json'.freeze
 
       def initialize(config)
-        @base_path = Pathname.new(config['translation_bundle']) + config['product_name'] + config['version'].to_s
+        @base_path = Pathname.new(config.translation_bundle) + config.product_name + config.version.to_s
       end
 
       def load_bundle(component, locale)
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] component=#{component}, locale=#{locale}"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] component=#{component}, locale=#{locale}" }
 
         file_name = BUNDLE_PREFIX + locale + BUNDLE_SUFFIX
         file_path = @base_path + component + file_name
@@ -29,13 +24,13 @@ module SgtnClient
         bundle_data = JSON.parse(File.read(file_path))
         messages = bundle_data['messages']
 
-        raise SgtnClient::SingletonError, "no messages in local bundle file: #{file_path}." unless messages
+        raise SingletonError, "no messages in local bundle file: #{file_path}." unless messages
 
         messages
       end
 
       def available_bundles
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}]"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}]" }
 
         @available_bundles ||= begin
           @base_path.glob('*/*.json').reduce(Set.new) do |bundles, f|

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

@@ -5,40 +5,42 @@
 
 require 'faraday'
 require 'faraday_middleware'
+require 'set'
 
 module SgtnClient
-  module Common
-    autoload :BundleID, 'sgtn-client/common/data'
-  end
-
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
-    class SgtnServer
+    class SgtnServer # :nodoc:
       ERROR_ILLEGAL_DATA = 'server returned illegal data.'
       ERROR_BUSINESS_ERROR = 'server returned business error.'
+      ERROR_PARTIAL_SUCCESS = 'the request to server was partially successful.'
+      ERROR_NO_DATA = 'no expected data in response from server. path: %s. Body is: %s'
 
       REQUEST_ARGUMENTS = { timeout: 10 }.freeze
 
       def initialize(config)
-        @server_url = config['vip_server']
-
-        product_root = format('i18n/api/v2/translation/products/%s/versions/%s', config['product_name'], config['version'])
+        product_root = format('i18n/api/v2/translation/products/%<name>s/versions/%<version>s',
+                              name: config.product_name, version: config.version)
 
         @bundle_url = "#{product_root}/locales/%s/components/%s"
         @locales_url = "#{product_root}/localelist"
         @components_url = "#{product_root}/componentlist"
+
+        @conn = Faraday.new(config.vip_server, request: REQUEST_ARGUMENTS) do |f|
+          f.response :json # decode response bodies as JSON
+          f.use :gzip
+          f.response :raise_error
+          f.response :logger, config.logger, { log_level: :debug, headers: false, bodies: true }
+        end
       end
 
       def load_bundle(component, locale)
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] component=#{component}, locale=#{locale}"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] component=#{component}, locale=#{locale}" }
 
-        messages = query_server(format(@bundle_url, locale, component), ['messages'])
-        messages
+        query_server(format(@bundle_url, locale, component), ['messages'])
       end
 
       def available_bundles
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}]"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}]" }
 
         components_thread = Thread.new { available_components }
         available_locales.reduce(Set.new) do |bundles, locale|
@@ -59,35 +61,24 @@ module SgtnClient
       end
 
       def query_server(url, path_to_data = [], queries = nil, headers = nil)
-        conn = Faraday.new(@server_url, request: REQUEST_ARGUMENTS) do |f|
-          f.response :json # decode response bodies as JSON
-          f.use :gzip
-          f.response :raise_error
-          f.response :logger, SgtnClient.logger, { log_level: :debug }
-        end
-        resp = conn.get(url, queries, headers)
+        resp = @conn.get(url, queries, headers)
 
         process_business_error(resp.body)
-        extract_data(resp.body, path_to_data)
-      end
-
-      def extract_data(parsedbody, path_to_data)
-        data = parsedbody.dig('data', *path_to_data)
-        raise SgtnClient::SingletonError, "no expected data in response. Body is: #{parsedbody}" unless data
 
-        data
+        resp.body&.dig('data', *path_to_data) ||
+          (raise SingletonError, format(ERROR_NO_DATA, path_to_data, resp.body))
       end
 
       def process_business_error(parsedbody)
         b_code = parsedbody.dig('response', 'code')
         unless b_code >= 200 && b_code < 300 || b_code >= 600 && b_code < 700
-          raise SgtnClient::SingletonError, "#{ERROR_BUSINESS_ERROR} #{parsedbody['response']}"
+          raise SingletonError, "#{ERROR_BUSINESS_ERROR} #{parsedbody['response']}"
         end
 
-        # 600 means a successful response, 6xx means partial successful.
-        SgtnClient.logger.warn "#{ERROR_BUSINESS_ERROR} #{parsedbody['response']}" if b_code > 600
+        # 600/200 means a successful response, 6xx/2xx means partial successful.
+        SgtnClient.logger.warn "#{ERROR_PARTIAL_SUCCESS} #{parsedbody['response']}" if b_code != 600 && b_code != 200
       rescue TypeError, ArgumentError, NoMethodError => e
-        raise SgtnClient::SingletonError, "#{ERROR_ILLEGAL_DATA} #{e}. Body is: #{parsedbody}"
+        raise SingletonError, "#{ERROR_ILLEGAL_DATA} #{e}. Body is: #{parsedbody}"
       end
     end
   end

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

@@ -2,46 +2,44 @@
 # SPDX-License-Identifier: EPL-2.0
 
 module SgtnClient
-  autoload :SingleOperation, 'sgtn-client/common/single_operation'
-  autoload :CacheUtil, 'sgtn-client/util/cache-util'
-
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
     module SingleLoader
-      def load_bundle(component, locale)
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}"
+      def load_bundle(component, locale, sync: true)
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}" }
 
-        @single_bundle_loader ||= single_loader { |c, l| super(c, l) }
-        id = CacheUtil.get_cachekey(component, locale)
-        @single_bundle_loader.operate(id, component, locale)&.value
+        do_single_load(Common::BundleID.new(component, locale), sync) { super(component, locale) }
       end
 
-      def available_bundles
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}]"
+      def available_bundles(sync: true)
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}]" }
 
-        @single_available_bundles_loader ||= single_loader { super }
-        @single_available_bundles_loader.operate(CONSTS::AVAILABLE_BUNDLES_KEY)&.value
+        do_single_load(CONSTS::AVAILABLE_BUNDLES_KEY, sync) { super() }
       end
 
-      private
-
-      def single_loader(&block)
-        loader = nil
-        none_alive = proc { |_, thread| thread.nil? }
-        creator = proc do |id, _, *args|
+      def initialize(*args)
+        none_alive = proc { |_, thread| thread.nil? || thread.alive? == false }
+        creator = proc do |id, &block|
           Thread.new do
-            SgtnClient.logger.debug "start single loading #{id}"
+            SgtnClient.logger.debug { "start single loading #{id}" }
             begin
-              block.call(*args)
+              block.call
             ensure
               # delete thread from hash after finish
-              loader.remove_object(id)
+              @single_loader.remove_object(id)
             end
           end
         end
 
-        loader = SgtnClient::SingleOperation.new(none_alive, &creator)
+        @single_loader = SingleOperation.new(none_alive, &creator)
+
+        super
+      end
+
+      private
+
+      def do_single_load(id, sync, &block)
+        thread = @single_loader.operate(id, &block)
+        thread&.value if sync
       end
     end
   end

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

@@ -2,25 +2,20 @@
 # SPDX-License-Identifier: EPL-2.0
 
 require 'pathname'
+require 'set'
 require 'yaml'
 
 module SgtnClient
-  module Common
-    autoload :BundleID, 'sgtn-client/common/data'
-  end
-
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
     class Source
       def initialize(config)
-        @source_bundle_path = Pathname.new(config['source_bundle'])
+        @source_bundle_path = Pathname.new(config.source_bundle)
       end
 
       def load_bundle(component, locale = nil)
         return if locale && locale != CONSTS::REAL_SOURCE_LOCALE # return when NOT querying source
 
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] component=#{component}"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}] component=#{component}" }
 
         total_messages = {}
 
@@ -34,18 +29,18 @@ module SgtnClient
           end
         end
 
-        raise SgtnClient::SingletonError, "no local source messages for component #{component}" if total_messages.empty?
+        raise SingletonError, "no local source messages for component #{component}" if total_messages.empty?
 
         total_messages
       end
 
       def available_bundles
-        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}]"
+        SgtnClient.logger.debug { "[#{method(__callee__).owner}.#{__callee__}]" }
 
         @available_bundles ||= begin
           @source_bundle_path.children.select(&:directory?).reduce(Set.new) do |bundles, component|
             component.glob('**/*.{yml, yaml}') do |_|
-              bundles << Common::BundleID.new(component.basename.to_s, SgtnClient::LocaleUtil.get_source_locale)
+              bundles << Common::BundleID.new(component.basename.to_s, LocaleUtil.get_source_locale)
               break bundles
             end || bundles
           end

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

@@ -2,15 +2,10 @@
 # SPDX-License-Identifier: EPL-2.0
 
 module SgtnClient
-  autoload :StringUtil, 'sgtn-client/util/string-util'
-  autoload :LocaleUtil, 'sgtn-client/util/locale-util'
-
   module TranslationLoader
-    autoload :CONSTS, 'sgtn-client/loader/consts'
-
     module SourceComparer
       def load_bundle(component, locale)
-        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}"
+        SgtnClient.logger.debug { "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}" }
 
         # source locale and old source locale don't need comparison because they are bases of comparison
         real_locale = cache_to_real_map[locale]

data/lib/sgtn-client/loader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+#  Copyright 2022 VMware, Inc.
+#  SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  module TranslationLoader # :nodoc:
+    autoload :Cache, 'sgtn-client/loader/cache'
+    autoload :CacheFiller, 'sgtn-client/loader/cache'
+    autoload :Chain, 'sgtn-client/loader/chain_loader'
+    autoload :CONSTS, 'sgtn-client/loader/consts'
+    autoload :LoaderFactory, 'sgtn-client/loader/loader_factory'
+    autoload :LocalTranslation, 'sgtn-client/loader/local_translation'
+    autoload :SgtnServer, 'sgtn-client/loader/server'
+    autoload :SingleLoader, 'sgtn-client/loader/single_loader'
+    autoload :SourceComparer, 'sgtn-client/loader/source_comparer'
+    autoload :Source, 'sgtn-client/loader/source'
+  end
+end

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

@@ -1,88 +1,50 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-module SgtnClient
-      LOGFILE_SHIFT_AGE = 4
-
-      module Common
-        autoload :BundleID,        "sgtn-client/common/data"
-      end
-      module Core
-            autoload :Cache,        "sgtn-client/core/cache"
-      end
-
-      autoload :Translation,        "sgtn-client/api/translation"
-      autoload :T,                  "sgtn-client/api/t"
-      autoload :Source,             "sgtn-client/api/source"
-      autoload :Config,             "sgtn-client/core/config"
-      autoload :Logging,            "sgtn-client/core/logging"
-      autoload :Exceptions,         "sgtn-client/core/exceptions"
-      autoload :ValidateUtil,       "sgtn-client/util/validate-util"
-      autoload :LocaleUtil,         "sgtn-client/util/locale-util"
-      autoload :FileUtil,           "sgtn-client/util/file-util"
-      autoload :CacheUtil,          "sgtn-client/util/cache-util"
-      autoload :StringUtil,          "sgtn-client/util/string-util"
-
-      module Formatters
-            autoload :PluralFormatter,    "sgtn-client/formatters/plurals/plural_formatter"
-      end
-
-
-      class << self
-            def configure(options = {}, &block)
-            SgtnClient::Config.configure(options, &block)
-            end
-
-            include Logging
-            def load(*args)
-                  # load configuration file
-                  begin
-                    SgtnClient::Config.load(args[0], args[1])
-                    SgtnClient::ValidateUtil.validate_config()
-                  rescue => exception
-                    file = File.open('./error.log', 'a')
-                    file.sync = true
-                    log = Logger.new(file)
-                    log.error exception.message
-                  end
-
-                  # create log file
-                  file = './sgtnclient_d.log'
-                  SgtnClient.logger.debug "[Client][load]create log file=#{file}"
-                  if args[2] != nil
-                        file = args[2]
-                  end
-                  file = File.open(file, 'a')
-                  file.sync = true
-                  SgtnClient.logger = Logger.new(file, LOGFILE_SHIFT_AGE)
-
-                  # Set log level for sandbox mode
-                  env = SgtnClient::Config.default_environment
-                  mode = SgtnClient::Config.configurations[env]["mode"]
-                  SgtnClient.logger.debug "[Client][load]set log level, mode=#{mode}"
-                  if mode == 'sandbox'
-                        SgtnClient.logger.level = Logger::DEBUG
-                  else 
-                        SgtnClient.logger.level = Logger::INFO
-                  end
-
-                  # initialize cache
-                  disable_cache = SgtnClient::Config.configurations[env]["disable_cache"]
-                  SgtnClient.logger.debug "[Client][load]cache initialize, disable_cache=#{disable_cache}"
-                  if disable_cache != nil
-                        SgtnClient::Core::Cache.initialize(disable_cache)
-                  else
-                        SgtnClient::Core::Cache.initialize()
-                  end
-            end
-
-            def logger
-                  SgtnClient::Config.logger
-            end
-
-            def logger=(log)
-                  SgtnClient::Config.logger = log
-            end           
-      end
-  
+require 'forwardable'
+require 'yaml'
+
+module SgtnClient # :nodoc:
+  autoload :Common,             'sgtn-client/common'
+  autoload :TranslationLoader,  'sgtn-client/loader'
+  autoload :SingleOperation,    'sgtn-client/common/single_operation'
+  autoload :Translation,        'sgtn-client/api/translation'
+  autoload :T,                  'sgtn-client/api/t'
+  autoload :Source,             'sgtn-client/api/source'
+  autoload :Config,             'sgtn-client/core/config'
+  autoload :Exceptions,         'sgtn-client/core/exceptions'
+  autoload :ValidateUtil,       'sgtn-client/util/validate-util'
+  autoload :LocaleUtil,         'sgtn-client/util/locale-util'
+  autoload :StringUtil,         'sgtn-client/util/string-util'
+  autoload :SingletonError,     'sgtn-client/exceptions'
+  autoload :I18nBackend,        'sgtn-client/i18n_backend'
+
+  module Formatters # :nodoc:
+    autoload :PluralFormatter, 'sgtn-client/formatters/plurals/plural_formatter'
+  end
+
+  class << self
+    extend Forwardable
+
+    def_delegator Config, :instance, :config
+    def_delegators :config, :logger, :logger=
+
+    def load(config_file, env, log_file = nil)
+      configurations = YAML.load(File.read(config_file))
+      config_hash = configurations[env]
+      raise "Configuration[#{env}] NotFound" unless config_hash
+
+      config_hash['log_file'] = log_file if log_file
+      config.update(config_hash)
+      ValidateUtil.validate_config
+    end
+
+    def locale
+      RequestStore.store[:locale] ||= LocaleUtil.get_fallback_locale
+    end
+
+    def locale=(value)
+      RequestStore.store[:locale] = value
+    end
+  end
 end

data/lib/sgtn-client/util/locale-util.rb

@@ -3,10 +3,10 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-require 'set'
+require 'concurrent/map'
 
 module SgtnClient
-  class LocaleUtil
+  class LocaleUtil # :nodoc:
     MAP_LOCALES = {
       'zh-cn' => 'zh-hans',
       'zh-tw' => 'zh-hant',
@@ -14,57 +14,89 @@ module SgtnClient
       'zh-hant-tw' => 'zh-hant'
     }.freeze
     LOCALE_SEPARATOR = '-'
+    EN_LOCALE = 'en'
+    @locale_match_results = Concurrent::Map.new
+    @lowercase_locales_map = Concurrent::Map.new
+
+    def self.get_best_locale(locale, component)
+      component_result = @locale_match_results[component] ||= begin
+        components = SgtnClient.config.available_components
+        unless components.empty? || components.include?(component)
+          raise SingletonError, "component '#{component}' doesn't exist!"
+        end
+
+        Concurrent::Map.new
+      end
 
-    def self.get_best_locale(locale)
-      return locale if Config.available_locales.include?(locale)
-
-      return get_fallback_locale if locale.nil?
-
-      locale = locale.to_s
-      return get_fallback_locale if locale.empty?
-
-      get_best_match(locale.gsub('_', LOCALE_SEPARATOR).downcase)
-    end
-
-    def self.is_source_locale(locale = nil)
-      locale == get_source_locale
+      component_result[locale] ||= begin
+                component_result.delete(component_result.keys[Random.rand(component_result.size)]) if component_result.size >= 50
+
+                if SgtnClient.config.available_locales(component).include?(locale)
+                  locale
+                elsif locale.nil?
+                  get_fallback_locale
+                else
+                  locale = locale.to_s
+                  if locale.empty?
+                    get_fallback_locale
+                  else
+                    candidates = lowercase_locales_map(component)
+                    if candidates.empty?
+                      locale
+                    else
+                      get_best_match(locale.gsub('_', LOCALE_SEPARATOR).downcase, candidates)
+                    end
+                  end
+                end
+              end
     end
 
-    def self.get_best_match(locale)
+    def self.get_best_match(locale, candidates)
       locale = MAP_LOCALES[locale] || locale
-      lowercase_locales_map[locale] or begin
+      candidates[locale] or begin
         index = locale.rindex(LOCALE_SEPARATOR)
         return get_fallback_locale if index.nil?
 
-        get_best_match(locale[0...index])
+        get_best_match(locale[0...index], candidates)
       end
     end
 
     def self.get_source_locale
-      'en'
+      EN_LOCALE
     end
 
     def self.get_default_locale
-      env = SgtnClient::Config.default_environment
-      SgtnClient::Config.configurations[env]['default_language']
+      EN_LOCALE
     end
 
     def self.get_fallback_locale
-      @fallback_locale ||= get_default_locale || get_source_locale || 'en'
+      locale_fallbacks[0]
+    end
+
+    def self.locale_fallbacks
+      @locale_fallbacks ||= [get_default_locale, get_source_locale, EN_LOCALE].uniq(&:to_s) - [nil, '']
     end
 
-    def self.lowercase_locales_map
-      @lowercase_locales_map ||= Config.available_locales.each_with_object({}) do |locale, memo|
+    def self.lowercase_locales_map(component)
+      @lowercase_locales_map[component] ||= SgtnClient.config.available_locales(component).each_with_object({}) do |locale, memo|
         memo[locale.to_s.downcase] = locale
       end
     end
 
-    def self.reset_available_locales(type)
-      @lowercase_locales_map = nil if type == :available_locales
+    def self.reset_locale_data(type, component = nil)
+      return unless type == :available_locales
+
+      if component.nil?
+        @locale_match_results.clear
+        @lowercase_locales_map.clear
+      else
+        @locale_match_results.delete(component)
+        @lowercase_locales_map.delete(component)
+      end
     end
 
-    SgtnClient::Config.add_observer(self, :reset_available_locales)
+    SgtnClient.config.add_observer(self, :reset_locale_data)
 
-    private_class_method :get_best_match, :lowercase_locales_map, :reset_available_locales
+    private_class_method :get_best_match, :lowercase_locales_map, :reset_locale_data
   end
 end

data/lib/sgtn-client/util/string-util.rb

@@ -7,6 +7,9 @@ module SgtnClient
       super(str)
       @locale = locale
     end
-    attr_accessor :locale
+
+    def localize(locale)
+      super(@locale || locale)
+    end
   end
-end 
+end