Project

General

Profile

« Previous | Next » 

Revision ce98dac2

Added by Marc Dequènes over 13 years ago

  • ID ce98dac2cc160cda69c76da624e6e21777b44128

[evol] work on cyborg server protocol and API (refs #31)

View differences:

bin/mapmaker
class MapMakerInterface < CyborgServerDefaultInterface
class DNS < CyborgServerInterface
def api_zone_exists?
"coucou"
end
split_mode_command :api_zone_exists?
end
end
end
lib/cyborghood/cyborg/interface.rb
class CyborgServerInterface
include Singleton
@split_mode_commands = []
class << self
attr_reader :split_mode_commands
end
def self.split_mode_command(*syms)
new_split_mode_commands = self.split_mode_commands || []
syms.each do |sym|
raise CyberError.new(:unrecoverable, "programmation", "not a symbol") unless sym.is_a? Symbol
raise CyberError.new(:unrecoverable, "programmation", "not an API method") unless api_method_name?(sym.to_s)
new_split_mode_commands << sym
end
instance_variable_set(:@split_mode_commands, new_split_mode_commands)
end
def self.decompose_command(cmd)
object, method = cmd.split('.', 2)
if method
begin
klass = object.split('::').inject(self) {|scope, const_name| scope.const_get(const_name)}
rescue
return
end
else
if object.index("::")
return
else
klass = self
method = cmd
end
end
[klass, method]
end
def self.is_split_mode_command?(cmd)
klass, method = decompose_command(cmd)
return false if klass.nil?
(klass.split_mode_commands || []).include? api_method_to_class_method_name(method)
end
def self.api_method_name?(method)
method =~ /^api_(.+)$/
$1
end
def self.api_method_to_class_method_name(method)
"api_#{method}".to_sym
end
def initialize
@config = Config.instance
end
......
end
def api_methods
@methods ||= self.methods.collect{|m| $1 if m =~ /^api_(.*)$/ }.compact
@methods ||= self.methods.collect{|m| self.class.api_method_name?(m) }.compact
end
# preliminary incoming message handling
def call(cmd)
object, method = cmd.split('.', 2)
if method
begin
klass = object.split('::').inject(self.class) {|scope, const_name| scope.const_get(const_name)}
rescue
return "551 unknown object"
end
else
klass = self.class
method = cmd
end
def call(cmd, args, data)
klass, method = self.class.decompose_command(cmd)
return "551 unknown object" if klass.nil?
inst = klass.instance
real_method = "api_#{method}"
unless inst.api_methods.include?(method)
return "551 this object has no such method"
end
begin
formated_data = data.to_yaml
rescue
return "552 wrong format for extra data"
end
begin
# preliminary outgoing message handling
return inst.send(real_method).to_yaml
real_method = self.class.api_method_to_class_method_name(method)
r = inst.send(real_method, *args) { formated_data }
r.to_yaml
rescue
return "550 method call failed"
end
......
end
class CyborgServerDefaultInterface < CyborgServerInterface
API_VERSION = "0.1~"
PROTOCOL_VERSION = "0.1~"
def api_product
PRODUCT
......
VERSION
end
def api_api_version
API_VERSION
def api_protocol_version
PROTOCOL_VERSION
end
def api_bot_name
lib/cyborghood/cyborg/server.rb
require 'eventmachine'
require 'cyborghood/cyborg/interface'
require 'shellwords'
module CyborgHood
......
class Conversation < EventMachine::Protocols::LineAndTextProtocol
private_class_method :new
# don't rely on EventMachine's default, it may change one day
MaxLineLength = 16*1024
EOD = "\033[0J"
def initialize(interface)
@interface = interface
super
@config = Config.instance
@split_data_mode = false
@split_data_cmd = nil
@split_data_cmd_args = []
@split_data = []
end
def send_line(msg)
send_data "#{msg}\r\n"
send_data "#{msg}\n"
logger.debug "Sent data [#{identifier}]: #{msg}"
end
def post_init
......
end
def receive_line(data)
logger.debug "Received [#{identifier}]: #{data}"
send_line @interface.instance.call(data)
return if data.empty?
if data == EOD
logger.debug "Received EOD [#{identifier}]"
exit_split_mode
else
if @split_data_mode
logger.debug "Received data (split mode) [#{identifier}]: #{data}"
@split_data << data
else
logger.debug "Received data [#{identifier}]: #{data}"
begin
cmd_parts = Shellwords.shellsplit(data)
rescue
logger.error "Error [#{identifier}]: syntax error"
send_line "552 syntax error"
return
end
cmd = cmd_parts.shift
args = cmd_parts
if @interface.is_split_mode_command? cmd
enter_split_mode(cmd, args)
else
receive_command(cmd, args)
end
end
end
end
def receive_command(cmd, args, data = nil)
logger.debug "Executing command '#{cmd}' [#{identifier}]"
send_line @interface.instance.call(cmd, args, data)
end
def receive_error(msg)
......
def unbind
logger.debug "Conversation finished with #{identifier}"
end
protected
def enter_split_mode(cmd, args)
if @split_data_mode
logger.error "Error [#{identifier}]: already in split mode"
send_line "551 protocol error"
@split_data_mode = false
@split_data_cmd = nil
@split_data_cmd_args = []
else
logger.debug "Entered split mode for command '#{cmd}' [#{identifier}]"
@split_data_mode = true
@split_data_cmd = cmd
@split_data_cmd_args = args
end
@split_data = []
end
def exit_split_mode
if @split_data_mode
logger.debug "Quit split mode for command '#{@split_data_cmd}' [#{identifier}]"
receive_command(@split_data_cmd, @split_data_cmd_args, @split_data.join("\n"))
else
logger.error "Error [#{identifier}]: not in split mode"
send_line "551 protocol error"
end
@split_data_mode = false
@split_data_cmd = nil
@split_data_cmd_args = []
@split_data = []
end
end
class ConversationUNIXSocket < Conversation

Also available in: Unified diff