fixes to pynorm for Python3 and normMsgr.py and normFileSend.py examples

examples/normSocket.h

@@ -119,7 +119,7 @@ typedef enum NormSocketEventType
 } NormSocketEventType;
     
     
-// Right now, these options MUST be set after NormOpen() 
+// Right now, these options MUST be set _after_ NormOpen() 
 // but _before_ NormConnect() or NormListen()
 // (This will be expanded, perhaps to include parameters 
 //  that can be changed after connection setup)

examples/python/normFileSend.py

@@ -10,7 +10,7 @@ from random import randint
 import pynorm
 
 USAGE = 'usage: %s [options] <file>' % sys.argv[0]
-DEFAULT_ADDR = '224.1.2.3'
+DEFAULT_ADDR = u'224.1.2.3'
 DEFAULT_PORT = 6003
 
 def get_option_parser():
@@ -29,7 +29,7 @@ def main(argv):
     (opts, args) = get_option_parser().parse_args(argv)
 
     if len(args) != 2:
-        print get_option_parser().get_usage()
+        print(get_option_parser().get_usage())
         return 1
 
     filepath = os.path.abspath(args[1])
@@ -40,23 +40,23 @@ def main(argv):
     session = instance.createSession(opts.address, opts.port)
     if opts.iface:
         session.setMulticastInterface(opts.iface)
-    session.setTxRate(256e10)
+    session.setTxRate(1.0e+06)
     session.startSender(randint(0, 1000), 1024**2, 1400, 64, 16)
 
-    print 'Sending file %s' % filename
+    print(('Sending file %s' % filename))
     session.fileEnqueue(filepath, filename)
 
     try:
         for event in instance:
             if event == 'NORM_TX_FLUSH_COMPLETED':
-                print 'Flush completed, exiting.'
+                print('Flush completed, exiting.')
                 return 0
             else:
-                print event
+                print(event)
     except KeyboardInterrupt:
         pass
 
-    print 'Exiting.'
+    print('Exiting.')
     return 0
 # end main
 

examples/python/normMsgr.py

@@ -14,7 +14,8 @@ class InputThread(Thread):
     
     def __init__(self, parent, *args, **kwargs):
         super(InputThread, self).__init__(*args, **kwargs)
-        self.setDaemon(True)  ;# this is "child" daemon thread
+        #self.setDaemon(True)  ;# this is "child" daemon thread  (setDaemon is deprecated)
+        self.daemon = True
         self.msgr = parent
         
     def run(self):
@@ -233,7 +234,8 @@ class NormEventHandler(Thread):
     
     def __init__(self, parentMsgr, *args, **kwargs):
         super(NormEventHandler, self).__init__(*args, **kwargs)
-        self.setDaemon(True)  ;# this is "child" daemon thread
+        #self.setDaemon(True)  ;# this is "child" daemon thread (setDaemon is deprecated)
+        self.daemon = True
         self.lock = Lock()
         self.msgr = parentMsgr
         

src/common/normNode.cpp

