[Moeng-cvs] Mamura/tests/netobjs NetObjects.rb,1.2,1.3 NetSessions.rb,1.2,1.3

[<b_l...@us...>]

Update of /cvsroot/moeng/Mamura/tests/netobjs
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31148

Modified Files:
	NetObjects.rb NetSessions.rb 
Log Message:
Some more changes/corrections. I am now convinced this is not the way to do network communication.

Index: NetObjects.rb
===================================================================
RCS file: /cvsroot/moeng/Mamura/tests/netobjs/NetObjects.rb,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** NetObjects.rb	10 Mar 2004 20:42:59 -0000	1.2
--- NetObjects.rb	12 Mar 2004 19:28:20 -0000	1.3
***************
*** 6,10 ****
  
  class NetObjectController
!     attr_reader :channel
      
      def initialize(netsession, channel)
--- 6,10 ----
  
  class NetObjectController
!     attr_reader :channel, :server_objs, :netsession
      
      def initialize(netsession, channel)
***************
*** 16,24 ****
          
          @netsession.on_receive(channel) { |message, from|
!             self.on_receive(message, from)
          }
      end
  
!     def on_receive(message, from)
          # Extract information from message
          server_obj = message[0]
--- 16,24 ----
          
          @netsession.on_receive(channel) { |message, from|
!             receive(message, from)
          }
      end
  
!     def receive(message, from)
          # Extract information from message
          server_obj = message[0]
***************
*** 31,35 ****
              obj = @server_objs.at(obj_id)
              if obj
!                 obj.on_receive(from, mess)
              end
          else
--- 31,37 ----
              obj = @server_objs.at(obj_id)
              if obj
!                 obj.receive(from, mess)
!             else
!                 puts "Warning, message received from unknown object!"
              end
          else
***************
*** 37,44 ****
              obj = @client_objs.at(obj_id)
              if obj
!                 obj.on_receive(mess)
              elsif @create_closure
                  obj = NetObjectClient.new(obj_id, from, self)
!                 if @create_closure.call(obj, mess)
                      @client_objs[obj_id] = obj
                  end
--- 39,48 ----
              obj = @client_objs.at(obj_id)
              if obj
!                 obj.receive(mess)
              elsif @create_closure
                  obj = NetObjectClient.new(obj_id, from, self)
!                 type = mess[0]
!                 mess = mess[1]
!                 if @create_closure.call(obj, type, mess)
                      @client_objs[obj_id] = obj
                  end
***************
*** 67,82 ****
          @server = server
          @controller = controller
      end
  
!     def send(message)
          @server.send(@controller.channel, [true, @obj_id, message])
      end
  
!     def on_receive_call(handler)
!         @handler = handler
      end
  
!     def on_receive(message)
!         @handler.on_receive(message) if @handler
      end
  end
--- 71,90 ----
          @server = server
          @controller = controller
+         @receive_closures = Hash.new
      end
  
!     def send(type, message)
!         message = [type, message]
          @server.send(@controller.channel, [true, @obj_id, message])
      end
  
!     def on_receive(type, &closure)
!         @receive_closures[type] = closure
      end
  
!     def receive(message)
!         type = message[0]
!         message = message[1]
!         @receive_closures[type].call(message) if @receive_closures[type]
      end
  end
***************
*** 91,98 ****
      def initialize(controller)
          @controller = controller
!         @obj_id = controller.next_obj_id
      end
  
