skn_utils 5.4.0 → 5.8.0

data/bin/concurrent_test_grouped

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_grouped
+#
+
+require 'bundler/setup'
+require 'skn_utils'
+
+
+# ##
+# MainLine
+# ##
+#
+begin
+  # CommandJSONPost, CommandFORMGet, CommandJSONGet,
+  # CommandJSONPut, CommandFORMDelete
+  commands = [
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/posts"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/comments"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/todos/1"),
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/users")
+  ]
+
+  # Initialize the queue with Async Workers by default
+  provider = SknUtils::ConcurrentJobs.call
+
+  # Populate WorkQueue
+  provider.register_jobs(commands, SknUtils::HttpProcessor) # mis-spelling these params result in an immediate exception (line 43 below)
+
+  # Execute WorkQueue
+  result = provider.render_jobs
+
+  if result.success?
+    puts "Success: true"
+    puts "Values: #{result.values}"
+    puts "Messages: #{result.messages}"
+  else
+    puts "Success: false - errors: #{result.messages.join(', ')}"
+    puts "Values: #{result.values}"
+  end
+
+#  result.values
+rescue => e
+  $stderr.puts e.message, e.backtrace
+end

data/bin/concurrent_test_procs

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_procs
+#
+require 'bundler/setup'
+require 'skn_utils'
+
+
+# ##
+# MainLine
+# ##
+#
+begin
+  # CommandJSONPost, CommandFORMGet, CommandJSONGet,
+  # CommandJSONPut, CommandFORMDelete
+  commands = [
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/posts"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/comments"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/todos/1"),
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/users")
+  ]
+
+  # Initialize the queue with Async Workers by default
+  provider = SknUtils::ConcurrentJobs.call
+
+  # Populate WorkQueue
+  work_proc = ->(cmd) { SknSuccess.(cmd.uri.request_uri, "Ok") }  # mis-spelling these params result in [SknFailure, SknFailure, ...] results
+  provider.register_jobs(commands, work_proc)
+
+  # Execute WorkQueue
+  result = provider.render_jobs
+
+  if result.success?
+    puts "Success: true"
+    puts "Values: #{result.values}"
+    puts "Messages: #{result.messages}"
+  else
+    puts "Success: false - errors: #{result.messages.join(', ')}"
+    puts "Values: #{result.values}"
+  end
+
+#  result.values
+rescue => e
+  $stderr.puts e.message, e.backtrace
+end

data/bin/concurrent_test_wrapped

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_wrapped
+#
+
+require 'bundler/setup'
+require 'skn_utils'
+
+
+# ##
+# MainLine
+# ##
+#
+begin
+  # CommandJSONPost, CommandFORMGet, CommandJSONGet,
+  # CommandJSONPut, CommandFORMDelete
+  commands = [
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/posts"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/comments"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/todos/1"),
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/users")
+  ]
+
+  # Initialize the queue with Async Workers by default
+  provider = SknUtils::ConcurrentJobs.call
+
+  # Populate WorkQueue
+  commands.each do |command|
+    provider.register_job do
+      SknUtils::JobWrapper.call(command, SknUtils::HttpProcessor)  # mis-spelling these params result in [nil, nil, ...] results
+    end
+  end
+
+  # Execute WorkQueue
+  result = provider.render_jobs
+
+  if result.success?
+    puts "Success: true"
+    puts "Values: #{result.values}"
+    puts "Messages: #{result.messages}"
+  else
+    puts "Success: false - errors: #{result.messages.join(', ')}"
+    puts "Values: #{result.values}"
+  end
+
+#  result.values
+rescue => e
+  $stderr.puts e.message, e.backtrace
+end

data/lib/skn_container.rb

@@ -1,4 +1,5 @@
-# ##
+# frozen_string_literal: true
+
 # ##
 # SknContainer
 # - Key/Value Container where keys and/or values can be any valid Ruby Class, Proc, Instance, or object.

data/lib/skn_failure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ##
 # Bad Result
 #

data/lib/skn_hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 #
 

data/lib/skn_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ##
 # SknRegistry
 # - Key/Value Container where keys and/or values can be any valid Ruby Class, Proc, Instance, or object.
@@ -71,9 +73,8 @@ class SknRegistry < Concurrent::Hash
     attr_reader :item, :options
 
     def initialize(item, options = {})
-      @item, @options = item, {
-          call: item.is_a?(::Proc)
-      }.merge(options)
+      @item    = item
+      @options = { call: item.is_a?(::Proc) }.merge(options)
     end
 
     # Determine if call is required, without changing original values
