Changeset 1584

Timestamp:

01/20/10 20:33:32 (2 years ago)

Author:

tolteque

Message:

o Lotatc:

• Modify radarServer to send and receive frame in the new Fashion.

--- OF COURSE NOT TESTED --- :)

Location:

trunk

Files:

• lotatc_server/lotatc_radarServer.py (modified) (36 diffs)
• textNewCnx.py (modified) (5 diffs)

trunk/lotatc_server/lotatc_radarServer.py

@@ -25 +25 @@
 from configuration_object     import ConfigurationObject
 from lotatc_radarList         import *
+from cnxObj                   import *  
 
 # List of commands
@@ -86 +87 @@
     self.logger.debug('__init__')
     
+    # Create cnxObj used to communicate with RadarClient
+    self.cnxObj = CnxObj( request)
+    
     # This is the PSEUDO of the troller
     self.controllerId = None
@@ -95 +99 @@
     # This the dictionary used for the objects sent to this troller
     self.objects={}
-    
     
     # There is no protection, but there is not a lot of risk ...
@@ -159 +162 @@
   # @param self  instance id
   def handle(self):
-
-    # 'incompleteMessage' is the start of a message which has been truncated during transmission ...
-    # It has to be prepend to the first message of the next buffer.
-    incompleteMessage=""
-
     while(True):
-      # Get one segment
       try:
-        buffer = self.request.recv(1024)
-        #- If client close the connection, buffer is void...
-        if not buffer:
-            #- Buffer void, return
-            return
+        frames = self.cnxObj.receiveFrame()
+        # Test if client has close the connection
+        if len( frames[0]):
+          return
       except:
-          return
-
-      # Detecte if the last message of the buffer is complete or not
-      if buffer.endswith( os.linesep):
-        lastMessageIsComplete = True
-      else:
-        lastMessageIsComplete = False
+        return
 
       # Test for EndOfMission notified by LuaServer
@@ -197 +187 @@
       self.radarServer.coalitionLocks[cst_coalitionLut[0]].release()
 
-      # split buffer in messages
-      msgList = buffer.split(os.linesep)
-      
-      # If there is an incompleteMessage, pre-pend this incompleteMessage
-      # with the first message of the buffer.
-      if incompleteMessage !="":
-        msgList[0] = incompleteMessage + msgList[0]
-        incompleteMessage =""
-      
-      # Process each message
-      nbrMessages = len(msgList)
-      for index in range(nbrMessages):
-        if lastMessageIsComplete or (index != nbrMessages-1):
-          msg = msgList[index]
-          if len(msg) and msg != os.linesep:
-            data = msg.strip()
-            request = data.split("|", 1)[0]
-
-            if request == DATA_REQ:
-              self.dataRequest()
-
-            elif request == BROADCAST_REQ:
-              # items[1] => sendTo
-              # items[2] => incomming message
-              items = data.split("|", 2)
-              message = MSG + "|" + items[1] + "|" + self.controllerId + "|" + items[2] + os.linesep
-              self.server.broadcastMessage(message, self.controllerCoalition, items[1], self.controllerId)
-
-            elif request == TAG_SET:
-              self.tagObject(data)
-                
-            elif request == GRAPH_ADD:
-              self.graphAdd(data)
-                
-            elif request == GRAPH_DEL:
-              self.graphDelete(data)
-
-            elif request == GRAPH_MOD:
-              self.graphModify(data)
-
-            elif request == GRAPH_MSG_ID_REQ:
-              self.graphGetMsgId(data)
-
-            elif request == GRAPH_LOCK_REQ:
-              self.graphLock(data)
+
+      # Process each received frame
+      for frame in frames:
+        opCode = frame.split("|", 1)[0]
+
+        if opCode == DATA_REQ:
+          self.dataRequest()
+
+        elif opCode == BROADCAST_REQ:
+          # items[1] => sendTo
+          # items[2] => incomming message
+          items = frame.split("|", 2)
+          message = MSG + "|" + items[1] + "|" + self.controllerId + "|" + items[2]
+          self.server.broadcastMessage(message, self.controllerCoalition, items[1], self.controllerId)
+
+        elif opCode == TAG_SET:
+          self.tagObject(frame)
+            
+        elif opCode == GRAPH_ADD:
+          self.graphAdd(frame)
+            
+        elif opCode == GRAPH_DEL:
+          self.graphDelete(frame)
+
+        elif opCode == GRAPH_MOD:
+          self.graphModify(frame)
+
+        elif opCode == GRAPH_MSG_ID_REQ:
+          self.graphGetMsgId(frame)
+
+        elif opCode == GRAPH_LOCK_REQ:
+          self.graphLock(frame)
+          
+        elif opCode == GRAPH_UNLOCK_REQ:
+          self.graphUnlock(frame)
+
+        elif opCode == LOGIN:
+          self.login(frame)
+
+        elif opCode == CONFIG_REQ:
+          self.configRequest(frame)
+
+        elif opCode == MISSION_REQ:
+          self.sendMissionData()
+
+        elif opCode == SEND_TO_ONE_PLAYER:
+          items = frame.split("|", 2)
+          playerId = items[1]
+          message  = items[2]
+          self.server.sendToPlayer( playerId, message)
+        
+        elif opCode == SEND_TO_ALL_PLAYERS:
+          self.server.sendToPlayer( None, frame.split("|", 1)[1])
+          
+        else:
+          self.logger.debug("Unkwon command: %s" % opCode)
               
