local_message 0.0.1

data/lib/local_message/local_message_client.rb

@@ -0,0 +1,42 @@
+require 'socket'
+
+class LocalMessageClient
+
+  attr_reader :server, :port, :username, :listen_port
+
+  def initialize(server_hostname, server_port, user_name)
+    @server = server_hostname
+    @port = server_port
+    @username = user_name
+    @listen_port = Random.rand(2000..30_000)
+  end
+
+  def register
+    send("@register #{username} #{listen_port}")
+  end
+
+  def send(message)
+    socket = TCPSocket.open(server, port)
+    sleep 1
+    socket.write(message)
+    socket.close
+    #puts "Waiting for server acknowledgement..."
+    #listen
+  end
+
+  def new_listen_port
+    @listen_port = Random.rand(1000..30_000)
+  end
+
+  def listen
+    #puts "Listening on #{listen_port}..."
+    server = TCPServer.open(listen_port)
+    client = server.accept
+    #puts "Connection open, waiting for message..."
+    message = client.read
+    client.close
+    server.close
+    message
+  end
+
+end

data/lib/local_message/local_message_router.rb

@@ -0,0 +1,130 @@
+require 'socket'
+
+class LocalMessageRouter
+
+  attr_reader :port, :registered_users, :open_ports
+
+  def initialize(listening_port)
+    @port = listening_port
+    @registered_users = {}
+    @open_ports = []
+  end
+
+  def start
+    server = TCPServer.open(port)
+    begin
+
+      puts "Listening on port: #{port}..."
+      Thread.start(server.accept) do |client|
+        fam, port, hostname, ip = client.peeraddr
+        puts "Connection initiated from #{hostname}:#{port}"
+        message = client.read
+        puts "Message from #{hostname}:#{port}: #{message}"
+        puts handle(message, port, ip)
+        puts "Closing connection from #{hostname}:#{port}"
+        client.close
+      end
+
+    end while true
+  end
+
+  def handle(message, port, ip)
+    if register?(message)
+      username, port = strip_username_port(message)
+      register(username, port.to_i, ip)
+      if registered?(username)
+        puts "Registered #{username} => #{ip}:#{port}"
+      else
+        puts "Couldn't register #{username}"
+      end
+      #send_register_ack(ip, port, username)
+    elsif has_recipient?(message)
+      recipient = strip_recipient(message)
+      sender = username_by_ip(ip)
+      forward_message(sender, recipient, message)
+      if registered?(recipient)
+        #send_ack(ip, port, recipient, message)
+      else
+        #send_ack(ip, port, recipient, "No such recipient")
+      end
+    else
+      "Message not handled"
+    end
+  end
+
+  def register?(message)
+    return true if /@register/.match(message)
+    false
+  end
+
+  def registered?(username)
+    registered_users.has_key?(username)
+  end
+
+  def register(username, port, ip)
+    registered_users[username] = LocalMessageUser.new(port, ip)
+  end
+
+  def send_register_ack(hostname, port, username)
+    if registered?(username)
+      send(hostname, port, "Successfully registered #{username}")
+      "Successfully registered #{username}"
+    else
+      send(hostname, port, "Failed to register #{username}")
+      "Failed to register #{username}"
+    end
+  end
+
+  def username_by_ip(ip)
+    registered_users.values.each do |user|
+      return registered_users.key(user) if user.hostname == ip
+    end
+  end
+
+  def strip_username_port(message)
+    /@register\s+(.+)\s+(\d+)/.match(message)
+    [$1, $2]
+  end
+
+  def has_recipient?(message)
+    return true if /(@.+)\s+/.match(message)
+    false
+  end
+
+  def strip_recipient(message)
+    message.split[0].slice(1..-1)
+  end
+
+  def strip_message(message)
+    message.split[1..-1].join(" ")
+  end
+
+  def forward_message(sender, recipient, message)
+    if registered?(recipient)
+      info = registered_users[recipient]
+      message_with_sender = "@#{sender} #{strip_message(message)}"
+      puts "Sending message to #{recipient}, host: #{info.hostname} port: #{info.port}"
+      send(info.hostname, info.port, message_with_sender)
+    end
+  end
+
+  def port_open?(port)
+    open_ports.include?(port)
+  end
+
+  def send(hostname, port, message)
+    Thread.new do
+      puts "Sending #{message} to #{hostname}:#{port}"
+      socket = TCPSocket.open(hostname, port)
+      sleep 1
+      socket.write(message)
+      socket.close
+    end
+  end
+
+  def send_ack(hostname, port, recipient, message)
+    send(hostname, port, "Sent #{message} to #{recipient}")
+    "Sent #{message} to #{hostname}:#{port}"
+  end
+
+end

data/lib/local_message/local_message_user.rb

@@ -0,0 +1,22 @@
+class LocalMessageUser
+
+  attr_reader :port, :hostname
+
+  def initialize(port_number, host_name)
+    @port = port_number
+    @hostname = host_name
+  end
+
+  def ==(other)
+    hostname == other.hostname
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    hostname.hash
+  end
+
+end

data/lib/local_message.rb

@@ -0,0 +1,3 @@
+require 'local_message/local_message_router'
+require 'local_message/local_message_client'
+require 'local_message/local_message_user'

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: local_message
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Elliot Shiu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-06 00:00:00.000000000 Z
+dependencies: []
+description: Routes messages across a local network.
+email: elliot@sandbochs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/local_message.rb
+- lib/local_message/local_message_router.rb
+- lib/local_message/local_message_client.rb
+- lib/local_message/local_message_user.rb
+homepage: http://www.github.com/sandbochs
+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.24
+signing_key: 
+specification_version: 3
+summary: A message router and client.
+test_files: []