emonti-rbkb 0.6.1.1

data/lib/rbkb/plug/blit.rb

@@ -0,0 +1,220 @@
+
+module Plug
+  module Blit
+    include Base
+
+    DEFAULT_IPADDR = "127.0.0.1"
+    DEFAULT_PORT = 25195
+    DEFAULT_PROTOCOL = :TCP
+
+    OPCODES = {
+      0 => :squelch,
+      1 => :unsquelch,
+      2 => :delete,
+      5 => :sendmsg,
+      6 => :list_peers,
+
+      0xfe => :clear,
+      0xff => :kill,
+    }
+
+    attr_accessor :kind
+
+    def initialize(transport, slave)
+      super(transport)
+
+      @kind = :blitsrv
+      @slave = slave
+      @peers = slave.peers
+      initbuf
+    end
+
+    def post_init
+      # override so we don't get unneccessary "Start" message from Base
+    end
+
+    def unbind
+      # override so we don't get unneccessary "closed" message from Base
+    end
+
+
+    ### Blit protocol stuff
+    SIG = "BLT"
+
+    # (re)initializes the blit buffer
+    def initbuf
+      @buf = StringIO.new
+    end
+    
+    def receive_data dat
+      return unless (@buf.write(dat) > SIG.size) or (@buf.pos > (SIG.size + 1))
+
+      @buf.rewind
+
+      return unless @buf.read(SIG.size) == SIG and
+                    op = OPCODES[ @buf.read(1)[0] ]
+
+      initbuf if self.send(op)
+    end
+    
+
+    def self.blit_header(op)
+      return nil unless opno = OPCODES.invert[op]
+      SIG + opno.chr
+    end
+
+    def mute
+      unless ( peerno=@buf.read(2) and peerno.size == 2 and
+               peer=@peers[peerno.dat_to_num(:big)] )
+
+        UI.log "** BLIT-ERROR(Malformed or missing peer for mute)"
+        return true
+      end
+    end
+
+    def self.make_mute(peerno)
+      self.blit_header(:squelch) +
+        peerno.to_bytes(2, :big)
+    end
+
+    def unmute
+      unless ( peerno=@buf.read(2) and peerno.size == 2 and
+               peer=@peers[peerno.dat_to_num(:big)] )
+        UI.log "** BLIT-ERROR(Malformed or missing peer for unmute)"
+        return true
+      end
+    end
+
+    def self.make_squelch(peerno)
+      self.blit_header(:squelch) +
+        peerno.to_bytes(2, :big)
+    end
+
+    def sendmsg
+      unless peerno=@buf.read(2) and peerno.size == 2 and
+             bufsiz=@buf.read(4) and bufsiz.size == 4
+        UI.log "** BLIT-ERROR(Malformed sendmsg)"
+        return true
+      end
+
+      peerno = peerno.dat_to_num(:big)
+      bufsiz = bufsiz.dat_to_num(:big)
+
+      if (rdat=@buf.read(bufsiz)).size == bufsiz
+        if peer=@peers[peerno]
+          peer.say(rdat, self)
+          return true
+        else
+          UI.log "** BLIT-ERROR(Invalid peer index #{peerno})"
+          return true
+        end
+      else
+        return nil
+      end
+    end
+
+    # Blit packed message format is (SUBJECT TO CHANGE):
+    #   "BLT"
+    #   char   opcode
+    #   uint16be idx   = index of slave peer to send to
+    #   uint32le size  = length of data
+    #   str      data
+    def self.make_sendmsg(idx, dat)
+      self.blit_header(:sendmsg) +
+        idx.to_bytes(2, :big) + 
+        dat.size.to_bytes(4, :big) + 
+        dat
+    end
+
+    def kill
+      UI.log("** BLIT-KILL - Received shutdown command")
+      EM.stop
+    end
+
+    def self.make_kill(idx=nil)
+      self.blit_header(:kill)
+    end
+
+    def clear
+      @peers.each { |p| p.close }
+      @peers.replace []
+    end
+
+    def self.make_clear
+      self.blit_header(:clear)
+    end
+
+    def delete(peerno)
+      @peers.delete(peerno)
+    end
+
+    def self.make_delete(idx=0)
+      self.blit_header(:delete) +
+        idx.to_bytes(2, :big)
+    end
+
+    def list_peers
+      UI.log("** BLIT-LISTPEERS - Received list peers command")
+
+      @peers.each_index {|i| UI.log "**   #{i} - #{@peers[i].name}"}
+      UI.log("** BLIT-LISTPEERS-END - End of peer list")
+    end
+
+    def self.make_list_peers
+      self.blit_header(:list_peers)
+    end
+
+    #----------------------------------------------------------------------
+    # Convenience methods for blit clients
+    #----------------------------------------------------------------------
+
+    BLIT_HANDLERS = {
+      :TCP => lambda {|msg| 
+        s=TCPSocket.new(@blit_addr, @blit_port)
+        wl=s.write(msg)
+        s.close
+        return wl
+      },
+      :UDP => lambda {|msg|
+        s=UDPSocket.new
+        wl=s.send( msg, 0, @blit_addr, @blit_port)
+        s.close
+        return wl
+      }
+    }
+
+    def self.blit_init(opts={})
+      @blit_addr = (opts[:addr] || DEFAULT_IPADDR)
+      @blit_port = (opts[:port] || DEFAULT_PORT)
+      proto = (opts[:protocol] || DEFAULT_PROTOCOL)
+      @blit_handler = BLIT_HANDLERS[ proto ]
+      raise "invalid blit transport protocol" unless @blit_handler
+    end
+
+    def self.initialized?
+      @blit_addr and @blit_port and @blit_handler
+    end
+
+    def self.blit_send(data, idx=0)
+      msg = make_sendmsg(idx, data)
+      blit_raw(msg)
+    end
+
+    def self.blit_raw(buf)
+      raise "use blit_init first!" unless self.initialized?
+      @blit_handler.call buf
+    end
+
+  end  # of module Blit
+
+
+end # of module Plug
+
+class String
+  #----------------------------------------------------------------------
+  # A Blit sender convenience method for strings
+  def blit(idx=0)
+    raise "blit must be initialized with blit_init" unless Plug::Blit.initialized?
+    Plug::Blit.blit_send(self, idx)
+  end
+end

