mirror of
https://github.com/TangentFoxy/slam.git
synced 2024-11-14 10:24:21 +00:00
Split from vrld/Stuff
This commit is contained in:
Matthias Richter
parent
289c5ccb8e
commit
c19dccec48
@ -1,58 +0,0 @@
|
|||||||
**Lua-RPC** is a simple premote procedure call protocol implemented in Lua. This
|
|
||||||
is meant to be a proof of concept. Please don't use it in productive environments.
|
|
||||||
|
|
||||||
|
|
||||||
Dependencies
|
|
||||||
============
|
|
||||||
|
|
||||||
- luasocket: http://w3.impa.br/~diego/software/luasocket/
|
|
||||||
- any class commons enabled class library: https://github.com/bartbes/Class-Commons
|
|
||||||
--> hump.class is included
|
|
||||||
|
|
||||||
Usage example
|
|
||||||
=============
|
|
||||||
|
|
||||||
server.lua:
|
|
||||||
|
|
||||||
require 'class' -- any class commons enabled library
|
|
||||||
local RPC = require 'rpc'
|
|
||||||
|
|
||||||
-- open server at port 12345 on localhost
|
|
||||||
server = RPC.server(12345, '127.0.0.1')
|
|
||||||
|
|
||||||
-- register 'print' function as remotely callable
|
|
||||||
server:register('print', print)
|
|
||||||
|
|
||||||
-- register a function that returns a value
|
|
||||||
server:register('twice', function(x) return 2 * x end)
|
|
||||||
|
|
||||||
-- yet another way to define callable functions
|
|
||||||
function server.registry.thrice(x) return 3 * x end
|
|
||||||
|
|
||||||
-- run the server
|
|
||||||
while true do
|
|
||||||
server:serve()
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
client.lua:
|
|
||||||
|
|
||||||
require 'class'
|
|
||||||
local RPC = require 'rpc'
|
|
||||||
|
|
||||||
-- create new client to call functions from server at localhost:12345
|
|
||||||
client = RPC.client('127.0.0.1', 12345)
|
|
||||||
|
|
||||||
-- set actions what to do on success/failure of the remote call.
|
|
||||||
-- these are the defaults
|
|
||||||
client.on_success = print
|
|
||||||
client.on_failure = error
|
|
||||||
|
|
||||||
-- queue some functions
|
|
||||||
client.rpc.print("Hello world!\nHello remote server!")
|
|
||||||
client.rpc.twice(2)
|
|
||||||
|
|
||||||
-- you can also define function-specific callbacks.
|
|
||||||
-- prototype is client:call(function_name, on_success, on_failure, ...)
|
|
||||||
client:call('thrice', function(result) print('3 * 2 = ', result) end, function(err) print("RPC error:", err), 3)
|
|
||||||
|
|
||||||
@ -1,116 +0,0 @@
|
|||||||
--[[
|
|
||||||
Copyright (c) 2010-2011 Matthias Richter
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
Except as contained in this notice, the name(s) of the above copyright holders
|
|
||||||
shall not be used in advertising or otherwise to promote the sale, use or
|
|
||||||
other dealings in this Software without prior written authorization.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
]]--
|
|
||||||
|
|
||||||
local function __NULL__() end
|
|
||||||
|
|
||||||
-- class "inheritance" by copying functions
|
|
||||||
local function inherit(class, interface, ...)
|
|
||||||
if not interface then return end
|
|
||||||
assert(type(interface) == "table", "Can only inherit from other classes.")
|
|
||||||
|
|
||||||
-- __index and construct are not overwritten as for them class[name] is defined
|
|
||||||
for name, func in pairs(interface) do
|
|
||||||
if not class[name] then
|
|
||||||
class[name] = func
|
|
||||||
end
|
|
||||||
end
|
|
||||||
for super in pairs(interface.__is_a or {}) do
|
|
||||||
class.__is_a[super] = true
|
|
||||||
end
|
|
||||||
|
|
||||||
return inherit(class, ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- class builder
|
|
||||||
local function new(args)
|
|
||||||
local super = {}
|
|
||||||
local name = '<unnamed class>'
|
|
||||||
local constructor = args or __NULL__
|
|
||||||
if type(args) == "table" then
|
|
||||||
-- nasty hack to check if args.inherits is a table of classes or a class or nil
|
|
||||||
super = (args.inherits or {}).__is_a and {args.inherits} or args.inherits or {}
|
|
||||||
name = args.name or name
|
|
||||||
constructor = args[1] or __NULL__
|
|
||||||
end
|
|
||||||
assert(type(constructor) == "function", 'constructor has to be nil or a function')
|
|
||||||
|
|
||||||
-- build class
|
|
||||||
local class = {}
|
|
||||||
class.__index = class
|
|
||||||
class.__tostring = function() return ("<instance of %s>"):format(tostring(class)) end
|
|
||||||
class.construct = constructor or __NULL__
|
|
||||||
class.inherit = inherit
|
|
||||||
class.__is_a = {[class] = true}
|
|
||||||
class.is_a = function(self, other) return not not self.__is_a[other] end
|
|
||||||
|
|
||||||
-- intercept assignment in global environment to infer the class name
|
|
||||||
if not (type(args) == "table" and args.name) then
|
|
||||||
local env, env_meta, interceptor = getfenv(0), getmetatable(getfenv(0)), {}
|
|
||||||
function interceptor:__newindex(key, value)
|
|
||||||
if value == class then
|
|
||||||
local name = tostring(key)
|
|
||||||
getmetatable(class).__tostring = function() return name end
|
|
||||||
end
|
|
||||||
-- restore old metatable and insert value
|
|
||||||
setmetatable(env, env_meta)
|
|
||||||
if env.global then env.global(key) end -- handle 'strict' module
|
|
||||||
env[key] = value
|
|
||||||
end
|
|
||||||
setmetatable(env, interceptor)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- inherit superclasses (see above)
|
|
||||||
inherit(class, unpack(super))
|
|
||||||
|
|
||||||
-- syntactic sugar
|
|
||||||
local meta = {
|
|
||||||
__call = function(self, ...)
|
|
||||||
local obj = {}
|
|
||||||
setmetatable(obj, self)
|
|
||||||
self.construct(obj, ...)
|
|
||||||
return obj
|
|
||||||
end,
|
|
||||||
__tostring = function() return name end
|
|
||||||
}
|
|
||||||
return setmetatable(class, meta)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- interface for cross class-system compatibility (see https://github.com/bartbes/Class-Commons).
|
|
||||||
if class_commons ~= false and not common then
|
|
||||||
common = {}
|
|
||||||
function common.class(name, prototype, parent)
|
|
||||||
local init = prototype.init or (parent or {}).init
|
|
||||||
return new{name = name, inherits = {prototype, parent}, init}
|
|
||||||
end
|
|
||||||
function common.instance(class, ...)
|
|
||||||
return class(...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- the module
|
|
||||||
return setmetatable({new = new, inherit = inherit},
|
|
||||||
{__call = function(_,...) return new(...) end})
|
|
||||||
221
lua-rpc/rpc.lua
221
lua-rpc/rpc.lua
@ -1,221 +0,0 @@
|
|||||||
local socket = require 'socket'
|
|
||||||
assert(common and common.class, "A Class Commons implementation is required")
|
|
||||||
|
|
||||||
-- TODO: more serializers
|
|
||||||
local function is_serializable(t,v)
|
|
||||||
return t == "number" or
|
|
||||||
t == "boolean" or
|
|
||||||
t == "string" or
|
|
||||||
t == "nil" or
|
|
||||||
(getmetatable(v) or {}).__tostring ~= nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local function serialize(...)
|
|
||||||
local args = {n = select('#', ...), ...}
|
|
||||||
local serialized = {}
|
|
||||||
for i = 1,args.n do
|
|
||||||
local t, v = type(args[i]), args[i]
|
|
||||||
if not is_serializable(t,v) then
|
|
||||||
error(("Cannot serialize values of type `%s'."):format(t))
|
|
||||||
end
|
|
||||||
serialized[i] = ("%s<%s>"):format(t,tostring(v))
|
|
||||||
end
|
|
||||||
return table.concat(serialized, ",")
|
|
||||||
end
|
|
||||||
|
|
||||||
local converter = {
|
|
||||||
['nil'] = function() return nil end,
|
|
||||||
string = function(v) return v end,
|
|
||||||
number = tonumber,
|
|
||||||
boolean = function(v) return v == 'true' end,
|
|
||||||
}
|
|
||||||
local function deserialize_helper(iter)
|
|
||||||
local token = iter()
|
|
||||||
if not token then return end
|
|
||||||
|
|
||||||
local t,v = token:match('(%w+)(%b<>)')
|
|
||||||
return (converter[t] or error)(v:sub(2,-2)), deserialize_helper(iter)
|
|
||||||
end
|
|
||||||
local function deserialize(str)
|
|
||||||
return deserialize_helper(str:gmatch('%w+%b<>'))
|
|
||||||
end
|
|
||||||
|
|
||||||
--
|
|
||||||
-- RPC SERVER
|
|
||||||
--
|
|
||||||
local server = {}
|
|
||||||
|
|
||||||
local function capabilities(self, pattern)
|
|
||||||
pattern = pattern or ".*"
|
|
||||||
local ret = {}
|
|
||||||
for name, _ in pairs(self.registry) do
|
|
||||||
if name:match(pattern) then
|
|
||||||
ret[#ret+1] = name
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return table.concat(ret, "\n")
|
|
||||||
end
|
|
||||||
|
|
||||||
function server:init(port, address)
|
|
||||||
port = port or 0
|
|
||||||
address = address or '*'
|
|
||||||
self.socket = assert(socket.bind(address, port))
|
|
||||||
self.socket:settimeout(0)
|
|
||||||
self.address, self.port = self.socket:getsockname()
|
|
||||||
self.registry = {}
|
|
||||||
|
|
||||||
function self.registry.capabilities(...) return capabilities(self, ...) end
|
|
||||||
end
|
|
||||||
|
|
||||||
function server:register(name, func)
|
|
||||||
assert(name, "Missing argument: `name'")
|
|
||||||
assert(func, "Missing argument: `func'")
|
|
||||||
self.registry[name] = func
|
|
||||||
end
|
|
||||||
|
|
||||||
function server:remove(name)
|
|
||||||
assert(name, "Missing argument: `name'")
|
|
||||||
self.registry[name] = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
function server:defined(name)
|
|
||||||
assert(name, "Missing argument: `name'")
|
|
||||||
return self.registry[name] ~= nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local function execute(self, func, args)
|
|
||||||
if not self.registry[func] then
|
|
||||||
return false, ("Tried to execute unknown function `%s'"):format(func)
|
|
||||||
end
|
|
||||||
|
|
||||||
return (function(pcall_ok, ...)
|
|
||||||
if pcall_ok then
|
|
||||||
return true, serialize(...)
|
|
||||||
end
|
|
||||||
return false, ...
|
|
||||||
end)(pcall(self.registry[func], deserialize(args)))
|
|
||||||
end
|
|
||||||
|
|
||||||
function server:serve()
|
|
||||||
assert(self.socket, "Server socket not initialized")
|
|
||||||
|
|
||||||
local client,err = self.socket:accept()
|
|
||||||
if client then
|
|
||||||
local line = client:receive('*l')
|
|
||||||
local bytes = tonumber(line:match('^RPC:(%d+)$'))
|
|
||||||
if bytes then
|
|
||||||
line = client:receive(bytes)
|
|
||||||
local token, func, args = line:match('^([^:]+):([^:]+):(.*)%s*')
|
|
||||||
if token and func and args then
|
|
||||||
local ok, ret = execute(self, func, args)
|
|
||||||
local str = ("RPC:%s:%s:%s\r\n"):format(token, tostring(ok), ret)
|
|
||||||
client:send(str)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
client:close()
|
|
||||||
elseif not client and err ~= 'timeout' then
|
|
||||||
error(err)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--
|
|
||||||
-- RPC CLIENT
|
|
||||||
--
|
|
||||||
local client = {}
|
|
||||||
|
|
||||||
function client:init(address, port)
|
|
||||||
assert(address and port, "Need server address and port")
|
|
||||||
self.address, self.port = address, port
|
|
||||||
self.workers = {}
|
|
||||||
self.on_success = print
|
|
||||||
self.on_failure = error
|
|
||||||
self.rpc = setmetatable({}, {__index = function(_,func)
|
|
||||||
return function(...) return self:call(func, self.on_success, self.on_failure,...) end
|
|
||||||
end})
|
|
||||||
end
|
|
||||||
|
|
||||||
local function query(self, func, args)
|
|
||||||
local client = socket.tcp()
|
|
||||||
client:settimeout(10)
|
|
||||||
local _, err = client:connect(self.address, self.port)
|
|
||||||
if err then
|
|
||||||
return false, ("Cannot connect to %s[%s]: %s"):format(self.address, self.port, err)
|
|
||||||
end
|
|
||||||
client:settimeout(0)
|
|
||||||
|
|
||||||
local token = ("%d-%s"):format(os.time(), math.random())
|
|
||||||
local str = ("%s:%s:%s\r\n"):format(token, func, args)
|
|
||||||
|
|
||||||
_, err = client:send(("RPC:%d\r\n"):format(str:len()))
|
|
||||||
if err then
|
|
||||||
client:close()
|
|
||||||
return false, ("Cannot send query header to %s[%s]: %s"):format(self.address, self.port, err)
|
|
||||||
end
|
|
||||||
|
|
||||||
_, err = client:send(str)
|
|
||||||
if err then
|
|
||||||
client:close()
|
|
||||||
return false, ("Cannot send query message to %s[%s]: %s"):format(self.address, self.port, err)
|
|
||||||
end
|
|
||||||
|
|
||||||
local lines = {}
|
|
||||||
while true do
|
|
||||||
local line, err = client:receive('*l')
|
|
||||||
if line then
|
|
||||||
lines[#lines+1] = line
|
|
||||||
elseif err == "closed" then
|
|
||||||
local ret = table.concat(lines,'\n')
|
|
||||||
local ret_token, success, values = ret:match("^RPC:([^:]+):([^:]+):(.*)%s*$")
|
|
||||||
if not (ret_token and success and values) then
|
|
||||||
return false, ("Malformated answer: `%s'"):format(ret)
|
|
||||||
end
|
|
||||||
|
|
||||||
if ret_token == token then
|
|
||||||
return (success == 'true'), values
|
|
||||||
else
|
|
||||||
return false, ("Token mismatch: expected `%s', got `%s'"):format(token, ret_token)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
-- err == 'timeout'
|
|
||||||
coroutine.yield()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function client:call(func, on_success, on_failure, ...)
|
|
||||||
local args = serialize(...)
|
|
||||||
local q = coroutine.create(function() return query(self, func, args) end)
|
|
||||||
local worker = function()
|
|
||||||
local coroutine_ok, call_ok, returns = coroutine.resume(q)
|
|
||||||
if coroutine_ok and call_ok ~= nil and returns ~= nil then
|
|
||||||
if call_ok then
|
|
||||||
on_success(deserialize(returns))
|
|
||||||
else
|
|
||||||
on_failure(returns)
|
|
||||||
end
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
return coroutine_ok
|
|
||||||
end
|
|
||||||
self.workers[worker] = worker
|
|
||||||
end
|
|
||||||
|
|
||||||
function client:dispatch()
|
|
||||||
local to_remove = {}
|
|
||||||
for _, worker in pairs(self.workers) do
|
|
||||||
if not worker() then
|
|
||||||
to_remove[worker] = worker
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for _, worker in pairs(to_remove) do
|
|
||||||
self.workers[worker] = nil
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--
|
|
||||||
-- THE MODULE
|
|
||||||
--
|
|
||||||
return {
|
|
||||||
server = common.class("RPC.server", server),
|
|
||||||
client = common.class("RPC.client", client),
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue
Block a user