-            elif request == GRAPH_UNLOCK_REQ:
-              self.graphUnlock(data)
-
-            elif request == LOGIN:
-              self.login(data)
-
-            elif request == CONFIG_REQ:
-              self.configRequest(data)
-
-            elif request == MISSION_REQ:
-              self.sendMissionData()
-
-            elif request == SEND_TO_ONE_PLAYER:
-              items = data.split("|", 2)
-              playerId = items[1]
-              message  = items[2]
-              self.server.sendToPlayer( playerId, message)
-            
-            elif request == SEND_TO_ALL_PLAYERS:
-              self.server.sendToPlayer( None, data.split("|", 1)[1])
-              
-            else:
-              self.logger.debug("Unkwon command: %s" % request)
-              
-            # End of: if request == DATA_REQ
-          # End of: if len(msg) and msg != LINE_SEP
-        # End of: if lastMessageIsComplete or (index != nbrMessages-1):
-        else: 
-          incompleteMessage = msgList[index]
-        
       # End of: for index in range(nbrMessages):
     # End of: while(True):
@@ -293 +264 @@
             # Yes -> remove lock and notify other client about Unlock
             self.graph[graphId]["LockBy"] = None
-            self.server.broadcastMessage(GRAPH_UNLOCK_REP + "|%s|%s|%s" % (0, graphId, "1" + os.linesep), self.controllerCoalition, "ALL")
+            self.server.broadcastMessage( GRAPH_UNLOCK_REP + "|%s|%s|%s" % (0, graphId, "1"), self.controllerCoalition, "ALL")
         self.lock.release()
 
@@ -318 +289 @@
           debugMessage = "|--> Incorrect client version"
           self.logger.debug(debugMessage)
-          self.request.send(LOGIN_NACK + debugMessage + os.linesep)
+          self.cnxObj.sendFrame( LOGIN_NACK + debugMessage)
           return
         if password == controllerPwd and self.radarServer.controllerOk(self):
@@ -327 +298 @@
           self.graph = self.mainInfo["GRAPH"][coalition]
           self.logger.info("The troller '%s' is working for '%s' coalition"  % (self.controllerId, self.controllerCoalition))
-          self.request.send(LOGIN_ACK + "|%s|%s" % (coalition, str( CST_LOTATC_NETWORK_VERSION ) + os.linesep) )
+          self.cnxObj.sendFrame( LOGIN_ACK + "|%s|%s" % (coalition, str( CST_LOTATC_NETWORK_VERSION)) )
 
           # MissionStartTime is to be sent
@@ -348 +319 @@
               message += "|%s|%s" % (key,graph["Data"])
 
-            message += os.linesep
-            self.request.send(message)
+            self.cnxObj.sendFrame( message)
           # End of: if len(self.graph):
 
@@ -358 +328 @@
       debugMessage = "|--> Incorrect logging password"
       self.logger.debug(debugMessage)
