tupelo 0.18 → 0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60516b564c0329a1544a913f4ec1680bd8308de8
-  data.tar.gz: 6aadbcc4c96e57d762d072e266ff921972f58578
+  metadata.gz: a8a67711763af58aa46979622519450ba198e603
+  data.tar.gz: fc399bd00b0b69ec5938a0d3ffae68155c186ae7
 SHA512:
-  metadata.gz: 75b24e537a78c831be55b389457a41fd527bf3fc88cb7e4dd358d03ecc492d439157ce28a3191ae86946c2df12a5ee5f74b5b388aebd8a9da57e0e1cc0af8386
-  data.tar.gz: 53a0848f5b3c30e091fc0bd0d58fced4703b77561099866b032e1d9f7c312a85da01d2a4066c2979f2632caa31a6c97466b21cf4319acca99308f4beddaa25d5
+  metadata.gz: 0f3570788a47744267fc361e25bd50b56bf327177764fb428317cb51ed1870c7e86acc8df53ef28d60278f9c902057b2a5275f86eba29189ea80f28259ddfc9f
+  data.tar.gz: 85a3be5a56f49d9518c2ed1409d992654e3f36f80847b441d7f4d84bf29afba541c11164c4052f97e208916e9a2a4cbf57aeef04736207160d4c6b4cd2d69e25

data/example/lease.rb

@@ -52,9 +52,8 @@ Tupelo.application do
   # one worker lives. This demonstrates how to recover from worker failure
   # and prevent "lost tuples".
   child passive: true do
-    require 'tupelo/client/atdo'
-
     scheduler = make_scheduler
+
     alive_until = Hash.new(0)
 
     loop do

data/example/observer.rb

@@ -32,6 +32,9 @@ Tupelo.application do
         counter = t.read count: Numeric
         log "entering new state: #{counter}"
         t.wait
+        # If you prefer to check for failure periodically, rather than
+        # blocking with #wait, then simply call t.failed? You can call
+        # t.missing to see which tuples caused the failure.
       rescue Tupelo::Client::TransactionFailure => ex
         log "leaving old state: #{counter}"
       end

data/example/riemann/event-subspace.rb

@@ -0,0 +1,60 @@
+class Tupelo::Client
+  def define_event_subspace
+    define_subspace("event", {
+    # field         type        description
+    #                           (from http://riemann.io/concepts.html)
+
+      host:         String,   # A hostname, e.g. "api1", "foo.com"
+
+      service:      String,   # e.g. "API port 8000 reqs/sec"
+
+      state:        String,   # Any string less than 255 bytes, e.g. "ok",
+                              # "warning", "critical"
+
+      time:         Numeric,  # The time of the event, in unix epoch seconds
+
+      description:  String,   # Freeform text
+
+      tags:         Array,    # Freeform list of strings,
+                              # e.g. ["rate", "fooproduct", "transient"]
+
+      metric:       Numeric,  # A number associated with this event,
+                              # e.g. the number of reqs/sec.
+
+      ttl:          Numeric,  # A floating-point time, in seconds, that this
+                              # event is considered valid for. Expired states
+                              # may be removed from the index.
+
+      custom:       nil       # Any data
+                              # (not quite same as riemann's custom event attrs,
+                              # which are just arbitrary key-value pairs;
+                              # tupelo does not permit wildcards in keys)
+    })
+  end
+
+  # This could be a subspace of the event subspace, but for now, we can just
+  # use it as a template to select critical events out of the event subspace.
+  CRITICAL_EVENT = {
+    host:         nil,
+    service:      nil,
+    state:        /\A(?:critical|fatal)\z/i,
+    time:         nil,
+    description:  nil,
+    tags:         nil,
+    metric:       nil,
+    ttl:          nil,
+    custom:       nil
+  }.freeze
+
+  EXPIRED_EVENT = {
+    host:         nil,
+    service:      nil,
+    state:        /\Aexpired\z/i,
+    time:         nil,
+    description:  nil,
+    tags:         nil,
+    metric:       nil,
+    ttl:          nil,
+    custom:       nil
+  }.freeze
+end

data/example/riemann/expirer-v1.rb

