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)
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 test_conformance_009_pass():
"""
oadrDistributeEvent eiEventSignal’s with a signalName of “SIMPLE” MUST
use signalPayload values of 0=normal; 1=moderate; 2=high; 3=special.
"""
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])
async def test_conformance_021():
"""
If venID, vtnID, or eventID value is included in the payload, the receiving
entity MUST validate that the ID value is as expected and generate an error
if an unexpected value is received.
Exception: A VEN MUST NOT generate an error upon receipt of a canceled
event whose eventID is not previously known.
"""
server = OpenADRServer(vtn_id='TestVTN', http_port=8001)
server.add_handler('on_create_party_registration', on_create_party_registration)
server.add_handler('on_poll', _on_poll)
await server.run_async()
client = OpenADRClient(ven_name="TestVEN",
vtn_url="http://localhost:8001/OpenADR2/Simple/2.0b")
await client.create_party_registration()
event = {'event_descriptor':
{'event_id': generate_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() + timedelta(minutes=30),
'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(),
'current_value': 123
}],
'targets': [{'ven_id': '123'}]
}
add_event(ven_id=client.ven_id,
event_id = event['event_descriptor']['event_id'],
event=event)
message_type, message_payload = await client.poll()
assert message_type == 'oadrDistributeEvent'
await client.stop()
await server.stop()
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
async def _on_poll(ven_id, request_id=None):
cur = DB.cursor()
cur.execute(
"""SELECT event_id, event FROM events WHERE ven_id = ? AND status = 'new' LIMIT 1""",
(ven_id, ))
result = cur.fetchone()
if result:
event_id, event = result
event_request_id = generate_id()
with DB:
DB.execute(
"""UPDATE events SET request_id = ? WHERE event_id = ?""",
(event_request_id, event_id))
response_type = 'oadrDistributeEvent'
response_payload = {
'response': {
'request_id': request_id,
'response_code': 200,
'response_description': 'OK'
},
'request_id': event_request_id,
'vtn_id': VTN_ID,
'events': [json.loads(event)]
}
else:
response_type = 'oadrResponse'
response_payload = {
'response': {
'request_id': request_id,
'response_code': 200,
'response_description': 'OK'
},
'ven_id': ven_id
}
return response_type, response_payload
async def handle_message(self, message_type, message_payload):
hooks.call('before_handle', message_type, message_payload)
if message_type in self.handlers:
handler = self.handlers[message_type]
result = handler(message_payload)
if iscoroutine(result):
result = await result
if result is not None:
response_type, response_payload = result
if is_dataclass(response_payload):
response_payload = asdict(response_payload)
elif response_payload is None:
response_payload = {}
else:
response_type, response_payload = 'oadrResponse', {}
response_payload['vtn_id'] = self.vtn_id
if 'ven_id' in message_payload:
response_payload['ven_id'] = message_payload['ven_id']
response_payload['response'] = {'request_id': message_payload.get('request_id', None),
'response_code': 200,
'response_description': 'OK'}
response_payload['request_id'] = utils.generate_id()
else:
response_type, response_payload = self.error_response('oadrResponse',
enums.STATUS_CODES.COMPLIANCE_ERROR,
"A message of type "
f"{message_type} should not be "
f"sent to this endpoint ({self.__service_name__})")
logger.info(f"Responding to {message_type} with a {response_type} message: {response_payload}.")
hooks.call('after_handle', response_type, response_payload)
return response_type, response_payload
async def register_reports(self, reports):
"""
Tell the VTN about our reports. The VTN miht respond with an
oadrCreateReport message that tells us which reports are to be sent.
"""
request_id = utils.generate_id()
payload = {
'request_id': request_id,
'ven_id': self.ven_id,
'reports': reports,
'report_request_id': 0
}
service = 'EiReport'
message = self._create_message('oadrRegisterReport', **payload)
response_type, response_payload = await self._perform_request(
service, message)
# Handle the subscriptions that the VTN is interested in.
if 'report_requests' in response_payload:
for report_request in response_payload['report_requests']:
await self.create_report(report_request)
message_type = 'oadrCreatedReport'
message_payload = {}
return message_type, message_payload
async def register_reports(self, reports):
"""
Tell the VTN about our reports. The VTN miht respond with an
oadrCreateReport message that tells us which reports are to be sent.
"""
request_id = utils.generate_id()
payload = {'request_id': request_id,
'ven_id': self.ven_id,
'reports': reports,
'report_request_id': 0}
for report in payload['reports']:
utils.setmember(report, 'report_request_id', 0)
service = 'EiReport'
message = self._create_message('oadrRegisterReport', **payload)
response_type, response_payload = await self._perform_request(service, message)
# Handle the subscriptions that the VTN is interested in.
if 'report_requests' in response_payload:
for report_request in response_payload['report_requests']:
result = await self.create_report(report_request)
# Send the oadrCreatedReport message
message_type = 'oadrCreatedReport'
message_payload = {'pending_reports': [{'report_request_id': utils.getmember(report, 'report_request_id')} for report in self.report_requests]}
message = self._create_message('oadrCreatedReport', response={'response_code': 200,
'response_description': 'OK'},
ven_id=self.ven_id,
**message_payload)
response_type, response_payload = await self._perform_request(service, message)
async def query_registration(self):
"""
Request information about the VTN.
"""
request_id = generate_id()
service = 'EiRegisterParty'
message = self._create_message('oadrQueryRegistration', request_id=request_id)
response_type, response_payload = await self._perform_request(service, message)
return response_type, response_payload
async def create_party_registration(self,
http_pull_model=True,
xml_signature=False,
report_only=False,
profile_name='2.0b',
transport_name='simpleHttp',
transport_address=None,
ven_id=None):
"""
Take the neccessary steps to register this client with the server.
:param bool http_pull_model: Whether to use the 'pull' model for HTTP.
:param bool xml_signature: Whether to sign each XML message.
:param bool report_only: Whether or not this is a reporting-only client
which does not deal with Events.
:param str profile_name: Which OpenADR profile to use.
:param str transport_name: The transport name to use. Either 'simpleHttp' or 'xmpp'.
:param str transport_address: Which public-facing address the server should use
to communicate.
:param str ven_id: The ID for this VEN. If you leave this blank,
a VEN_ID will be assigned by the VTN.
"""
request_id = utils.generate_id()
service = 'EiRegisterParty'
payload = {
'ven_name': self.ven_name,
'http_pull_model': http_pull_model,
'xml_signature': xml_signature,
'report_only': report_only,
'profile_name': profile_name,
'transport_name': transport_name,
'transport_address': transport_address
}
if ven_id:
payload['ven_id'] = ven_id
message = self._create_message('oadrCreatePartyRegistration',
request_id=request_id,
**payload)
response_type, response_payload = await self._perform_request(
service, message)
if response_type is None:
return
if response_payload['response']['response_code'] != 200:
status_code = response_payload['response']['response_code']
status_description = response_payload['response'][
'response_description']
logger.error(f"Got error on Create Party Registration: "
f"{status_code} {status_description}")
return
self.ven_id = response_payload['ven_id']
self.registration_id = response_payload['registration_id']
self.poll_frequency = response_payload.get('requested_oadr_poll_freq',
timedelta(seconds=10))
logger.info(f"VEN is now registered with ID {self.ven_id}")
logger.info(f"The polling frequency is {self.poll_frequency}")
return response_type, response_payload
def create_dummy_event(ven_id):
"""
Creates a dummy event
"""
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": 0, "signal_payload": 8.0},
{"duration": timedelta(minutes=1), "uid": 1, "signal_payload": 10.0},
{"duration": timedelta(minutes=1), "uid": 2, "signal_payload": 12.0},
{"duration": timedelta(minutes=1), "uid": 3, "signal_payload": 14.0},
{"duration": timedelta(minutes=1), "uid": 4, "signal_payload": 16.0},
{"duration": timedelta(minutes=1), "uid": 5, "signal_payload": 18.0},
{"duration": timedelta(minutes=1), "uid": 6, "signal_payload": 20.0},
{"duration": timedelta(minutes=1), "uid": 7, "signal_payload": 10.0},
{"duration": timedelta(minutes=1), "uid": 8, "signal_payload": 20.0}],
"signal_name": "LOAD_CONTROL",
"signal_type": "x-loadControlCapacity",
"signal_id": generate_id(),
"measurement": {"name": "voltage",
"description": "Voltage",
"unit": "V",
"scale": "none"},
"current_value": 0.0}]
event_targets = [{"ven_id": 'VEN001'}, {"ven_id": 'VEN002'}]
event = {'active_period': active_period,
'event_descriptor': event_descriptor,
'event_signals': event_signals,
'targets': event_targets,
'targets_by_type': group_targets_by_type(event_targets),
'response_required': 'always'}
return event
def create_dummy_event(ven_id):
"""
Creates a dummy event
"""
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'}
return event
async def request_event(self, reply_limit=1):
"""
Request the next Event from the VTN, if it has any.
"""
payload = {'request_id': generate_id(),
'ven_id': self.ven_id,
'reply_limit': reply_limit}
message = self._create_message('oadrRequestEvent', **payload)
service = 'EiEvent'
response_type, response_payload = await self._perform_request(service, message)
return response_type, response_payload
async def add_event(self, ven_id, signal_name, signal_type, intervals,
target, callback):
"""
Convenience method to add an event with a single signal.
:param str ven_id: The ven_id to whom this event must be delivered.
:param str signal_name: The OpenADR name of the signal; one of openleadr.objects.SIGNAL_NAME
:param str signal_type: The OpenADR type of the signal; one of openleadr.objects.SIGNAL_TYPE
:param str intervals: A list of intervals with a dtstart, duration and payload member.
:param str callback: A callback function for when your event has been accepted (optIn) or refused (optOut).
"""
if self.services['event_service'].polling_method == 'external':
logger.error(
"You cannot use the add_event method after you assign your own on_poll "
"handler. If you use your own on_poll handler, you are responsible for "
"delivering events from that handler. If you want to use OpenLEADRs "
"message queuing system, you should not assign an on_poll handler. "
"Your Event will NOT be added.")
return
event_id = generate_id()
if not isinstance(target, list):
target = [target]
event_descriptor = objects.EventDescriptor(
event_id=event_id,
modification_number=0,
market_context="None",
event_status="near",
created_date_time=datetime.now(timezone.utc))
event_signal = objects.EventSignal(intervals=intervals,
signal_name=signal_name,
signal_type=signal_type,
signal_id=generate_id(),
targets=target)
event = objects.Event(event_descriptor=event_descriptor,
event_signals=[event_signal],
targets=target)
if ven_id not in self.message_queues:
self.message_queues[ven_id] = asyncio.Queue()
await self.message_queues[ven_id].put(event)
self.services['event_service'].pending_events[event_id] = callback
async def _on_create_party_registration(payload):
registration_id = generate_id()
ven_id = generate_id()
add_ven(payload['ven_name'], ven_id, registration_id)
payload = {
'response': {
'response_code': 200,
'response_description': 'OK',
'request_id': payload['request_id']
},
'ven_id':
ven_id,
'registration_id':
registration_id,
'profiles': [{
'profile_name': '2.0b',
'transports': {
'transport_name': 'simpleHttp'
}
}],
'requested_oadr_poll_freq':
timedelta(seconds=10)
}
return 'oadrCreatedPartyRegistration', payload
async def test_conformance_008_raise():
"""
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()
},
{'intervals': [{'duration': timedelta(minutes=1),
'signal_payload': 1},
{'duration': timedelta(minutes=2),
'signal_payload': 2},
{'duration': timedelta(minutes=2),
'signal_payload': 3}],
'signal_name': enums.SIGNAL_NAME.SIMPLE,
'signal_type': enums.SIGNAL_TYPE.DELTA,
'signal_id': generate_id()
}]
}
with pytest.raises(ValueError):
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])
async def _report_queue_worker(self):
"""
A Queue worker that pushes out the pending reports.
"""
try:
while True:
report = await self.pending_reports.get()
service = 'EiReport'
message = self._create_message('oadrUpdateReport',
ven_id=self.ven_id,
request_id=utils.generate_id(),
reports=[report])
try:
response_type, response_payload = await self._perform_request(service, message)
except Exception as err:
logger.error(f"Unable to send the report to the VTN. Error: {err}")
else:
if 'cancel_report' in response_payload:
await self.cancel_report(response_payload['cancel_report'])
except asyncio.CancelledError:
return
def add_event(self, ven_id, signal_name, signal_type, intervals, callback=None, event_id=None,
targets=None, targets_by_type=None, target=None, response_required='always',
market_context="oadr://unknown.context", notification_period=None,
ramp_up_period=None, recovery_period=None, signal_target_mrid=None):
"""
Convenience method to add an event with a single signal.
:param str ven_id: The ven_id to whom this event must be delivered.
:param str signal_name: The OpenADR name of the signal; one of openleadr.objects.SIGNAL_NAME
:param str signal_type: The OpenADR type of the signal; one of openleadr.objects.SIGNAL_TYPE
:param str intervals: A list of intervals with a dtstart, duration and payload member.
:param str callback: A callback function for when your event has been accepted (optIn) or refused (optOut).
:param list targets: A list of Targets that this Event applies to.
:param target: A single target for this event.
:param dict targets_by_type: A dict of targets, grouped by type.
:param str market_context: A URI for the DR program that this event belongs to.
:param timedelta notification_period: The Notification period for the Event's Active Period.
:param timedelta ramp_up_period: The Ramp Up period for the Event's Active Period.
:param timedelta recovery_period: The Recovery period for the Event's Active Period.
If you don't provide a target using any of the three arguments, the target will be set to the given ven_id.
"""
if self.services['event_service'].polling_method == 'external':
logger.error("You cannot use the add_event method after you assign your own on_poll "
"handler. If you use your own on_poll handler, you are responsible for "
"delivering events from that handler. If you want to use OpenLEADRs "
"message queuing system, you should not assign an on_poll handler. "
"Your Event will NOT be added.")
return
if not re.match(r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?", market_context):
raise ValueError("The Market Context must be a valid URI.")
event_id = event_id or utils.generate_id()
if response_required not in ('always', 'never'):
raise ValueError("'response_required' should be either 'always' or 'never'; "
f"you provided '{response_required}'.")
# Figure out the target for this Event
if target is None and targets is None and targets_by_type is None:
targets = [{'ven_id': ven_id}]
elif target is not None:
targets = [target]
elif targets_by_type is not None:
targets = utils.ungroup_targets_by_type(targets_by_type)
if not isinstance(targets, list):
targets = [targets]
if signal_type not in enums.SIGNAL_TYPE.values:
raise ValueError(f"""The signal_type must be one of '{"', '".join(enums.SIGNAL_TYPE.values)}', """
f"""you specified: '{signal_type}'.""")
if signal_name not in enums.SIGNAL_NAME.values and not signal_name.startswith('x-'):
raise ValueError(f"""The signal_name must be one of '{"', '".join(enums.SIGNAL_TYPE.values)}', """
f"""or it must begin with 'x-'. You specified: '{signal_name}'""")
if not intervals or not isinstance(intervals, (list, tuple)) or len(intervals) == 0:
raise ValueError(f"The intervals must be a list of intervals, you specified: {intervals}")
event_descriptor = objects.EventDescriptor(event_id=event_id,
modification_number=0,
market_context=market_context,
event_status="far",
created_date_time=datetime.now(timezone.utc))
event_signal = objects.EventSignal(intervals=intervals,
signal_name=signal_name,
signal_type=signal_type,
signal_id=utils.generate_id())
# Make sure the intervals carry timezone-aware timestamps
for interval in intervals:
if utils.getmember(interval, 'dtstart').tzinfo is None:
utils.setmember(interval, 'dtstart',
utils.getmember(interval, 'dtstart').astimezone(timezone.utc))
logger.warning("You supplied a naive datetime object to your interval's dtstart. "
"This will be interpreted as a timestamp in your local timezone "
"and then converted to UTC before sending. Please supply timezone-"
"aware timestamps like datetime.datetime.new(timezone.utc) or "
"datetime.datetime(..., tzinfo=datetime.timezone.utc)")
active_period = utils.get_active_period_from_intervals(intervals, False)
active_period.ramp_up_period = ramp_up_period
active_period.notification_period = notification_period
active_period.recovery_period = recovery_period
event = objects.Event(active_period=active_period,
event_descriptor=event_descriptor,
event_signals=[event_signal],
targets=targets,
response_required=response_required)
self.add_raw_event(ven_id=ven_id, event=event, callback=callback)
return event_id
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)
"signal_id": generate_id(),
"measurement": {"name": "voltage",
"description": "Voltage",
"unit": "V",
"scale": "none"},
"current_value": 0.0}]
event_targets = [{"ven_id": 'VEN001'}, {"ven_id": 'VEN002'}]
event = {'active_period': active_period,
'event_descriptor': event_descriptor,
'event_signals': event_signals,
'targets': event_targets,
'targets_by_type': group_targets_by_type(event_targets),
'response_required': 'always'}
return event
reports = [{'report_id': generate_id(),
'duration': timedelta(seconds=3600),
'report_descriptions': [{'r_id': generate_id(),
'report_subject': {'end_device_asset': {'mrid': 'meter001'}},
'report_data_source': {'resource_id': 'resource001'},
'report_type': 'usage',
'measurement': asdict(measurement),
'reading_type': 'Direct Read',
'market_context': 'http://MarketContext1',
'sampling_rate': {'min_period': timedelta(seconds=10), 'max_period': timedelta(seconds=30), 'on_change': False}} for measurement in enums.MEASUREMENTS.values],
'report_specifier_id': generate_id(),
'report_name': 'METADATA_HISTORY_USAGE',
'report_request_id': None,
'created_date_time': datetime.now(timezone.utc)}]
for report in reports:
def poll_responder(ven_id, message_type, message_payload):
return message_type, message_payload
event = objects.Event(event_descriptor=objects.EventDescriptor(
event_id='event123',
event_status='far',
modification_number='1',
market_context='http://marketcontext01'),
event_signals=[
objects.EventSignal(
signal_name='simple',
signal_type='level',
signal_id=utils.generate_id(),
intervals=[
objects.Interval(
dtstart=datetime.now(timezone.utc),
duration=timedelta(minutes=10),
signal_payload=1)
])
],
targets=[{
'ven_id': 'ven123'
}])
poll_responses = [('oadrResponse', {}),
('oadrDistributeEvent', {
'events': [asdict(event)]
}),
def add_event(self,
ven_id,
signal_name,
signal_type,
intervals,
callback,
targets=None,
targets_by_type=None,
target=None,
market_context="oadr://unknown.context"):
"""
Convenience method to add an event with a single signal.
:param str ven_id: The ven_id to whom this event must be delivered.
:param str signal_name: The OpenADR name of the signal; one of openleadr.objects.SIGNAL_NAME
:param str signal_type: The OpenADR type of the signal; one of openleadr.objects.SIGNAL_TYPE
:param str intervals: A list of intervals with a dtstart, duration and payload member.
:param str callback: A callback function for when your event has been accepted (optIn) or refused (optOut).
:param list targets: A list of Targets that this Event applies to.
:param target: A single target for this event.
:param dict targets_by_type: A dict of targets, grouped by type.
:param str market_context: A URI for the DR program that this event belongs to.
If you don't provide a target using any of the three arguments, the target will be set to the given ven_id.
"""
if self.services['event_service'].polling_method == 'external':
logger.error(
"You cannot use the add_event method after you assign your own on_poll "
"handler. If you use your own on_poll handler, you are responsible for "
"delivering events from that handler. If you want to use OpenLEADRs "
"message queuing system, you should not assign an on_poll handler. "
"Your Event will NOT be added.")
return
if not re.match(
r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?",
market_context):
raise ValueError("The Market Context must be a valid URI.")
event_id = utils.generate_id()
# Figure out the target for this Event
if target is None and targets is None and targets_by_type is None:
targets = [{'ven_id': ven_id}]
elif target is not None:
targets = [target]
elif targets_by_type is not None:
targets = utils.ungroup_targets_by_type(targets_by_type)
if not isinstance(targets, list):
targets = [targets]
event_descriptor = objects.EventDescriptor(
event_id=event_id,
modification_number=0,
market_context=market_context,
event_status="near",
created_date_time=datetime.now(timezone.utc))
event_signal = objects.EventSignal(intervals=intervals,
signal_name=signal_name,
signal_type=signal_type,
signal_id=utils.generate_id(),
targets=targets)
event = objects.Event(event_descriptor=event_descriptor,
event_signals=[event_signal],
targets=targets)
if ven_id not in self.message_queues:
self.message_queues[ven_id] = asyncio.Queue()
self.message_queues[ven_id].put_nowait(event)
self.services['event_service'].pending_events[event_id] = callback
def add_report(self, callback, resource_id, measurement,
data_collection_mode='incremental',
report_specifier_id=None, r_id=None,
report_name=enums.REPORT_NAME.TELEMETRY_USAGE,
reading_type=enums.READING_TYPE.DIRECT_READ,
report_type=enums.REPORT_TYPE.READING, sampling_rate=None, data_source=None,
scale="none", unit=None, power_ac=True, power_hertz=50, power_voltage=230,
market_context=None):
"""
Add a new reporting capability to the client.
:param callable callback: A callback or coroutine that will fetch the value for a specific
report. This callback will be passed the report_id and the r_id
of the requested value.
:param str resource_id: A specific name for this resource within this report.
:param str measurement: The quantity that is being measured (openleadr.enums.MEASUREMENTS).
:param str data_collection_mode: Whether you want the data to be collected incrementally
or at once. If the VTN requests the sampling interval to be
higher than the reporting interval, this setting determines
if the callback should be called at the sampling rate (with
no args, assuming it returns the current value), or at the
reporting interval (with date_from and date_to as keyword
arguments). Choose 'incremental' for the former case, or
'full' for the latter case.
:param str report_specifier_id: A unique identifier for this report. Leave this blank for a
random generated id, or fill it in if your VTN depends on
this being a known value, or if it needs to be constant
between restarts of the client.
:param str r_id: A unique identifier for a datapoint in a report. The same remarks apply as
for the report_specifier_id.
:param str report_name: An OpenADR name for this report (one of openleadr.enums.REPORT_NAME)
:param str reading_type: An OpenADR reading type (found in openleadr.enums.READING_TYPE)
:param str report_type: An OpenADR report type (found in openleadr.enums.REPORT_TYPE)
:param datetime.timedelta sampling_rate: The sampling rate for the measurement.
:param str unit: The unit for this measurement.
"""
# Verify input
if report_name not in enums.REPORT_NAME.values and not report_name.startswith('x-'):
raise ValueError(f"{report_name} is not a valid report_name. Valid options are "
f"{', '.join(enums.REPORT_NAME.values)}",
" or any name starting with 'x-'.")
if reading_type not in enums.READING_TYPE.values and not reading_type.startswith('x-'):
raise ValueError(f"{reading_type} is not a valid reading_type. Valid options are "
f"{', '.join(enums.READING_TYPE.values)}"
" or any name starting with 'x-'.")
if report_type not in enums.REPORT_TYPE.values and not report_type.startswith('x-'):
raise ValueError(f"{report_type} is not a valid report_type. Valid options are "
f"{', '.join(enums.REPORT_TYPE.values)}"
" or any name starting with 'x-'.")
if scale not in enums.SI_SCALE_CODE.values:
raise ValueError(f"{scale} is not a valid scale. Valid options are "
f"{', '.join(enums.SI_SCALE_CODE.values)}")
if sampling_rate is None:
sampling_rate = objects.SamplingRate(min_period=timedelta(seconds=10),
max_period=timedelta(hours=24),
on_change=False)
elif isinstance(sampling_rate, timedelta):
sampling_rate = objects.SamplingRate(min_period=sampling_rate,
max_period=sampling_rate,
on_change=False)
if data_collection_mode not in ('incremental', 'full'):
raise ValueError("The data_collection_mode should be 'incremental' or 'full'.")
if data_collection_mode == 'full':
args = inspect.signature(callback).parameters
if not ('date_from' in args and 'date_to' in args and 'sampling_interval' in args):
raise TypeError("Your callback function must accept the 'date_from', 'date_to' "
"and 'sampling_interval' arguments if used "
"with data_collection_mode 'full'.")
# Determine the correct item name, item description and unit
if isinstance(measurement, objects.Measurement):
item_base = measurement
elif measurement.upper() in enums.MEASUREMENTS.members:
item_base = enums.MEASUREMENTS[measurement.upper()]
else:
item_base = objects.Measurement(item_name='customUnit',
item_description=measurement,
item_units=unit,
si_scale_code=scale)
if scale is not None:
if scale in enums.SI_SCALE_CODE.values:
item_base.si_scale_code = scale
else:
raise ValueError("The 'scale' argument must be one of '{'. ',join(enums.SI_SCALE_CODE.values)}")
# Check if unit is compatible
if unit is not None and unit != item_base.item_units \
and unit not in item_base.acceptable_units:
logger.warning(f"The supplied unit {unit} for measurement {measurement} "
f"will be ignored, {item_base.item_units} will be used instead."
f"Allowed units for this measurement are: "
f"{', '.join(item_base.acceptable_units)}")
# Get or create the relevant Report
if report_specifier_id:
report = find_by(self.reports,
'report_name', report_name,
'report_specifier_id', report_specifier_id)
else:
report = find_by(self.reports, 'report_name', report_name)
if not report:
report_specifier_id = report_specifier_id or generate_id()
report = objects.Report(created_date_time=datetime.now(),
report_name=report_name,
report_specifier_id=report_specifier_id,
data_collection_mode=data_collection_mode)
self.reports.append(report)
# Add the new report description to the report
target = objects.Target(resource_id=resource_id)
r_id = generate_id()
report_description = objects.ReportDescription(r_id=r_id,
reading_type=reading_type,
report_data_source=target,
report_subject=target,
report_type=report_type,
sampling_rate=sampling_rate,
measurement=item_base,
market_context='Market01')
self.report_callbacks[(report.report_specifier_id, r_id)] = callback
report.report_descriptions.append(report_description)
async def test_conformance_014_warn(caplog):
"""
If currentValue is included in the payload, it MUST be set to 0 (normal)
when the event status is not “active” for the SIMPLE signalName.
"""
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() + timedelta(minutes=30),
'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(),
'current_value':
123
}],
'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,
"The current_value for a SIMPLE event that is not yet active must be 0. This will be corrected."
)]
event = {
'active_period': active_period,
'event_descriptor': event_descriptor,
'event_signals': event_signals,
'targets': event_targets,
'response_required': 'always'
}
return event
testcases = [
('oadrCanceledOpt',
dict(response={
'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()
},
opt_id=generate_id())),
('oadrCanceledPartyRegistration',
dict(response={
'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()
},
registration_id=generate_id(),
ven_id='123ABC')),
('oadrCanceledReport',
dict(response={
'response_code': 200,
'response_description': 'OK',
'request_id': generate_id()
async def _on_create_party_registration(payload):
registration_id = generate_id()
return VEN_ID, registration_id
async def register_report(self, payload):
"""
Handle the VENs reporting capabilities.
"""
report_requests = []
args = inspect.signature(self.on_register_report).parameters
if all(['measurement' in args, 'resource_id' in args,
'min_sampling_interval' in args, 'max_sampling_interval' in args,
'unit' in args, 'scale' in args]):
for report in payload['reports']:
result = [self.on_register_report(resource_id=rd['report_subject']['resource_id'],
measurement=rd['measurement']['item_description'],
unit=rd['measurement']['item_units'],
scale=rd['measurement']['si_scale_code'],
min_sampling_interval=rd['sampling_rate']['min_period'],
max_sampling_interval=rd['sampling_rate']['max_period'])
for rd in report['report_descriptions']]
if iscoroutine(result[0]):
result = await gather(*result)
result = [(report['report_descriptions'][i]['r_id'], *result[i])
for i in range(len(report['report_descriptions']))]
report_requests.append(result)
else:
# Use the 'full' mode for openADR reporting
result = [self.on_register_report(report) for report in payload['reports']]
if iscoroutine(result[0]):
result = await gather(*result) # Now we have r_id, callback, sampling_rate
report_requests = result
for i, report_request in enumerate(report_requests):
if report_request is not None:
if not all(len(rrq) in (3, 4) for rrq in report_request):
logger.error("Your on_register_report handler did not return a valid response")
# Validate the report requests
for i, report_request in enumerate(report_requests):
if report_request is None:
continue
# Check if all sampling rates per report_request are the same
sampling_interval = min(rrq[2] for rrq in report_request if rrq is not None)
if not all(rrq is not None and report_request[0][2] == sampling_interval for rrq in report_request):
logger.error("OpenADR does not support multiple different sampling rates per "
"report. OpenLEADR will set all sampling rates to "
f"{sampling_interval}")
# Form the report request
oadr_report_requests = []
for i, report_request in enumerate(report_requests):
if report_request is None:
continue
orig_report = payload['reports'][i]
report_specifier_id = orig_report['report_specifier_id']
report_request_id = generate_id()
specifier_payloads = []
for rrq in report_request:
if len(rrq) == 3:
r_id, callback, sampling_interval = rrq
report_interval = sampling_interval
elif len(rrq) == 4:
r_id, callback, sampling_interval, report_interval = rrq
report_description = find_by(orig_report['report_descriptions'], 'r_id', r_id)
reading_type = report_description['reading_type']
specifier_payloads.append(objects.SpecifierPayload(r_id=r_id,
reading_type=reading_type))
# Append the callback to our list of known callbacks
self.report_callbacks[(report_request_id, r_id)] = callback
# Add the ReportSpecifier to the ReportRequest
report_specifier = objects.ReportSpecifier(report_specifier_id=report_specifier_id,
granularity=sampling_interval,
report_back_duration=report_interval,
specifier_payloads=specifier_payloads)
# Add the ReportRequest to our outgoing message
oadr_report_requests.append(objects.ReportRequest(report_request_id=report_request_id,
report_specifier=report_specifier))
# Put the report requests back together
response_type = 'oadrRegisteredReport'
response_payload = {'report_requests': oadr_report_requests}
return response_type, response_payload
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
async def register_report(self, payload):
"""
Handle the VENs reporting capabilities.
"""
report_requests = []
args = inspect.signature(self.on_register_report).parameters
if all([
'ven_id' in args, 'resource_id' in args, 'measurement' in args,
'min_sampling_interval' in args, 'max_sampling_interval'
in args, 'unit' in args, 'scale' in args
]):
mode = 'compact'
else:
mode = 'full'
if payload['reports'] is None:
return
for report in payload['reports']:
if report['report_name'] == 'METADATA_TELEMETRY_STATUS':
if mode == 'compact':
results = [
self.on_register_report(
ven_id=payload['ven_id'],
resource_id=rd.get('report_data_source',
{}).get('resource_id'),
measurement='Status',
unit=None,
scale=None,
min_sampling_interval=rd['sampling_rate']
['min_period'],
max_sampling_interval=rd['sampling_rate']
['max_period'])
for rd in report['report_descriptions']
]
results = await utils.gather_if_required(results)
elif mode == 'full':
results = await utils.await_if_required(
self.on_register_report(report))
elif report['report_name'] == 'METADATA_TELEMETRY_USAGE':
if mode == 'compact':
results = [
self.on_register_report(
ven_id=payload['ven_id'],
resource_id=rd.get('report_data_source',
{}).get('resource_id'),
measurement=rd['measurement']['description'],
unit=rd['measurement']['unit'],
scale=rd['measurement']['scale'],
min_sampling_interval=rd['sampling_rate']
['min_period'],
max_sampling_interval=rd['sampling_rate']
['max_period'])
for rd in report['report_descriptions']
]
results = await utils.gather_if_required(results)
elif mode == 'full':
results = await utils.await_if_required(
self.on_register_report(report))
elif report['report_name'] in ('METADATA_HISTORY_USAGE',
'METADATA_HISTORY_GREENBUTTON'):
if payload['ven_id'] not in self.registered_reports:
self.registered_reports[payload['ven_id']] = []
report['report_name'] = report['report_name'][9:]
self.registered_reports[payload['ven_id']].append(report)
report_requests.append(None)
continue
else:
logger.warning(
"Reports other than TELEMETRY_USAGE, TELEMETRY_STATUS, "
"HISTORY_USAGE and HISTORY_GREENBUTTON are not yet supported. "
f"Skipping report with name {report['report_name']}.")
report_requests.append(None)
continue
# Perform some rudimentary checks on the returned type
if results is not None:
if not isinstance(results, list):
logger.error(
"Your on_register_report handler must return a list of tuples or None; "
f"it returned '{results}' ({results.__class__.__name__})."
)
results = None
else:
for i, r in enumerate(results):
if r is None:
continue
if not isinstance(r, tuple):
if mode == 'compact':
logger.error(
"Your on_register_report handler must return a tuple or None; "
f"it returned '{r}' ({r.__class__.__name__})."
)
elif mode == 'full':
logger.error(
"Your on_register_report handler must return a list of tuples or None; "
f"The first item from the list was '{r}' ({r.__class__.__name__})."
)
results[i] = None
# If we used compact mode, prepend the r_id to each result
# (this is already there when using the full mode)
if mode == 'compact':
results = [
(report['report_descriptions'][i]['r_id'],
*results[i])
for i in range(len(report['report_descriptions']))
if isinstance(results[i], tuple)
]
report_requests.append(results)
utils.validate_report_request_tuples(report_requests, mode=mode)
for i, report_request in enumerate(report_requests):
if report_request is None or len(report_request) == 0 or all(
rrq is None for rrq in report_request):
continue
# Check if all sampling rates per report_request are the same
sampling_interval = min(rrq[2] for rrq in report_request
if isinstance(rrq, tuple))
if not all(rrq is not None
and report_request[0][2] == sampling_interval
for rrq in report_request):
logger.error(
"OpenADR does not support multiple different sampling rates per "
"report. OpenLEADR will set all sampling rates to "
f"{sampling_interval}")
# Form the report request
oadr_report_requests = []
for i, report_request in enumerate(report_requests):
if report_request is None or len(report_request) == 0 or all(
rrq is None for rrq in report_request):
continue
orig_report = payload['reports'][i]
report_specifier_id = orig_report['report_specifier_id']
report_request_id = utils.generate_id()
specifier_payloads = []
for rrq in report_request:
if len(rrq) == 3:
r_id, callback, sampling_interval = rrq
report_interval = sampling_interval
elif len(rrq) == 4:
r_id, callback, sampling_interval, report_interval = rrq
report_description = utils.find_by(
orig_report['report_descriptions'], 'r_id', r_id)
reading_type = report_description['reading_type']
specifier_payloads.append(
objects.SpecifierPayload(r_id=r_id,
reading_type=reading_type))
# Append the callback to our list of known callbacks
self.report_callbacks[(report_request_id, r_id)] = callback
# Add the ReportSpecifier to the ReportRequest
report_specifier = objects.ReportSpecifier(
report_specifier_id=report_specifier_id,
granularity=sampling_interval,
report_back_duration=report_interval,
specifier_payloads=specifier_payloads)
# Add the ReportRequest to our outgoing message
oadr_report_requests.append(
objects.ReportRequest(report_request_id=report_request_id,
report_specifier=report_specifier))
# Put the report requests back together
response_type = 'oadrRegisteredReport'
response_payload = {'report_requests': oadr_report_requests}
# Store the requested reports
self.requested_reports[payload['ven_id']] = oadr_report_requests
return response_type, response_payload