-      self.request.send(LOGIN_NACK + debugMessage + os.linesep)
+      self.cnxObj.sendFrame( LOGIN_NACK + debugMessage)
     else:
       debugMessage = "|--> Incorrect logging message length"
       self.logger.debug(debugMessage)
-      self.request.send(LOGIN_NACK + debugMessage + os.linesep)
+      self.cnxObj.sendFrame( LOGIN_NACK + debugMessage)
     # End of: if len(items) == 3:
 
@@ -388 +358 @@
 
     # Send response
-    self.request.send(configRep + os.linesep)
+    self.cnxObj.sendFrame( configRep)
 
 
@@ -400 +370 @@
     if self.globalServerConfig.Mission:
       for m in self.globalServerConfig.Mission:
-        self.request.send(MISSION_REP + "|" + m + os.linesep)
+        self.cnxObj.sendFrame( MISSION_REP + "|" + m)
       # End of: for m in self.globalServerConfig.Mission:
         
       # For the moment it is a stub
-      self.request.send(MISSION_END + os.linesep)
+      self.cnxObj.sendFrame(MISSION_END)
       
     else:
       message = "Mission has not been imported ..."
       self.logger.debug(message)
-      self.request.send("%s|%s" % (MISSION_NACK, message+os.linesep))
+      self.cnxObj.sendFrame("%s|%s" % ( MISSION_NACK, message))
     # End of: if self.globalServerConfig.Mission:
 
@@ -431 +401 @@
         if (self.mainObjects):
           # Send MissionStartTime
-          message = MISSION_START_TIME + "|%s\n" % self.mainInfo["MissionStartTime"]
-          self.request.send(message)
+          message = MISSION_START_TIME + "|%s" % self.mainInfo["MissionStartTime"]
+          self.cnxObj.sendFrame( message)
           self.sendMissionStartTime = False
           print "Send MissionStartTime"
@@ -439 +409 @@
       self.lock.acquire()
       # Send DATA_REP with timestamp for the time slot
-      message = "%s|%s\n" % (DATA_START,  self.mainInfo["TimeStamp"][self.controllerCoalition])
+      frame = self.cnxObj.buildFrame( "%s|%s" % (DATA_START,  self.mainInfo["TimeStamp"][self.controllerCoalition]))
       # Loop over detected objects
       for (key, thisObject) in self.mainObjects.iteritems():
@@ -448 +418 @@
           self.objects[key] = thisObject.clone()
 #           self.logger.info("Static info for id:%s %s %s" % (key, thisObject.unitName, thisObject.pilotName))
-          message = message + (DATA_REP0 + "|%s|%s|%s|%s|%s" %
-                              (key, thisObject.type.encode('utf-8'), thisObject.unitClsId, thisObject.pilotName.encode('utf-8'), thisObject.coalition + os.linesep))
+          frame += self.cnxObj.buildFrame( DATA_REP0 + "|%s|%s|%s|%s|%s" %
+                                           (key, thisObject.type.encode('utf-8'), thisObject.unitClsId, thisObject.pilotName.encode('utf-8'), thisObject.coalition))
                                             
           # ------------------------------------------------------------------------------------
           # Send  variable part
-          message = message + (DATA_REP1 + "|%s|%s|%s|%s|%s" %
-                                          (key, thisObject.x, thisObject.y, thisObject.z, str(thisObject.bearing) + os.linesep))
+          frame += self.cnxObj.buildFrame( DATA_REP1 + "|%s|%s|%s|%s|%s" %
+                                           (key, thisObject.x, thisObject.y, thisObject.z, str(thisObject.bearing)))
 
           # As it is a new object, test for Tag to be sent.
           if self.tag.has_key(key):
             tag = self.tag[key]
-            message = message + TAG_SET + "|%s|%s" % (key, tag + os.linesep)
+            frame += self.cnxObj.buildFrame( TAG_SET + "|%s|%s" % (key, tag))
 #             self.logger.info("Send tag id:%s Tag:%s" % (key, tag))
           # End of: if self.tag.has_key(key):
@@ -467 +437 @@
 #           self.logger.debug("Update info for id:%s Name:%s" % (key, localObject.unitName))
           # We have just to send the differences
