singleton-client-test 0.7.0.33 → 0.7.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2a32a268d9bc9b395baeb2d296049cbbb29a40c081968d6e8a5ae364c39444c
-  data.tar.gz: fdf427aaf792fbff1bf6afa404d6e0aeeea030b9fa90b7eab578cbe46659656e
+  metadata.gz: 6722a7f77f8f9ee4fbf2f481d0c66e30b818c61746a9c7e8471fc1b225079f72
+  data.tar.gz: ba0e6acade9bc655f97a731cf760e15097b713e99000cf8f2612e4975a357d2d
 SHA512:
-  metadata.gz: 1ecfa3b8fbc1ef494e41a517a102856f4717d408845eeac43cd751c24df2a590404082cd00670b280fd8c404b3dd95ecd2ae5c06f7b0c0b23172b9eb7ab2fff7
-  data.tar.gz: 0a8aee2dd03eaa02c981cdfaa097ffbddebc2118c7c7a63625ad19ca332ecf582fac19a812339ef9920dac37765a03b30d9800d69cfe9dd2b854762ee0796170
+  metadata.gz: 27e3c13e20185a08049c2d634bc11e3a6d4e05095802e3c76026b74c34acd3a327b2e49c79020b9143479747e9d25fbfe5eaf4c859621afdc23f512859efd0fc
+  data.tar.gz: bed85d6578397cd90e0823574f552d7f7e98e19a0f49e35e12963eecc32d5f87d85b8c0a8ab2c50c5c66b3ea81e630334194f8d4600fdc4a0eec2bf391b2decb

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

@@ -1,7 +1,7 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-require 'sgtn-client/loader/local_source_bundle'
+require 'sgtn-client/loader/source'
 
 module SgtnClient
   autoload :CacheUtil, 'sgtn-client/util/cache-util'
@@ -9,16 +9,7 @@ module SgtnClient
   class Source
     def self.loadBundles(locale)
       SgtnClient.logger.debug "[Source][loadBundles]locale=#{locale}"
-      env = SgtnClient::Config.default_environment
       SgtnClient::Config.configurations.default = locale
-      source_bundle = SgtnClient::Config.configurations[env]['source_bundle']
-      Dir.foreach(source_bundle) do |component|
-        next if %w[. ..].include? component
-
-        bundle = load_bundle(component)
-        cachekey = SgtnClient::CacheUtil.get_cachekey(component, LocaleUtil.get_source_locale)
-        SgtnClient::CacheUtil.write_cache(cachekey, bundle)
-      end
     end
   end
 end

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

@@ -1,110 +1,113 @@
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
-module SgtnClient
-  autoload :StringUtil, 'sgtn-client/util/string-util'
-
-  module TranslationLoader
-    autoload :LocalBundle, 'sgtn-client/loader/local_bundle'
-    autoload :ServerBundle, 'sgtn-client/loader/server_bundle'
-    autoload :SourceComparer, 'sgtn-client/loader/source_comparer'
-    autoload :SingleLoader, 'sgtn-client/loader/single_loader'
-    autoload :Cache, 'sgtn-client/loader/cache'
-  end
+require 'request_store'
 
+module SgtnClient
   module Translation
-    def self.getString(component, key, locale)
-      SgtnClient.logger.debug "[Translation.getString]component: #{component}, key: #{key}, locale: #{locale}"
-      str = getTranslation(component, key, locale)
-      if str.nil? && !LocaleUtil.is_source_locale(locale)
-        str = getTranslation(component, key, LocaleUtil.get_source_locale)
+    module Implementation
+      # <b>DEPRECATED:</b> Please use <tt>Singleton:translate</tt> instead.
+      def getString(component, key, locale)
+        SgtnClient.logger.debug "[Translation.getString]component: #{component}, key: #{key}, locale: #{locale}"
+        translate(key, component, locale) { nil }
       end
-      str
-    end
 
