distributor 0.0.1

data/lib/distributor.rb

@@ -0,0 +1,2 @@
+module Distributor
+end

data/lib/distributor/client.rb

@@ -0,0 +1,88 @@
+require "distributor"
+require "distributor/connector"
+require "distributor/multiplexer"
+require "json"
+
+class Distributor::Client
+
+  def initialize(input, output=input)
+    @connector   = Distributor::Connector.new
+    @multiplexer = Distributor::Multiplexer.new(output)
+    @handlers    = {}
+    @processes   = []
+    @on_close    = Hash.new([])
+
+    # reserve a command channel
+    @multiplexer.reserve(0)
+
+    # feed data from the input channel into the multiplexer
+    @connector.handle(input) do |io|
+      @multiplexer.input io
+    end
+
+    @connector.on_close(input) do |io|
+      @multiplexer.output 0, JSON.dump({ "command" => "close", "ch" => ch })
+    end
+
+    # handle the command channel of the multiplexer
+    @connector.handle(@multiplexer.reader(0)) do |io|
+      data = JSON.parse(io.readpartial(4096))
+
+      case command = data["command"]
+      when "close" then
+        ch = data["ch"]
+        @on_close[ch].each { |c| c.call(ch) }
+      when "launch" then
+        ch = data["ch"]
+        @multiplexer.reserve ch
+        @handlers[data["id"]].call(ch)
+        @handlers.delete(data["id"])
+        @processes << ch
+      else
+        raise "no such command: #{command}"
+      end
+    end
+  end
+
+  def output(ch, data)
+    @multiplexer.output ch, data
+  end
+
+  def run(command, &handler)
+    id = "#{Time.now.to_f}-#{rand(10000)}"
+    @multiplexer.output 0, JSON.dump({ "id" => id, "command" => "run", "args" => command })
+    @handlers[id] = handler
+  end
+
+  def hookup(ch, input, output)
+    # handle data incoming on the multiplexer
+    @connector.handle(@multiplexer.reader(ch)) do |io|
+      begin
+        data = io.readpartial(4096)
+        # output.write "#{ch}: #{data}"
+        output.write data
+      rescue EOFError
+        @multiplexer.output 0, JSON.dump({ "command" => "close", "ch" => ch })
+      end
+    end
+
+    # handle data incoming from the input channel
+    @connector.handle(input) do |io|
+      begin
+        data = io.readpartial(4096)
+        @multiplexer.output ch, data
+      rescue EOFError
+        @processes.each { |ch| @multiplexer.close(ch) }
+      end
+    end
+  end
+
+  def on_close(ch, &blk)
+    @on_close[ch] << blk
+  end
+
+  def start
+    loop { @connector.listen }
+  end
+
+end

data/lib/distributor/connector.rb

@@ -0,0 +1,28 @@
+require "distributor"
+
+class Distributor::Connector
+
+  attr_reader :connections
+
+  def initialize
+    @connections = {}
+    @on_close = Hash.new([])
+  end
+
+  def handle(from, &handler)
+    @connections[from] = handler
+  end
+
+  def on_close(from, &handler)
+    @on_close[from] << handler
+  end
+
+  def listen
+    rs, ws = IO.select(@connections.keys)
+    rs.each do |from|
+      @on_close.each { |c| c.call } if from.eof?
+      self.connections[from].call(from)
+    end
+  end
+
+end

data/lib/distributor/multiplexer.rb

@@ -0,0 +1,47 @@
+require "distributor"
+require "distributor/packet"
+
+class Distributor::Multiplexer
+
+  def initialize(output)
+    @output  = output
+    @readers = {}
+    @writers = {}
+
+    @output.sync = true
+  end
+
+  def reserve(ch=nil)
+    ch ||= @readers.keys.length
+    raise "channel already taken: #{ch}" if @readers.has_key?(ch)
+    @readers[ch], @writers[ch] = IO.pipe
+    ch
+  end
+
+  def reader(ch)
+    @readers[ch] || raise("no such channel: #{ch}")
+  end
+
+  def writer(ch)
+    @writers[ch] || raise("no such channel: #{ch}")
+  end
+
+  def input(io)
+    ch, data = Distributor::Packet.parse(io)
+    return if ch.nil?
+    writer(ch).write data
+  rescue IOError
+    @output.write Distributor::Packet.create(0, JSON.dump({ "command" => "close", "ch" => ch }))
+  end
+
+  def output(ch, data)
+    @output.write Distributor::Packet.create(ch, data)
+  rescue Errno::EPIPE
+  end
+
+  def close(ch)
+    writer(ch).close
+  rescue IOError
+  end
+
+end