@@ -0,0 +1,25 @@
+class Tupelo::Client
+  # Expire old events.
+  def run_expirer_v1
+    scheduler = make_scheduler
+    
+    read subspace("event") do |event|
+      next if event["state"] == "expired"
+
+      event_exp = event["time"] + event["ttl"]
+      scheduler.at event_exp do
+        transaction do
+          take event
+          pulse event.merge("state" => "expired")
+            # Not sure if this is riemann semantics. Using #pulse rather
+            # that #write means that the expired event exists in the
+            # space only while the transaction is executing, but that is
+            # enough to trigger any client that is waiting on a template
+            # that matches the event. Use the --debug-expiration switch
+            # to see this happening (and use -v to make log messages
+            # verbose, showing timestamps).
+        end
+      end
+    end
+  end
+end

data/example/riemann/producer.rb

@@ -0,0 +1,32 @@
+class Tupelo::Client
+  # Generate some events.
+  def run_producer i
+    event = {
+      host:         `hostname`.chomp,
+      service:      "service #{i}",
+      state:        "",
+      time:         0,
+      description:  "",
+      tags:         [],
+      metric:       0,
+      ttl:          0,
+      custom:       nil
+    }.freeze
+
+    e_ok = event.merge(
+      state:    "ok",
+      time:     Time.now.to_f,
+      ttl:      0.2
+    )
+
+    if e_ok[:ttl] == 0.0
+      pulse e_ok # no need to bother with expiration
+    else
+      write e_ok
+    end
+    
+    log "created event #{e_ok}"
+    
+    sleep 0.5 # Let it expire
+  end
+end

data/example/riemann/riemann-v1.rb

@@ -0,0 +1,61 @@
+# A toy implementation of Riemann (http://riemann.io).
+#
+# Version 1 uses the default tuplespace for all subspaces, which is inefficient
+# for searching.
+
+require 'tupelo/app'
+require_relative 'event-subspace'
+require_relative 'producer'
+require_relative 'expirer-v1'
+
+N_PRODUCERS = 3
+N_CONSUMERS = 2
+
+Tupelo.application do
+
+  local do
+    use_subspaces!
+    define_event_subspace
+  end
+
+  N_PRODUCERS.times do |i|
+    child subscribe: [] do # N.b., no subscriptions
+      log.progname = "producer #{i}"
+      run_producer i
+    end
+  end
+
+  N_CONSUMERS.times do |i|
+    # stores events
+    child subscribe: "event", passive: true do
+      log.progname = "consumer #{i}"
+      read subspace("event") do |event|
+        log event ### need filtering, actions, etc.
+      end
+    end
+  end
+  
+  # critical event alerter
+  child subscribe: "event", passive: true do
+    log.progname = "alerter"
+    read Tupelo::Client::CRITICAL_EVENT do |event|
+      log.error event
+    end
+  end
+
+  if argv.include?("--debug-expiration")
+    # expired event debugger
+    child subscribe: "event", passive: true do
+      log.progname = "expiration debugger"
+      read Tupelo::Client::EXPIRED_EVENT do |event|
+        log event
+      end
+    end
+  end
+
+  # expirer: stores current events and looks for events that can be expired.
+  child subscribe: "event", passive: true do
+    log.progname = "expirer"
+    run_expirer_v1
+  end
+end

data/example/riemann/riemann-v2.rb

@@ -0,0 +1,72 @@
+# A toy implementation of Riemann (http://riemann.io).
+#
+# Version 2 stores the event subspace using different data
+# structures in different clients, depending on needs:
+#
+#   * generic consumers need to index by host and service
+#
+#   * the expiration manager need to sort by expiration time
+#
+#   * the critical event alerter doesn't need to sort at all.
+
+abort "work in progress"
+
+require 'tupelo/app'
+require_relative 'event-subspace'
+require_relative 'producer'
+require_relative 'expirer-v2'
+
+N_PRODUCERS = 3
+N_CONSUMERS = 2
+
+Tupelo.application do
+
+  local do
+    use_subspaces!
+    define_event_subspace
+  end
+
+  N_PRODUCERS.times do |i|
+    child subscribe: [] do # N.b., no subscriptions
+      log.progname = "producer #{i}"
+      run_producer i ### V2: manual tagging
+    end
+  end
+
+  N_CONSUMERS.times do |i|
+    # stores events indexed by host, service
+    child subscribe: "event", passive: true do ### tuplespace: sqlite
+      log.progname = "consumer #{i}"
+      read subspace("event") do |event|
+        log event ### need filtering, actions, etc.
+      end
+    end
+  end
+  
+  # critical event alerter
+  child subscribe: "event", passive: true do ### tuplespace: bag?
+    log.progname = "alerter"
+    read Tupelo::Client::CRITICAL_EVENT do |event|
+      log.error event
+    end
+  end
+
+  if argv.include?("--debug-expiration")
+    # expired event debugger
+    child subscribe: "event", passive: true do
+      log.progname = "expiration debugger"
+      read Tupelo::Client::EXPIRED_EVENT do |event|
+        log event
+      end
+    end
+  end
+
+  # expirer: stores current events and looks for events that can be expired.
+  child subscribe: "event", passive: true do
+    log.progname = "expirer"
+    run_expirer_v2
+    ### use rbtree
+  end
+  
+  ### Add sinatra app.
+end

