wires 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40c67db203689c9ec0f32d844252da5fd125d0b6
-  data.tar.gz: 9d27b886a47150a99e68d1e10f7d0e9cc4550b31
+  metadata.gz: ed473de572f57451505cf39568dc498f6b2055fc
+  data.tar.gz: 6c6a3f80746359292cd22dd84c26c29b90957ef7
 SHA512:
-  metadata.gz: a3d64df40e1a6ae3e73a8534a9a2955df9462eae21ba54119ff4b9be1ba775fc1b490497b824c3030f75d32356fd05592f1cb86d4143c7a2492a672b4480d37e
-  data.tar.gz: b801be4fd8e4ad7d6d90a45575c5b865e052a3d11de7267db4f5c4fac3ea482b5e8e22b35e6db87bad5811eba6e3af2ff9ef564c802195a5a5e38f42648ebd74
+  metadata.gz: a2c40457ba7ecc2f8120e723fa3a3a13788ffd53c438b55d477c96f32336ec39c7a66cd7e08c7c0d27598c5725a205902e86866c725f5a99503d1aefa70765dd
+  data.tar.gz: d8e3993a55c2b6f4060d0ee1d7fd4df75af8a6ee64d0be1be40a8fc30d15d71fe26d5c18f927526cbaa6bb286d7520014fb674fb3c5606b913143c7c673533fe

data/lib/wires/hub.rb

@@ -14,17 +14,34 @@ module Wires
         @queue = Queue.new
         
         @child_threads      = Array.new
-        @child_threads_lock = Mutex.new
+        @child_threads_lock = Monitor.new
         
+        @before_runs = Queue.new
+        @after_runs  = Queue.new
         @before_kills = Queue.new
         @after_kills  = Queue.new
         
         @please_finish_all = false
         @please_kill       = false
         
+        @at_exit = Proc.new{nil}
+        at_exit do self.at_exit_proc end
+        
+        @fire_proc_alive = Proc.new do |x|
+          @queue << [x, Thread.current]
+          @thread.wakeup
+          sleep
+        end
+        @fire_proc_dead = Proc.new do |x|
+          @queue << [x, nil]
+        end
+        @fire_proc = @fire_proc_dead
+        
         state_machine_init
       nil end
       
+      def at_exit_proc;  @at_exit.call; end
+      
       # Make subclasses call class_init
       def inherited(subcls)
         subcls.class_init
@@ -37,7 +54,7 @@ module Wires
       # Start the Hub event loop (optional flags change thread behavior)
       #
       # valid flags:
-      # [+:blocking+] Hub event loop will be run in calling thread,
+      # [+:in_place+] Hub event loop will be run in calling thread,
       #               blocking until Hub is killed.  If this flag is not
       #               specified, the Hub event loop is run in a new thread, 
       #               which the main thread joins in at_exit.
@@ -45,9 +62,9 @@ module Wires
         request_state :alive until alive?
         
         # If :blocking, block now, else block at exit
-        (flags.include? :blocking)   ?
-          (join_hegemon_auto_thread) :
-          (at_exit { join_hegemon_auto_thread unless $! })
+        (flags.include? :in_place)   ?
+          (@thread.join) :
+          (@at_exit = Proc.new { @thread.join if @thread and not $! })
       end
       
       ##
@@ -62,6 +79,20 @@ module Wires
         block_until_state :dead if (flags.include? :blocking)
       nil end
       
+      # Register hook to execute before run - can call multiple times
+      def before_run(proc=nil, retain:false, &block)
+        func = (block or proc)
+        expect_type func, Proc
+        @before_runs << [func, retain]
+      nil end
+      
+      # Register hook to execute after run - can call multiple times
+      def after_run(proc=nil, retain:false, &block)
+        func = (block or proc)
+        expect_type func, Proc
+        @after_runs << [func, retain]
+      nil end
+      
       # Register hook to execute before kill - can call multiple times
       def before_kill(proc=nil, retain:false, &block)
         func = (block or proc)
@@ -78,13 +109,17 @@ module Wires
       
       # Put x in the queue, and block until x is processed (if Hub is running)
       def fire(x)
