def test_event_only_targets_by_type(caplog):
now = datetime.now(timezone.utc)
event = {
'active_period': {
'dtstart': now,
'duration': timedelta(seconds=10)
},
'event_descriptor': {
'event_id': 'event123',
'modification_number': 1,
'priority': 0,
'event_status': 'far',
'created_date_time': now
},
'event_signals': [{
'signal_name':
'simple',
'signal_type':
'level',
'intervals': [{
'dtstart': now,
'duration': timedelta(seconds=10),
'signal_payload': 1
}]
}],
'targets_by_type': {
'ven_id': ['ven456']
},
'response_required':
'always'
}
msg = messaging.create_message('oadrDistributeEvent', events=[event])
message_type, message_payload = messaging.parse_message(msg)
assert message_payload['events'][0]['targets'] == [{'ven_id': 'ven456'}]
async def _perform_request(self, service, message):
await self._ensure_client_session()
logger.debug(f"Client is sending {message}")
url = f"{self.vtn_url}/{service}"
try:
async with self.client_session.post(url, data=message) as req:
content = await req.read()
if req.status != HTTPStatus.OK:
logger.warning(f"Non-OK status when performing a request to {url} with data "
f"{message}: {req.status} {content.decode('utf-8')}")
return None, {}
logger.debug(content.decode('utf-8'))
except aiohttp.client_exceptions.ClientConnectorError as err:
# Could not connect to server
logger.error(f"Could not connect to server with URL {self.vtn_url}:")
logger.error(f"{err.__class__.__name__}: {str(err)}")
return None, {}
except Exception as err:
logger.error(f"Request error {err.__class__.__name__}:{err}")
return None, {}
try:
message_type, message_payload = parse_message(content)
except Exception as err:
logger.error(f"The incoming message could not be parsed or validated: {err}")
return None, {}
return message_type, message_payload
async def test_conformance_001():
dt = datetime(2020,
1,
1,
12,
0,
0,
tzinfo=timezone(offset=timedelta(hours=4)))
msg = create_message(
'oadrCreateOpt', **{
'opt_id': generate_id(),
'opt_type': enums.OPT.OPT_IN,
'opt_reason': enums.OPT_REASON.ECONOMIC,
'ven_id': generate_id(),
'created_date_time': dt,
'request_id': generate_id(),
'event_id': generate_id(),
'modification_number': 1,
'targets': [{
'ven_id': '123'
}]
})
parsed_type, parsed_msg = parse_message(msg)
assert parsed_msg['created_date_time'].tzinfo == timezone.utc
assert parsed_msg['created_date_time'] == dt.astimezone(timezone.utc)
def test_oadr_event():
event = objects.Event(
event_descriptor=objects.EventDescriptor(
event_id=1,
modification_number=0,
market_context='MarketContext1',
event_status=enums.EVENT_STATUS.NEAR),
active_period=objects.ActivePeriod(dtstart=datetime.now(),
duration=timedelta(minutes=10)),
event_signals=[
objects.EventSignal(intervals=[
objects.Interval(dtstart=datetime.now(),
duration=timedelta(minutes=5),
uid=0,
signal_payload=1),
objects.Interval(dtstart=datetime.now(),
duration=timedelta(minutes=5),
uid=1,
signal_payload=2)
],
targets=[objects.Target(ven_id='1234')],
signal_name=enums.SIGNAL_NAME.LOAD_CONTROL,
signal_type=enums.SIGNAL_TYPE.LEVEL,
signal_id=1,
current_value=0)
],
targets=[objects.Target(ven_id='1234')])
response = objects.Response(response_code=200,
response_description='OK',
request_id='1234')
msg = create_message('oadrDistributeEvent',
response=response,
events=[event])
message_type, message_payload = parse_message(msg)
def test_oadr_event_targets_and_targets_by_type():
event = objects.Event(
event_descriptor=objects.EventDescriptor(
event_id=1,
modification_number=0,
market_context='MarketContext1',
event_status=enums.EVENT_STATUS.NEAR),
active_period=objects.ActivePeriod(dtstart=datetime.now(),
duration=timedelta(minutes=10)),
event_signals=[
objects.EventSignal(intervals=[
objects.Interval(dtstart=datetime.now(),
duration=timedelta(minutes=5),
uid=0,
signal_payload=1),
objects.Interval(dtstart=datetime.now(),
duration=timedelta(minutes=5),
uid=1,
signal_payload=2)
],
targets=[objects.Target(ven_id='1234')],
signal_name=enums.SIGNAL_NAME.LOAD_CONTROL,
signal_type=enums.SIGNAL_TYPE.LEVEL,
signal_id=1,
current_value=0)
],
targets=[{
'ven_id': 'ven123'
}],
targets_by_type={'ven_id': ['ven123']})
msg = create_message('oadrDistributeEvent', events=[event])
validate_xml_schema(ensure_bytes(msg))
message_type, message_payload = parse_message(msg)
def test_message_validation():
msg = create_message('oadrPoll',
ven_id='123',
cert=TEST_CERT,
key=TEST_KEY,
passphrase='openadr')
parsed_type, parsed_message = parse_message(msg)
assert parsed_type == 'oadrPoll'
def test_message_validation():
msg = create_message('oadrPoll',
ven_id='123',
cert=TEST_CERT,
key=TEST_KEY)
tree = etree.fromstring(msg.encode('utf-8'))
validate_xml_signature(tree)
parsed_type, parsed_message = parse_message(msg)
assert parsed_type == 'oadrPoll'
async def test_conformance_002():
"""
The uid element is REQUIRED for each eiEventSignal interval. Within a sin-
gle oadrDistributeEvent eiEventSignal, uid MUST be expressed as an inter-
val number with a base of 0 and an increment of 1 for each subsequent in-
terval.
"""
event_id = generate_id()
event = {'event_descriptor':
{'event_id': event_id,
'modification_number': 0,
'modification_date': datetime.now(),
'priority': 0,
'market_context': 'MarketContext001',
'created_date_time': datetime.now(),
'event_status': enums.EVENT_STATUS.FAR,
'test_event': False,
'vtn_comment': 'No Comment'},
'active_period':
{'dtstart': datetime.now(),
'duration': timedelta(minutes=30)},
'event_signals':
[{'intervals': [{'duration': timedelta(minutes=10),
'signal_payload': 1},
{'duration': timedelta(minutes=10),
'signal_payload': 2},
{'duration': timedelta(minutes=10),
'signal_payload': 3}],
'signal_name': enums.SIGNAL_NAME.SIMPLE,
'signal_type': enums.SIGNAL_TYPE.DELTA,
'signal_id': generate_id()
}],
'targets': [{'ven_id': '123'}]
}
# Create a message with this event
msg = create_message('oadrDistributeEvent',
response={'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()},
request_id=generate_id(),
vtn_id=generate_id(),
events=[event])
# Parse the message
parsed_type, parsed_msg = parse_message(msg)
assert parsed_type == 'oadrDistributeEvent'
intervals = parsed_msg['events'][0]['event_signals'][0]['intervals']
# Verify that the interval uid's are numbered consecutively and starting at 0
assert intervals[0]['uid'] == 0
assert intervals[0]['signal_payload'] == 1
assert intervals[1]['uid'] == 1
assert intervals[1]['signal_payload'] == 2
assert intervals[2]['uid'] == 2
assert intervals[2]['signal_payload'] == 3
async def _perform_request(self, service, message):
await self._ensure_client_session()
logger.debug(f"Client is sending {message}")
url = f"{self.vtn_url}/{service}"
try:
async with self.client_session.post(url, data=message) as req:
content = await req.read()
if req.status != HTTPStatus.OK:
logger.warning(
f"Non-OK status {req.status} when performing a request to {url} "
f"with data {message}: {req.status} {content.decode('utf-8')}"
)
return None, {}
logger.debug(content.decode('utf-8'))
except aiohttp.client_exceptions.ClientConnectorError as err:
# Could not connect to server
logger.error(
f"Could not connect to server with URL {self.vtn_url}:")
logger.error(f"{err.__class__.__name__}: {str(err)}")
return None, {}
except Exception as err:
logger.error(f"Request error {err.__class__.__name__}:{err}")
return None, {}
if len(content) == 0:
return None
try:
tree = validate_xml_schema(content)
if self.vtn_fingerprint:
validate_xml_signature(tree)
message_type, message_payload = parse_message(content)
except XMLSyntaxError as err:
logger.warning(
f"Incoming message did not pass XML schema validation: {err}")
return None, {}
except errors.FingerprintMismatch as err:
logger.warning(err)
return None, {}
except InvalidSignature:
logger.warning("Incoming message had invalid signature, ignoring.")
return None, {}
except Exception as err:
logger.error(
f"The incoming message could not be parsed or validated: {err}"
)
return None, {}
if 'response' in message_payload and 'response_code' in message_payload[
'response']:
if message_payload['response']['response_code'] != 200:
logger.warning(
"We got a non-OK OpenADR response from the server: "
f"{message_payload['response']['response_code']}: "
f"{message_payload['response']['response_description']}")
return message_type, message_payload
async def test_conformance_008_autocorrect(caplog):
"""
oadrDistributeEvent eventSignal interval durations for a given event MUST
add up to eiEvent eiActivePeriod duration.
"""
event_id = generate_id()
event = {'event_descriptor':
{'event_id': event_id,
'modification_number': 0,
'modification_date': datetime.now(),
'priority': 0,
'market_context': 'MarketContext001',
'created_date_time': datetime.now(),
'event_status': enums.EVENT_STATUS.FAR,
'test_event': False,
'vtn_comment': 'No Comment'},
'active_period':
{'dtstart': datetime.now(),
'duration': timedelta(minutes=5)},
'event_signals':
[{'intervals': [{'duration': timedelta(minutes=10),
'signal_payload': 1},
{'duration': timedelta(minutes=10),
'signal_payload': 2},
{'duration': timedelta(minutes=10),
'signal_payload': 3}],
'signal_name': enums.SIGNAL_NAME.SIMPLE,
'signal_type': enums.SIGNAL_TYPE.DELTA,
'signal_id': generate_id()
}],
'targets': [{'ven_id': '123'}]
}
# Create a message with this event
msg = create_message('oadrDistributeEvent',
response={'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()},
request_id=generate_id(),
vtn_id=generate_id(),
events=[event])
assert caplog.record_tuples == [("openleadr", logging.WARNING, f"The active_period duration for event {event_id} (0:05:00) differs from the sum of the interval's durations (0:30:00). The active_period duration has been adjusted to (0:30:00).")]
parsed_type, parsed_msg = parse_message(msg)
assert parsed_type == 'oadrDistributeEvent'
total_time = sum([i['duration'] for i in parsed_msg['events'][0]['event_signals'][0]['intervals']],
timedelta(seconds=0))
assert parsed_msg['events'][0]['active_period']['duration'] == total_time
def test_message(message_type, data):
# file = open('representations.rst', 'a')
# print(f".. _{message_type}:", file=file)
# print("", file=file)
# print(message_type, file=file)
# print("="*len(message_type), file=file)
# print("", file=file)
# print("OpenADR payload:", file=file)
# print("", file=file)
# print(".. code-block:: xml", file=file)
# print(" ", file=file)
message = create_message(message_type, **data)
# message = re.sub(r"\s\s+","",message)
# message = message.replace("\n","")
# xml_lines = etree.tostring(etree.fromstring(message.replace('\n', '').encode('utf-8')), pretty_print=True).decode('utf-8').splitlines()
# for line in xml_lines:
# print(" " + line, file=file)
# print("", file=file)
# print("OpenLEADR representation:", file=file)
# print(" ", file=file)
# print(".. code-block:: python3", file=file)
# print(" ", file=file)
validate_xml_schema(message)
parsed = parse_message(message)[1]
# dict_lines = pformat(parsed).splitlines()
# for line in dict_lines:
# print(" " + line, file=file)
# print("", file=file)
# print("", file=file)
if message_type == 'oadrRegisterReport':
for report in data['reports']:
for rd in report['report_descriptions']:
if 'measurement' in rd:
rd['measurement'].pop('ns')
if message_type == 'oadrDistributeEvent':
for event in data['events']:
for signal in event['event_signals']:
if 'measurement' in signal:
signal['measurement'].pop('ns')
assert parsed == data
def test_event_with_wrong_response_required(caplog):
now = datetime.now(timezone.utc)
event = {
'active_period': {
'dtstart': now,
'duration': timedelta(seconds=10)
},
'event_descriptor': {
'event_id': 'event123',
'modification_number': 1,
'priority': 0,
'event_status': 'far',
'created_date_time': now
},
'event_signals': [{
'signal_name':
'simple',
'signal_type':
'level',
'intervals': [{
'dtstart': now,
'duration': timedelta(seconds=10),
'signal_payload': 1
}]
}],
'targets': [{
'ven_id': 'ven123'
}],
'response_required':
'blabla'
}
msg = messaging.create_message('oadrDistributeEvent', events=[event])
assert ("The response_required property in an Event should be "
"'never' or 'always', not blabla. Changing to 'always'."
) in caplog.messages
message_type, message_payload = messaging.parse_message(msg)
assert message_payload['events'][0]['response_required'] == 'always'
async def handler(self, request):
"""
Handle all incoming POST requests.
"""
try:
# Check the Content-Type header
content_type = request.headers.get('content-type', '')
if not content_type.lower().startswith("application/xml"):
raise errors.HTTPError(status=HTTPStatus.BAD_REQUEST,
description="The Content-Type header must be application/xml; "
f"you provided {request.headers.get('content-type', '')}")
content = await request.read()
hooks.call('before_parse', content)
# Validate the message to the XML Schema
message_tree = validate_xml_schema(content)
# Parse the message to a type and payload dict
message_type, message_payload = parse_message(content)
if message_type == 'oadrResponse':
raise errors.SendEmptyHTTPResponse()
if 'vtn_id' in message_payload \
and message_payload['vtn_id'] is not None \
and message_payload['vtn_id'] != self.vtn_id:
raise errors.InvalidIdError(f"The supplied vtnID is invalid. It should be '{self.vtn_id}', "
f"you supplied {message_payload['vtn_id']}.")
# Check if we know this VEN, ask for reregistration otherwise
if message_type not in ('oadrCreatePartyRegistration', 'oadrQueryRegistration') \
and 'ven_id' in message_payload and hasattr(self, 'ven_lookup'):
result = await utils.await_if_required(self.ven_lookup(ven_id=message_payload['ven_id']))
if result is None or result.get('registration_id', None) is None:
raise errors.RequestReregistration(message_payload['ven_id'])
# Authenticate the message
if request.secure and 'ven_id' in message_payload:
if hasattr(self, 'fingerprint_lookup'):
await authenticate_message(request, message_tree, message_payload,
fingerprint_lookup=self.fingerprint_lookup)
elif hasattr(self, 'ven_lookup'):
await authenticate_message(request, message_tree, message_payload,
ven_lookup=self.ven_lookup)
else:
logger.error("Could not authenticate this VEN because "
"you did not provide a 'ven_lookup' function. Please see "
"https://openleadr.org/docs/server.html#signing-messages for info.")
# Pass the message off to the handler and get the response type and payload
try:
# Add the request fingerprint to the message so that the handler can check for it.
if request.secure and message_type == 'oadrCreatePartyRegistration':
message_payload['fingerprint'] = utils.get_cert_fingerprint_from_request(request)
response_type, response_payload = await self.handle_message(message_type,
message_payload)
except Exception as err:
logger.error("An exception occurred during the execution of your "
f"{self.__class__.__name__} handler: "
f"{err.__class__.__name__}: {err}")
raise err
if 'response' not in response_payload:
response_payload['response'] = {'response_code': 200,
'response_description': 'OK',
'request_id': message_payload.get('request_id')}
response_payload['vtn_id'] = self.vtn_id
if 'ven_id' not in response_payload:
response_payload['ven_id'] = message_payload.get('ven_id')
except errors.RequestReregistration as err:
response_type = 'oadrRequestReregistration'
response_payload = {'ven_id': err.ven_id}
msg = self._create_message(response_type, **response_payload)
response = web.Response(text=msg,
status=HTTPStatus.OK,
content_type='application/xml')
except errors.SendEmptyHTTPResponse:
response = web.Response(text='',
status=HTTPStatus.OK,
content_type='application/xml')
except errors.ProtocolError as err:
# In case of an OpenADR error, return a valid OpenADR message
response_type, response_payload = self.error_response(message_type,
err.response_code,
err.response_description)
msg = self._create_message(response_type, **response_payload)
response = web.Response(text=msg,
status=HTTPStatus.OK,
content_type='application/xml')
except errors.HTTPError as err:
# If we throw a http-related error, deal with it here
response = web.Response(text=err.response_description,
status=err.response_code)
except XMLSyntaxError as err:
logger.warning(f"XML schema validation of incoming message failed: {err}.")
response = web.Response(text=f'XML failed validation: {err}',
status=HTTPStatus.BAD_REQUEST)
except errors.FingerprintMismatch as err:
logger.warning(err)
response = web.Response(text=str(err),
status=HTTPStatus.FORBIDDEN)
except InvalidSignature:
logger.warning("Incoming message had invalid signature, ignoring.")
response = web.Response(text='Invalid Signature',
status=HTTPStatus.FORBIDDEN)
except Exception as err:
# In case of some other error, return a HTTP 500
logger.error(f"The VTN server encountered an error: {err.__class__.__name__}: {err}")
response = web.Response(status=HTTPStatus.INTERNAL_SERVER_ERROR)
else:
# We've successfully handled this message
msg = self._create_message(response_type, **response_payload)
response = web.Response(text=msg,
status=HTTPStatus.OK,
content_type='application/xml')
hooks.call('before_respond', response.text)
return response
def test_message_validation_complex():
now = datetime.now(timezone.utc)
event_id = generate_id()
active_period = {
"dtstart": now + timedelta(minutes=1),
"duration": timedelta(minutes=9)
}
event_descriptor = {
"event_id": event_id,
"modification_number": 1,
"modification_date_time": now,
"priority": 1,
"market_context": "http://MarketContext1",
"created_date_time": now,
"event_status": "near",
"test_event": "false",
"vtn_comment": "This is an event"
}
event_signals = [{
"intervals": [{
"duration": timedelta(minutes=1),
"uid": 1,
"signal_payload": 8
}, {
"duration": timedelta(minutes=1),
"uid": 2,
"signal_payload": 10
}, {
"duration": timedelta(minutes=1),
"uid": 3,
"signal_payload": 12
}, {
"duration": timedelta(minutes=1),
"uid": 4,
"signal_payload": 14
}, {
"duration": timedelta(minutes=1),
"uid": 5,
"signal_payload": 16
}, {
"duration": timedelta(minutes=1),
"uid": 6,
"signal_payload": 18
}, {
"duration": timedelta(minutes=1),
"uid": 7,
"signal_payload": 20
}, {
"duration": timedelta(minutes=1),
"uid": 8,
"signal_payload": 10
}, {
"duration": timedelta(minutes=1),
"uid": 9,
"signal_payload": 20
}],
"signal_name":
"LOAD_CONTROL",
#"signal_name": "simple",
#"signal_type": "level",
"signal_type":
"x-loadControlCapacity",
"signal_id":
generate_id(),
"current_value":
9.99
}]
event_targets = [{"ven_id": 'VEN001'}, {"ven_id": 'VEN002'}]
event = {
'active_period': active_period,
'event_descriptor': event_descriptor,
'event_signals': event_signals,
'targets': event_targets,
'response_required': 'always'
}
msg = create_message('oadrDistributeEvent',
request_id=generate_id(),
response={
'request_id': 123,
'response_code': 200,
'response_description': 'OK'
},
events=[event],
cert=TEST_CERT,
key=TEST_KEY)
tree = etree.fromstring(msg.encode('utf-8'))
validate_xml_signature(tree)
parsed_type, parsed_msg = parse_message(msg)
def test_message(message_type, data):
message = create_message(message_type, **data)
print(message)
parsed = parse_message(message)[1]
assert parsed == data
async def test_conformance_006():
"""
The presence of any string except “false” in the oadrDistributeEvent
testEvent element MUST be treated as a trigger for a test event.
"""
# Monkey patch our own formatter to prevent an error being raised
from openleadr.messaging import TEMPLATES
def booleanformat_monkey(value):
"""
Format a boolean value
"""
if isinstance(value, bool):
if value == True:
return "true"
elif value == False:
return "false"
else:
return value
booleanformat_original = TEMPLATES.filters['booleanformat']
TEMPLATES.filters['booleanformat'] = booleanformat_monkey
event_id = generate_id()
event = {
'event_descriptor': {
'event_id': event_id,
'modification_number': 0,
'modification_date': datetime.now(),
'priority': 0,
'market_context': 'MarketContext001',
'created_date_time': datetime.now(),
'event_status': enums.EVENT_STATUS.FAR,
'test_event': "HelloThere",
'vtn_comment': 'No Comment'
},
'active_period': {
'dtstart': datetime.now(),
'duration': timedelta(minutes=30)
},
'event_signals': [{
'intervals': [{
'duration': timedelta(minutes=10),
'signal_payload': 1
}, {
'duration': timedelta(minutes=10),
'signal_payload': 2
}, {
'duration': timedelta(minutes=10),
'signal_payload': 3
}],
'signal_name':
enums.SIGNAL_NAME.SIMPLE,
'signal_type':
enums.SIGNAL_TYPE.DELTA,
'signal_id':
generate_id()
}],
'targets': [{
'ven_id': '123'
}]
}
# Create a message with this event
msg = create_message('oadrDistributeEvent',
response={
'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()
},
request_id=generate_id(),
vtn_id=generate_id(),
events=[event])
parsed_type, parsed_message = parse_message(msg)
assert parsed_type == 'oadrDistributeEvent'
assert parsed_message['events'][0]['event_descriptor'][
'test_event'] == True
# Restore the original booleanformat function
TEMPLATES.filters['booleanformat'] = booleanformat_original