!     def send(computers, message)
          computers.each { |comp|
              comp.send(@controller.channel, [false, @obj_id, message])
--- 99,111 ----
      def initialize(controller)
          @controller = controller
!         
!         @obj_id = @controller.next_obj_id
!         @controller.server_objs[obj_id] = self
!         
!         @receive_closures = Hash.new
      end
  
!     def send(computers, type, message)
!         message = [type, message]
          computers.each { |comp|
              comp.send(@controller.channel, [false, @obj_id, message])
***************
*** 100,109 ****
      end
  
!     def on_receive_call(handler)
!         @handler = handler
      end
  
!     def on_receive(computer, message)
!         @handler.on_receive(computer, message) if @handler
      end
  end
--- 113,130 ----
      end
  
!     def on_receive(type, &closure)
!         @receive_closures[type] = closure
      end
  
!     def receive(computer, message)
!         puts "NetObjectServer receives #{message}"
!         type = message[0]
!         message = message[1]
!         
!         if @receive_closures[type]
!             @receive_closures[type].call(computer, message)
!         else
!             puts "No closure defined for message type #{type}"
!         end
      end
  end

Index: NetSessions.rb
===================================================================
RCS file: /cvsroot/moeng/Mamura/tests/netobjs/NetSessions.rb,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** NetSessions.rb	10 Mar 2004 20:42:59 -0000	1.2
--- NetSessions.rb	12 Mar 2004 19:28:20 -0000	1.3
***************
*** 19,23 ****
          # message is expected to be an array, but can in theory be any object
          # that can be used with the Marshal module
!         @tcp_socket.write(Marshal.dump([channel, message]))
          @tcp_socket.write("\n\n")
      end
--- 19,24 ----
          # message is expected to be an array, but can in theory be any object
          # that can be used with the Marshal module
!         packet = [channel, message]
!         @tcp_socket.write(Marshal.dump(packet))
          @tcp_socket.write("\n\n")
      end
***************
*** 35,77 ****
  
  class NetSession
-     attr_reader :computers
-     
      def initialize()
          @messages = Array.new
!         @computers = Array.new
          @mutex = Mutex.new
          @receive_closures = Hash.new
      end
  
      def listen(port)
!         # Start listening for connections on the given port (spawn a thread for
!         # this job)
!         Thread.new(port) do |port|
!             gs = TCPServer.open(port)
!             addr = gs.addr
!             addr.shift
!             puts("Server is on " + addr.join(":"))
  
!             loop do
!                 Thread.start(gs.accept) do |socket|
                      # Add a new NetComputer object for connecting computer
!                     comp = NetComputer.new(socket, self)
!                     @mutex.synchronize { @computers.push(comp) }
! 
                      # Call the closure if defined
                      if (@computer_connected_closure)
                          @computer_connected_closure.call(comp)
                      end
! 
!                     # Wait for messages until computer disconnects
!                     while incoming = socket.gets(nil)
!                         message = Marshal.load(incoming)
!                         print("Server received ", message, "\n")
!                         @mutex.synchronize { @messages.push([message, comp]) }
!                     end
! 
                      # Disconnected, close and remove for computers array
!                     puts("Computer disconnected")
!                     @mutex.synchronize { @computers.delete(comp) }
                      
                      # Call the closure if defined
--- 36,83 ----
  
  class NetSession
      def initialize()
          @messages = Array.new
!         @computers = Hash.new
          @mutex = Mutex.new
          @receive_closures = Hash.new
      end
+     
+     def listen_async(port)
+         # Spawn a thread and start listening there
+         Thread.new(port) do |port|
+             listen(port)
+         end
+     end
  
      def listen(port)
!         # Start listening for connections on the given port
!         gs = TCPServer.open(port)
!         addr = gs.addr
!         addr.shift
!         puts("Server is on " + addr.join(":"))
!         socks = [gs]
  
!         loop do
!             nsock = select(socks)
!             next if nsock == nil
!             for s in nsock[0]
!                 if s == gs
!                     ns = s.accept
!                     socks.push(ns)
!                     
                      # Add a new NetComputer object for connecting computer
!                     comp = NetComputer.new(ns, self)
!                     @mutex.synchronize { @computers[ns] = comp }
!     
                      # Call the closure if defined
                      if (@computer_connected_closure)
                          @computer_connected_closure.call(comp)
                      end
!                 elsif s.eof?
                      # Disconnected, close and remove for computers array
!                     print(s, " disconnected\n")
!                     s.close
!                     socks.delete(s)
!                     @mutex.synchronize { @computers.delete(s) }
                      
                      # Call the closure if defined
***************
*** 79,82 ****
--- 85,91 ----
                          @computer_disconnected_closure.call(comp)
                      end
+                 elsif incoming = s.gets("\n\n")
+                     message = Marshal.load(incoming)
+                     @mutex.synchronize { @messages.push([message, comp]) }
                  end
              end
***************
*** 88,97 ****
          Thread.new do
              # Connect to a server at adress:port
!             print("Connecting to ", host, ":", port, " ...\n")
              STDOUT.flush
              socket = TCPSocket.open(host, port)
              comp = NetComputer.new(socket, self)
!             @computers.push(comp)
!             print("Connected to:   ", socket.peeraddr.join(":"), "\n")
              
              while incoming = socket.gets("\n\n")
--- 97,106 ----
          Thread.new do
              # Connect to a server at adress:port
!             print("Connecting to ", host, ":", port, " ... ")
              STDOUT.flush
              socket = TCPSocket.open(host, port)
              comp = NetComputer.new(socket, self)
!             @computers[socket] = comp
!             print("connected\n")
              
              while incoming = socket.gets("\n\n")
***************
*** 103,107 ****
              # Disconnected
              puts("Server disconnected")
!             @mutex.synchronize { @computers.delete(comp) }
          end
      end
--- 112,116 ----
              # Disconnected
              puts("Server disconnected")
!             @mutex.synchronize { @computers.delete(socket) }
          end
      end
***************
*** 125,128 ****
--- 134,139 ----
                  if @receive_closures[channel]
                      @receive_closures[channel].call(mess, from)
+                 else
+                     puts "No closure defined for channel (#{channel})!"
                  end
              }
***************
*** 130,132 ****
--- 141,147 ----
          }
      end
+     
+     def computers
+         @computers.values
+     end
  end