errands 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a781f76605abb3a1044de0fe07eeb8239e747f17
-  data.tar.gz: 24ab0e0c763815f8250ba72ebf8a72c98eee9ec0
+  metadata.gz: 0b3ec45541ab232b30e76994f6f9e157e6ce0090
+  data.tar.gz: fab0fe7273f9ac5617597da2a114bbc4c1fceb05
 SHA512:
-  metadata.gz: 0f2c8a6784b251e01f897004db3249c606ae129e421d7137481789732d9690a5a5384df3f559324ef01f7a2acba78a37b4b191eff432c147a7555adc95993c2b
-  data.tar.gz: 8faf6c10f519130311a048d71d0b0c80a30d6e8a69bdca20cb8a4429b7cd13d0d5f265bebd5388622b433801841fbc2f2172873bb9f672cd3aa63217b4d6bbf9
+  metadata.gz: 8fc4027f696fc7b287b34f2fed5e9159ad7548c16ba9bfedd95e4a66854c854bde830b54dbc0c8ab2a0cc1b1317a3ed839e376974058b522a31046969ccccf14
+  data.tar.gz: 674b812a10089f7d5829fb2f1a53f633c648270a361f4a160f4fb51863cfc6d6164e6ba2e2d629db720a7a156ad726f2849032d7c51e12e160f5397cfb812931

data/lib/errands/alternate_private_access.rb

@@ -0,0 +1,51 @@
+module Errands
+
+  module AlternatePrivateAccess
+
+    def self.included(singleton)
+      class << singleton
+        attr_accessor :errands_store
+      end
+    end
+
+    def self.extended(klass)
+      class << klass
+        attr_accessor :errands_store
+      end
+    end
+
+    def set_store(store)
+      singleton_class.errands_store = store
+    end
+
+    private
+
+    def our_store!(h = nil)
+      (Thread.main[singleton_class.errands_store] = h || {}).tap do |store|
+        if t = store[:threads]
+          t.singleton_class.include AlternatePrivateAccess
+          t.singleton_class.errands_store = singleton_class.errands_store
+        end
+
+        if r = Thread.main[singleton_class.errands_store][:receptors]
+          r.singleton_class.include AlternatePrivateAccess
+          r.singleton_class.errands_store = singleton_class.errands_store
+
+          def r.default(key)
+            self[key] = Errands::Receptors::Receptor.new(key).tap do |v|
+              v.singleton_class.include Errands::AlternatePrivateAccess
+              v.singleton_class.errands_store = singleton_class.errands_store
+            end
+          end
+        end
+
+      end
+    end
+
+    def our
+      singleton_class.errands_store && Thread.main[singleton_class.errands_store]
+    end
+
+  end
+
+end

data/lib/errands/runner.rb

@@ -1,178 +1,363 @@
 module Errands
 
-  module Runner
+  module ThreadAccessor
 
-    module ThreadAccessors
+    def self.extended(klass)
+      klass.include PrivateAccess
+    end
 
-      def thread_accessors(*accessors)
-        accessors.each do |a|
-          define_method a, -> { our[a] }
-        end
+    def thread_accessor(*accessors)
+      accessors.each do |a|
+        define_method a, -> { our[a] }
+        define_method "#{a}=", ->(v) { our[a] = v }
+      end
+    end
+
+    module PrivateAccess
+
+      def err(h = {})
+        his_store! Thread.current, h
+      end
+
+      private
+
+      def our_store!(h = nil)
+        Thread.main[:errands] = h || {}
+      end
+
+      def his_store!(thread, h = nil)
+        thread[:errands] = h || {}
+      end
+
+      def my
+        Thread.current[:errands]
+      end
+
+      def his(thread)
+        thread[:errands]
+      end
+
+      def our
+        Thread.main[:errands]
       end
 
     end
 
-    class ImplementationError < StandardError; end
+  end
+
+  module Started
+
+    def start(*_)
+      new(*_).tap &:start
+    end
 
-    %w|job process|.each do |m|
-      define_method m do |*_|
-        raise method(__method__).owner::ImplementationError,
-          "#{__method__} has to be implemented in client class"
+    def run(*_)
+      new(*_).tap do |e|
+        Process.daemon if (callee = __callee__) == :daemon
+        startups << define_method(:startups_alternate_run) { { callee => true } } if __callee__ != __method__
+        e.run
       end
     end
 
-    def self.included(klass)
-      klass.extend ThreadAccessors
+    alias_method :daemon, :run
+    alias_method :threaded_run, :run
+    alias_method :noop_run, :run
+
+    def started_workers(*_)
+      (@started_workers ||= [:worker]).concat _.map(&:to_sym).flatten
     end
 
