address_space_sqlite: Py2.7 compatibility

Author: brubbel

opcua/common/sqlite3_backend.py

@@ -1,10 +1,12 @@
 
+import sys
 import time
 import sqlite3
 import threading
 from multiprocessing import Lock
 
 class SQLite3Backend(object):
+    PY2 = sys.version_info < (3, 0)
     CHECKP_INTERVAL = 90 # [sec] WAL checkpoint
 
     def __init__(self, sqlFile = None, readonly=True):
@@ -74,6 +76,8 @@ def _db_connect(self):
             detect_types = sqlite3.PARSE_DECLTYPES,
             check_same_thread = False
         )
+        if SQLite3Backend.PY2:
+            self._conn[CID].text_factory = bytes
         c = self._get_conn().cursor()
         if self.readonly is True:
             c.execute('PRAGMA query_only=1')

opcua/server/address_space_sqlite.py

@@ -1,7 +1,9 @@
 
+import sys
 import os.path
 import time
 import datetime
+import sqlite3
 from struct import pack
 
 from opcua import ua
@@ -83,6 +85,7 @@ class AddressSpaceSQLite(AddressSpace):
     Load the standard address space nodes from a SQLite database.
     Intended for slow devices, such as Raspberry Pi, to greatly improve start up time
     """
+    PY2 = sys.version_info < (3, 0)
     ATTR_TABLE_NAME = 'Attributes'
     REFS_TABLE_NAME = 'References'
     CUR_TIME_NODEID = NumericNodeId(ua.ObjectIds.Server_ServerStatus_CurrentTime, 0)
@@ -258,11 +261,18 @@ def _write_references(self, nodeid, ndata):
     def _read_nodedata(backend, nodeid, ndata):
         # Search key = numeric nodeid in opc-ua binary format
         numNodeId = AddressSpaceSQLite._nodeid_to_numeric(nodeid)
-        hexNodeId = ua.ua_binary.nodeid_to_binary(numNodeId).hex()
+        hexNodeId = AddressSpaceSQLite._to_hex(ua.ua_binary.nodeid_to_binary(numNodeId))
 
         AddressSpaceSQLite._read_attributes(backend, hexNodeId, ndata)
         AddressSpaceSQLite._read_references(backend, hexNodeId, ndata)
 
+    @staticmethod
+    def _to_hex(b):
+        if AddressSpaceSQLite.PY2:
+            return "".join("{:02x}".format(ord(c)) for c in b)
+        else:
+            return b.hex()
+
     @staticmethod
     def _read_attributes(backend, hexNodeId, ndata, attrTable=ATTR_TABLE_NAME):
         cmd = 'SELECT * FROM "{tn}" WHERE NodeId = x\'{h}\''.format(tn=attrTable, h=hexNodeId)
@@ -339,15 +349,15 @@ def _insert_attribute(backend, nodeid, attrId, attr, table=ATTR_TABLE_NAME):
 
         cmd = 'INSERT OR REPLACE INTO "{tn}" VALUES ({q})'.format(tn=table, q=', '.join('?'*10))
         params = (
-          memoryview(primaryKey),
-          memoryview(binNodeId),
+          sqlite3.Binary(primaryKey),
+          sqlite3.Binary(binNodeId),
           int(attrId),
           attr.value.ServerTimestamp,
           None if attr.value.ServerPicoseconds is None else int(attr.value.ServerPicoseconds),
           attr.value.SourceTimestamp,
           None if attr.value.SourcePicoseconds is None else int(attr.value.SourcePicoseconds),
           int(attr.value.StatusCode.value),
-          memoryview(ua.ua_binary.variant_to_binary(attr.value.Value)),
+          sqlite3.Binary(ua.ua_binary.variant_to_binary(attr.value.Value)),
           str(nodeid)
         )
         backend.execute_write(cmd, params=params)
@@ -425,18 +435,18 @@ def _insert_reference(backend, nodeid, ref, table=REFS_TABLE_NAME):
 
         cmd = 'INSERT OR REPLACE INTO "{tn}" VALUES ({q})'.format(tn=table, q=', '.join('?'*13))
         params = (
-          memoryview(primaryKey),
-          memoryview(binNodeId),
-          memoryview(ua.ua_binary.nodeid_to_binary(ref.ReferenceTypeId)),
+          sqlite3.Binary(primaryKey),
+          sqlite3.Binary(binNodeId),
+          sqlite3.Binary(ua.ua_binary.nodeid_to_binary(ref.ReferenceTypeId)),
           int(bool(ref.IsForward)),
-          memoryview(refNodeId),
+          sqlite3.Binary(refNodeId),
           int(ref.BrowseName.NamespaceIndex),
           None if ref.BrowseName.Name is None else str(ref.BrowseName.Name),
           None if ref.DisplayName.Text is None else str(ref.DisplayName.Text),
           None if ref.DisplayName.Locale is None else str(ref.DisplayName.Locale),
           int(ref.DisplayName.Encoding),
           int(ref.NodeClass),
-          memoryview(ua.ua_binary.nodeid_to_binary(ref.TypeDefinition)),
+          sqlite3.Binary(ua.ua_binary.nodeid_to_binary(ref.TypeDefinition)),
           str(nodeid)
         )
         backend.execute_write(cmd, params=params)

opcua/ua/ua_binary.py

@@ -125,6 +125,8 @@ def unpack(data):
 
 
 class _Primitive1(object):
+    PY2 = sys.version_info < (3, 0)
+
     def __init__(self, fmt):
         self._fmt = fmt
         st = struct.Struct(fmt.format(1))
@@ -141,17 +143,20 @@ def pack_array(self, data):
         if data is None:
             return Primitives.Int32.pack(-1)
         sizedata = Primitives.Int32.pack(len(data))
-        fmt = bytes(self._fmt.format(len(data)), 'utf-8')
+        fmt = self._str_to_bytes(self._fmt.format(len(data)))
         return sizedata + struct.pack(fmt, *data)
 
     def unpack_array(self, data, length):
         if length == -1:
             return None
         if length == 0:
             return ()
-        fmt = bytes(self._fmt.format(length), 'utf-8')
+        fmt = self._str_to_bytes(self._fmt.format(length))
         return struct.unpack(fmt, data.read(self.size * length))
 
+    @staticmethod
+    def _str_to_bytes(_str, PY2=PY2):
+        return bytes(_str) if PY2 else bytes(_str, 'utf-8')
 
 class Primitives1(object):
     SByte = _Primitive1("<{:d}b")