tupelo 0.21 → 0.22

data/example/bingo/bingo-v2.rb

@@ -1,20 +0,0 @@
-
-__END__
-  # dealer
-  child passive: true do
-    loop do
-      # transaction -- add to v2
-      _, player_id = take ["buy", nil]
-      
-    end
-  end
-  
-  # player -- in v3 use subspace per player
-end
-
-## how to buy 4 without increasing contention risk
-
-## reduce contention for cards by randomizing or cons. hashing?
-
- ## swapping these lines -> more contention?
- 

data/example/broker-queue.rb

@@ -1,35 +0,0 @@
-# more like how you would do it in redis, except that the queue is not stored in
-# the central server, so operations on it are not a bottleneck, FWIW
-
-require 'tupelo/app'
-
-N_PLAYERS = 10
-
-Tupelo.application do
-  N_PLAYERS.times do
-    # sleep rand / 10 # reduce contention -- could also randomize inserts
-    child do
-      me = client_id
-      write name: me
-      
-      you = transaction do
-        game = read_nowait(
-          player1: nil,
-          player2: me)
-        break game["player1"] if game
-      
-        unless take_nowait name: me
-          raise Tupelo::Client::TransactionFailure
-        end
-
-        you = take(name: nil)["name"]
-        write(
-          player1: me,
-          player2: you)
-        you
-      end
-
-      log "now playing with #{you}"
-    end
-  end
-end

data/example/child-of-child.rb

@@ -1,34 +0,0 @@
-require 'tupelo/app'
-
-### need a programmatic way to start up clients
-
-Tupelo.application do |app|
-
-  app.child do ## local still hangs
-    3.times do |i|
-      app.child do
-        write [i]
-        log "wrote #{i}"
-      end
-    end
-
-    3.times do
-      log take [nil]
-    end
-  end
-end
-
-__END__
-
-this hangs sometimes but not always:
-
-  tick    cid status operation
-A: client 3: wrote 0
-A: client 4: wrote 1
-     1      3        batch write [0]
-     2      4        batch write [1]
-A: client 2: [0]
-     3      2        atomic take [0]
-     4      2        atomic take [1]
-A: client 2: [1]
-A: client 5: wrote 2

data/example/dataflow.rb

@@ -1,21 +0,0 @@
-# http://slashdot.org/topic/bi/how-is-reactive-different-from-procedural-programming
-# http://developers.slashdot.org/story/14/01/13/2119202/how-reactive-programming-differs-from-procedural-programming
-# bud and bloom
-
-# TODO: DSL for expressing data dependency relations
-
-require 'tupelo/app'
-
-N_WORKERS = 2
-
-Tupelo.application do
-  N_WORKERS.times do
-    child passive: true do
-      
-    end
-  end
-
-  local do
-    #write 
-  end
-end

data/example/pregel/dist-opt.rb

@@ -1,15 +0,0 @@
-#
-# Minor optimization:
-
-class KeyMatcher
-  def initialize i, n
-    @i = i
-    @n = n
-  end
-
-  def === id
-    id % @n == @i
-  end
-end
-
-vertex = take id: v_id_matcher, step: step, rank: nil, active: true

data/example/riemann/v2/event-sql.rb

@@ -1,56 +0,0 @@
-require 'sequel'
-
-    @db = Sequel.sqlite
-    @db.create_table :events do
-      primary_key   :id # id is not significant to our app
-      text          :host, null: false ## need this ?
-      text          :service, null: false
-      text          :state
-      number        :time
-      text          :description
-      number        :metric
-      number        :ttl
-
-      index         [:host, :service]
-    end
-
-    @db.create_table :tags do
-      foreign_key   :event_id, :events
-      text          :tag
-      index         :tag
-      primary_key   [:event_id, :tag]
-    end
-
-    @db.create_table :customs do
-      foreign_key   :event_id, :events
-      text          :key
-      text          :value
-      index         :key
-      primary_key   [:event_id, :key]
-    end
-
-require 'pp'
-#@db.tables.each do |table|
-#  pp @db.schema(table)
-#end
-
-events = @db[:events]
-tags = @db[:tags]
-customs = @db[:customs]
-
-events << {host: "foo.bar", service: "httpd"}
-events << {host: "foo.bar", service: "sshd"}
-tags << {event_id: 1, tag: "red"}
-customs << {event_id: 1, key: "a", value: "1"}
-customs << {event_id: 1, key: "b", value: "2"}
-customs << {event_id: 2, key: "b", value: "3"}
-
-pp events.all
-pp tags.all
-pp customs.all
-
-full_events = events.join(:tags, :event_id => :id).join(:customs, :event_id => :events__id)
-
-p full_events
-pp full_events.all
-