-    def self.getString_p(component, key, plural_args, locale)
-      SgtnClient.logger.debug "[Translation][getString_p]component=#{component}, key=#{key}, locale=#{locale}"
-      str = getTranslation(component, key, locale)
-      if str.nil?
-        unless LocaleUtil.is_source_locale(locale)
-          str = getTranslation(component, key, LocaleUtil.get_source_locale)
-          str.to_plural_s(LocaleUtil.get_source_locale, plural_args) if str
-        end
-      else
-        locale = str.locale if str.is_a?(SgtnClient::StringUtil)
-        str.to_plural_s(locale, plural_args)
+      # <b>DEPRECATED:</b> Please use <tt>Singleton:translate</tt> instead.
+      def getString_p(component, key, plural_args, locale)
+        SgtnClient.logger.debug "[Translation][getString_p]component=#{component}, key=#{key}, locale=#{locale}"
+        translate(key, component, locale, **plural_args) { nil }
       end
-    end
-
-    def self.getString_f(component, key, args, locale, *optionals)
-      SgtnClient.logger.debug "[Translation][getString_f]component=#{component}, key=#{key}, locale=#{locale}"
-      s = getString(component, key, locale, *optionals)
-      return nil if s.nil?
 
-      if args.is_a?(Hash)
-        args.each do |source, arg|
-          s.gsub! "{#{source}}", arg
+      # <b>DEPRECATED:</b> Please use <tt>Singleton:translate</tt> instead.
+      def getString_f(component, key, args, locale, *_optionals)
+        SgtnClient.logger.debug "[Translation][getString_f]component=#{component}, key=#{key}, locale=#{locale}"
+        s = translate(key, component, locale) { nil }
+        return nil if s.nil?
+
+        if args.is_a?(Hash)
+          args.each do |source, arg|
+            s.gsub! "{#{source}}", arg
+          end
+        elsif args.is_a?(Array)
+          s = s % args
         end
-      elsif args.is_a?(Array)
-        s = s % args
+        s
       end
-      s
-    end
 
-    def self.getStrings(component, locale)
-      SgtnClient.logger.debug "[Translation][getStrings]component=#{component}, locale=#{locale}"
-      locale = SgtnClient::LocaleUtil.get_best_locale(locale)
-      items = get_cs(component, locale)
-      if (items.nil? || items['messages'].nil?) && !LocaleUtil.is_source_locale(locale)
-        items = get_cs(component, LocaleUtil.get_source_locale)
+      # <b>DEPRECATED:</b> Please use <tt>Singleton:get_translations</tt> instead.
+      def getStrings(component, locale)
+        get_translations(component, locale)
       end
 
-      items
-    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}"
 
-    def self.getTranslation(component, key, locale)
-      locale = SgtnClient::LocaleUtil.get_best_locale(locale)
-      items = get_cs(component, locale)
-      items&.dig('messages', key)
-    end
+        locale = locale.nil? ? self.locale : SgtnClient::LocaleUtil.get_best_locale(locale)
 
-    def self.get_cs(component, locale)
-      cache_item = load_bundle(component, locale)
-      cache_item&.dig(:items)
-    end
+        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)
+        end
 
-    def self.load_bundle(component, locale)
-      init_translations unless initialized?
-      super
-    end
+        if result.nil?
+          return key unless block_given?
+
+          result = yield
+          return if result.nil?
+        end
 
-    class << self
-      def initialized?
-        @initialized ||= false
+        if kwargs.empty?
+          result
+        else
+          locale = result.locale if result.is_a?(SgtnClient::StringUtil)
+          result.localize(locale) % kwargs
+        end
       end
+      alias t translate
 
-      def init_translations
-        # TODO: Lock to initialize?
-        env = SgtnClient::Config.default_environment
-        mode = SgtnClient::Config.configurations[env]['bundle_mode']
-        SgtnClient.logger.debug "[Translation][init_translations]mode=#{mode}"
+      def get_translations(component, locale = nil)
+        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}] component: #{component}, locale: #{locale}"
 
-        if mode == 'offline'
-          extend SgtnClient::TranslationLoader::LocalBundle
-        else
-          extend SgtnClient::TranslationLoader::ServerBundle
+        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
 
-        extend SgtnClient::TranslationLoader::SourceComparer
-        extend SgtnClient::TranslationLoader::Cache
+        { 'component' => component, 'locale' => locale, 'messages' => items || {} } if items
+      end
 
