singleton-client-test 0.7.0.33 → 0.7.0.36

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

@@ -0,0 +1,51 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require 'json'
+require 'pathname'
+
+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

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require 'faraday'
+require 'faraday_middleware'
+
+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.'
+
+      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'])
+
+        @bundle_url = "#{product_root}/locales/%s/components/%s"
+        @locales_url = "#{product_root}/localelist"
+        @components_url = "#{product_root}/componentlist"
+      end
+
+      def load_bundle(component, 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__}]"
+
+        components_thread = Thread.new { available_components }
+        available_locales.reduce(Set.new) do |bundles, locale|
+          components_thread.value.reduce(bundles) do |inner_bundles, component|
+            inner_bundles << Common::BundleID.new(component, locale)
+          end
+        end
+      end
+
+      private
+
+      def available_locales
+        query_server(@locales_url, ['locales'])
+      end
+
+      def available_components
+        query_server(@components_url, ['components'])
+      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)
+
+        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
+      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']}"
+        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}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# Copyright 2022 VMware, Inc.
+# 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}"
+
+        @single_bundle_loader ||= single_loader { |c,l| super(c,l) }
+        id = CacheUtil.get_cachekey(component, locale)
+        @single_bundle_loader.operate(id, component, locale)&.value
+      ensure
+        # delete thread from hash after finish
+        @single_bundle_loader.remove_object(id)
+      end
+
+      def available_bundles
+        SgtnClient.logger.debug "[#{__FILE__}][#{__callee__}]"
+
+        @single_available_bundles_loader ||= single_loader { super }
+        @single_available_bundles_loader.operate(CONSTS::AVAILABLE_BUNDLES_KEY)&.value
+      ensure
+        @single_available_bundles_loader.remove_object(CONSTS::AVAILABLE_BUNDLES_KEY)
+      end
+
+      private
+      def single_loader(&block)
+        none_alive = proc { |_, thread| thread.nil? || thread.alive? == false }
+        creator = proc do |id, _, *args|
+          Thread.new do
+            SgtnClient.logger.debug "start single loading #{id}"
+            block.call(*args)
+          end
+        end
+
+        SgtnClient::SingleOperation.new(none_alive, &creator)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require 'pathname'
+
+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'])
+      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}"
+
+        total_messages = {}
+
+        (@source_bundle_path + component).glob('**/*.{yml, yaml}') do |f|
+          bundle = YAML.safe_load(File.read(f))
+          messages = bundle&.first&.last # TODO: Warn about inconsistent source locale
+          if messages.is_a?(Hash)
+            total_messages.merge!(messages)
+          else
+            SgtnClient.logger.error "[#{method(__callee__).owner}.#{__callee__}] invalid bundle data in #{f}"
+          end
+        end
+
+        raise SgtnClient::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__}]"
+
+        @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)
+              break bundles
+            end || bundles
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,37 +2,57 @@
 # SPDX-License-Identifier: EPL-2.0
 
 module SgtnClient
-  autoload :Source, 'sgtn-client/loader/local_source_bundle'
-end
-module SgtnClient::TranslationLoader::SourceComparer
-  def load_bundle(component, locale)
-    # source locale always uses source bundles
-    return SgtnClient::Source.load_bundle(component) if SgtnClient::LocaleUtil.is_source_locale(locale)
+  autoload :StringUtil, 'sgtn-client/util/string-util'
+  autoload :LocaleUtil, 'sgtn-client/util/locale-util'
 
-    translation_bundle_thread = Thread.new { super(component, locale) }
-    old_source_bundle = super(component, SgtnClient::LocaleUtil.get_source_locale)
-    source_bundle = get_cs(component, SgtnClient::LocaleUtil.get_source_locale)
-    translation_bundle = translation_bundle_thread.value
+  module TranslationLoader
+    autoload :CONSTS, 'sgtn-client/loader/consts'
 
-    compare_source(translation_bundle, old_source_bundle, source_bundle)
-  end
+    module SourceComparer
+      def load_bundle(component, 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]
+        return super(component, real_locale) if real_locale
+
+        old_source_bundle_thread = Thread.new { load_bundle(component, CONSTS::OLD_SOURCE_LOCALE) }
+        source_bundle_thread = Thread.new { load_bundle(component, LocaleUtil.get_source_locale) }
+        translation_bundle = super(component, locale)
+
+        begin
+          old_source_bundle = old_source_bundle_thread.value
+          source_bundle = source_bundle_thread.value
+        rescue StandardError => e
+          SgtnClient.logger.error "[#{__FILE__}][#{__callee__}] failed to load soruce(or old source) bundle. component:#{component}. error: #{e}"
+          return translation_bundle
+        end
+
+        compare_source(translation_bundle, old_source_bundle, source_bundle)
+      end
+
+      private
+
+      def compare_source(translation_bundle, old_source_bundle, source_bundle)
+        if !translation_bundle.is_a?(Hash) || !source_bundle.is_a?(Hash) || !old_source_bundle.is_a?(Hash)
+          SgtnClient.logger.warn "can't do source comparison because some bundle data are wrong."
+          return translation_bundle
+        end
+
+        source_bundle.each do |key, value|
+          if old_source_bundle[key] != value || translation_bundle[key].nil?
+            translation_bundle[key] = StringUtil.new(value, LocaleUtil.get_source_locale)
+          end
+        end
+        translation_bundle
+      end
 