data/example/sqlite/tmp/poi-sqlite.rb

@@ -1,35 +0,0 @@
-require 'sequel'
-
-db = Sequel.sqlite
-db.create_table "poi" do
-  primary_key   :id
-  float         :lat, null: false
-  float         :lng, null: false
-  text          :desc
-end
-
-#p db
-#p db.schema :poi
-
-poi = db[:poi]
-
-10.times do |i|
-  poi << {
-    lat:  rand,
-    lng:  rand,
-    desc: "point #{i}"
-  }
-end
-
-#p poi.all
-#exit
-
-poi << {lat: 1, lng: 2, desc: "a"}
-poi << {lat: 1, lng: 2, desc: "b"}
-
-#p poi.count
-p poi.select(:lat, :lng, :desc).
-  where(lat: 0..1, lng: 0..1)
-  
-p poi.select(:lat, :lng, :desc).
-  where(lat: 0..1, lng: 0..1).limit(5).all

data/example/subspaces/addr-book-v1.rb

@@ -1,104 +0,0 @@
-## TODO
-##
-## scaling params
-
-require 'tupelo/app'
-
-ab_tag = "my address book"
-ab_sort_field = 1
-ab_val_field = 2
-cmd_tag = "#{ab_tag} commands"
-resp_tag = "#{ab_tag} responses"
-
-Tupelo.application do
-  local do
-    # Subspace for tuples belonging to the addr book.
-    define_subspace(
-      tag:          ab_tag,
-      template:     [
-        {value: ab_tag},
-        {type:  "string"},  # name <-- ab_sort_field references this field
-        nil                 # address; can be any object <-- ab_val_field
-      ]
-    )
-    
-    # Subspace for commands for fetch and delete.
-    # We can't use #read and #take because then the requesting client
-    # would have to subscribe to the ab_tag subspace.
-    define_subspace(
-      tag:          cmd_tag,
-      template:     [
-        {value: cmd_tag},
-        {type:  "string"},  # cmd name
-        {type:  "list"}     # arguments
-      ]
-    )
-
-    # Subspace for responses to commands. Identify the command this is in
-    # response to by copying it (alternately, could use ids).
-    define_subspace(
-      tag:          resp_tag,
-      template:     [
-        {value: resp_tag},
-        {type:  "string"},  # cmd name
-        {type:  "list"},    # arguments
-        nil                 # result of query -- type depends on command
-      ]
-    )
-  end
-
-  ## Could set N_SORTED_SET_SPACE > 1, but lookups are so fast it would
-  ## just lead to contention and redundant computation. Redundancy is useful
-  ## though.
-
-  # Inserts are just writes, which are handled by Worker and SortedSetSpace,
-  # so this child's app loop only needs to handle special commands: fetch and
-  # delete, which are delegated to the SortedSetSpace.
-  child tuplespace: [SortedSetSpace, ab_tag, ab_sort_field, ab_val_field],
-        subscribe: [ab_tag, cmd_tag], passive: true do
-    loop do
-      transaction do
-        _, cmd, args = take(subspace cmd_tag)
-
-        case cmd
-        when "delete"
-          args.each do |name|
-            take [ab_tag, name, nil]
-          end
-
-        when "fetch"
-          name = args[0]
-          _, _, addr = read [ab_tag, name, nil]
-          write [resp_tag, name, args, addr]
-
-        when "next", "prev"
-          name = args[0]
-          _, name2, addr = read SortedSetTemplate[ab_tag, cmd, name]
-          write [resp_tag, name, args, name2, addr]
-
-        when "first", "last"
-          _, name, addr = read SortedSetTemplate[ab_tag, cmd]
-          write [resp_tag, name, args, name, addr]
-
-        else # maybe write an error message in a tuple
-          log.error "bad command: #{cmd}"
-        end
-      end
-    end
-  end
-  
-  child subscribe: resp_tag do
-    # write some ab entries
-    write [ab_tag, "McFirst, Firsty", "123 W. Crescent Terrace"]
-    write [ab_tag, "Secondismus, Deuce", "456 S. West Way"]
-
-    # make some queries
-    write [cmd_tag, "first", []]
-    *, name, addr = take [resp_tag, "first", [], nil, nil]
-    log "first entry: #{name} => #{addr}"
-    
-    write [cmd_tag, "next", [name]]
-    *, name, addr = take [resp_tag, "next", [name], nil, nil]
-    log "next entry: #{name} => #{addr}"
-  end
-end

data/example/subspaces/addr-book-v2.rb

@@ -1,16 +0,0 @@
-require 'tupelo/app'
-
-Tupelo.application do
-  local do
-    define_subspace(
-      tag:          "address books",
-      template:     {
-        book:       {type: "string"},
-        name:       {type: "string"},
-        address:    nil
-      }
-    )
-
-    define_subspace
-  end
-end

data/example/subspaces/sorted-set-space-OLD.rb

@@ -1,130 +0,0 @@
-require 'rbtree'
-
-class SortedSetTemplate
-  class << self
-    alias [] new
-  end
-  
-  # cmd can be "next", "prev", "first", "last"
-  # for next/prev, args is ["name"]
-  # for first/last, args is empty
-  def initialize tag, cmd, *args
-    @tag = tag
-    @cmd = cmd
-    @args = args
-  end
-  
-  def === other
-    raise ### should not need this?
-  end
-  
-  def find_in rbtree
-    case @cmd
-    when "first"
-      rbtree.first
-    ###
-  end
-end
-
-# A tuple store (in-memory) that is optimized for (key_string, object) pairs.
-# The object may be any serializable object (built up from numbers, booleans,
-# nil, strings, hashes and arrays).
-#
-# Unlike in a key-value store, a given key_string may occur more than once.
-# It is up to the application to decide whether to enforce key uniqueness or
-# not (for example, by taking (k,...) before writing (k,v).
-#
-# This store should be used only by clients that subscribe to a subspace
-# that can be represented as pairs. (See memo2.rb.)
-#
-# This store also manages meta tuples, which it keeps in an array, just like
-# the default Tuplespace class does.
-class SortedSetSpace
-  include Enumerable
-
-  attr_reader :tag, :hash, :metas
-
-  def initialize tag
-    @tag = tag
-    clear
-  end
-
-  def clear
-    @hash = Hash.new {|h,k| h[k] = []}
-      # It's up to the application to enforce that these arrays have size <=1.
-    @metas = []
-      # We are automatically subscribed to tupelo metadata (subspace defs), so
-      # we need to keep them somewhere.
-  end
-
-  def each
-    hash.each do |k, vs|
-      vs.each do |v|
-        yield tag, k, v
-      end
-    end
-    metas.each do |tuple|
-      yield tuple
-    end
-  end
-
-  def insert tuple
-    if tuple.kind_of? Array
-        # and tuple.size == 3 and tuple[0] == tag and tuple[1].kind_of? String
-        # This is redundant, because of subscribe.
-      t, k, v = tuple
-      hash[k] << v
-
-    else
-      metas << tuple
-    end
-  end
-
-  def delete_once tuple
-    if tuple.kind_of? Array
-        # and tuple.size == 3 and tuple[0] == tag and tuple[1].kind_of? String
-        # This is redundant, because of subscribe.
-      t, k, v = tuple
-      if hash.key?(k) and hash[k].include? v
-        hash[k].delete v
-        hash.delete k if hash[k].empty?
-        true
-      else
-        false
-      end
-
-    else
-      if i=metas.index(tuple)
-        delete_at i
-      end
-    end
-  end
-
-  def transaction inserts: [], deletes: [], tick: nil
-    deletes.each do |tuple|
-      delete_once tuple or raise "bug"
-    end
-
-    inserts.each do |tuple|
-      insert tuple.freeze ## should be deep_freeze
-    end
-  end
-
-  def find_distinct_matches_for templates
-    templates.inject([]) do |tuples, template|
-      tuples << find_match_for(template, distinct_from: tuples)
-    end
-  end
-
-  def find_match_for template, distinct_from: []
-    case template
-    when SortedSetTemplate
-      template.find_in rbtree, distinct_from: distinct_from ###
-    else
-      # fall back to linear search
-      find do |tuple|
-        template === tuple and not distinct_from.any? {|t| t.equal? tuple}
-      end
-    end
-  end
-end