data/lib/rbkb/plug/peer.rb

@@ -0,0 +1,64 @@
+require 'socket'
+
+module Plug
+
+  class Peer
+    attr_reader :addr, :transport, :name, :owner, :host, :port
+    attr_accessor :mute
+
+    def initialize(addr, owner)
+      @addr = addr
+      @owner = owner
+      @transport = @owner.transport
+
+      @port, @host = Socket.unpack_sockaddr_in(@addr)
+      @name = "PEER-#{@host}:#{@port}(#{@transport})"
+    end
+
+    def say(dat, sender)
+      UI.dump(sender.name, self.name, dat)
+
+      if @transport == :UDP
+        @owner.send_datagram(dat, @host, @port)
+      else
+        @owner.send_data(dat)
+      end
+    end
+
+    def close
+      @owner.unbind unless @transport == :UDP
+    end
+  end
+
+
+  class PeerList < Array
+    def initialize(owner, *args)
+      @owner = owner
+      @transport = @owner.transport
+      
+      super(*args)
+    end
+
+    def find_peer(addr)
+      self.find {|p| p.addr == addr }
+      return nil
+    end
+
+    def add_peer(addr)
+      self << Peer.new(addr, @owner)
+      self.last
+    end
+
+    def add_peer_manually(host, port)
+      addr = Socket.pack_sockaddr_in(port, host)
+      return (find_peer(addr) || add_peer(addr))
+    end
+
+    def delete(addr)
+      if p=find_peer(addr)
+        p.close
+        super(p)
+      end
+    end
+  end
+end

data/lib/rbkb/plug/plug.rb