data/lib/distributor/packet.rb

@@ -0,0 +1,36 @@
+require "distributor"
+
+class Distributor::Packet
+
+  PROTOCOL_VERSION = 1
+
+  def self.create(channel, data)
+    packet = "DIST"
+    packet += pack(PROTOCOL_VERSION)
+    packet += pack(channel)
+    packet += pack(data.length)
+    packet += data
+  end
+
+  def self.parse(io)
+    header = io.read(4)
+    return if header.nil?
+    raise "invalid header" unless header == "DIST"
+    version = unpack(io.read(4))
+    channel = unpack(io.read(4))
+    length  = unpack(io.read(4))
+    data    = ""
+    data   += io.readpartial([4096,length-data.length].min) while data.length < length
+
+    [ channel, data ]
+  end
+
+  def self.pack(num)
+    [num.to_s(16).rjust(8,"0")].pack("H8")
+  end
+
+  def self.unpack(string)
+    string.unpack("N").first
+  end
+
+end

data/lib/distributor/server.rb

@@ -0,0 +1,66 @@
+require "distributor"
+require "distributor/connector"
+require "distributor/multiplexer"
+require "pty"
+
+class Distributor::Server
+
+  def initialize(input, output=input)
+    @connector   = Distributor::Connector.new
+    @multiplexer = Distributor::Multiplexer.new(output)
+
+    # reserve a command channel
+    @multiplexer.reserve(0)
+
+    # feed data from the input channel into the multiplexer
+    @connector.handle(input) do |io|
+      @multiplexer.input io
+    end
+
+    # handle the command channel of the multiplexer
+    @connector.handle(@multiplexer.reader(0)) do |io|
+      data = JSON.parse(io.readpartial(4096))
+
+      case command = data["command"]
+      when "close" then
+        @multiplexer.close data["ch"]
+      when "run" then
+        ch = run(data["args"])
+        @multiplexer.output 0, JSON.dump({ "id" => data["id"], "command" => "launch", "ch" => ch })
+      else
+        raise "no such command: #{command}"
+      end
+    end
+  end
+
+  def run(command)
+    ch = @multiplexer.reserve
+
+    rd, wr, pid = PTY.spawn(command)
+
+    # handle data incoming from process
+    @connector.handle(rd) do |io|
+      begin
+        @multiplexer.output(ch, io.readpartial(4096))
+      rescue EOFError
+        @multiplexer.output 0, JSON.dump({ "command" => "close", "ch" => ch })
+      end
+    end
+
+    # handle data incoming on the multiplexer
+    @connector.handle(@multiplexer.reader(ch)) do |input_io|
+      data = input_io.readpartial(4096)
+      wr.write data
+    end
+
+    ch
+  end
+
+  def close(ch)
+  end
+
+  def start
+    loop { @connector.listen }
+  end
+
+end

data/lib/distributor/version.rb

@@ -0,0 +1,5 @@
+module Distributor
+
+  VERSION = "0.0.1"
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: distributor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70336779621500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.13.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70336779621500
+description: TCP Multiplexer
+email: ddollar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/distributor/client.rb
+- lib/distributor/connector.rb
+- lib/distributor/multiplexer.rb
+- lib/distributor/packet.rb
+- lib/distributor/server.rb
+- lib/distributor/version.rb
+- lib/distributor.rb
+homepage: http://github.com/ddollar/distributor
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: TCP Multiplexer
+test_files: []