DuckCorp » CyborgHood

# Note: Event machine core is mono-thread, so this code is not threadsafe.

# Only long tasks will be run in threads, which do not care about all this.

module BotProtocol

VERSION = "0.1"

CAPABILITIES = []

@@request_callback = proc{|result| process_request_result(result) }

# TODO:

# - check for request/reply couples (reply to wrong of non-existent request)

# - check for negociation wip/done

def initialize(conversation)

@conversation = conversation

@negociation_received = false

@negociation_sent = false

@negociation_ok = false

end

def negociation_ok?

@negociation_ok

end

def process_received_message(message)

method = "receive_" + message.action_code.downcase.tr(" ", "_")

if respond_to? method

send(method, message)

else

send_error_protocol "unknown action"

end

end

def process_request_result(result)

if result[:error]

send_error_action(result[:reply_message], result[:error])

else

send_reply_result(result[:reply_message], result[:action_result])

end

end

def receive_announce_helo(message)

unless message.conv_thread.id == 0

return send_quit_decline "bad negociation"

end

unless message.parameters[:bot_name] =~ Conversation::BOT_ID_PATTERN

return send_quit_decline "bad bot name"

end

unless message.parameters[:protocol_version] == VERSION

return send_quit_decline "protocol version does not match"

end

@negociation_received = true

@conversation.set_peer_info(message.parameters[:bot_name], message.parameters[:capabilities])

if @negociation_sent

send_announce_ok(message)

@negociation_ok = true

else

send_announce_helo(message)

@negociation_sent = true

end

end

def receive_announce_ok(message)

unless @negociation_sent and @negociation_received

send_quit_decline "bad negociation"

end

@negociation_ok = true

end

def receive_request_capabilities(message)

send_reply_result(message, @conversation.capabilities + CAPABILITIES)

end

def receive_request_call(message)

unless @conversation.bot.interface.is_node? message.parameters[:node]

return send_error_action(message, "bad node")

end

send_reply_ack(message)

@conversation.bot.schedule_task(@@request_callback) do

result = {

:reply_message => message

}

begin

result[:action_result] = @conversation.bot.interface.call(message.conv_thread.session,

message.parameters[:node],

message.parameters[:data])

rescue

result[:error] = $!

end

end

end

def receive_request_exists(message)

unless @conversation.bot.interface.is_node? message.parameters[:node]

return send_error_action(message, "bad node")

end

send_reply_ack(message)

@conversation.bot.schedule_task(@@request_callback) do

{

:reply_message => message,

:action_result => @conversation.bot.interface.has_node? message.parameters[:node]

}

end

end

def receive_request_describe(message)

# TODO: implement when ready in the interface

send_quit_decline(message, "not implemented")

end

def send_announce_helo(recv_message = nil)

action_code = "ANNOUNCE HELO"

message = (recv_message.nil? ? @conversation.thread('system').new_message(action_code) :

recv_message.create_reply(action_code))

message.send

end

def send_announce_ok(recv_message)

recv_message.create_reply("ANNOUNCE OK").send

end

def send_request_capabilities

@conversation.thread('system').new_message("REQUEST EXISTS", { :node => node }).send

end

def send_request_call(conv_thread, node)

conv_thread.new_message("REQUEST CALL", { :node => node }).send

end

def send_request_exists(conv_thread, node)

conv_thread.new_message("REQUEST EXISTS", { :node => node }).send

end

def send_request_describe(conv_thread, node)

conv_thread.new_message("REQUEST DESCRIBE", { :node => node }).send

end

def send_error_protocol(error, fatal = false)

@conversation.thread('system').new_message("ERROR PROTOCOL", { :error => error }).send

@conversation.set_error_status(fatal)

end

def send_error_action(recv_message, error)

recv_message.create_reply("ERROR ACTION", { :error => error }).send

end

def send_reply_ack(recv_message)

recv_message.create_reply("REPLY ACK").send

end

def send_reply_decline(recv_message, reason)

recv_message.create_reply("REPLY DECLINE", { :reason => reason }).send

end

def send_reply_result(recv_message, result)

recv_message.create_reply("REPLY ACK", { :result => result }).send

end

def send_quit_decline(reason)

@conversation.thread('system').new_message("QUIT LEAVING", { :reason => reason }).send

end

def send_quit_leaving

@conversation.thread('system').new_message("QUIT LEAVING").send

end

end