@@ -0,0 +1,195 @@
+
+require "rbkb/plug/peer.rb"
+require 'stringio'
+require 'socket'
+
+
+module Plug
+  module UI
+    LOGCFG = {:out => STDERR, :dump => :hex}
+
+    def self.prompt(*msg); STDERR.puts msg ; STDIN.gets ; end
+
+    def self.log(*msg); LOGCFG[:out].puts msg ; end
+
+    def self.verbose(*msg); LOGCFG[:out].puts msg if LOGCFG[:verbose] ; end
+
+    def self.debug(*msg); LOGCFG[:out].puts msg if LOGCFG[:debug] ; end
+
+    def self.dump(from, to, dat)
+      if dump=LOGCFG[:dump]
+        LOGCFG[:out].puts "%% #{from} SAYS TO #{to} LEN=#{dat.size}", 
+          (dump == :hex)? dat.hexdump(:out => StringIO.new) : dat,
+          "%%"
+      end
+    end
+  end
+
+
+  module Base
+    attr_accessor :peers, :transport, :kind
+
+    def initialize(transport)
+#      raise "Invalid transport #{transport.inspect}" unless (:UDP, :TCP).include?(transport)
+      @transport = transport
+      @peers = PeerList.new(self)
+    end
+
+    def name
+      sn = get_sockname
+      addr = sn ? Socket.unpack_sockaddr_in(sn).reverse.join(":") : "PENDING"
+      "#{kind.to_s.upcase}-#{addr}(#{@transport})"
+    end
+
+
+    # plug_peer creates a peering association for a given peer based on 
+    # get_peername. The existing or newly created peer object is returned.
+    def plug_peer
+      paddr = get_peername
+      peer = (@peers.find_peer(paddr) || @peers.add_peer(paddr) )
+    end
+
+
+    # plug_receive is used by receive_data to divert incoming messages. 
+    # The "peer" is added if it is not already present. This instance 
+    # will check whether # a peer is "muted" and will return the peer if not.
+    # This method can be overriden by child classes to implement additional
+    # checks. It receives "dat" so that such checks can optionally make
+    # forwarding decisions based on message data contents as well.
+    #
+    # Returns: 
+    #   - nil : indicates that the message should be stifled
+    #   - A peer object : indicates that the message should be processed 
+    #     further
+    def plug_receive(dat)
+      peer = plug_peer
+      return peer unless peer.mute
+    end
+   
+    # This instance of the say method is an abstract stub and just 
+    # "dumps" the message. It should be overridden and optionally called 
+    # with super() if you actually want to do anything useful when 
+    # incoming messages are received.
+    def say(dat, sender)
+      UI.dump(sender.name, self.name, dat)
+    end
+
+    def post_init
+      UI.verbose "** #{name} Started"
+      if @kind==:server and peer=plug_peer
+        UI.log "** #{name} CONNECTED TO #{peer.name}"
+      end
+    end
+
+    def receive_data(dat)
+      if peer=plug_receive(dat)
+        say(dat, peer) 
+      end
+      return peer
+    end
+
+    def connection_completed
+      peer = plug_peer
+      UI.log "** #{name} CONNECTED TO #{peer.name}"
+      return peer
+    end
+
+    def unbind
+      UI.log "** Connection " + ((@peers.empty?)? "refused." : "closed.")
+      EM.stop
+    end
+  end
+
+
+  # An abstract module to implement custom servers for any protocol
+  # incoming messages are diverted to 'process(dat, sender)' which takes
+  # a block, the yields to which are messages to respond with
+  module UdpServer 
+    include Base
+
+    def kind ; :server ; end
+
+    def say(dat, sender)
+      super(dat, sender)
+
+      if self.respond_to? :process
+        self.send(:process, dat, sender) { |rply| sender.say(rply, self) }
+      end
+    end
+  end
+
+
+
+  # Telson is just a receiver for blit
+  module Telson
+    include Base
+    def kind ; :telson ; end
+  end
+
+
+  # Uses an array of static messages as a datasource for opaque protocol
+  # messages. Useful as a generic blit-able loop
+  module ArrayFeeder
+    include Base
+    attr_accessor :pos, :feed, :step, :close_at_end, :go_first, 
+                  :squelch_exhausted
+    
+    def initialize(transport, opts={})
+      super(transport)
+
+      @pos = 0
+      @feed = []
+
+      opts.each_pair do |k,v|
+        accessor = k.to_s + "="
+        if self.respond_to?(accessor)
+          self.send(accessor, v)
+        else
+          raise "Bad attribute: #{k}"
+        end
+      end
+      raise "feed must be enumerable" unless @feed.kind_of? Enumerable
+    end
+    
+    def go
+      if @go_first
+        feed_data
+        @go_first = false
+      end
+    end
+
+    def connection_completed
+      peer=super()
+      go if @go_first
+      return peer
+    end
+
+    
+    def say(dat, sender)
+      super(dat, sender)
+      if @step
+        EventMachine.defer(
+          proc { UI.prompt ">> Hit [enter] to continue at #{@pos}:" },
+          proc {|x| feed_data }
+        )
+      else
+        feed_data
+      end
+    end
+
+    def feed_data(dst=plug_peer)
+      unless dat=@feed[@pos]
+        UI.log "** FEED EXHAUSTED" unless @squelch_exhausted
+        return nil
+      end
+
+      dst.say dat.to_s, self
+
+      if (@pos += 1) >= @feed.size and @close_at_end
+        close_connection_after_writing
+      end
+    end
+
+  end # ArrayFeeder
+end # Plug
+