-    attr_accessor :running_mode
+    def startups
+      @startups ||= []
+    end
 
-    def run(options = startup)
-      start options
-      our[:events] = []
+    private
+
+    def default_workers(*_)
+      started_workers(*_).tap { |s| s.delete :worker }
+    end
 
-      loop do
-        errands *our[:events].shift if our[:events].any?
+  end
+
+  class Receptors < Hash
+
+    class Receptor < Array
+
+      module Track
+
+        def track(v, r = nil)
+          v.__send__ "instance_variable_#{r ? :set : :get}", *["@receptor_track", r].compact
+        rescue => e
+          my.merge!(data: v, error: :tracking_error)
+          raise e
+        end
+
+      end
+
+      include ThreadAccessor::PrivateAccess
+      include Track
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def shift(*_)
+        my[:data] = super.tap { |value| my.merge! receptor_track: track(value), latency: empty? }
+      end
+
+      def <<(value)
+        return if value.nil?
+        track value, my[:receptor_track]
+        super.tap { our[:threads][@name] && our[:threads][@name].run }
       end
+
     end
 
-    def start(options = startup)
-      our.merge! options
-      starter
+    def default(key)
+      self[key] = Receptor.new key
+    end
+
+  end
+
+  class Runners < Hash
+
+    include ThreadAccessor::PrivateAccess
+
+    def [](k)
+      v = super
+      v if v && v.alive?
     end
 
-    def my
-      Thread.current[:runner] ||= {}
+    def []=(k, v)
+      our[k] = super if v.is_a? Thread
     end
 
-    def his(t, k, v = nil)
-      t[:runner] ||= {}
-      v ? t[:runner][k] = v : t[:runner][k]
+    def delete(k)
+      our.delete k
+      super
     end
 
-    def our
-      Thread.main[:runner] ||= {}
+    def stopping_order(all = false)
+      scope(:type, :starter).merge(scope(:type, :data_acquisition)).merge all ? self : {}
     end
 
-    def starter
-      running do
-        loop do
-          if secure_check :worker, :alive?
-            sleep 1
-          else
-            secure_check :worker, :join
-            worker
-          end
-        end
+    def key_sliced(*list)
+      select_keys = keys & list.flatten
+      typecast select { |k, v| select_keys.include? k }
+    end
 
-        errands :stop, :starter
-      end
+    def alive
+      typecast select { |k, v| self[k] }
+    end
+
+    def scope(s, value = true)
+      typecast select { |k, v| his(v)[s] == value }
+    end
+
+    private
+
+    def typecast(h)
+      self.class.new.merge! h
     end
 
+  end
+
+  module LousyCompat
+
     def worker
-      our[:work_done] = false
-
-      running do
-        loop do
-          begin
-            (our[:work_done] = true) && break if work_done?
-            process job
-            sleep our[:frequency] if our[:frequency]
-          rescue => e
-            log_error e
-          end
-        end
+      working :worker, :process, :job
+    end
+
+  end
+
+  module Runner
+
+    def self.included(klass)
+      klass.extend(ThreadAccessor).extend(Started)
+      klass.thread_accessor :events, :receptors, :threads
+    end
+
+    attr_accessor :running_mode
+
+    def start(options = startups)
+      our_store! options.merge(threads: Runners.new, receptors: Receptors.new)
+      starter
+    end
+
+    def run(options = startups)
+      start options unless started?
+      our.merge! events: receptors[:events]
+      our[:threaded_run] || our[:noop_run] ? running { main_loop } : main_loop
+    end
+
+    def starter(*_)
+      if our[:starter]
+        self.class.started_workers *_
+      elsif !our[:noop_run]
+        starting self.class.started_workers
+      end
+    end
+
+    def starting(started)
+      puts ["Starting #{self.class} with :", our[:config], "workers : #{started}", "\n"].join("\n") unless our[:quiet]
 
-        our[:work_done] && work_done
-        errands :stop, :worker
+      running thread_name, loop: true, started: started, type: :starter do
+        Array(my[:started]).uniq.each { |s| threads[s] ||= send *(respond_to?(s, true) ? [s] : [:working, s]) }
+        sleep frequency || 1
       end
     end
 
-    def stop(threads = nil)
-      our_selection(threads || our[:threads]) do |n, t|
-        if Thread.current == t
-          errands :stop, n
-        else
-          t.exit
-          t.join
-          wait_for n, :status, false
+    def working(*_)
+      work_done, processing, data_acquisition = working_jargon *_
+      our[work_done] = false
+
+      running _.first, loop: true, type: :data_acquisition do
+        unless my[:stop] ||= our[work_done] = checked_send("#{work_done}?")
+          r = ready_receptor! processing
+          ((r << send(data_acquisition)) && !my[:latency]) || sleep(frequency.to_i)
         end
       end
