def test_MessageMarshalCpp(self):
snk = sb.MessageSink('my_msg', MyMsg, self.filtering_callback)
c = sb.launch('huge_msg_cpp',
execparams={
'LOGGING_CONFIG_URI':
'file://' + os.getcwd() + '/logconfig.cfg'
})
c.connect(snk)
sb.start()
time.sleep(5)
fp = None
try:
fp = open('foo/bar/test.log', 'r')
except:
pass
if fp != None:
log_contents = fp.read()
fp.close()
try:
os.remove('foo/bar/test.log')
except:
pass
try:
os.rmdir('foo/bar')
except:
pass
try:
os.rmdir('foo')
except:
pass
number_warnings = log_contents.count('Maximum message size exceeded')
self.assertEquals(number_warnings, 2)
self.assertEqual(self.messages_passed, 101)
def test_MessageMarshalJava(self):
snk = sb.MessageSink('my_msg', MyMsg, self.filtering_callback)
c = sb.launch('huge_msg_java',
execparams={
'LOGGING_CONFIG_URI':
'file://' + os.getcwd() + '/logconfig.cfg'
})
c.connect(snk)
sb.start()
time.sleep(2)
log_contents = ''
begin_time = time.time()
while time.time() - begin_time < 10:
fp = None
try:
fp = open('foo/bar/test.log', 'r')
except:
pass
if fp != None:
log_contents = fp.read()
fp.close()
number_warnings_1 = log_contents.count(
'Could not deliver the message. Maximum message size exceeded, trying individually.'
)
number_warnings_2 = log_contents.count(
'Could not deliver the message. Maximum message size exceeded')
if number_warnings_1 == 1 and number_warnings_2 == 3 and self.messages_passed == 101:
break
try:
os.remove('foo/bar/test.log')
except:
pass
try:
os.rmdir('foo/bar')
except:
pass
try:
os.rmdir('foo')
except:
pass
self.assertEquals(number_warnings_1, 1)
self.assertEquals(number_warnings_2, 3)
self.assertEqual(self.messages_passed, 101)
def test_MessagingJava(self):
src = sb.MessageSource('foo')
c = sb.launch('msg_through_java')
src.connect(c)
snk = sb.MessageSink('foo', Foo, self.callback)
c.connect(snk)
sb.start()
src.sendMessage({'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'})
_begin = time.time()
_now = time.time()
while _now - _begin < 5:
if self.rcv_msg != None:
break
_now = time.time()
self.assertEquals(self.rcv_msg.a, 'A')
self.assertEquals(self.rcv_msg.b, 'B')
self.assertEquals(self.rcv_msg.c, 'C')
self.rcv_msg = None
src.sendMessage({'a': 'A', 'b': 'B', 'c': 'C'})
while _now - _begin < 5:
if self.rcv_msg != None:
break
_now = time.time()
self.assertEquals(self.rcv_msg.a, 'A')
self.assertEquals(self.rcv_msg.b, 'B')
self.assertEquals(self.rcv_msg.c, 'C')
self.rcv_msg = None
src.sendMessage({'a': 'A', 'c': 'C'})
while _now - _begin < 5:
if self.rcv_msg != None:
break
_now = time.time()
self.assertEquals(self.rcv_msg.a, 'A')
self.assertEquals(self.rcv_msg.b, None)
self.assertEquals(self.rcv_msg.c, 'C')
self.rcv_msg = None
# when the cut that I request is complete, this callback will receive the message
def responseCallback(id_, message_response):
print 'Got this response:', id_, message_response
fp = dom.fileMgr.open(message_response.file_location, True)
data = fp.read(fp.sizeOf())
fp.close()
dom.fileMgr.remove(message_response.file_location)
print '========= got data of length:', len(data)
# request a cut from 15 seconds ago. Make the cut 3 seconds long. The cut is center at 1.01MHz and is 50 kHz wide
request = {
'cut_request::time_begin': now - 15,
'cut_request::time_end': now - 12,
'cut_request::freq_begin': 985000,
'cut_request::freq_end': 1035000,
'cut_request::request_id': 'hello'
}
print '... sending request for a cut:', request
src = sb.MessageSource('cut_request')
src.connect(control, providesPortName='request')
snk = sb.MessageSink('cut_response', CutResponse, responseCallback)
control.connect(snk, usesPortName='response')
sb.start()
src.sendMessage(request)
time.sleep(2)
archiver.releaseObject()
sample_write.releaseObject()
def listen_waveform_ports(domain, waveform_ports):
"""Listen to message events on specific waveform ports on domain
Parameters
----------
domain : str
The Redhawk domain to connect
waveform_ports : list of tuples
This will be a list of ports. Each tuple is a combination of
(WAVEFORM_NAME, PORT_NAME)
Returns
-------
my_msgs : dict
Dictionary where keys is the combo of waveform + port name
The value will be the recorded messages.
"""
# -------------- connect ----------------------------------------------
dom = redhawk.attach(domain)
# ------------------------ prepare variables --------------------------
my_msg_sinks = {}
my_msgs = {}
my_msg_recorder = {}
waveform_ports_connected = 0
print_decimation = 0
PRINT_EVERY_NTH_LOOP = 20
while waveform_ports_connected < len(waveform_ports):
if print_decimation == 0:
print("Connecting ports ({} of {} complete) ...".format(
waveform_ports_connected, len(waveform_ports)))
print_decimation = (print_decimation + 1) % PRINT_EVERY_NTH_LOOP
# -------------- get applications ---------------------------------
waveforms = dom.applications
# add a message sink per port
for (c_name, c_port) in waveform_ports:
# enforce strings
c_name = str(c_name)
c_port = str(c_port)
waveform_port_key = c_name + ":" + c_port
if not waveform_port_key in my_msg_sinks:
# select waveform from the list
c_wave = find_waveform(waveforms, c_name)
try:
# get the port of interest
port_inst = c_wave.getPort(c_port)
# --------------- connect to message sink ---------------------
msg_record = MessageRecorder()
msg_sink = sb.MessageSink(
messageCallback=msg_record.msgCallback,
storeMessages=True)
port_inst.connectPort(\
msg_sink.getPort("msgIn"),
"conn_"+ str(uuid.uuid1()))
msg_sink.start()
# track sink
my_msg_sinks[waveform_port_key] = msg_sink
my_msg_recorder[waveform_port_key] = msg_record
print(
"Connected Waveform Name = {}, Port Name = {}".format(
str(c_name), str(c_port)))
waveform_ports_connected = waveform_ports_connected + 1
except:
pass
# Wait for a tenth of a second before trying again
time.sleep(0.1)
# ----------------------- user prompt to end --------------------------
if len(my_msg_sinks) > 0:
prompt("Hit enter when you are finished recording messages ...")
else:
print("No connections set...exiting")
# -------------------------- get messages -----------------------------
for key in my_msg_sinks.keys():
#my_msgs[key] = my_msg_sinks[key].getMessages()
# NOTE: use message recorder to update timestamps
my_msgs[key] = my_msg_recorder[key].getMessages()
try:
my_msg_sinks[key].releaseObject()
except Exception as e:
print("Failed to release msg sink: %s" % str(e))
return my_msgs