-        if not dead? # yield to event loop thread until awoken by it later
-          @queue << [x, Thread.current]
-          sleep
-        else        # don't wait if Hub isn't running - would cause lockup
-          @queue << [x, nil]
-        end
+        raise ThreadError, "You can't fire events from this thread." \
+          if Thread.current==@_hegemon_auto_thread \
+          or Thread.current==@thread
+        
+        @queue << [x, Thread.current]
+        (x[2] and @thread) ?
+          sleep            :
+          Thread.pass
+        
       nil end
+      # threadlock :fire, lock: :@child_threads_lock
       def <<(x); fire(x); end
       
       def flush_queue
@@ -94,7 +129,6 @@ module Wires
       
     private
       
-      
       # Flush/run queue of [proc, retain]s, retaining those with retain==true
       def run_hooks(hooks)
         retained = Queue.new
@@ -114,9 +148,9 @@ module Wires
         a_thread = Thread.new{nil}
         while a_thread
           @child_threads_lock.synchronize do
+            flush_queue
             a_thread = @child_threads.shift
           end
-          flush_queue if alive?
           a_thread.join if a_thread
           sleep 0 # Yield to other threads
         end
@@ -157,7 +191,6 @@ module Wires
           
           # Start the new child thread
           @child_threads << Thread.new do
-            waiting_thread.wakeup unless blocking or not waiting_thread
             proc.call(event)
             waiting_thread.wakeup if blocking and waiting_thread
           end
@@ -172,6 +205,19 @@ module Wires
     #***
     class << self
       include Hegemon
+      
+      # Protect Hub users methods that could cause deadlock
+      # if called from inside an event
+      private :state_obj,
+              :state_objs,
+              :request_state,
+              :update_state,
+              :do_state_tasks,
+              :iter_hegemon_auto_loop,
+              :start_hegemon_auto_thread,
+              :join_hegemon_auto_thread,
+              :end_hegemon_auto_thread
+      
       def state_machine_init
         
         impose_state :dead
@@ -179,16 +225,25 @@ module Wires
         declare_state :dead do
           
           transition_to :alive do
-            after { start_hegemon_auto_thread }
+            before { run_hooks @before_runs }
+            after  { run_hooks @after_runs }
+            after  { do_state_tasks }
+            after  { start_hegemon_auto_thread(0.1) }
+            # after  { @fire_proc = @fire_proc_alive }
           end
         end
         
         declare_state :alive do
           
-          task do
-            # puts "task #{Thread.current.inspect}"; 
-            if @queue.empty? then sleep(0)
-            else process_item(@queue.shift) end
+          task do |i|
+            
+            @thread = Thread.new do
+              while true
+                if @queue.empty? then sleep 0.1
+                else process_item(@queue.shift) end
+              end
+            end if i==0
+            
           end
           
           transition_to :dead do
@@ -198,11 +253,15 @@ module Wires
             
             before { join_children if @please_finish_all }
             
-            after  { run_hooks @after_kills  }
+            after  { @thread.kill; @thread = nil}
             
             after  { @please_kill = false }
             after  { @please_finish_all = false }
             
+            after  { run_hooks @after_kills }
+            
+            # after  { @fire_proc = @fire_proc_dead }
+            
             after  { end_hegemon_auto_thread }
             after  { do_state_tasks }
           end

data/lib/wires/time.rb

@@ -139,7 +139,6 @@ module Wires
       def main_loop
         
         @keepgoing = true
-        @thread = Thread.current
         pending = Array.new
         on_deck = nil
         
@@ -172,8 +171,8 @@ module Wires
     
     # Use fired event to only start scheduler when Hub is running
     # This also gets the scheduler loop its own thread within the Hub's threads
-    on :time_scheduler_start, self do; main_loop; end;
-    Channel.new(self).fire(:time_scheduler_start)
+    # on :time_scheduler_start, self do; main_loop; end;
+    # Channel.new(self).fire(:time_scheduler_start)
     
     # Stop the main loop upon death of Hub
     Hub.before_kill(retain:true) do 
@@ -183,8 +182,8 @@ module Wires
     end
     
     # Refire the start event after Hub dies in case it restarts
-    Hub.after_kill(retain:true) do 
-      Channel.new(self).fire(:time_scheduler_start)
+    Hub.after_run(retain:true) do 
+      @thread = Thread.new { main_loop }
     end
     
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wires
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Joe McIlvain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-07 00:00:00.000000000 Z
+date: 2013-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,34 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: threadlock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: hegemon
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement