singleton-client-test 0.7.7.2 → 0.7.7.5

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,15 +5,10 @@
 
 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
       ERROR_ILLEGAL_DATA = 'server returned illegal data.'
       ERROR_BUSINESS_ERROR = 'server returned business error.'
@@ -21,9 +16,9 @@ module SgtnClient
       REQUEST_ARGUMENTS = { timeout: 10 }.freeze
 
       def initialize(config)
-        @server_url = config['vip_server']
+        @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/%s/versions/%s', config.product_name, config.version)
 
         @bundle_url = "#{product_root}/locales/%s/components/%s"
         @locales_url = "#{product_root}/localelist"
@@ -31,14 +26,14 @@ module SgtnClient
       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
       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|
@@ -73,7 +68,7 @@ module SgtnClient
 
       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
+        raise SingletonError, "no expected data in response. Body is: #{parsedbody}" unless data
 
         data
       end
@@ -81,13 +76,13 @@ module SgtnClient
       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
       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,42 @@
 # 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
+  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,88 @@ 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.shift 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

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

@@ -6,32 +6,22 @@ module SgtnClient
   class ValidateUtil
 
       def self.validate_config()
-        env = SgtnClient::Config.default_environment
-        SgtnClient.logger.debug "[ValidateUtil][validate_config] env = #{env}"
-        messages = "\n"
+        puts "validating config..."
+        messages = ""
 
-        mode = SgtnClient::Config.configurations[env]["mode"]
-        if mode != 'sandbox' && mode != 'live'
-          messages =  messages + "Configuration[mode] has to be 'sandbox' or 'live'!\n"
+        version = SgtnClient.config.version
+        SgtnClient.config.version = version.to_s
+        if version.to_s !~ /\A(\d+\.)*\d+\z/
+          messages = messages +  "Configuration[version] has to be standard as '#.#.#, e.g '1.0.0'!\n"
         end
-
-        #version = SgtnClient::Config.configurations[env]["version"]
-        #if version.is_a? Integer
-          #messages = messages +  "Configuration[version] has to be standard as '#.#.#, e.g '1.0.0'!\n"
-        #end
         
-        cache_expiry_period = SgtnClient::Config.configurations[env]["cache_expiry_period"]
+        cache_expiry_period = SgtnClient.config.cache_expiry_period
         if cache_expiry_period != nil && (cache_expiry_period.is_a? Integer) == false
           messages = messages +  "Configuration[cache_expiry_period] has to be a number!\n"
         end
-        
-        disable_cache = SgtnClient::Config.configurations[env]["disable_cache"]
-        if disable_cache != nil && disable_cache != false && disable_cache != true
-          messages = messages +  "Configuration[disable_cache] has to be a 'true' or 'false'!\n"
-        end
-        
-        if messages != "\n"
-          raise SgtnClient::Exceptions::MissingConfig.new(messages)
+
+        if messages != ""
+          raise Exceptions::MissingConfig.new(messages)
         end
       end