diff options
Diffstat (limited to 'src/modules/tcp_connect.lua')
-rw-r--r-- | src/modules/tcp_connect.lua | 150 |
1 files changed, 150 insertions, 0 deletions
diff --git a/src/modules/tcp_connect.lua b/src/modules/tcp_connect.lua new file mode 100644 index 0000000..c5171ea --- /dev/null +++ b/src/modules/tcp_connect.lua @@ -0,0 +1,150 @@ +-- +-- gcsd +-- +-- gcsd the generic command sequencer daemon can be used to serialize +-- commands sent over various paralell communication channels to a +-- single command output. It can be seen as a multiplexer for any +-- kind of communication between a single resource and various clients +-- which want to submit commands to it or query information from it. +-- gcsd is written in C and Lua. The goal is to provide an easy to +-- understand high level API based on Lua which can be used to +-- implement the business logic of the so formed multiplexer daemon. +-- +-- +-- Copyright (C) 2009-2010 Markus Grueneis <gimpf@spreadspace.org> +-- Christian Pointner <equinox@spreadspace.org> +-- +-- This file is part of gcsd. +-- +-- gcsd is free software: you can redistribute it and/or modify +-- it under the terms of the GNU General Public License as published by +-- the Free Software Foundation, either version 3 of the License, or +-- any later version. +-- +-- gcsd is distributed in the hope that it will be useful, +-- but WITHOUT ANY WARRANTY; without even the implied warranty of +-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-- GNU General Public License for more details. +-- +-- You should have received a copy of the GNU General Public License +-- along with gcsd. If not, see <http://www.gnu.org/licenses/>. +-- + +-- tcp_connect module class +local tcp_connect = {} +tcp_connect.properties = { type=defines.INOUT_MODULE, name="tcp-connect", max_instances=-1 } +tcp_connect.next_id = 0 + +-- create new instance of tcp_connect module class +function tcp_connect:new(config, runtype) + local inst = {} + inst.class = self + inst.config = config + inst.config.runtype = runtype + if(config.name == nil or config.name == "") then + inst.name = self.properties.name .. self.next_id + self.next_id = self.next_id + 1 + else + inst.name = config.name + end + + local handle, connected = tcp.client(config.addr, config.port, config.resolv_type, config.source) + if(not handle) then + return nil + end + inst.connected = connected + + handle.in_buffer = "" + handle.out_buffer = "" + function handle:read() + -- TODO: which size should we request?? + local buffer, err = tcp.recv(self.fd, 100) + if(buffer == nil) then + log.printf(log.ERROR, inst.name .. ": connection error: %s", err) + return defines.KILL_MODULE -- TODO: reconnect + end + if(#buffer == 0) then + log.printf(log.INFO, inst.name .. ": connection closed") + return defines.KILL_MODULE -- TODO: reconnect + end + + self.in_buffer = self.in_buffer .. buffer + if(inst.config.runtype == defines.IN_MODULE) then + self.in_buffer = command_table:dispatch(self.in_buffer) + else + self.in_buffer = response_table:dispatch(self.in_buffer) + end + + return defines.OK + end + function handle:write() + local len, err = tcp.send(self.fd, self.out_buffer) + if(len == nil) then + log.printf(log.ERROR, inst.name .. ": connection error: %s", err) + ret = defines.KILL_MODULE -- TODO: reconnect + else + self.out_buffer = string.sub(self.out_buffer, len+1) + end + if(inst.config.runtype == defines.OUT_MODULE and self.out_buffer == "") then + command_queue:command_sent() + end + return defines.OK + end + + local client = {} + client.module_instance = inst + client.name = inst.name .. "#0" + function client:process_response() end + function client:process_timeout() end + function client:get_read_handles() + return { handle } + end + function client:get_write_handles() + if(handle.out_buffer ~= "") then + return { handle } + else + return {} + end + end + function client:cleanup() + rawio.close(handle.fd) + end + handle.client_instance = client + + local connect_handle = {} + connect_handle.fd = handle.fd + function connect_handle:read() return defines.OK end + function connect_handle:write() + local connected, err = tcp.connect(handle.fd) + if(not connected) then + return defines.KILL_MODULE + end + inst.connected = true + client_list:register(client) + return defines.OK + end + connect_handle.client_instance = client + + function inst:cleanup() + client_list:unregister_by_module(self) + end + function inst:get_read_handles() + return {} + end + function inst:get_write_handles() + if(not inst.connected) then + return { connect_handle } + else + return {} + end + end + function inst:start_command(command) + handle.out_buffer = command + end + setmetatable(inst, {}) + getmetatable(inst).__gc = function() inst:cleanup() end + + return inst +end + +return tcp_connect |