+    end
 
-      our[:stopped] = !status.values.any? { |t| t.alive? }
+    def exit_on_stop
+      stop
+      exit
     end
 
-    def status
-      our_selection our[:threads]
+    def stop(*_)
+      [false, true].each do |all|
+        list = threads.key_sliced(_.any? ? _ : stopped_threads)
+        list.alive.each { |n, t| his(t)[:stop] = true }
+        list.stopping_order(all).alive.each { |n, t| exiting(n, !all || t.stop?) }
+      end
+
+      stopped?
+      threads.key_sliced(_.any? ? _ : stopped_threads).alive.empty?
     end
 
     def status
-      our_selection our[:threads]
+      {}.tap { |s| threads.each { |name, t| s[name] = t.status } }
     end
 
     def wait_for(key, meth = nil, result = true)
-      loop do
-        break if meth && our[key].respond_to?(meth) ?
-          our[key].send(meth) == result :
-          !!our[key] == result
-      end
+      time = Time.now.to_f
+      loop {
+        break if @errands_wait_timeout && Time.now.to_f - time > @errands_wait_timeout
+        break if meth && our[key].respond_to?(meth, true) ?
+          ((our[key].send(meth) == result) rescue nil) :
+          !!our[key] == result }
+    end
+
+    def stopped?
+      our[:stopped] = threads.key_sliced(stopped_threads).alive.empty?
     end
 
-    def work_done?
-      false
+    def started?
+      !!our && !!threads && our[:started] = !stopped?
     end
 
     private
 
-    def our_selection(selection)
-      our.dup.select do |k, v|
-        Array(selection).include?(k).tap { |bool|
-          yield k, our[k] if bool && block_given?
-        }
+    def frequency(name = nil)
+      our[:config] && our[:config][:frequencies] && our[:config][:frequencies][name || my[:name]]
+    end
+
+    def main_loop
+      rescued_loop do
+        (e = events.shift) ? errands(*e) : sleep(frequency(:main_loop) || 1)
       end
     end
 
-    def errands(errand, *_)
-      name = thread_name(1).to_s << "_#{errand}"
+    def ready_receptor!(processing)
+      receptors[processing].tap { threads[processing] ||= spring processing }
+    end
 
-      running name.to_sym do
-        send errand, *_
-        our[:threads].delete my[:name]
+    def spring(processing)
+      running processing, loop: true, deletable: true do
+        data = receptors[my[:name]].shift || Thread.stop || receptors[my[:name]].shift
+        data && send(processing, data).tap do |r|
+          if my[:receptor_track] && my[:receptor_track][:receptor].name != my[:name]
+            my[:receptor_track][:receptor] << my[:receptor_track].merge(result: r).reject { |k, v| k == :receptor }
+          end
+        end
       end
     end
 
-    def running(name = nil, &block)
+    def errands(errand, *_)
+      running("#{thread_name(1)}_#{errand}".to_sym, deletable: true) { send errand, *_ }
+    end
+
+    def running(name = thread_name, options = {}, &block)
       if @running_mode
         send @running_mode, &block
       else
-        register_thread name || thread_name, Thread.new(&block)
+        threads[name] = Thread.new {
+          (my && my[:name] && (my[:named] = true)) || Thread.stop || (my[:named] = true)
+          r = my[:result] = my[:loop] ? rescued_loop(&block) : block.call
+          ["stop_#{name}", our[name] && "stop_#{his(our[name])[:type]}"].compact.each { |s| checked_send s }
+          my[:deletable] && threads.delete(name)
+          r
+        }.tap { |t|
+          his_store! t, { name: name, time: Time.now.to_f, stop: false, type: :any, receptor_track: my && my.delete(:receptor_track) }.merge(options)
+          t.run unless his(t)[:named]
+        }
       end
     end
 
+    def exiting(name, force = true)
+      force && Thread.current == our[name] ? errands(:exiting, name) : our[name] && (force || our[name].stop?) && our[name].exit
+      wait_for name, :alive?, false
+    end
+
+    def stopped_threads
+      our[:stopped_threads] || threads.keys.reject { |k| k.to_s =~ /^errands_.+_stop$/}
+    end
+
     def thread_name(caller_depth = 2)
       caller_locations(caller_depth, 1).first.base_label.dup.tap { |n|
         n << "_" << Time.now.to_f.to_s.sub('.', '_') if n.end_with? 's'
       }.to_sym
     end
 
