SHARE
TWEET

Untitled

a guest Dec 1st, 2012 84 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. local VERSION = "1.0"
  2. local PACKET_HEARTBEAT = "heartbeat"
  3. local PACKET_CONNECT = "connect"
  4. local PACKET_DATA = "data"
  5.  
  6. local DEBUG = nil
  7.  
  8. function tablelength(T)
  9.   local count = 0
  10.   for _ in pairs(T) do count = count + 1 end
  11.   return count
  12. end
  13.  
  14. function serialize(id, data)
  15.         local packet = {}
  16.         packet["id"] = id
  17.         packet["data"] = data
  18.         return textutils.serialize(packet)..""
  19. end
  20.  
  21. function unserialize(packet)
  22.         return textutils.unserialize(packet)
  23. end
  24.  
  25. function log(message)
  26.         if DEBUG then
  27.                 print("[Debug] "..message)
  28.         end
  29. end
  30.  
  31. function create(socket_type, debug)
  32.         DEBUG = debug
  33.         rednet.open("back")
  34.         prototype = {}
  35.         if socket_type == "server" then
  36.                 local server_events = {}
  37.                 local clients = {}
  38.                 clients["count"] = 0
  39.  
  40.                 local hostname = "Sockets Proxy Server"
  41.                 local maxclients = 30
  42.  
  43.                 local _listen = false
  44.                
  45.                 prototype["hostname"] = function(value)
  46.                         hostname = value
  47.                         return prototype
  48.                 end
  49.  
  50.                 prototype["maxclients"] = function(value)
  51.                         maxclients = value
  52.                         return prototype
  53.                 end
  54.  
  55.                 prototype["stop"] = function()
  56.                         _listen = false
  57.                         return prototype
  58.                 end
  59.  
  60.                 prototype["listen"] = function()
  61.                         _listen = true
  62.                         while _listen do
  63.                                 log("Wait for connection")
  64.                                 local socketid, packet, distance = rednet.receive()
  65.                                 local _socketid = socketid
  66.                                 if packet ~= nil then
  67.                                         log("["..socketid.."] accepting packet")
  68.                                         packet = unserialize(packet)
  69.                                         log("["..socketid.."] check packet")
  70.                                         if packet.data ~= nil then
  71.                                                 log("["..socketid.."] packet id "..packet.id)
  72.                                                 if packet.data.destination ~= nil then
  73.                                                         log("["..socketid.."] client is proxy swapping to real client "..packet.data.destination)
  74.                                                         socketid = packet.data.destination
  75.                                                 end
  76.                                                 if packet.id == PACKET_CONNECT and clients[socketid] ~= nil then
  77.                                                         log("["..socketid.."] restored socket")
  78.                                                         local socket = clients[socketid]
  79.                                                         socket.emit('connect')
  80.                                                         prototype.trigger("connect", {clients[socketid]})
  81.                                                 elseif packet.id == PACKET_CONNECT and clients[socketid] == nil then
  82.                                                         log("["..socketid.."] creating socket")
  83.                                                         local socket = {}
  84.                                                         socket["id"] = socketid
  85.                                                         socket["events"] = {}
  86.                                                         socket["emit"] = function(event, args)
  87.                                                                 if args == nil then
  88.                                                                         args = {}
  89.                                                                 end
  90.                                                                 local data = {}
  91.                                                                 data["name"] = event
  92.                                                                 data["args"] = args
  93.                                                                 if _socketid ~= socketid then
  94.                                                                         data["destination"] = socketid
  95.                                                                 end
  96.                                                                 local packet = serialize(PACKET_DATA, data)
  97.                                                                 rednet.send(_socketid, packet)
  98.                                                         end
  99.                                                         socket["on"] = function(event, func)
  100.                                                                 if socket.events[event] == nil then
  101.                                                                         socket.events[event] = {}
  102.                                                                 end
  103.                                                                 table.insert(socket.events[event], func)
  104.                                                                 return socket
  105.                                                         end
  106.                                                         socket["trigger"] = function(event, args)
  107.                                                                 log("["..socketid.."] trigger "..event)
  108.                                                                 if args == nil then
  109.                                                                         args = {}
  110.                                                                 end
  111.                                                                 for index, func in pairs(socket.events[event]) do
  112.                                                                         func(unpack(args))
  113.                                                                 end
  114.                                                                 return socket
  115.                                                         end
  116.                                                         socket.emit('connect')
  117.                                                         clients[socket.id] = socket
  118.                                                         clients.count = clients.count + 1
  119.                                                         log("["..socketid.."] registered ")
  120.                                                         prototype.trigger("connect", {socket})
  121.                                                 elseif packet.id == PACKET_DATA and clients[socketid] then
  122.                                                         log("["..socketid.."] receiving data packet")
  123.                                                         local socket = nil
  124.                                                         if clients[socketid] ~= nil then
  125.                                                                 socket = clients[socketid]
  126.                                                         elseif packet.data.destination ~= nil then
  127.                                                                 socket = clients[packet.data.destination]
  128.                                                         end
  129.                                                         if socket ~= nil then
  130.                                                                 if packet.data.name ~= nil then
  131.                                                                         local args = {}
  132.                                                                         if packet.data.args == nil then
  133.                                                                                 args = packet.data.args
  134.                                                                         end
  135.                                                                         socket.trigger(packet.data.name, args)
  136.                                                                 end
  137.                                                         end
  138.                                                 end
  139.                                         end
  140.                                         log("["..socketid.."] free")
  141.                                 end
  142.                                 sleep(0.1)
  143.                         end
  144.                 end
  145.                
  146.                 prototype["on"] = function(event, func)
  147.                         if server_events[event] == nil then
  148.                                 server_events[event] = {}
  149.                         end
  150.                         table.insert(server_events[event], func)
  151.                         return prototype
  152.                 end
  153.  
  154.                 prototype["trigger"] = function(event, args)
  155.                         if args == nil then
  156.                                 args = {}
  157.                         end
  158.                         for index, func in pairs(server_events[event]) do
  159.                                 func(unpack(args))
  160.                         end
  161.                         return prototype
  162.                 end
  163.         elseif socket_type == "client" or socket_type == nil then
  164.                 local connected = false
  165.                 local client_events = {}
  166.                 local server_host = nil
  167.                 local _listen = false
  168.  
  169.                 prototype["send"] = function(packet)
  170.                         if server_host ~= nil then
  171.                                 log("Sending packet...")
  172.                                 rednet.send(host, packet)
  173.                         else
  174.                                 log("Broadcasting packet...")
  175.                                 rednet.broadcast(packet)
  176.                         end
  177.                         return prototype
  178.                 end
  179.  
  180.                 prototype["connect"] = function(host)
  181.                         server_host = host
  182.                         local packet = serialize(PACKET_CONNECT, {})
  183.                         prototype.send(packet)
  184.                         _listen = true
  185.                         while _listen do
  186.                                 local socketid, packet, distance = rednet.receive()
  187.                                 if packet ~= nil then
  188.                                         log("["..socketid.."] accepted packet")
  189.                                         packet = unserialize(packet)
  190.                                         log("["..socketid.."] check packet")
  191.                                         if packet.data ~= nil then
  192.                                                 log("["..socketid.."] packet id "..packet.id)
  193.                                                 if packet.id == PACKET_DATA then
  194.                                                         if packet.data.name ~= nil then
  195.                                                                 local args = {}
  196.                                                                 if packet.data.args == nil then
  197.                                                                         args = packet.data.args
  198.                                                                 end
  199.                                                                 prototype.trigger(packet.data.name, args)
  200.                                                         end
  201.                                                 end
  202.                                         else
  203.                                                 log("["..socketid.."] invalid packet")
  204.                                         end
  205.                                 end
  206.                                 sleep(0.1)
  207.                         end
  208.                         return prototype
  209.                 end
  210.                
  211.                 prototype["disconnect"] = function(event, args)
  212.                         return prototype
  213.                 end
  214.                
  215.                 prototype["on"] = function(event, func)
  216.                         if client_events[event] == nil then
  217.                                 client_events[event] = {}
  218.                         end
  219.                         table.insert(client_events[event], func)
  220.                         return prototype
  221.                 end
  222.  
  223.                 prototype.on("connect", function()
  224.                         log("Connected")
  225.                 end)
  226.  
  227.                 prototype["emit"] = function(event, args)
  228.                         if args == nil then
  229.                                 args = {}
  230.                         end
  231.                         local data = {}
  232.                         data["name"] = event
  233.                         data["args"] = args
  234.                         local packet = serialize(PACKET_DATA, data)
  235.                         prototype.send(packet)
  236.                         return prototype
  237.                 end
  238.  
  239.                 prototype["trigger"] = function(event, args)
  240.                         if args == nil then
  241.                                 args = {}
  242.                         end
  243.                         for index, func in pairs(client_events[event]) do
  244.                                 func(unpack(args))
  245.                         end
  246.                         return prototype
  247.                 end
  248.         end
  249.         return prototype
  250. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top