@@ -94,18 +95,19 @@ class SknRegistry < Concurrent::Hash
   def initialize(&block)
     super
     block.call(self) if block_given?
+    @__substitutes = {}
   end
 
   # public instance methods
   def register(key, contents = nil, options = {}, &block)
     if block_given?
       item = block
-      options = contents if contents.is_a?(::Hash)
+      options.merge!(contents) if contents.is_a?(::Hash)
     else
       item = contents
     end
 
-    self[key] = Content.new(item, options)
+    self.store( key, Content.new(item, options) )
 
     self # enable chaining
   end
@@ -114,4 +116,22 @@ class SknRegistry < Concurrent::Hash
     self[key]&.call(render_proc)
   end
 
+  def register_mock(key, contents = nil, options = {}, &block)
+    if member?(key)
+      @__substitutes.store(key, self.delete(key) )
+    end
+
+    register(key, contents, options, &block)
+  end
+  alias_method :substitute, :register_mock
+
+  def unregister_mocks!
+    @__substitutes.keys.each do |k|
+      self[k] = @__substitutes.delete(k)
+    end
+
+    nil
+  end
+  alias_method :restore!, :unregister_mocks!
+
 end

data/lib/skn_settings.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Initialize:
 #   SknSettings.load_config_basename!('some_name')

data/lib/skn_success.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ##
 # Good Result
 #

data/lib/skn_utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 
 require "skn_utils/version"
 require 'psych'
@@ -8,9 +10,12 @@ require 'time'
 require 'concurrent'
 unless defined?(Rails)
   begin
+    require "uri"
+    require "net/http"
+    require 'net/https'
     require 'deep_merge'
   rescue LoadError => e
-    puts e.message
+    $stderr.puts e.message, e.backtrace
   end
 end
 require 'skn_utils/core_extensions'
@@ -25,6 +30,11 @@ require 'skn_utils/null_object'
 require 'skn_utils/notifier_base'
 require 'skn_utils/configuration'
 require 'skn_utils/configurable'
+require 'skn_utils/wrappable'
+
+require "skn_utils/job_commands"
+require "skn_utils/http_processor"
+require "skn_utils/concurrent_jobs"
 
 require 'skn_hash'
 require 'skn_registry'
@@ -48,7 +58,7 @@ module SknUtils
       [SknFailure, SknFailure].any? {|o| res.kind_of?(o) } ? res : SknSuccess.( res )
 
     rescue StandardError, ScriptError => error
-      puts "#{retry_count} - #{error.class.name}:#{error.message}"
+      $stderr.puts "#{retry_count} - #{error.class.name}:#{error.message}"
       if retry_count <= attempts
         retry_count+= 1
         sleep(pause_between)
@@ -86,3 +96,4 @@ module SknUtils
   end
 
 end
+

data/lib/skn_utils/concurrent_jobs.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+# ##
+#
+#
+# See JobCommands, HttpProcessor, ...
+# See ./bin/par_test_[block|grouped|wrapped] examples
+#
+
+module SknUtils
+
+  class SyncWorker
+    def initialize(&blk)
+      @blk = blk
+    end
+
+    def call
+      @blk.call
+    rescue => ex
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+    end
+  end
+
+  class AsyncWorker
+    def initialize(&blk)
+      @blk = Concurrent::Promise.execute(&blk)
+    end
+
+    def call
+      @blk.value
+    rescue => ex
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+    end
+  end
+
+  class Result
+    def initialize(merged)
+      @merged = merged
+    end
+
+    def success?
+      @merged.all?(&:success) rescue false
+    end
+
+    def messages
+      @merged.map(&:message)&.compact rescue []
+    end
+
+    def values
+      @merged
+    end
+  end
+
+  class CallableWrapperJob
+    def self.call(callable, command)
+      callable.call(command)
+    rescue => ex
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+    end
+  end
+  class JobWrapper
+    def self.call(command, callable)
+      callable.call(command)
+    rescue => ex
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+    end
+  end
+
+  class ConcurrentJobs
+    attr_reader :elapsed_time_string
+
+    def self.call(async: true)
+      worker = async ? AsyncWorker : SyncWorker
+      new(worker: worker)
+    end
+
+    def initialize(worker:)
+      @worker  = worker
+      @workers = []
+    end
+
+    # commands: array of command objects related to callable
+    # callable: callable class or proc, ex:SknUtils::HttpProcessor
+    # callable must return SknSuccess || SknFailure
+    def register_jobs(commands, callable)
+      commands.each do |command|
+        register_job do
+          JobWrapper.call(command,callable)
+        end
+      end
+    end
+
+    def register_job(&blk)
+      @workers << @worker.new(&blk)
+    end
+
+    def render_jobs
+      stime = SknUtils.duration
+      merged = @workers.each_with_object([]) do |worker, acc|
+        begin
+          res = worker.call
+          acc.push( res.nil? ? SknFailure.("Unknown", {cause: "Nil Return Value to render Jobs", backtrace: []}) : res )
+        rescue => ex
+          failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+          acc.push SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+        end
+      end
+      @elapsed_time_string = SknUtils.duration(stime)
+      Result.new(merged)
+    rescue => e
+      Result.new(merged || [])
+    end
+  end
+end

