/ - Diff - CyborgHood - DuckCorp Projects

         bindtextdomain("cyborghood_mapmaker", {:path => Config::L10N_DIR, :charset => "UTF-8"})
         class MapMaker < Cyborg
           include SimpleServer
           include BotServer
           def interface
             MapMakerInterface.instance

     #++
     require 'cyborghood'
     require 'eventmachine'
     module CyborgHood
-...
         def run
           logger.info "Bot starting"
           EventMachine.run do
             start_work
           end
         end
         def start_work
           # use "aspects" Modules to define behaviors
         end
         def ask_to_stop
           logger.info "Bot was asked to stop..."
           EventMachine.stop
         end
         # core capabilities
         def capabilities
           []
         end
         def schedule_task(callback, &task)
           EventMachine.defer(task, callback)
         end
       end
     end

           @protocol = BotProtocol.new(self)
         end
         def capabilities
           []
         end
         def post_init
           logger.debug "New conversation with #{identifier}"
         end
-...
           @split_data_message = nil
           @split_data = []
         end
       end
       class ConversationUNIXSocket < Conversation
         public_class_method :new
         def identifier
           "unix_socket/#{@signature}"
         end
         def capabilities
           super + []
           "#{@bot.identifier_prefix}/#{@signature}"
         end
       end
     end

         end
         def receive_request_capabilities(message)
           send_reply_result(message, @conversation.capabilities + CAPABILITIES)
           send_reply_result(message, @conversation.bot.capabilities + CAPABILITIES)
         end
         def receive_request_call(message)

     # along with this program.  If not, see <http://www.gnu.org/licenses/>.
     #++
     require 'eventmachine'
     require 'cyborghood/cyborg/interface'
     require 'cyborghood/cyborg/conversation'
     module CyborgHood
       class BotServer
         private_class_method :new
         attr_reader :interface
         def self.build(interface)
           case Config.instance.botnet.connection_type
           when 'unix_socket'
             return BotServerUNIXSocket.new(interface)
           else
             raise CyberError.new(:unrecoverable, "config", "Unknown botnet connection type")
           end
         end
         def initialize(interface)
           @interface = interface
           @config = Config.instance
           @comm_list = {}
         end
         def run
           EventMachine.run do
             yield
           end
         end
         def stop
           @comm_list.values.each {|conv| conv.bye }
           EventMachine.stop
         end
         # used to quit properly and later to reuse communication channels
         def register_communication(peer, conversation)
           @comm_list[peer] = conversation
         end
         def unregister_communication(peer)
           @comm_list.delete(peer)
         end
         def schedule_task(callback, &task)
           EventMachine.defer(task, callback)
         end
       end
       class BotServerUNIXSocket < BotServer
         public_class_method :new
         def initialize(interface)
           super(interface)
       module BotServerUNIXSocket
         def setup
           super
           @socket = File.join(Config::RUN_DIR, @config.bot_name.downcase + ".sock")
           at_exit { remove_socket_file }
         end
         def run
           super do
             EventMachine.start_unix_domain_server(@socket, ConversationUNIXSocket, self)
           end
         def start_work
           super
           EventMachine.start_unix_domain_server(@socket, Conversation, self)
         end
         private
         def remove_socket_file
           File.delete(@socket) if @socket && File.exist?(@socket)
         end
         # backend-specific capabilities
         def capabilities
           super + []
         end
         # TODO: should be common to the future BotClientUNIXSocket
         def identifier_prefix
           "unix_socket"
         end
       end
       # default interface if not overridden
-...
         include CyborgServerRootInterfaceAddon
       end
       module SimpleServer
       module BotServer
         attr_reader :interface
         def self.included(base)
           case Config.instance.botnet.connection_type
           when 'unix_socket'
             return base.class_eval("include BotServerUNIXSocket")
           else
             raise CyberError.new(:unrecoverable, "config", "Unknown botnet connection type")
           end
         end
         def setup
           super
           @server = BotServer.build(self.interface)
           @comm_list = {}
         end
         def run
           super
           @server.run
         # used to quit properly and later to reuse communication channels
         def register_communication(peer, conversation)
           @comm_list[peer] = conversation
         end
         def unregister_communication(peer)
           @comm_list.delete(peer)
         end
         def ask_to_stop
           @server.stop
           @comm_list.values.each {|conv| conv.bye }
           super
         end

Project

General

Profile

DuckCorp » CyborgHood

Revision bc642412

Added by Marc Dequènes about 14 years ago