data/lib/tupelo/client/scheduler.rb

@@ -0,0 +1,56 @@
+require 'atdo'
+
+module Tupelo
+  class Client
+    class Scheduler < AtDo
+      DEFAULT_STORAGE =
+        begin
+          require 'rbtree'
+          MultiRBTree
+        rescue LoadError
+          Array
+        end
+
+      # Instead of calling this method, call Client#make_scheduler.
+      def initialize client, **opts
+        @client = client
+        super **opts
+      end
+
+      # Accepts numeric +time+ or Time instance. Logs errors that occur
+      # in +action+. Otherwise, same as AtDo#at from the atdo gem.
+      def at time, &action
+        time = Time.at(time) if time.kind_of? Numeric
+        super time do
+          begin
+            action.call
+          rescue => ex
+            @client.log.error "error in action scheduled for #{time}:" +
+              " #{ex.class}: #{ex}\n  #{ex.backtrace.join("\n  ")}"
+          end
+        end
+      end
+    end
+
+    # Returns a scheduler, which has a method that you can call to schedule
+    # an action at a time:
+    #
+    #   s = make_scheduler # or client.make_scheduler
+    #   s.at t do ... end
+    #
+    # where t can be either a Time or Numeric seconds.
+    #
+    # The scheduler runs in its own thread. It uses a red-black tree to store
+    # the actions, if the rbtree gem is installed and you do not specify
+    # 'storage: Array'. Otherwise it uses a sorted Array, which is fine for
+    # small schedules.
+    #
+    # Scheduler is used internally by Worker to manage transaction timeouts,
+    # but client code may create its own scheduler -- see example/lease.rb.
+    #
+    def make_scheduler **opts
+      opts[:storage] ||= Scheduler::DEFAULT_STORAGE
+      Scheduler.new self, **opts
+    end
+  end
+end

data/lib/tupelo/client/worker.rb

@@ -1,8 +1,8 @@
 require 'thread'
 require 'tupelo/client/reader'
 require 'tupelo/client/transaction'
+require 'tupelo/client/scheduler'
 require 'object-template'
-require 'atdo'
 
 class Tupelo::Client
   class Worker
@@ -70,6 +70,7 @@ class Tupelo::Client
       @seq = nil
       @arc = nil
       @log = client.log
+      @scheduler = nil
 
       @client_id = nil
       @global_tick = nil
@@ -142,19 +143,19 @@ class Tupelo::Client
       cmd_queue << :stop
       worker_thread.join if worker_thread ## join(limit)?
       msg_reader_thread.kill if msg_reader_thread
-      @atdo.stop if @atdo
+      @scheduler.stop if @scheduler
     end
 
     # stop without any remote handshaking
     def stop!
       @msg_reader_thread.kill if msg_reader_thread
       @worker_thread.kill if worker_thread
-      @atdo.stop if @atdo
+      @scheduler.stop if @scheduler
     end
 
     def at time, &action
-      @atdo ||= AtDo.new
-      @atdo.at time do
+      @scheduler ||= client.make_scheduler
+      @scheduler.at time do
         cmd_queue << action
       end
     end

data/lib/tupelo/version.rb

@@ -1,3 +1,3 @@
 module Tupelo
-  VERSION = "0.18"
+  VERSION = "0.19"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tupelo
 version: !ruby/object:Gem::Version
-  version: '0.18'
+  version: '0.19'
 platform: ruby
 authors:
 - Joel VanderWerf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-25 00:00:00.000000000 Z
+date: 2014-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atdo
@@ -145,6 +145,11 @@ files:
 - example/pulse.rb
 - example/read-in-trans.rb
 - example/remote.rb
+- example/riemann/event-subspace.rb
+- example/riemann/expirer-v1.rb
+- example/riemann/producer.rb
+- example/riemann/riemann-v1.rb
+- example/riemann/riemann-v2.rb
 - example/small-simplified.rb
 - example/small.rb
 - example/socket-broker.rb
@@ -153,7 +158,6 @@ files:
 - example/subspaces/addr-book.rb
 - example/subspaces/pubsub.rb
 - example/subspaces/ramp.rb