-        load_translations
-        @initialized = true
+      def locale
+        RequestStore.store[:locale] ||= SgtnClient::LocaleUtil.get_fallback_locale
       end
 
-      def load_translations; end
-    end
+      def locale=(value)
+        RequestStore.store[:locale] = SgtnClient::LocaleUtil.get_best_locale(value)
+      end
 
-    private_class_method :getTranslation, :get_cs, :load_bundle, :initialized?, :load_translations
+      private
+
+      def get_bundle(component, locale)
+        get_bundle!(component, locale)
+      rescue StandardError => e
+        SgtnClient.logger.error "[#{method(__callee__).owner}.#{__callee__}] failed to get a bundle. component: #{component}, locale: #{locale}"
+        SgtnClient.logger.error e
+        nil
+      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)
+      end
+    end
+    extend Implementation
   end
 end

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

@@ -0,0 +1,30 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  module Common
+    class BundleID
+      attr_reader :locale, :component
+
+      def initialize(component, locale)
+        @locale = locale
+        @component = component
+        @key = [@component, @locale].hash
+      end
+
+      def hash
+        @key
+      end
+
+      def ==(other)
+       (other.is_a? self.class) && @locale == other.locale && @component == other.component
+      end
+
+      alias eql? ==
+
+      def to_s
+        "locale=#{@locale}, component=#{@component}}"
+      end
+    end
+  end
+end

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

@@ -20,6 +20,7 @@ module SgtnClient
         @conditions.each do |con|
           return obj unless con.call(id, obj, *args)
         end
+        # TODO: whatif returning nil
         @hash[id] = @creator.call(id, obj, *args)
       end
     end

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

@@ -4,8 +4,14 @@
 require 'erb'
 require 'yaml'
 
+
 module SgtnClient
   #include Exceptions
+
+  module TranslationLoader
+    autoload :LoaderFactory, 'sgtn-client/loader/loader_factory'
+  end
+
   module Configuration
 
     def config
@@ -42,7 +48,7 @@ module SgtnClient
     :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, :bundle_mode,
+    :verbose_logging, :product_name, :version, :vip_server,
     :translation_bundle, :source_bundle, :cache_expiry_period, :disable_cache, :default_language
 
 
@@ -152,6 +158,34 @@ module SgtnClient
           Logging.logger
         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
+          end
+          bundles.locales
+        end
+
         private
         # Read configurations from the given file name
         # === Arguments
@@ -161,7 +195,6 @@ module SgtnClient
           erb.filename = file_name
           YAML.load(erb.result)
         end       
-          
 
     end
   end

data/lib/sgtn-client/exceptions.rb

@@ -0,0 +1,6 @@
+#  Copyright 2022 VMware, Inc.
+#  SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  class SingletonError < StandardError; end
+end

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

@@ -1,47 +1,71 @@
+# frozen_string_literal: true
+
 # Copyright 2022 VMware, Inc.
 # SPDX-License-Identifier: EPL-2.0
 
 module SgtnClient
   autoload :CacheUtil, 'sgtn-client/util/cache-util'
-  autoload :SingleOperation, 'sgtn-client/common/single_operation'
-end
-module SgtnClient::TranslationLoader::Cache
-  def load_bundle(component, locale)
-    cache_key = SgtnClient::CacheUtil.get_cachekey(component, locale)
-    SgtnClient.logger.debug "[#{self.to_s}][#{__FILE__}][#{__method__}] cache_key=#{cache_key}"
-    cache_item = SgtnClient::CacheUtil.get_cache(cache_key)
-    if cache_item.nil?
-      # refresh synchronously if not in cache
-      SgtnClient.logger.debug "[#{self.to_s}][#{__FILE__}][#{__method__}] Cache miss. cache_key=#{cache_key}"
-      cache_item = (single_loader { |c, l| super(c, l) }).operate(cache_key, component, locale).value 
-      # TODO: if an error occurs when requesting a bundle, need to avoid more requests
-    elsif SgtnClient::CacheUtil.is_expired(cache_item) && locale != SgtnClient::LocaleUtil.get_source_locale # local source never expires.
-      SgtnClient.logger.debug "[#{self.to_s}][#{__FILE__}][#{__method__}] Bundle cache is expired. cache_key=#{cache_key}"
-      @single_loader.operate(cache_key, component, locale) # refresh in background
-    end
-    cache_item
-  end
 