@@ -1975,7 +1975,7 @@ void NormSenderNode::Sync(NormObjectId objectId)
             }
             else if (objectId > firstPending)
             {
-               bool incrementResyncCount = false;  // may just be a squelch trim
+               bool incrementResyncCount = false;  // may just be a squelch trim 
                NormObject* obj;
                while ((obj = rx_table.Find(rx_table.RangeLo())) &&
                       (obj->GetId() < objectId)) 

src/common/normObject.cpp

@@ -140,6 +140,7 @@ bool NormObject::Open(const NormObjectSize& objectSize,
     fec_block_mask = NormPayloadId::GetFecBlockMask(fecId, fecM);
     
     UINT32 blockIdMax = fec_block_mask;
+    
     if (IsStream()) blockIdMax = (blockIdMax / 2) - 1;
     if ((numBlocks.MSB() > 0) || (numBlocks.LSB() > blockIdMax))
     {

src/common/normSession.cpp

@@ -759,7 +759,7 @@ bool NormSession::StartSender(UINT16 instanceId,
                               UINT16 segmentSize,
                               UINT16 numData,
                               UINT16 numParity,
-                              UINT8 fecId)
+                              UINT8  fecId)
 {
     UINT16 blockSize = numData + numParity;
     if (blockSize <= 255)

src/pynorm/core.py

@@ -214,8 +214,8 @@ def get_libnorm():
 
     # Sender functions
     libnorm.NormStartSender.restype = ctypes.c_bool
-    libnorm.NormStartSender.argtypes = [ctypes.c_void_p, ctypes.c_uint16,
+    libnorm.NormStartSender.argtypes = [ctypes.c_void_p, ctypes.c_uint16, ctypes.c_uint32, ctypes.c_uint16, 
-            ctypes.c_uint32, ctypes.c_uint16, ctypes.c_ubyte, ctypes.c_ubyte]
+                                        ctypes.c_uint16, ctypes.c_uint16, ctypes.c_uint8]
     libnorm.NormStartSender.errcheck = errcheck_bool
 
     libnorm.NormStopSender.restype = None

src/pynorm/instance.py

@@ -73,21 +73,23 @@ class Instance(object):
         if not result:
             sys.stderr.write("NormInstance.getNextEvent() warning: no more NORM events\n")
             return False
+            
         # Note a NORM_EVENT_INVALID can be OK (with NORM_SESSION_INVALID)    
         if self._estruct.type == c.NORM_EVENT_INVALID:
             return Event(c.NORM_EVENT_INVALID, None, None, None)
-        
+            
         if self._estruct.session == c.NORM_SESSION_INVALID:
             raise NormError("No new event")
+            
         try:
             sender = self._senders[self._estruct.sender]
         except KeyError:
             sender = self._senders[self._estruct.sender] = Node(self._estruct.sender)
         try:
-            object = self._objects[self._estruct.object]
+            obj = self._objects[self._estruct.object]
         except KeyError:
-            object = self._objects[self._estruct.object] = Object(self._estruct.object)
+            obj = self._objects[self._estruct.object] = Object(self._estruct.object)
-        return Event(self._estruct.type, self._sessions[self._estruct.session], sender, object)
+        return Event(self._estruct.type, self._sessions[self._estruct.session], sender, obj)
 
     def getDescriptor(self):
         return libnorm.NormGetDescriptor(self)
@@ -99,7 +101,7 @@ class Instance(object):
         if localId == None:
             localId = c.NORM_NODE_ANY
         session = Session(self, address, port, localId)
-        self._sessions[session] = session
+        self._sessions[session._session] = session
         return session
 
     ## Properties
@@ -130,12 +132,15 @@ class Instance(object):
     def __iter__(self):
         return self
 
-    def next(self):
+    def __next__(self):
         """So you can iterate over the events."""
         try:
           return self.getNextEvent()
         except NormError:
           raise StopIteration
+          
+    def next(self):
+        return __next__()
 
     def __cmp__(self, other):
         return cmp(self._as_parameter_, other._as_parameter)

src/pynorm/session.py

@@ -23,7 +23,7 @@ class Session(object):
         localId - NormNodeId
         """
         self._instance = instance
-        self._session = libnorm.NormCreateSession(instance, address, port, localId)
+        self._session = libnorm.NormCreateSession(instance, address.encode('utf-8'), port, localId)
         self.sendGracefulStop = False
         self.gracePeriod = 0
 
@@ -33,10 +33,11 @@ class Session(object):
 
     def setUserData(self, data):
         """data should be a string"""
-        libnorm.NormSetUserData(self, data)
+        libnorm.NormSetUserData(self, data.encode('utf-8'))
 
     def getUserData(self):
-        return libnorm.NormGetUserData(self)
+        data = libnorm.NormGetUserData(self)
+        return data.decode('utf-8') if data else None
 
     def getNodeId(self):
         return libnorm.NormGetLocalNodeId(self)
@@ -48,10 +49,10 @@ class Session(object):
         libnorm.NormSetRxPortReuse(self, enable, bindToSessionAddr)
 
     def setMulticastInterface(self, iface):
-        libnorm.NormSetMulticastInterface(self, iface)
+        libnorm.NormSetMulticastInterface(self, iface.encode('utf-8'))
     
     def setSSM(self, srcAddr):
-        libnorm.NormSetSSM(self, srcAddr)
+        libnorm.NormSetSSM(self, srcAddr.encode('utf-8'))
         
     def setTTL(self, ttl):
         libnorm.NormSetTTL(self, ttl)
@@ -69,9 +70,8 @@ class Session(object):
         libnorm.NormSetReportInterval(self, interval)
 
     ## Sender functions
-    def startSender(self, sessionId, bufferSpace, segmentSize, blockSize, numParity):
+    def startSender(self, sessionId, bufferSpace, segmentSize, blockSize, numParity, fecId=0):
-        libnorm.NormStartSender(self, sessionId, bufferSpace, segmentSize,
+        libnorm.NormStartSender(self, sessionId, bufferSpace, segmentSize, blockSize, numParity, fecId)
-                blockSize, numParity)
 
     def stopSender(self):
         libnorm.NormStopSender(self)
@@ -122,19 +122,19 @@ class Session(object):
         libnorm.NormSetGroupSize(self, size)
 
     def fileEnqueue(self, filename, info=""):
-        return Object(libnorm.NormFileEnqueue(self, filename, info, len(info)))
+        return Object(libnorm.NormFileEnqueue(self, filename.encode('utf-8'), info.encode('utf-8'), len(info)))
 
     def dataEnqueue(self, data, info=""):
-        return Object(libnorm.NormDataEnqueue(self, data, len(data), info, len(info)))
+        return Object(libnorm.NormDataEnqueue(self, data.encode('utf-8'), len(data), info.encode('utf-8'), len(info)))
 
     def requeueObject(self, normObject):
         libnorm.NormRequeueObject(self, normObject)
 
     def streamOpen(self, bufferSize, info=""):
-        return Object(libnorm.NormStreamOpen(self, bufferSize, info, len(info)))
+        return Object(libnorm.NormStreamOpen(self, bufferSize, info.encode('utf-8'), len(info)))
 
     def sendCommand(self, cmdBuffer, robust=False):
-        return libnorm.NormSendCommand(self, cmdBuffer, len(cmdBuffer), robust)
+        return libnorm.NormSendCommand(self, cmdBuffer.encode('utf-8'), len(cmdBuffer), robust)
 	
     def cancelCommand(self):
         libnorm.NormCancelCommand(self)
@@ -161,9 +161,9 @@ class Session(object):
     def startReceiver(self, bufferSpace):
         libnorm.NormStartReceiver(self, bufferSpace)
 
-    def stopReceiver(self, gracePeriod=0):
+    def stopReceiver(self):
         """This will be called automatically if the receiver is active"""
-        libnorm.NormStopReceiver(self, gracePeriod)
+        libnorm.NormStopReceiver(self)
 
     def setRxCacheLimit(self, count):
         libnorm.NormSetRxCacheLimit(self, count)
@@ -199,8 +199,8 @@ class Session(object):
 
     ## Private functions
     def __del__(self):
-        self.stopReceiver(self.gracePeriod)
+        self.stopReceiver()
-        self.stopSender(self.sendGracefulStop)
+        self.stopSender()
         libnorm.NormDestroySession(self)
 
     @property