-          message = message + (DATA_REP1 + "|%s" % key)
+          message = (DATA_REP1 + "|%s" % key)
           if localObject.x != thisObject.x:
             message = message + ("|%s" % thisObject.x)
@@ -492 +462 @@
             message = message + "|"
           
-          message = message + os.linesep
+          frame += self.cnxObj.buildFrame( message)
         # End of: if not self.objects.has_key(key):  
       # End of: for (key, thisObject) in self.mainObjects.iteritems():
       
       # Send "end of transmition"
-      message = message + (DATA_END + os.linesep)
-      self.request.send(message)
+      frame += self.cnxObj.buildFrame( DATA_END)
+      self.cnxObj.sendFrame( message, multiFrame=True)
 
 
@@ -504 +474 @@
       # Check if there are new mobile radars
       newRadarFound = False
-      message = CONFIG_REP1
+      frame = CONFIG_REP1
       for (key, thisObject) in  self.mainObjects.iteritems():
         if cst_coalitionLut[int(thisObject.coalition)] == self.controllerCoalition:
@@ -512 +482 @@
               newRadarFound = True
               self.mobileRadarKeys.append(key)
-              message = message + "|%s|%s|%s" % (key, thisObject.unitName.encode('utf-8'), thisObject.pilotName.encode('utf-8'))
+              frame = frame + "|%s|%s|%s" % (key, thisObject.unitName.encode('utf-8'), thisObject.pilotName.encode('utf-8'))
             # End of: if thisObject.unitName in self.mobileRadarTypes:
           # End of: if not (key in self.mobileRadarKeys):
@@ -519 +489 @@
       
       if newRadarFound:
-        message = message + os.linesep
-        self.request.send(message)
+        self.cnxObj.sendFrame( frame)
       # End of: if newRadarFound:
           
@@ -531 +500 @@
           # Radar has been killed, send a message and tag it as "to remove"
           self.logger.info("Radar killed: id:%s" % key)
-          message = "%s|%s%s" %(RADAR_KILLED, key, os.linesep)
-          self.request.send(message)
+          frame = "%s|%s" %( RADAR_KILLED, key)
+          self.cnxObj.sendFrame( frame)
           keysToRemove.append(key)
         # End of: if not self.mainObjects.has_key(key):
@@ -557 +526 @@
       message = "Login or ConfigSet is missing ..."
       self.logger.debug(message)
-      self.request.send(DATA_REQ_NACK + "|--> %s" % message + os.linesep)
+      self.cnxObj.sendFrame( DATA_REQ_NACK + "|--> %s" % message)
     # End of: if self.controllerId :
 
@@ -566 +535 @@
   # @param message    message to be sent
   def sendMessage(self, message):
-    self.request.send(message)
+    self.cnxObj.sendFrame( message)
 
 
@@ -585 +554 @@
     # Save tag, then it is accessible by every troller.
     self.tag[objectId] = tag
-    self.server.broadcastMessage(TAG_SET + "|%s|%s" % (objectId, tag + os.linesep), self.controllerCoalition, "ALL")
+    self.server.broadcastMessage( TAG_SET + "|%s|%s" % (objectId, tag ), self.controllerCoalition, "ALL")
 
 # ============================================================
@@ -611 +580 @@
   def graphDelete(self,  data):
     self.logger.info("GraphDel request")
-    items     = data.split("|", 1)
-    graphId   = items[1]
+    items   = data.split("|", 1)
+    graphId = items[1]
 
     self.server.graphDelete( self.controllerCoalition, self.graph, graphId, self.controllerId, True)
@@ -634 +603 @@
       if self.graph[graphId]["LockBy"] == self.controllerId:
         self.graph[graphId]["Data"] = graphData
-        self.server.broadcastMessage(GRAPH_MOD + "|%s|%s" % (graphId, graphData + os.linesep), self.controllerCoalition, "ALL")
+        self.server.broadcastMessage( GRAPH_MOD + "|%s|%s" % (graphId, graphData), self.controllerCoalition, "ALL")
       else:
         self.logger.error("Troller %s tries to modify graph %s, but lock is missing" % (self.controllerId, graphId) )    
@@ -654 +623 @@
     self.lock.acquire()
     print "ASSIGN", msgId, self.controllerId