-    def register_thread(name, thread)
-      ((our[:threads] ||= []) << name).uniq!
-      his our[name] = thread, :name, name
+    def rescued_loop
+      loop { our["#{my[:name]}_iteration".to_sym] = begin
+        my[:stop] ? break : yield; Time.now
+      rescue => e
+        log_error e, my[:data], my
+      end }
+    end
+
+    def checked_send(meth, recipient = self, *_)
+      recipient.respond_to?(meth, true) && (recipient.send(meth, *_) rescue nil)
     end
 
-    def secure_check(name, meth)
-      our[name] && our[name].respond_to?(meth) && our[name].send(meth)
+    def working_jargon(started, processing = nil, data_acquisition = nil)
+      [ "#{started}_done".to_sym,
+        processing || "#{started}_process".to_sym,
+        data_acquisition || "#{started}_data_acquisition".to_sym ]
     end
 
-    def log_error(e)
-      puts e.message
+    def log_error(e, data, *_)
+      puts(e) || puts(e.message) || puts(data) || puts(e.backtrace) || puts(_) if our[:verbose]
     end
 
-    def startup
-      {}
+    def startups
+      self.class.startups
+        .dup
+        .tap { |s| s << :startup if respond_to?(:startup, true) }
+        .uniq
+        .inject({}) { |s, m| extended_merge(s, __send__(m)) }
     end
 
-    def work_done; end
+    def extended_merge(from, to)
+      from.tap do |f|
+        to.keys.each do |k|
+          f[k] = f[k].is_a?(Hash) && to[k].is_a?(Hash) ? extended_merge(f[k], to[k]) : to[k]
+        end
+      end
+    end
 
   end
 

data/lib/errands/test_helpers/wrapper.rb

@@ -0,0 +1,122 @@
+require 'errands/alternate_private_access'
+
+module Errands
+
+  module TestHelpers
+
+    module OurStore
+
+      def initialize(*_)
+        s = if _.size == 1 && _.first.is_a?(Hash)
+          _.first.delete(:startup).tap { _.pop if _.first.empty? }
+        elsif _.last.is_a?(Hash)
+          _.pop[:startup]
+        end
+
+        our_store! (s.is_a?(Hash) ? s : send(s)) || {}
+
+        super
+      end
+
+    end
+
+    module ResetStartedWorkers
+
+      def reset_started_workers
+        @started_workers = nil
+      end
+
+    end
+
+    module StopAll
+
+      def stopped_threads
+        threads.keys.reject { |k| k.to_s =~ /^errands_.+_stop$/}
+      end
+
+    end
+
+    class Wrapper
+
+      class Vanilla
+
+        extend ThreadAccessor::PrivateAccess
+
+        class << self
+
+          def theirs
+            our
+          end
+
+        end
+
+      end
+
+      include Errands::AlternatePrivateAccess
+
+      def self.helper
+        @instance = new
+      end
+
+      def self.help(helped, options = {}, &block)
+        helper
+        #~ @instance.theirs_reset! unless options[:reset] == false
+        @instance.help helped, &block
+      end
+
+      def initialize
+        set_store :errands_test
+        our_store!
+      end
+
+      def theirs
+        Vanilla.theirs
+      end
+
+      def help(helped)
+        (our[:helped] = helped).tap do |i|
+          i.instance_variable_set '@errands_wait_timeout', 10
+          i.start unless i.started?
+          yield i if block_given?
+        end
+      end
+
+      def helped(i = nil)
+        i ? our[:helped] = i : our[:helped]
+      end
+
+      def push_event(e)
+        theirs && theirs[:events] && theirs[:events] << e
+      end
+
+      def theirs_reset!
+        theirs && theirs.clear
+      end
+
+      def self.after
+        threads_cleanup
+
+        if @instance
+          @instance.stop_helped if @instance.helped
+          @instance.theirs_reset!
+        end
+
+        @instance = nil
+      end
+
+      def self.threads_cleanup
+        while (t = Thread.list.select { |t| t[:errands] } - [Thread.main]).any?
+          t.each &:exit
+        end
+      end
+
+      def stop_helped
+        helped.stop
+        helped.wait_for :stopped
+      end
+
+    end
+
+  end
+
+end

data/lib/errands/version.rb

@@ -1,3 +1,3 @@
 module Errands
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: errands
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - lacravate
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-15 00:00:00.000000000 Z
+date: 2018-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -61,7 +61,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/errands.rb
+- lib/errands/alternate_private_access.rb
 - lib/errands/runner.rb
+- lib/errands/test_helpers/wrapper.rb
 - lib/errands/version.rb
 homepage: https://github.com/lacravate/errands
 licenses: []