-  private
+  module TranslationLoader
+    autoload :CONSTS, 'sgtn-client/loader/consts'
 
-  def single_loader
-    @single_loader ||= begin
-      none_alive = proc { |_, thread| thread.nil? || thread.alive? == false }
-      to_run = proc do |id|
-        cache_item = SgtnClient::CacheUtil.get_cache(id)
-        cache_item&.dig(:items).nil? || SgtnClient::CacheUtil.is_expired(cache_item)
-      end
-      creator = proc do |id, _, c, l|
-        Thread.new do
-          SgtnClient.logger.debug "Refreshing cache for #{c}/#{l}"
-          cache_item = SgtnClient::CacheUtil.write_cache(id, yield(c, l))
-          # delete thread from hash after finish
-          Thread.new { @single_loader.remove_object(id) }
-          cache_item
+    module Cache # :nodoc:
+      # get from cache, return expired data immediately
+      def get_bundle(component, 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
+
+        load_bundle(component, locale) # refresh synchronously if not in cache
       end
 
-      SgtnClient::SingleOperation.new(none_alive, to_run, &creator)
+      # load and save to cache
+      def load_bundle(component, locale)
+        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}] component=#{component}, locale=#{locale}"
+
+        key = SgtnClient::CacheUtil.get_cachekey(component, locale)
+        item = super
+        SgtnClient::CacheUtil.write_cache(key, item) if item
+        item
+      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
+
+        item = super
+        SgtnClient::CacheUtil.write_cache(CONSTS::AVAILABLE_BUNDLES_KEY, item) if item
+        item
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  module TranslationLoader
+    class Chain
+      attr_accessor :loaders
+
+      def initialize(*loaders)
+        self.loaders = loaders
+      end
+
+      def load_bundle(component, locale)
+        exception = nil
+
+        loaders.each do |loader|
+          begin
+            bundle = loader.load_bundle(component, locale)
+            return bundle if bundle
+          rescue StandardError => e
+            exception = e
+            SgtnClient.logger.error "[#{__FILE__}][#{__callee__}] {component: #{component},locale: #{locale}}, failed on #{loader.class}: #{e}"
+          end
+        end
+
+        raise exception || SgtnClient::SingletonError.new("can't load component: #{component}, locale: #{locale}")
+      end
+
+      def available_bundles
+        exception = nil
+        total_data = Set.new
+
+        loaders.each do |loader|
+          begin
+            item = loader.available_bundles
+            total_data += item
+          rescue StandardError => e
+            exception = e
+            SgtnClient.logger.error "[#{__FILE__}][#{__callee__}] failed on #{loader.class}: #{e}"
+          end
+        end
+
+        raise exception if total_data.empty? && exception
+
+        total_data
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+module SgtnClient
+  module TranslationLoader
+    module CONSTS
+      OLD_SOURCE_LOCALE = 'old_source'
+      REAL_SOURCE_LOCALE = 'latest'
+
+      AVAILABLE_BUNDLES_KEY = 'available_bundles'
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+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}"
+
+        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?
+
+        chain_loader = Class.new(Chain)
+        chain_loader.include SourceComparer if config['source_bundle'] || config['vip_server']
+        chain_loader.include SingleLoader
+        chain_loader.include Cache
+
+        chain_loader.new(*loaders)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require 'multi_json'
+
+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
+      end
+
+      def load_bundle(component, locale)
+        return if locale == CONSTS::REAL_SOURCE_LOCALE # return when querying source
+
+        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
+
+        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
+
+        messages
+      end
+
+      def available_bundles
+        SgtnClient.logger.debug "[#{method(__callee__).owner}.#{__callee__}]"
+
+        @available_bundles ||= begin
+          @base_path.glob('*/*.json').reduce(Set.new) do |bundles, f|
+            locale = f.basename.to_s.sub(/\A#{BUNDLE_PREFIX}/i, '').sub(/#{BUNDLE_SUFFIX}\z/i, '')
+            bundles.add Common::BundleID.new(f.parent.basename.to_s, locale)
+          end
+        end
+      end
+    end
+  end
+end