-- example/subspaces/riemann.rb
 - example/subspaces/shop/shop-v1.rb
 - example/subspaces/shop/shop-v2.rb
 - example/subspaces/simple.rb
@@ -186,9 +190,9 @@ files:
 - lib/tupelo/archiver/tuplespace.rb
 - lib/tupelo/archiver/worker.rb
 - lib/tupelo/client.rb
-- lib/tupelo/client/atdo.rb
 - lib/tupelo/client/common.rb
 - lib/tupelo/client/reader.rb
+- lib/tupelo/client/scheduler.rb
 - lib/tupelo/client/subspace.rb
 - lib/tupelo/client/transaction.rb
 - lib/tupelo/client/tuplespace.rb

data/example/subspaces/riemann.rb

@@ -1,103 +0,0 @@
-# A toy implementation of Riemann (http://riemann.io)
-#
-# Also, this is an example of storing a subspace using different data
-# structures in different clients, depending on needs: some clients (generic
-# consumers) need to index by host and service, and others (expiration manager)
-# need to sort by expiration time.
-
-require 'tupelo/app'
-
-N_PRODUCERS = 3
-N_CONSUMERS = 2
-
-Tupelo.application do
-
-  local do
-    use_subspaces!
-
-    define_subspace("event", {
-    # field         type        description
-    #                           (from http://riemann.io/concepts.html)
-
-      host:         String,   # A hostname, e.g. "api1", "foo.com"
-
-      service:      String,   # e.g. "API port 8000 reqs/sec"
-
-      state:        String,   # Any string less than 255 bytes, e.g. "ok",
-                              # "warning", "critical"
-
-      time:         Numeric,  # The time of the event, in unix epoch seconds
-
-      description:  String,   # Freeform text
-
-      tags:         Array,    # Freeform list of strings,
-                              # e.g. ["rate", "fooproduct", "transient"]
-
-      metric:       Numeric,  # A number associated with this event,
-                              # e.g. the number of reqs/sec.
-
-      ttl:          Numeric   # A floating-point time, in seconds, that this
-                              # event is considered valid for. Expired states
-                              # may be removed from the index.
-    })
-  end
-
-  N_PRODUCERS.times do
-    child subscribe: [] do # N.b., no subscriptions
-      event = {
-        host:         `hostname`.chomp,
-        service:      "service #{client_id}", # placeholder
-        state:        "",
-        time:         0,
-        description:  "",
-        tags:         [],
-        metric:       0,
-        ttl:          0
-      }.freeze
-
-      e_ok = event.merge(
-        state:    "ok",
-        time:     Time.now.to_f,
-        ttl:      1.0
-      )
-
-      if e_ok[:ttl] == 0.0
-        pulse e_ok # no need to bother with expiration
-      else
-        write e_ok
-      end
-    end
-  end
-
-  N_CONSUMERS.times do
-    # stores events indexed by host, service
-    child subscribe: "event", passive: true do ### tuplespace: sqlite
-      read subspace("event") do |event|
-        log event ### need filtering, actions, etc.
-      end
-    end
-  end
-  
-  # This could be a subspace of the event subspace.
-  critical_event = {
-    host:        nil,
-    service:     nil,
-    state:       /critical|fatal/i,
-    time:        nil,
-    description: nil,
-    tags:        nil,
-    metric:      nil,
-    ttl:         nil
-  }
-  
-  child subscribe: "event", passive: true do
-    read critical_event do |event|
-      log.error event
-    end
-  end
-
-  # expirer: stores current events in expiration order
-  child subscribe: "event", passive: true do
-    ### use rbtree
-  end
-end

data/lib/tupelo/client/atdo.rb

@@ -1,31 +0,0 @@
-require 'tupelo/client'
-require 'atdo'
-
-module Tupelo
-  class Client
-    class AtDo < ::AtDo
-      def initialize client, **opts
-        @client = client
-        super **opts
-      end
-
-      # Accepts numeric +time+. Logs errors in +action+. Otherwise, same
-      # as ::AtDo.
-      def at time, &action
-        time = Time.at(time) if time.kind_of? Numeric
-        super time do
-          begin
-            action.call
-          rescue => ex
-            @client.log.error "error in action scheduled for #{time}:" +
-              " #{ex.class}: #{ex}\n  #{ex.backtrace.join("\n  ")}"
-          end
-        end
-      end
-    end
-    
-    def make_scheduler **opts
-      AtDo.new self, **opts
-    end
-  end
-end