-  private
-
-  def compare_source(translation_bundle, old_source_bundle, source_bundle)
-    return translation_bundle if translation_bundle.nil? || source_bundle.nil? || old_source_bundle.nil?
-
-    old_source_messages = old_source_bundle['messages']
-    translation_messages = translation_bundle['messages']
-    translation_bundle['messages'] = new_translation_messages = {}
-    source_bundle['messages'].each do |key, value|
-      translation = translation_messages[key]
-      new_translation_messages[key] = if old_source_messages[key] == value && !translation.nil?
-                                        translation
-                                      else
-                                        SgtnClient::StringUtil.new(value, SgtnClient::LocaleUtil.get_source_locale)
-                                      end
+      def cache_to_real_map
+        @cache_to_real_map ||= {
+          LocaleUtil.get_source_locale => CONSTS::REAL_SOURCE_LOCALE,
+          CONSTS::OLD_SOURCE_LOCALE => LocaleUtil.get_source_locale
+        }.freeze
+      end
     end
-    translation_bundle
   end
 end

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

@@ -17,6 +17,7 @@ module SgtnClient
       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"
 
       module Formatters
             autoload :PluralFormatter,    "sgtn-client/formatters/plurals/plural_formatter"

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

@@ -8,13 +8,11 @@ module SgtnClient
 
   class CacheUtil
     def self.get_cache(cache_key)
-      SgtnClient.logger.debug "[CacheUtil]get cache with key #{cache_key}"
       SgtnClient::Core::Cache.get(cache_key)
     end
 
     def self.clear_cache
       SgtnClient::Core::Cache.clear
-      SgtnClient.logger.debug '[CacheUtil]clear cache'
     end
 
     def self.write_cache(cache_key, items)
@@ -24,7 +22,6 @@ module SgtnClient
       cache_expiry_period = SgtnClient::Config.configurations[env]['cache_expiry_period']
       # expired after 24 hours
       cache_expiry_period = 24 * 60 if cache_expiry_period.nil?
-      SgtnClient.logger.debug "[CacheUtil]write cache with key #{cache_key}, cache_expiry_period #{cache_expiry_period}"
       SgtnClient::Core::Cache.put(cache_key, items, cache_expiry_period)
     end
 

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

@@ -3,23 +3,21 @@
 require 'set'
 
 module SgtnClient
-  SUPPORTED_LOCALES = %w[en de es fr ko ja zh-Hans zh-Hant zh de-CH].freeze # TODO get this from service in online mode
-  
-  MAP_LOCALES = {
-    'zh-CN' => 'zh-Hans',
-    'zh-TW' => 'zh-Hant',
-    'zh-Hans-CN' => 'zh-Hans',
-    'zh-Hant-TW' => 'zh-Hant'
-  }.freeze
-
   class LocaleUtil
+    MAP_LOCALES = {
+      'zh-CN' => 'zh-Hans',
+      'zh-TW' => 'zh-Hant',
+      'zh-Hans-CN' => 'zh-Hans',
+      'zh-Hant-TW' => 'zh-Hant'
+    }.freeze
+
     def self.get_best_locale(locale)
-      return get_default_locale if locale.nil?
+      return get_fallback_locale if locale.nil?
 
       locale = locale.to_s
-      return get_default_locale if locale.empty?
+      return get_fallback_locale if locale.empty?
 
-      get_best_match(locale)
+      get_best_match(locale.gsub('_', '-'))
     end
 
     def self.is_source_locale(locale = nil)
@@ -27,11 +25,13 @@ module SgtnClient
     end
 
     def self.get_best_match(locale)
-      locale = locale.gsub('_', '-')
-      locale = SgtnClient::MAP_LOCALES[locale] if SgtnClient::MAP_LOCALES.key?(locale)
-      return locale if SUPPORTED_LOCALES.include?(locale)
-      return LocaleUtil.get_source_locale if locale.index('-').nil?
-      get_best_match(locale.slice(0..(locale.rindex('-')-1)) )  
+      locale = MAP_LOCALES[locale] || locale
+      return locale if Config.available_locales.include?(locale)
+
+      index = locale.rindex('-')
+      return get_fallback_locale if index.nil?
+
+      get_best_match(locale[0...index])
     end
 
     def self.get_source_locale
@@ -40,7 +40,11 @@ module SgtnClient
 
     def self.get_default_locale
       env = SgtnClient::Config.default_environment
-      SgtnClient::Config.configurations[env]['default_language'] || 'en'
+      SgtnClient::Config.configurations[env]['default_language']
+    end
+
+    def self.get_fallback_locale
+      @fallback_locale ||= get_default_locale || get_source_locale || 'en'
     end
 
     private_class_method :get_best_match

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

@@ -14,12 +14,7 @@ module SgtnClient
         if mode != 'sandbox' && mode != 'live'
           messages =  messages + "Configuration[mode] has to be 'sandbox' or 'live'!\n"
         end
-        
-        bundle_mode = SgtnClient::Config.configurations[env]["bundle_mode"]
-        if bundle_mode != 'offline' && bundle_mode != 'online'
-          messages = messages +  "Configuration[bundle_mode] has to be 'offline' or 'online'!\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"

data/lib/singleton-client.rb

@@ -0,0 +1,15 @@
+# Copyright 2022 VMware, Inc.
+# SPDX-License-Identifier: EPL-2.0
+
+require_relative 'singleton-ruby'
+
+module Sgtn # :nodoc:
+  # load configuration from a file
+  def self.load_config(*args)
+    SgtnClient.load(*args)
+  end
+
+  extend SgtnClient::Translation::Implementation
+
+  private_class_method :getString, :getString_p, :getString_f, :getStrings
+end

data/lib/singleton-ruby.rb

@@ -4,3 +4,5 @@
 require "sgtn-client/sgtn-client"
 require 'sgtn-client/cldr/core_ext'
 require 'twitter_cldr'
+
+require 'sgtn-client/exceptions.rb'