data/lib/skn_utils/configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # File: <gem-root>/lib/skn_utils/configurable.rb
 #  Ref: https://www.toptal.com/ruby/ruby-dsl-metaprogramming-guide
@@ -25,7 +27,7 @@ module SknUtils
   # end
   #
   #################
-  # During Definition
+  # -or- During Definition
   #################
   # class MyApp
   #   include SknUtils::Configurable.with(:app_id, :title, :cookie_name, {root_enable: true})
@@ -36,6 +38,7 @@ module SknUtils
   #     cookie_name { "#{app_id}_session" }
   #   end
   #
+  #   # these are the root_enable default settings
   #   self.logger = Logger.new
   #   self.env    = ENV.fetch('RACK_ENV', 'development')
   #   self.root   = Dir.pwd
@@ -56,6 +59,11 @@ module SknUtils
   # - env      =  string value from RACK_ENV
   # - registry =  SknRegistry instance
   # - logger   =  Assigned Logger instance
+  # - romDB    =  var for Rom-DB if used or Any Platform Database
+  # - metadata =  platform metadata container
+  # - userdata =  user area
+  # - metrics  =  platform metrics container
+  # - ...
   # #with(*user_attrs, enable_root: true|false) - defaults to enable of Main Class Attrs
   # ##
   # User-Defined Attrs
@@ -65,9 +73,9 @@ module SknUtils
 
   module Configurable
 
-    def self.with(*attrs, **options)
+    def self.with(*config_attrs, **root_options)
       _not_provided = Object.new
-      _app_main = options.empty? || options.values.any?{|v| v == true}
+      _root_options = root_options.empty? || root_options.values.any?{|v| v == true}
 
       # Define the config class/module methods
       config_class = Class.new do
@@ -79,7 +87,7 @@ module SknUtils
           instance_variable_set("@#{attr}", val)
         end
 
-        attrs.each do |attr|
+        config_attrs.each do |attr|
           define_method attr do |value = _not_provided, &block|
             if value === _not_provided && block.nil?
               result = instance_variable_get("@#{attr}")
@@ -90,7 +98,7 @@ module SknUtils
           end
         end
 
-        attr_writer *attrs
+        attr_writer *config_attrs
       end
 
       # Define the runtime access methods
@@ -101,7 +109,7 @@ module SknUtils
         def configure(&block)
           config.instance_eval(&block)
         end
-        if _app_main
+        if _root_options
           # Enable Rails<Like>.env and Rails.logger like feature:
           # - MyClass.env.production? or MyClass.logger or MyClass.root
           def registry
@@ -128,6 +136,38 @@ module SknUtils
           def logger=(obj)
             @__logger = obj
           end
+
+          # Any Platform Database
+          def romDB
+            @__db ||= nil
+          end
+          def romDB(obj)
+            @__db = obj
+          end
+
+          # Maybe Platform Metadata
+          def metadata
+            @__metadata ||= nil
+          end
+          def metadata=(obj)
+            @__metadata = obj
+          end
+
+          # Userdata container for any use
+          def userdata
+            @__userdata ||= nil
+          end
+          def userdata=(obj)
+            @__userdata = obj
+          end
+
+          # Metrics container for any use
+          def metrics
+            @__metrics ||= nil
+          end
+          def metrics=(obj)
+            @__metrics = obj
+          end
         end
       end
 
@@ -142,3 +182,12 @@ module SknUtils
 
   end # end module
 end # End module
+
+#
+# def [](key)
+#   @internal_var[key]
+# end
+#
+# def []=(key, value)
+#   @internal_var[key] = value
+# end