-    self.server.broadcastMessage(GRAPH_MSG_ID_REP + "|%s" % (str(msgId) + os.linesep), self.controllerCoalition, self.controllerId)
+    self.server.broadcastMessage( GRAPH_MSG_ID_REP + "|%s" % (str(msgId)), self.controllerCoalition, self.controllerId)
     msgId += 1
     self.lock.release()
@@ -675 +644 @@
       if self.graph[graphId]["LockBy"] == None:
         self.graph[graphId]["LockBy"] = self.controllerId
-        self.server.broadcastMessage(GRAPH_LOCK_REP + "|%s|%s|%s" % (msgId, graphId, "1" + os.linesep), self.controllerCoalition, "ALL")
+        self.server.broadcastMessage( GRAPH_LOCK_REP + "|%s|%s|%s" % (msgId, graphId, "1"), self.controllerCoalition, "ALL")
       else:
-        self.server.broadcastMessage(GRAPH_LOCK_REP + "|%s|%s|%s" % (msgId, graphId, "0" + os.linesep), self.controllerCoalition, self.controllerId)
+        self.server.broadcastMessage( GRAPH_LOCK_REP + "|%s|%s|%s" % (msgId, graphId, "0"), self.controllerCoalition, self.controllerId)
 
     else:
@@ -701 +670 @@
       if self.graph[graphId]["LockBy"] == self.controllerId:
         self.graph[graphId]["LockBy"] = None
-        self.server.broadcastMessage(GRAPH_UNLOCK_REP + "|%s|%s|%s" % (msgId, graphId, "1" + os.linesep), self.controllerCoalition, "ALL")
+        self.server.broadcastMessage( GRAPH_UNLOCK_REP + "|%s|%s|%s" % (msgId, graphId, "1"), self.controllerCoalition, "ALL")
       else:
-        self.server.broadcastMessage(GRAPH_UNLOCK_REP + "|%s|%s|%s" % (msgId, graphId, "0" + os.linesep), self.controllerCoalition, self.controllerId)
+        self.server.broadcastMessage( GRAPH_UNLOCK_REP + "|%s|%s|%s" % (msgId, graphId, "0"), self.controllerCoalition, self.controllerId)
     else:
       self.logger.warning("There is no graph with this key %s" % graphId)   
@@ -837 +806 @@
       nbrOfTroller += 1
         
-    message = message + os.linesep
-    self.broadcastMessage(message,  coalition,  "ALL")
+    self.broadcastMessage( message,  coalition,  "ALL")
 
     self.luaServer.setTrollerNumber(coalition, nbrOfTroller)
@@ -872 +840 @@
       nbrOfTroller += 1
         
-    message = message + os.linesep
-    self.broadcastMessage(message,  coalition,  "ALL")
-    
-    self.luaServer.setTrollerNumber(coalition, nbrOfTroller)
+    self.broadcastMessage( message,  coalition,  "ALL")
+    
+    self.luaServer.setTrollerNumber( coalition, nbrOfTroller)
 
 
@@ -887 +854 @@
   # @param controllerId    destination
   def broadcastMessage(self, message, coalition, controllerId, senderId=None):
-    self.logger.debug("broadcastMessage: '%s' to [%s, %s]" % (message, coalition, controllerId))
+    self.logger.debug("broadcastMessage: '%s' to [%s, %s]" % ( message, coalition, controllerId))
 
     # Is the message to be sent to all the trollers ?
@@ -893 +860 @@
       # Yes => loop over all the trollers of the coalition
       for requestHandle in self.requestHandleInfo[coalition]:
-        requestHandle.sendMessage(message)
+        requestHandle.sendMessage( message)
 
     else:
@@ -899 +866 @@
       for requestHandle in self.requestHandleInfo[coalition]:
         if requestHandle.controllerId == controllerId:
-          requestHandle.sendMessage(message)
+          requestHandle.sendMessage( message)
         elif requestHandle.controllerId == senderId:
-          requestHandle.sendMessage(message)
+          requestHandle.sendMessage( message)
        
 
@@ -930 +897 @@
       if ( check == False )  or  ( graphs[graphId]["LockBy"] == controlerId ):
         del graphs[graphId]
