400 lines
12 KiB
Python
400 lines
12 KiB
Python
"""Module to support the LmwSip class
|
|
|
|
See: LmwSip"""
|
|
|
|
import socket
|
|
import ssl
|
|
import select
|
|
import time
|
|
import re
|
|
import logging
|
|
from datetime import datetime, timedelta
|
|
from dateutil import tz
|
|
|
|
class LmwSip:
|
|
"""Class to connect to the LMW Standard Interface prototcol (sip)
|
|
|
|
This class iplement connection to the Rijkswaterstaat Meetnet
|
|
Water (LMW) with the Standard Interface Protocol using the
|
|
Rijkswaterstaat Meetnet Infrastructuur (RMI).
|
|
|
|
https://waterberichtgeving.rws.nl/water-en-weer/metingen
|
|
|
|
Support for:
|
|
ti
|
|
cmd(wn, vw, as)
|
|
|
|
"""
|
|
|
|
def __init__(self, user=None, password=None,
|
|
host="sip-lmw.rws.nl", port=443, meetnet="LMW", ssl = True,
|
|
check_ssl = True, timeout = 10, log = None):
|
|
"""LmwSip(user, password, [host], [port], [meetnet], [ssl], [check_ssl], [timeout], [log])
|
|
|
|
user(optinal): Lmw user name
|
|
password(optional): Lmw password
|
|
host(optional): Default sip-lmw.rws.nl
|
|
port(optional): Default 443
|
|
meetnet(optional): Default LMW
|
|
ssl(optional): Default true
|
|
check_ssl(optional): true
|
|
timeout(optional): 10
|
|
log(optional): None
|
|
|
|
Opens the connection and logs in
|
|
"""
|
|
self.user = user
|
|
self.password = password
|
|
self.host = host
|
|
self.port = port
|
|
self.meetnet = meetnet
|
|
self.ssl = ssl
|
|
self.check_ssl = check_ssl
|
|
self.timeout = timeout
|
|
self._socket = None
|
|
if (log != None):
|
|
self.log = log
|
|
self.log.debug("LmwSip.init")
|
|
else:
|
|
try:
|
|
self.log = logging.getLogger("lmwsip")
|
|
self.log.debug("LmwSip.init: Start log")
|
|
except Exception as e:
|
|
print("Logger failed: %s" % e)
|
|
if (self.host != None):
|
|
self.connect()
|
|
if (self.user != None):
|
|
self.login()
|
|
|
|
def lasttime(self, parameter):
|
|
#
|
|
# Find the last valid 10 minute window.
|
|
# The measurement of 12:00 is avaiable at 12:05:30.
|
|
# Before 12:05:30 we should use 11:50:00.
|
|
#
|
|
# At 12:05:29 we substract 15:29 from the time!
|
|
#
|
|
# Also note that we use GMT. So we should add one hour
|
|
# because we use GMT +1 (MET, UTC-1)
|
|
#
|
|
if (parameter.find("10") != -1):
|
|
now=time.time()
|
|
dt = now%600
|
|
if (dt < 330):
|
|
now = 3000 + now - dt
|
|
else:
|
|
now = 3600 + now - dt
|
|
else:
|
|
#
|
|
# e.g. H1 use 30 seconds to calculate the time.
|
|
#
|
|
dt = now%600
|
|
if (dt < 30):
|
|
now = 3540 + now - dt
|
|
else:
|
|
now = 3600 + now - dt
|
|
time_of_day=time.strftime("%H:%M", time.gmtime(now))
|
|
return { "day": time.strftime("%d-%m-%Y", time.gmtime(now)),
|
|
"time_of_day": time.strftime("%H:%M", time.gmtime(now)) }
|
|
|
|
def connect(self):
|
|
"""connect()
|
|
|
|
connects to lmw with tcp using the values of the object creation.
|
|
"""
|
|
try:
|
|
self._tcp = socket.create_connection((self.host, self.port))
|
|
except Exception as e:
|
|
self.log.error("LmwSip.connect(%s, %s) failed: %s",
|
|
self.host, self.port, e)
|
|
raise LmwSipConnectError("LmwSip.connect: Socket create failed")
|
|
if (self.ssl):
|
|
try:
|
|
self._context = ssl.create_default_context()
|
|
self._context.check_hostname = self.check_ssl
|
|
self._ssl = self._context.wrap_socket(self._tcp,
|
|
server_hostname=self.host)
|
|
self._socket = self._ssl
|
|
except Exception as e:
|
|
self.log.error("LmwSip.connect setup ssl failed:\n%s", e)
|
|
raise LmwSipConnectError("LmwSip.connect: setup ssl failed")
|
|
else:
|
|
self._socket = self._tcp
|
|
self._socket.settimeout(self.timeout)
|
|
|
|
def closesocket(self):
|
|
"""Closes the socket and set the socket to None. Doesn't logout"""
|
|
|
|
try:
|
|
self.log.debug("LmwSip.closesocket")
|
|
self._socket.close()
|
|
except Exception as e:
|
|
pass
|
|
self._socket = None
|
|
|
|
def send(self, sipcmd):
|
|
"""send(sipcmd)
|
|
|
|
send a sip command to the server
|
|
"""
|
|
if self._socket != None:
|
|
try:
|
|
logcmd = sipcmd.strip('\r')
|
|
if re.match("^LI", logcmd, re.IGNORECASE):
|
|
logcmd = re.sub(",.*", ", ******", logcmd)
|
|
self.log.debug("LmwSip.send(%s)" % logcmd)
|
|
self._socket.sendall(sipcmd.encode('ascii'))
|
|
except Exception as e:
|
|
self.log.error("LmwSip.send(%s) failed: %s", sipcmd, e)
|
|
self.closesocket()
|
|
raise LmwSipConnectError("LmwSip.send: Socket connection lost")
|
|
else:
|
|
self.log.warn("LmwSip.send: No connection")
|
|
|
|
def recv(self):
|
|
"""recv()
|
|
|
|
recieve a answer from the sip server
|
|
"""
|
|
buf=""
|
|
while self._socket != None and re.search("\r$", buf) == None:
|
|
try:
|
|
self.log.debug("LmwSip.recv: Waiting for data");
|
|
b = self._socket.recv(4096).decode('utf-8')
|
|
if (b == ""):
|
|
self.log.error("SipLmw.recv: socket closed")
|
|
self.closesocket()
|
|
raise LmwSipConnectError("LmwSip.recv: Socket close")
|
|
else:
|
|
buf += b
|
|
except Exception as e:
|
|
self.log.error("SipLmw.recv: socket timeout: %s", e)
|
|
self.closesocket()
|
|
raise LmwSipConnectError("LmwSip.recv: Socket timeout")
|
|
if self._socket == None:
|
|
self.log.warn("LmwSip.recv: No connection")
|
|
elif buf[0] != '!':
|
|
self.log.warn("LmwSip.recv: Sip error: %s" % buf.strip('\r'))
|
|
else:
|
|
self.log.debug("LmwSip.recv: result: %s" % buf.strip('\r'))
|
|
return(buf)
|
|
|
|
def login(self):
|
|
"""login()
|
|
|
|
Login lmw using the object creation user, password.
|
|
Raises a LmwLoginFailure exception on failure
|
|
"""
|
|
li="LI " + self.user + "," + self.password + "\r"
|
|
self.send(li)
|
|
d = self.recv()
|
|
if (d[0] != '!'):
|
|
raise LmwLoginFailure(self.user + ":" + d)
|
|
|
|
def ti(self):
|
|
"""ti()
|
|
|
|
Request the time from lmw and returns the string.
|
|
|
|
Raises a LmwCmdWarn of failure
|
|
"""
|
|
ti="TI " + self.meetnet + "\r"
|
|
self.send(ti)
|
|
d = self.recv()
|
|
return (d[2:-1])
|
|
|
|
def cmd(self, process, location, parameter, time_delta, day,
|
|
time_of_day, cmd_type="DATA"):
|
|
"""cmd(process, location, parameter, time_delta, day, time_of_day)
|
|
|
|
Send a cmd to LMW and returns the lmw string
|
|
|
|
process: <WN|VW|AS>
|
|
location: <lmw location (e.g. HOEK)>
|
|
parameter: <lmw parameter (e.g. H10)>
|
|
time_delta: <Time windows (max 23:59, e.g. +01:00>
|
|
day: <Date>
|
|
time_of_day: <Time>
|
|
cmd_type: [DATA|DATB|OORS|OORB|""]
|
|
|
|
Example:
|
|
lmw.cmd("WN", "HOEK", "H10", "+01:00", "13-08-2018", "16:00")
|
|
|
|
Returns:
|
|
The LMW answer string
|
|
"""
|
|
if (process == "AS"):
|
|
data=""
|
|
else:
|
|
data="," + cmd_type
|
|
|
|
cmdstr=process + " " + self.meetnet + "," + location + "," + \
|
|
parameter + "," + time_delta + "," + day + "," + \
|
|
time_of_day + data + "\r"
|
|
|
|
self.send(cmdstr)
|
|
d = self.recv()
|
|
if (d[0] != '!'):
|
|
raise LmwCmdWarn(cmdstr, d)
|
|
return (d[2:-1])
|
|
|
|
def value(self, process, location, parameter, day = None,
|
|
time_of_day = None):
|
|
"""value(process, location, parameter, [day], [time_of_day]):
|
|
|
|
Parameters:
|
|
process: <WN|VW|AS>
|
|
location: <lmw location (e.g. HOEK)>
|
|
parameter: <lmw parameter (e.g. H10)>
|
|
day: [date = now()]
|
|
time_of_day: [time = now()]
|
|
|
|
The default returns the last value.
|
|
|
|
Example:
|
|
lmw.data_string("WN", "HOEK", "H10")
|
|
|
|
Returns a single string value or None
|
|
"""
|
|
if (day == None or time_of_day == None):
|
|
last = self.lasttime(parameter)
|
|
if (day==None):
|
|
day=last["day"]
|
|
if (time_of_day==None):
|
|
time_of_day=last["time_of_day"]
|
|
res = self.cmd(process, location, parameter, "+00:00", day,
|
|
time_of_day, "DATA")
|
|
value=re.sub("/.*$", "", res)
|
|
if (value == "99999"):
|
|
value=""
|
|
elif (value == "-999999999"):
|
|
value=""
|
|
#
|
|
# We should check the "kwaliteit"
|
|
#
|
|
return(value)
|
|
|
|
def _lmwdelta_(self, startTime, endTime):
|
|
d = endTime - startTime
|
|
h = 24*d.days + d.seconds // 3600
|
|
m = (d.seconds % 3600)//60
|
|
return("+%02i:%02i" % (h, m))
|
|
|
|
def timeSerie(self, process, location, parameter,
|
|
startTime, endTime, cmd_type="DATB"):
|
|
"""timeSerie(process, location, parameter, startTime, endTime, cmd_type="DATA")
|
|
|
|
Parameters:
|
|
process: <WN|VW|AS>
|
|
location: <lmw location (e.g. HOEK)>
|
|
parameter: <lmw parameter (e.g. H10)>
|
|
startTime: Start time (datetime)
|
|
endTime: End time (datetime)
|
|
cmd_type: [DATA|DATB]
|
|
|
|
startTime is rounded up to the next measurement time.
|
|
So 12:00:00.000001 --> 12:00:10.00.0
|
|
|
|
The times should have correct timezone information. Otherwise local timezone
|
|
is assumed. Timezones are converted to 'GMT+1' for the sip commands.
|
|
|
|
Example:
|
|
lmw.data_string("WN", "HOEK", "H10", ...)
|
|
|
|
Returns a LmwtimeSerie object
|
|
|
|
Errors:
|
|
startTime > endTime
|
|
endTime - startTime > 24 hour
|
|
now - startTime < 30 days
|
|
"""
|
|
startTime = startTime.astimezone(tz.gettz('GMT+1'))
|
|
endTime = endTime.astimezone(tz.gettz('GMT+1'))
|
|
|
|
startTime += timedelta(microseconds=1000000-startTime.microsecond)
|
|
startTime += timedelta(seconds=60-startTime.second)
|
|
if (parameter.find("10") != -1):
|
|
if startTime.minute % 10 != 0:
|
|
delta = timedelta(minutes=10)
|
|
startTime += timedelta(minutes=(10-startTime.minute%10))
|
|
else:
|
|
delta = timedelta(minutes=1)
|
|
|
|
if startTime > endTime:
|
|
raise sipTimeSeriesError(startTime, endTime,
|
|
"starttime > endtime")
|
|
if endTime - startTime > timedelta(days=1):
|
|
raise sipTimeSeriesError(startTime, endTime,
|
|
"endtime - starttime > 24 hour")
|
|
if datetime.now(tz=tz.gettz('GMT+1')) - startTime > timedelta(days=30):
|
|
raise sipTimeSeriesError(startTime, endTime,
|
|
"now - starttime > 30 days")
|
|
if process == "VW":
|
|
cmd_type="DATA"
|
|
|
|
values = self.cmd(process, location, parameter,
|
|
self._lmwdelta_(startTime, endTime),
|
|
startTime.strftime("%d-%m-%Y"),
|
|
startTime.strftime("%H:%M"),
|
|
cmd_type)
|
|
return(lmwTimeSerie(startTime, delta, values))
|
|
|
|
def logout(self):
|
|
"""logout()
|
|
|
|
Logs of
|
|
"""
|
|
self.send("LO\r")
|
|
self.closesocket()
|
|
|
|
class lmwTimeSerie:
|
|
def __init__(self, start, delta, values):
|
|
self.ts = []
|
|
self.addvalues(start, delta, values)
|
|
|
|
def addvalues(self, start, delta, values):
|
|
for e in values.split(";"):
|
|
a = [ start ]
|
|
a.append(e.split("/"))
|
|
self.ts.append(a)
|
|
start += delta
|
|
|
|
class sipTimeSeriesError(Exception):
|
|
"""Parameter errors for timeSeries"""
|
|
def __init__(self, startTime, endTime, message):
|
|
self.startTime = startTime
|
|
self.endTime = endTime
|
|
self.message = message
|
|
|
|
def __str__(self):
|
|
return("%s\n starttime: %s\n end time: %s" %
|
|
(self.message, self.startTime, self.endTime))
|
|
|
|
class LmwSipConnectError(Exception):
|
|
"""Connection exceptions for LmwSip"""
|
|
|
|
def __init__(self, message):
|
|
self.message = message
|
|
|
|
def __str__(self):
|
|
return(self.message)
|
|
|
|
class LmwLoginFailure(Exception):
|
|
"""Exception from LmwSip on login failure"""
|
|
|
|
def __init__(self, user, message):
|
|
self.user = user
|
|
self.message = message
|
|
|
|
def __str__(self):
|
|
return("Login with user %s failed: %s", self.user, self.message)
|
|
|
|
class LmwCmdWarn(Warning):
|
|
"""Exception fro LmwSip on a cmd"""
|
|
def __init__(self, cmd, message):
|
|
self.cmd = cmd
|
|
self.message = message
|
|
|
|
def __str__(self):
|
|
return("Cmd %s failed: %s", self.cmd, self.message)
|