def extensionobject_from_binary(data):
"""
Convert binary-coded ExtensionObject to a Python object.
Returns an object, or None if TypeId is zero
"""
typeid = nodeid_from_binary(data)
Encoding = ord(data.read(1))
body = None
if Encoding & (1 << 0):
length = Primitives.Int32.unpack(data)
if length < 1:
body = Buffer(b"")
else:
body = data.copy(length)
data.skip(length)
if typeid.Identifier == 0:
return None
elif typeid in ua.extension_object_classes:
klass = ua.extension_object_classes[typeid]
if body is None:
raise UaError("parsing ExtensionObject {0} without data".format(
klass.__name__))
return from_binary(klass, body)
else:
e = ua.ExtensionObject()
e.TypeId = typeid
e.Encoding = Encoding
if body is not None:
e.Body = body.read(len(body))
return e
def extensionobject_from_binary(data):
"""
Convert binary-coded ExtensionObject to a Python object.
Returns an object, or None if TypeId is zero
"""
typeid = NodeId.from_binary(data)
Encoding = ord(data.read(1))
body = None
if Encoding & (1 << 0):
length = uabin.Primitives.Int32.unpack(data)
if length < 1:
body = Buffer(b"")
else:
body = data.copy(length)
data.skip(length)
if typeid.Identifier == 0:
return None
elif typeid in extension_object_classes:
klass = extension_object_classes[typeid]
if body is None:
raise UaError("parsing ExtensionObject {0} without data".format(klass.__name__))
return klass.from_binary(body)
else:
e = ExtensionObject()
e.TypeId = typeid
e.Encoding = Encoding
if body is not None:
e.Body = body.read(len(body))
return e
def read_node_history(self, node_id, start, end, nb_values):
with self._lock:
_c_read = self._conn.cursor()
table = self._get_table_name(node_id)
start_time, end_time, order, limit = self._get_bounds(start, end, nb_values)
cont = None
results = []
# select values from the database; recreate UA Variant from binary
try:
for row in _c_read.execute('SELECT * FROM "{tn}" WHERE "SourceTimestamp" BETWEEN ? AND ? '
'ORDER BY "_Id" {dir} LIMIT ?'.format(tn=table, dir=order),
(start_time, end_time, limit,)):
# rebuild the data value object
dv = ua.DataValue(variant_from_binary(Buffer(row[6])))
dv.ServerTimestamp = row[1]
dv.SourceTimestamp = row[2]
dv.StatusCode = ua.StatusCode(row[3])
results.append(dv)
except sqlite3.Error as e:
self.logger.error('Historizing SQL Read Error for %s: %s', node_id, e)
if nb_values:
if len(results) > nb_values:
cont = results[nb_values].SourceTimestamp
results = results[:nb_values]
return results, cont
def read_node_history(self, node_id, start, end, nb_values):
with self._lock:
_c_read = self._conn.cursor()
order = "ASC"
if start is None or start == ua.DateTimeMinValue:
order = "DESC"
start = ua.DateTimeMinValue
if end is None or end == ua.DateTimeMinValue:
end = datetime.utcnow() + timedelta(days=1)
if start < end:
start_time = start.isoformat(' ')
end_time = end.isoformat(' ')
else:
order = "DESC"
start_time = end.isoformat(' ')
end_time = start.isoformat(' ')
if nb_values:
limit = nb_values + 1 # add 1 to the number of values for retrieving a continuation point
else:
limit = -1 # in SQLite a LIMIT of -1 returns all results
table = self._get_table_name(node_id)
cont = None
results = []
# select values from the database; recreate UA Variant from binary ORDER BY "ServerTimestamp" DESC
try:
for row in _c_read.execute(
'SELECT * FROM "{tn}" WHERE "ServerTimestamp" BETWEEN ? AND ? '
'ORDER BY "Id" {dir} LIMIT ?'.format(tn=table,
dir=order), (
start_time,
end_time,
limit,
)):
dv = ua.DataValue(ua.Variant.from_binary(Buffer(row[6])))
dv.ServerTimestamp = row[1]
dv.SourceTimestamp = row[2]
dv.StatusCode = ua.StatusCode(row[3])
results.append(dv)
except sqlite3.Error as e:
self.logger.error('Historizing SQL Read Error for %s: %s',
node_id, e)
if nb_values:
if start > ua.DateTimeMinValue and len(results) > nb_values:
cont = results[nb_values].ServerTimestamp
results = results[:nb_values]
return results, cont
def read_event_history(self, source_id, start, end, nb_values, evfilter):
with self._lock:
#_c_read = self._conn.cursor()
table = self._get_table_name(source_id)
start_time, end_time, order, limit = self._get_bounds(
start, end, nb_values)
clauses, clauses_str = self._get_select_clauses(
source_id, evfilter)
cont = None
cont_timestamps = []
results = []
# select events from the database; SQL select clause is built from
# EventFilter and available fields
try:
cursor = self._db[table].find({
"_Timestamp": {
"$gte": start_time,
"$lt": end_time
}
}).sort('_Timestamp', pymongo.DESCENDING).limit(limit)
for result in cursor:
fdict = {}
cont_timestamps.append(result['_Timestamp'])
for i, field in enumerate(result['clauses_str']):
if field is not None:
fdict[clauses[i]] = variant_from_binary(
Buffer(field))
else:
fdict[clauses[i]] = ua.Variant(None)
results.append(events.Event.from_field_dict(fdict))
finally:
pass
if nb_values:
if len(results) > nb_values: # start > ua.get_win_epoch() and
cont = cont_timestamps[nb_values]
results = results[:nb_values]
return results, cont
def read_event_history(self, source_id, start, end, nb_values, evfilter):
with self._lock:
_c_read = self._conn.cursor()
table = self._get_table_name(source_id)
start_time, end_time, order, limit = self._get_bounds(
start, end, nb_values)
clauses, clauses_str = self._get_select_clauses(
source_id, evfilter)
cont = None
cont_timestamps = []
results = []
# select events from the database; SQL select clause is built from EventFilter and available fields
try:
for row in _c_read.execute(
'SELECT "_Timestamp", {cl} FROM "{tn}" WHERE "_Timestamp" BETWEEN ? AND ? ORDER BY "_Id" {dir} LIMIT ?'
.format(cl=clauses_str, tn=table,
dir=order), (start_time, end_time, limit)):
fdict = {}
cont_timestamps.append(row[0])
for i, field in enumerate(row[1:]):
if field is not None:
fdict[clauses[i]] = variant_from_binary(
Buffer(field))
else:
fdict[clauses[i]] = ua.Variant(None)
results.append(events.Event.from_field_dict(fdict))
except sqlite3.Error as e:
self.logger.error(
'Historizing SQL Read Error events for node %s: %s',
source_id, e)
if nb_values:
if len(results) > nb_values: # start > ua.get_win_epoch() and
cont = cont_timestamps[nb_values]
results = results[:nb_values]
return results, cont
def read_event_history(self, source_id, start, end, nb_values, evfilter):
with self._lock:
_c_read = self._conn.cursor()
order = "ASC"
if start is None or start == ua.DateTimeMinValue:
order = "DESC"
start = ua.DateTimeMinValue
if end is None or end == ua.DateTimeMinValue:
end = datetime.utcnow() + timedelta(days=1)
if start < end:
start_time = start.isoformat(' ')
end_time = end.isoformat(' ')
else:
order = "DESC"
start_time = end.isoformat(' ')
end_time = start.isoformat(' ')
if nb_values:
limit = nb_values + 1 # add 1 to the number of values for retrieving a continuation point
else:
limit = -1 # in SQLite a LIMIT of -1 returns all results
table = self._get_table_name(source_id)
clauses, clauses_str = self._get_select_clauses(
source_id, evfilter)
cont = None
cont_timestamps = []
results = []
# select events from the database; SQL select clause is built from EventFilter and available fields
try:
for row in _c_read.execute(
'SELECT "_Timestamp", {cl} FROM "{tn}" WHERE "_Timestamp" BETWEEN ? AND ? ORDER BY "_Id" {dir} LIMIT ?'
.format(cl=clauses_str, tn=table,
dir=order), (start_time, end_time, limit)):
fdict = {}
cont_timestamps.append(row[0])
for i, field in enumerate(row[1:]):
if field is not None:
fdict[clauses[i]] = ua.Variant.from_binary(
Buffer(field))
else:
fdict[clauses[i]] = ua.Variant(None)
results.append(events.Event.from_field_dict(fdict))
except sqlite3.Error as e:
self.logger.error(
'Historizing SQL Read Error events for node %s: %s',
source_id, e)
if nb_values:
if len(results) > nb_values: # start > ua.DateTimeMinValue and
cont = cont_timestamps[nb_values]
results = results[:nb_values]
return results, cont
def read_event_history(self, source_id, start, end, nb_values, evfilter):
with self._lock:
_c_read = self._conn.cursor()
order = "ASC"
if start is None or start == ua.DateTimeMinValue:
order = "DESC"
start = ua.DateTimeMinValue
if end is None or end == ua.DateTimeMinValue:
end = datetime.utcnow() + timedelta(days=1)
if start < end:
start_time = start.isoformat(' ')
end_time = end.isoformat(' ')
else:
order = "DESC"
start_time = end.isoformat(' ')
end_time = start.isoformat(' ')
if nb_values:
limit = nb_values + 1 # add 1 to the number of values for retrieving a continuation point
else:
limit = -1 # in SQLite a LIMIT of -1 returns all results
table = self._get_table_name(source_id)
clauses = self._get_select_clauses(source_id, evfilter)
cont = None
cont_timestamps = []
results = []
# select events from the database; SQL select clause is built from EventFilter and available fields
try:
for row in _c_read.execute('SELECT "_Timestamp", {cl} FROM "{tn}" WHERE "_Timestamp" BETWEEN ? AND ? '
'ORDER BY "_Id" {dir} LIMIT ?'.format(cl=clauses, tn=table, dir=order),
(start_time, end_time, limit,)):
# place all the variants in the event field list object
hist_ev_field_list = ua.HistoryEventFieldList()
i = 0
for field in row:
# if the field is the _Timestamp column store it in a list used for getting the continuation
if i == 0:
cont_timestamps.append(field)
else:
if field is not None:
hist_ev_field_list.EventFields.append(ua.Variant.from_binary(Buffer(field)))
else:
hist_ev_field_list.EventFields.append(ua.Variant(None))
i += 1
results.append(hist_ev_field_list)
except sqlite3.Error as e:
self.logger.error('Historizing SQL Read Error events for node %s: %s', source_id, e)
if nb_values:
if len(results) > nb_values: # start > ua.DateTimeMinValue and
cont = cont_timestamps[nb_values]
results = results[:nb_values]
return results, cont