-        self.broadcastMessage(GRAPH_DEL + "|%s" % (graphId + os.linesep), coalition, "ALL")
+        self.broadcastMessage( GRAPH_DEL + "|%s" % graphId, coalition, "ALL")
       else:
         self.logger.error("Troller %s tries to delete graph %s, but lock is missing" % (controlerId, graphId) )
@@ -956 +923 @@
     graphId = str(graphId)
     graphs[graphId] = {} 
-    graphs[graphId]["Data"]    = graphData
+    graphs[graphId]["Data"]   = graphData
     graphs[graphId]["LockBy"] = None
     self.coalitionLocks[coalition].release()
       
     # Broadcast message   
-    self.broadcastMessage(GRAPH_ADD + "|%s|%s" % (graphId, graphData + os.linesep), coalition, "ALL")
+    self.broadcastMessage( GRAPH_ADD + "|%s|%s" % (graphId, graphData), coalition, "ALL")
     
 # ============================================================

trunk/textNewCnx.py

@@ +1 @@
+# -*- coding: utf-8 -*-
+# vim: ts=4:sw=4
+#    This file is part of LOME.
+#
+#    LOME 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
+#    (at your option) any later version.
+#
+#    LOME 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 LOME.  If not, see <http://www.gnu.org/licenses/>.
+# 
+
 import os
 import sys
@@ -14 +32 @@
 
 
+sys.path.append( os.path.join( sys.path[0], 'common'))
+from cnxObj          import *
 
-#==============================================================================
-## Object used to send and receive data upon a socket or a request.
-class BaseCnxObj():
-
-  # Declaration of the two bits reserved for the transmission information
-  ZIPPED_DATA = 0x80000000
-  MULTI_FRAME = 0x40000000
-
-# ----------------------------------------------------------------------------
-  # Constructor
-  # @param self              object instance
-  def __init__( self):
-    pass
-
-# ----------------------------------------------------------------------------
-  # Methode used to build a multiFrame.
-  # @param self              object instance
-  # @param datas             datas to be sent
-  def buildFrame( self, datas):
-    datasLength = len(datas)
-    frame = struct.pack('L', datasLength)
-    frame += datas
-    return frame
-
-# ----------------------------------------------------------------------------
-  # Methode used to display frames from a multiframe.
-  # @param self              object instance
-  # @param multiFrame        multi frame to display
-  def displayMultiFrame( self, multiFrame):
-    index = 0
-    while ( index < len( multiFrame)):
-      length = struct.unpack('L', multiFrame[index:index+4])[0]
-      index += 4
-      print multiFrame[index:index+length]
-      index += length 
-
-      
-# ----------------------------------------------------------------------------
-  # Methode used to send a frame
-  # @param self              object instance
-  # @param datas             datas to be sent
-  # @param forceZip          flag used to force the the transmission of zipped data
-  # @param multiFrame        flag used to indicate that the frame is a multiframe
-  def sendFrame( self,  datas, forceZip=False, multiFrame=False):
-    # Process zip mode
-    datasLength = len(datas)
-    if forceZip or ( datasLength > 100):
-      datas = datas.encode("zip")
-      datasLength = len(datas) + self.ZIPPED_DATA
-    
-    # Process multiFrame mode
-    if multiFrame == True:
-      datasLength += self.MULTI_FRAME
-    
-    # Build message
-    message = struct.pack('L', datasLength)
-    message += datas
-
-    # Send message
-    self.send( message)
-
-
-# ----------------------------------------------------------------------------
-  # Methode used to receive a frame. It returns the clear data.
-  # @param self              object instance
-  def receiveFrame( self):
-    zippedData = False
-    multiFrame = False
-    # Read bufferLength from socket
-    buffer = ""
-    while( len( buffer) != 4):
-      buffer += self.recv( 4 - len( buffer))
-      if buffer == "":
-        break
-    
-    # Check if socket has been closed
-    if buffer != "":
-      dataLength = struct.unpack('L', buffer[0:4])[0]
-      
-      # Process dataLength for zipped data
-      if dataLength >= self.ZIPPED_DATA:
-        zippedData = True
-        dataLength -= self.ZIPPED_DATA
-      if dataLength >= self.MULTI_FRAME:
-        multiFrame = True
-        dataLength -= self.MULTI_FRAME
-        
-      # Receive datas
-      buffer = ""
-      while ( len( buffer) != dataLength):
-        buffer += self.recv( dataLength - len( buffer))
-      
-      # Unzip zipped data
-      if zippedData:
-        buffer = buffer.decode("zip")
-        
-      # Extract each frame of the multiFrame
-      if multiFrame == True:
-        bufferArray = []
-        index = 0
-        while ( index < len( buffer)):
-          length = struct.unpack('L', buffer[index:index+4])[0]
-          index += 4
-          bufferArray.append( buffer[index:index+length])
-          index += length 
-        return bufferArray
-        
-    # Return data
-    return [buffer]
-    
-    
-#==============================================================================
-## Object used to send and receive data upon a socket or a request.
-class QTCnxObj( BaseCnxObj, QTcpSocket):
-
-# ----------------------------------------------------------------------------
-  # Constructor
-  # @param self              object instance
-  def __init__( self):
-    BaseCnxObj.__init__( self)
-    QTcpSocket.__init__( self)
-    
-# ----------------------------------------------------------------------------
-  # Methode used to send a message
-  # @param self              object instance
-  # @param datas             datas to be sent
-  def send( self, datas):
-    self.write( datas)
-
-# ----------------------------------------------------------------------------
-  # Methode used to receive a message. It returns the clear data and a flag
-  # indicating if the data were zipped or not
-  # @param self              object instance
-  def recv( self, size):
-    return self.read( size)
-
-
-#==============================================================================
-## Object used to send and receive data upon a socket or a request.
-class CnxObj( BaseCnxObj):
-
-# ----------------------------------------------------------------------------
-  # Constructor
-  # @param self              object instance
-  def __init__( self, cnxObject):
-    BaseCnxObj.__init__( self)
-    self.cnxObj = cnxObject
-    
-# ----------------------------------------------------------------------------
-  # Methode used to send a message
-  # @param self              object instance
-  # @param datas             datas to be sent
-  def send( self, datas):
-    self.cnxObj.send( datas)
-
-# ----------------------------------------------------------------------------
-  # Methode used to receive a message. It returns the clear data and a flag
-  # indicating if the data were zipped or not
-  # @param self              object instance
-  def recv( self, size):
-    return self.cnxObj.recv( size)
 
 #==============================================================================
@@ -217 +76 @@
         return
       
-      if len( frames) and len(frames[0]):
+      if len( frames[0]):
         for frame in frames:
           print "Frame received: %s" % frame
@@ -259 +118 @@
   for index in range(0,5):
     frame += cnxObj.buildFrame( "This is the frame: %02d in a multiframe" % index)
-#  cnxObj.displayMultiFrame( frame)
   cnxObj.sendFrame( frame, multiFrame = True)
   
@@ -293 +151 @@
   status = app.exec_()
 
-    
   # Create and connect socket
-  #sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
-  #print "socket created"
-  #try:
-  #  sock.connect( ( 'localhost', 10312))
-  #  print "socket connected"
-  #except socket.error, msg:
-  #  print msg
-  #  return
-  #cnxObj = CnxObj( sock)
-  #cnxObj.sendFrame( "This is a buffer tansmitted in the clear mode")
-  #cnxObj.sendFrame( "This is a buffer tansmitted in the zip mode" ,  forceZip=True)    
-  #cnxObj.sendFrame( "This is a buffer tansmitted in the zip mode\n"*10)    
-
-  #sleep(2)
-  #sock.shutdown(2)
-  #sleep(1)
+  sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM)
+  print "socket created"
+  try:
+    sock.connect( ( 'localhost', 10312))
+    print "socket connected"
+  except socket.error, msg:
+    print msg
+    return
+  cnxObj = CnxObj( sock)
+  cnxObj.sendFrame( "This is a buffer tansmitted in the clear mode")
+  cnxObj.sendFrame( "This is a buffer tansmitted in the zip mode" ,  forceZip=True)    
+  cnxObj.sendFrame( "This is a buffer tansmitted in the zip mode\n"*10)    
+  
+  sleep(1)
+  sock.shutdown(2)
 
 # =================================================