def initialize(self): """ Initialize the MOOS app. """ logger.info("MOOS datastream initialize %s"%self) self.moos_host = self.kwargs.get('moos_host', 'localhost') self.moos_port = self.kwargs.get('moos_port', 9000) self.moos_name = self.kwargs.get('moos_name', self.component_name) ''' key = (self.moos_host, self.moos_port) if not key in AbstractMOOS._moosapps: AbstractMOOS._save_messages[key] = [] AbstractMOOS._moosapps[key] = pymoos.MOOSCommClient.MOOSApp() AbstractMOOS._moosapps[key].Run(self.moos_host, self.moos_port, "uMorse", self.moos_freq) logger.info("\tdatastream: host=%s:port=%d (freq: %.2fHz)" %(self.moos_host, self.moos_port, self.moos_freq)) logger.info("\tnew interface initialized") ''' # all instance share the same static MOOSApp according to host and port self.comms = pymoos.comms() self.comms.run(self.moos_host,self.moos_port,self.moos_name) self.time = pymoos.time
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() # Placeholder for the list of varables that we want self.NAV_X = [] self.NAV_Y = [] self.NAV_HEAD = []
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() # Initialize the MOOS lists self.LANDMARKS = [] self.NAV_AIDS = [] self.UNDERWATER = []
def main(_sigma_q, _sigma_r, _p_d, _p_s): global comms, f_gmphd, born_components, auv_nav_status comms = pymoos.comms() F = [[1, 0], [0, 1]] H = [[1, 0], [0, 1]] sigma_q = _sigma_q sigma_r = _sigma_r Q = [[math.pow(sigma_q, 2), 0], [0, math.pow(sigma_q, 2)]] R = [[math.pow(2 * sigma_r, 2), 0], [0, math.pow(2 * sigma_r, 2)]] p_d = _p_d p_s = _p_s clutter_intensity = 0 born_components = [] f_gmphd = gmphd.GMPHD([], p_s, p_d, F, Q, H, R, clutter_intensity) comms.set_on_connect_callback(on_connect) comms.set_on_mail_callback(on_mail) comms.run('localhost', 9001, 'gmphd-moos') while True: time.sleep(.01)
def __init__(self, sonar_msg_callback=None, waypoints_callback=None): """ :param host: MOOS host name/ip :param port: MOOS port :param name: Name of program """ # Logger stuff super().__init__() self.logger = logging.getLogger('messages.MoosMsgs') self.logger_bins = logging.getLogger('messages.MoosMsgs.bins') self.logger_pose = logging.getLogger('messages.MoosMsgs.pose') self.logger.debug('MOOS msgs initiated') # Init self.comms = pm.comms() self.comms.set_on_connect_callback(self.on_connect) self.add_queues() self.cur_pos_msg = MoosPosMsg() self.waypoint_list = None self.waypoint_counter = None # if LosSettings.enable_los and Settings.enable_autopilot: self.los_stop_event = threading.Event() self.los_start_event = threading.Event() self.los_restart_event = threading.Event() self.los_controller = LosController(self, 0.1, self.los_stop_event, self.los_start_event, self.los_restart_event) self.los_thread = threading.Thread() # threading.Thread(target=self.los_controller.loop, daemon=True)
def __init__(self): self.bathy_grid = gridgen.BathyGrid.from_bathymetry( \ $(BATHY_GRID), False) self.comms = pymoos.comms() self.comms.set_on_connect_callback(self.connect_callback) self.comms.set_on_mail_callback(self.message_received) pymoos.set_moos_timewarp($(WARP)) self.comms.set_comms_control_timewarp_scale_factor(0.4) self.comms.run('localhost', 9000, 'uSonarSimulator') # Initialize stored variables self.messages = dict() self.messages['NAV_X'] = 0 self.messages['NAV_Y'] = 0 self.messages['NAV_LAT'] = 0 self.messages['NAV_LONG'] = 0 self.messages['NAV_HEADING'] = 0 self.messages['NEXT_SWATH_SIDE'] = 'stbd' self.post_ready = False self.post_message = "" self.post_stbd = "" self.post_port = "" self.swath_angle = SWATH_ANGLE self.last_port_depth = 0 self.last_stbd_depth = 0 self.msg_count = 0
def main(_sigma_q, _sigma_r, _p_d, _p_s): global comms, f_gmphd, born_components, auv_nav_status comms = pymoos.comms() F = [[1, 0], [0, 1]] H = [[1, 0], [0, 1]] sigma_q = _sigma_q sigma_r = _sigma_r Q = [[math.pow(sigma_q, 2), 0], [0, math.pow(sigma_q, 2)]] R = [[math.pow(2*sigma_r, 2), 0], [0, math.pow(2*sigma_r, 2)]] p_d = _p_d p_s = _p_s clutter_intensity = 0 born_components = [] f_gmphd = gmphd.GMPHD([], p_s, p_d, F, Q, H, R, clutter_intensity) comms.set_on_connect_callback(on_connect) comms.set_on_mail_callback(on_mail) comms.run('localhost', 9001, 'gmphd-moos') i = 0 while True: i = i + 1 time.sleep(.1)
def __init__(self): self.moos_app_name = 'PySpectrogram' self.time_warp = 1 self.server_host = 'localhost' self.server_port = 9000 self.freq_sampling = 37500.0 self.num_samples = 16000 self.num_hydrophones = 5 self.aco_data = np.zeros( (self.num_samples, self.num_hydrophones )) #array that holds the acoustic data currently being processed self.aco_data_latest = None #array that holds new acoustic data while it waits to be processed self.aco_new = False #flag to indicate that new acoustic data has been read self.extents = None ''' Initialize Python-MOOS Communications ''' self.mooscomms = pymoos.comms() self.mooscomms.set_on_connect_callback(self.moos_on_connect) self.mooscomms.add_active_queue( 'cbf_queue', self.moos_on_new_acoustic_binary_data ) #let's use a queue callback instead to handle distinct messages self.mooscomms.add_message_route_to_active_queue( 'cbf_queue', 'DAQ_BINARY_DATA' ) #route 'DAQ_BINARY_DATA' messages to moos_on_new_acoustic_binary_data function self.mooscomms.run(self.server_host, self.server_port, self.moos_app_name) pymoos.set_moos_timewarp(self.time_warp)
def test_10_notify_msg(self): c = pymoos.comms() c.set_on_connect_callback( lambda: self.assertTrue(c.register('TEST_NOTIFY_MSG'))) c.run('localhost', 9000, 'test_notify_msg') c.wait_until_connected(5000) time.sleep(1) self.assertTrue(c.is_registered_for('TEST_NOTIFY_MSG')) t = pymoos.time() self.assertTrue(c.notify('TEST_NOTIFY_MSG', 1., t)) time.sleep(1) msgs = c.fetch() self.assertNotEqual(len(msgs), 0) for msg in msgs: self.assertEqual(msg.key(), 'TEST_NOTIFY_MSG') self.assertEqual(msg.name(), 'TEST_NOTIFY_MSG') self.assertTrue(msg.is_name('TEST_NOTIFY_MSG')) self.assertEqual(msg.double(), 1) self.assertTrue(msg.is_double()) self.assertEqual(msg.source(), 'test_notify_msg') self.assertFalse(msg.is_string()) self.assertFalse(msg.is_binary()) self.assertEqual(msg.time(), t) c.close(True)
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() self.All_ang = [] self.util = [] self.X = [] self.Y = [] self.cost = []
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() self.X = [] self.Y = [] self.Index = [] self.New_Pnt = [] self.New_Poly = []
def test_01_name(self): c = pymoos.comms() c.run('localhost', 9000, 'test_name') c.wait_until_connected(2000) self.assertEqual(c.get_moos_name(), 'test_name') self.assertEqual(c.get_community_name(), 'pymoos_test_db') c.close(True)
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() self.WPT = [] self.poly = [] self.point =[] self.heading = [] self.angles = [] self.util = [] self.buffer_width = []
def __init__(self, fname): # Init self.comms = pm.comms() self.fname = fname self.f = open(fname, 'r') self.reader = csv.DictReader(self.f, fieldnames=[ 'time', 'key', 'type', 'bearing', 'step', 'range_scale', 'length', 'dbytes', 'data' ])
def test_12_get_registered(self): c = pymoos.comms() c.run('localhost', 9000, 'test_get_registered') c.wait_until_connected(2000) c.register('MOOS_UPTIME', 0.) c.register('MOOS_UPTIME2', 0.) self.assertSetEqual(c.get_registered(), {'MOOS_UPTIME', 'MOOS_UPTIME2'}) c.close(True)
def test_30_on_connect_callback_inline(self): c = pymoos.comms() c.set_on_connect_callback( lambda: self.assertTrue(c.register('TEST_ON_CALLBACK_I'))) c.run('localhost', 9000, 'test_on_connect_callback_inline') c.wait_until_connected(2000) time.sleep(1) self.assertTrue(c.is_registered_for('TEST_ON_CALLBACK_I')) c.close(True)
def test_13_is_registered_for(self): c = pymoos.comms() c.run('localhost', 9000, 'test_is_registered_for') c.wait_until_connected(2000) self.assertFalse(c.is_registered_for('MOOS_UPTIME')) c.register('MOOS_UPTIME', 0.) self.assertTrue(c.is_registered_for('MOOS_UPTIME')) self.assertFalse(c.is_registered_for('MOOS_UPTIME2')) c.close(True)
def __init__(self, topic, proto): self.topic = topic self.proto = proto # TODO: set up MOOS subscription to variable # TODO: Set up protobuf decoding self.comms = pymoos.comms() self.comms.set_on_connect_callback(self.on_connect) queue_name = "echo_queue" self.comms.add_active_queue(queue_name, self.msg_callback) self.comms.add_message_route_to_active_queue(queue_name, self.topic) # Args are: server, port, my_name self.comms.run('localhost', 9000, 'moostopic_echo')
def __init__(self, fname): # Init self.comms = pm.comms() self.comms.set_on_connect_callback(self.on_connect) self.add_queues() self.fname = fname self.f = open(fname, 'w') self.writer = csv.DictWriter(self.f, fieldnames=[ 'time', 'key', 'type', 'bearing', 'step', 'range_scale', 'length', 'dbytes', 'data' ])
def test_31_on_connect_callback(self): logger.debug(' on ') c = pymoos.comms() def on_connect(): logger.debug(' on ') self.assertTrue(c.register('TEST_ON_CALLBACK', 0)) return True c.set_on_connect_callback(on_connect) c.run('localhost', 9000, 'test_on_connect_callback') c.wait_until_connected(2000) time.sleep(.1) self.assertTrue(c.is_registered_for('TEST_ON_CALLBACK')) c.close(True)
def __init__(self): self._x = 0.0 self._y = 0.0 self._z = 0.0 self._h = 0.0 #Bathy Sim self.sim = BathySim(123) #MOOS self._moos = pymoos.comms() self._moos.set_on_connect_callback(self.on_connect) self._moos.set_on_mail_callback(self.on_mail) self._update = False self._logfile = None self._file_label = ""
def test_00_run_close(self): c = pymoos.comms() self.assertFalse(c.is_connected()) self.assertFalse(c.is_running()) c.run('localhost', 9000, 'test_run_close') self.assertTrue(c.is_running()) # sleep for a little to make sure we have time to connect c.wait_until_connected(2000) self.assertTrue(c.is_connected()) self.assertTrue(c.is_asynchronous()) c.close(True) self.assertFalse(c.is_connected()) self.assertFalse(c.is_running())
def __init__(self): self.moos_app_name = 'PySpectrogram' self.time_warp = 1 self.server_host = 'localhost' self.server_port = 9000 self.freq_sampling = 37500.0 self.num_samples = 16000 self.num_hydrophones = 5 self.aco_data = np.zeros((self.num_samples, self.num_hydrophones)) #array that holds the acoustic data currently being processed self.aco_data_latest = None #array that holds new acoustic data while it waits to be processed self.aco_new = False #flag to indicate that new acoustic data has been read self.extents = None ''' Initialize Python-MOOS Communications ''' self.mooscomms = pymoos.comms() self.mooscomms.set_on_connect_callback(self.moos_on_connect) self.mooscomms.add_active_queue('cbf_queue', self.moos_on_new_acoustic_binary_data) #let's use a queue callback instead to handle distinct messages self.mooscomms.add_message_route_to_active_queue('cbf_queue', 'DAQ_BINARY_DATA') #route 'DAQ_BINARY_DATA' messages to moos_on_new_acoustic_binary_data function self.mooscomms.run(self.server_host, self.server_port, self.moos_app_name) pymoos.set_moos_timewarp(self.time_warp)
def test_32_on_mail_callback(self): logger.debug(' on ') c = pymoos.comms() self.received_mail = False def on_connect(): logger.debug(' on ') self.assertTrue(c.register('TEST_CALLBACK_ONMAIL_VAR', 0)) return True def on_new_mail(): logger.debug(' on ') for msg in c.fetch(): logger.debug(' one new mail ') self.assertTrue(msg.is_name('TEST_CALLBACK_ONMAIL_VAR')) self.assertEqual(msg.double(), 1) self.received_mail = True logger.debug(' mail processed ') return True c.set_on_connect_callback(on_connect) c.set_on_mail_callback(on_new_mail) c.run('localhost', 9000, 'test_on_mail_callback') c.wait_until_connected(2000) time.sleep(1) self.assertTrue(c.is_registered_for('TEST_CALLBACK_ONMAIL_VAR')) self.assertFalse(self.received_mail) self.assertTrue(c.notify('TEST_CALLBACK_ONMAIL_VAR', 1, -1)) time.sleep(1) self.assertTrue(self.received_mail) c.close(True)
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms() self.Des_Heading = [] self.Rudder = [] self.Heading = []
def __init__(self): self.comms = pymoos.comms() self.comms.set_on_connect_callback(self.connect_callback) self.comms.set_on_mail_callback(self.message_received) pymoos.set_moos_timewarp($(WARP)) self.comms.set_comms_control_timewarp_scale_factor(0.4) self.comms.run('localhost', 9000, 'pPathPlan') # Initialize stored variables self.messages = dict() self.messages['SWATH_EDGE'] = '' self.messages['SWATH_WIDTH_RECORD'] = '' self.messages['NEXT_SWATH_SIDE'] = 'stbd' self.messages['TURN_REACHED'] = 'false' self.post_ready = False self.post_message = '' self.turn_pt_message = '' self.start_line_message = '' self.need_to_process = False self.post_next_turn = False self.post_end = False self.turn_count = 0 # self.op_poly = [(16,-45), (50,-150), \ # (-85, -195), (-122, -70)] # SH 15 North Survey area: # self.op_poly = [(4075.0, -650.0), (3293, -2464), (2405, -2259), \ # (3180, -387)] # SH15 South Survey Area: # self.op_poly = [(2497.0, -4374.0), (1727, -6077), (588, -5468), \ # (1272, -3864)] # Small region for half step testing, SH 2015 # self.op_poly = [(655, -4429), (550, -4813), (198, -4725), (300, -4353)] self.op_poly = $(OP_POLY) # Newport, RI #self.op_poly = [ (-229,47), (-279,217), (-41,264), (0,100)] # South of Pier #self.op_poly = [ (-167, -194), (-136, -342), (199, -255), (142, -107) ] # Smaller South of Pier # self.op_poly = [ (-210, -192), (-191,-307), (10,-254), (-16,-144)] # VIEW_SEGLIST = "pts={10,-26:16,-45},label=emily_waypt_line_start, # label_color=white,edge_color=white,vertex_color=dodger_blue, # vertex_size=3,edge_size=1" pts_list = [str(pt[0]) + ',' + str(pt[1]) + ':' for pt in self.op_poly] # Back to the beginning pts_list.append(str(self.op_poly[0][0]) + ',' + str(self.op_poly[0][1])) pts_string = ''.join(pts_list) region_message = 'pts={' + pts_string + '},label=op_region,' + \ 'label_color=red,edge_color=red,vertex_color=red,edge_size=2' # Make sure we can send the message if self.comms.wait_until_connected(2000): print 'Posting op region: ' + pts_string self.comms.notify('VIEW_SEGLIST', region_message, pymoos.time()) print('Updating lines') # Put these in a function point_list = [str(pt[0]) + ',' + str(pt[1]) + ':' for pt in self.op_poly[0:2]] points_message = ''.join(point_list) points_message = 'points=' + points_message[:-1] self.comms.notify('SURVEY_UPDATE', points_message, pymoos.time()) start_heading = (self.op_poly[0][0] - self.op_poly[1][0], \ self.op_poly[0][1] - self.op_poly[1][1]) start_heading = pathplan.unit_vector(start_heading) start_line_message = 'points=' + \ str(self.op_poly[0][0] + start_heading[0] * ALIGNMENT_LINE_LEN) + ',' \ + str(self.op_poly[0][1] + start_heading[1] * ALIGNMENT_LINE_LEN) + \ ':' + str(self.op_poly[0][0]) + ',' + str(self.op_poly[0][1]) self.comms.notify('START_UPDATE', start_line_message, pymoos.time()) end_heading = (self.op_poly[1][0] - self.op_poly[0][0], \ self.op_poly[1][1] - self.op_poly[0][1]) end_heading = pathplan.unit_vector(end_heading) turn_pt_message = 'point=' + \ str(self.op_poly[1][0] + end_heading[0] * TURN_PT_OFFSET) + ',' \ + str(self.op_poly[1][1] + end_heading[1] * TURN_PT_OFFSET) self.comms.notify('TURN_UPDATE', turn_pt_message, pymoos.time()) home_message = 'station_pt = ' + str(self.op_poly[0][0] + \ start_heading[0] * 30) + ',' + str(self.op_poly[0][1] + \ start_heading[1] * 30) self.comms.notify('HOME_UPDATE', home_message, pymoos.time()) # move boat to start # self.comms.notify('NAV_X', str(self.op_poly[0][0] + \ # start_heading[0] * 30), pymoos.time()) # self.comms.notify('NAV_Y', str(self.op_poly[0][1] + \ # start_heading[1] * 30), pymoos.time()) # pdb.set_trace() else: print 'Timed out connecting before sending op region'
root.after(1000, Refresher) ##---------------------------------------------------------------------------## # Register for updates of the MOOS variables Landmarks and Nav_Aids once every # second ##---------------------------------------------------------------------------## def on_connect(): comms.register('Landmarks', 0) comms.register('Nav_Aids', 0) comms.register('Underwater_Objects', 0) return True # Initialize the MOOS connection and communication comms = pymoos.comms() comms.set_on_connect_callback(on_connect) comms.run('localhost', 9000, 'Camera') # Declare the MOOS lists as GLOBALS global LANDMARKS global NAV_AIDS global UNDERWATER # Initialize the MOOS lists LANDMARKS = [] NAV_AIDS = [] UNDERWATER = [] # Run the GUI - it updates with new MOOS Variables every second root = tk.Tk()
def __init__(self, sonar_port, pos_port, autopilot_ip, autopilot_server_port, autopilot_listen_port): super().__init__() # Logger stuff super().__init__() self.logger = logging.getLogger('messages.moosClient') self.logger_bins = logging.getLogger('messages.moosClient.bins') self.logger_pose = logging.getLogger('messages.moosClient.pose') self.logger.debug('MOOS msgs initiated') # Init self.comms = pm.comms() self.comms.set_on_connect_callback(self.on_connect) self.add_queues() self.buffer_lock = threading.Lock() self.sonar_update_thread = None self.sonar_server = socketserver.UDPServer( ('0.0.0.0', sonar_port), handler_factory(self.parse_sonar_msg)) self.sonar_server.allow_reuse_address = True self.sonar_thread = threading.Thread( target=self.sonar_server.serve_forever, daemon=True) if Settings.pos_msg_source == 0: self.pos_server = socketserver.UDPServer( ('0.0.0.0', pos_port), handler_factory(self.parse_pos_msg)) self.pos_thread = threading.Thread( target=self.pos_server.serve_forever, daemon=True) else: self.pos_stop_event = threading.Event() self.pos_thread = Wathdog(self.pos_stop_event, self.get_pos, Settings.pos_update_speed / 1000.0, daemon=True) if CollisionSettings.send_new_wps: self.autopilot_watchdog_stop_event = threading.Event() self.autopilot_watchdog_thread = Wathdog( self.autopilot_watchdog_stop_event, self.ping_autopilot_server, ConnectionSettings.autopilot_watchdog_timeout, daemon=True) self.ap_pos_received = threading.Event() self.guidance_mode = None if autopilot_listen_port is not None and Settings.enable_autopilot: self.autopilot_server = socketserver.UDPServer( ('0.0.0.0', autopilot_listen_port), handler_factory(self.parse_autopilot_msg)) self.autopilot_thread = threading.Thread( target=self.autopilot_server.serve_forever, daemon=True) if LosSettings.enable_los and Settings.enable_autopilot: self.los_stop_event = threading.Event() self.los_start_event = threading.Event() self.los_restart_event = threading.Event() self.los_controller = LosController(self, 0.1, self.los_stop_event, self.los_start_event, self.los_restart_event) self.los_thread = threading.Thread( ) # threading.Thread(target=self.los_controller.loop, daemon=True)
# Python-MOOS Bridge import pymoos # Used for delays import time # pyproj is a library that converts lat long coordinates into UTM import pyproj # GDAL is a library that reads and writes shapefiles from osgeo import ogr # Numpy is a useful tool for mathematical operations import numpy as np comms = pymoos.comms() #============================================================================== ## Initialize some global variables #============================================================================== # Calculate the origin LonLat2UTM = pyproj.Proj(proj='utm', zone=19, ellps='WGS84') LatOrigin = 43.071959194444446 LongOrigin = -70.711610833333339 x_origin,y_origin = LonLat2UTM(LongOrigin, LatOrigin) #============================================================================== # Convert MOOS x,y to Longitude and Latitude #============================================================================== def MOOSxy2LonLat(x, y):
def __init__(self): # Open a communication link to MOOS self.comms = pymoos.comms()
def test_20_zmsg_types(self): x = bytearray([0, 3, 0x15, 2, 6, 0xAA]) s = 'hello' d = 384.653 c = pymoos.comms() def on_connect(): self.assertTrue(c.register('TEST_STRING_VAR', 0)) self.assertTrue(c.register('TEST_DOUBLE_VAR', 0)) self.assertTrue(c.register('TEST_BINARY_VAR', 0)) return True c.set_on_connect_callback(on_connect) c.run('localhost', 9000, 'test_zmsg_types') c.wait_until_connected(2000) self.assertTrue(c.is_registered_for('TEST_STRING_VAR')) self.assertTrue(c.is_registered_for('TEST_DOUBLE_VAR')) self.assertTrue(c.is_registered_for('TEST_BINARY_VAR')) t = pymoos.time() self.assertTrue(c.notify('TEST_STRING_VAR', s, t)) self.assertTrue(c.notify('TEST_DOUBLE_VAR', d, t)) self.assertTrue(c.notify_binary('TEST_BINARY_VAR', str(x), t)) time.sleep(1) idx = 0 logger.debug('idx hit') msgs = c.fetch() logger.debug('fetch hit') self.assertNotEqual(len(msgs), 0) self.assertEqual(len(msgs), 3) for msg in msgs: logger.debug('iter hit') self.assertEqual(msg.time(), t) logger.debug('time hit') if msg.key() == 'TEST_STRING_VAR': logger.debug('string hit') self.assertTrue(msg.is_string()) self.assertEqual(msg.string(), s) self.assertFalse(msg.is_double()) self.assertFalse(msg.is_binary()) elif msg.key() == 'TEST_DOUBLE_VAR': logger.debug('double hit') self.assertTrue(msg.is_double()) self.assertEqual(msg.double(), d) self.assertFalse(msg.is_string()) self.assertFalse(msg.is_binary()) elif msg.key() == 'TEST_BINARY_VAR': logger.debug('binary hit') self.assertTrue(msg.is_binary()) self.assertEqual(str(msg.binary_data()), str(x)) self.assertTrue(msg.is_string()) self.assertFalse(msg.is_double()) idx += 1 logger.debug('idx++ hit') self.assertEqual(idx, 3) c.close(True)
def test_33_on_mail_active_queues(self): logger.debug(' on ') c = pymoos.comms() self.received_mail = False self.received_mail_q_v1 = False self.received_mail_q_v2 = False self.received_mail_q2_v = False def on_connect(): logger.debug(' on ') self.assertTrue(c.register('TEST_ONMAIL_ACTIVE_Q', 0)) self.assertTrue(c.register('TEST_ONQUEUE_VAR1', 0)) self.assertTrue(c.register('TEST_ONQUEUE_VAR2', 0)) self.assertTrue(c.register('TEST_ONQUEUE2_VAR', 0)) return True def on_new_mail_aq(): logger.debug(' on ') for msg in c.fetch(): logger.debug(' one new mail = ' + msg.key()) # self.assertTrue(msg.is_name('TEST_ONMAIL_ACTIVE_Q')) # self.assertEqual(msg.double(), 1) self.received_mail = True logger.debug(' mail processed') return True def queue1(msg): logger.debug(' on ') if msg.is_name('TEST_ONQUEUE_VAR1'): self.assertEqual(msg.double(), 2) self.received_mail_q_v1 = True elif msg.is_name('TEST_ONQUEUE_VAR2'): self.assertEqual(msg.double(), 3) self.received_mail_q_v2 = True return True def queue2(msg): logger.debug(' on ') if msg.is_name('TEST_ONQUEUE2_VAR'): self.assertEqual(msg.double(), 4) self.received_mail_q2_v = True return True c.set_on_connect_callback(on_connect) c.set_on_mail_callback(on_new_mail_aq) c.add_active_queue('queue1', queue1) c.add_message_route_to_active_queue('queue1', 'TEST_ONQUEUE_VAR1') c.add_message_route_to_active_queue('queue1', 'TEST_ONQUEUE_VAR2') c.add_active_queue('queue2', queue2) c.add_message_route_to_active_queue('queue2', 'TEST_ONQUEUE2_VAR') c.run('localhost', 9000, 'test_on_mail_active_queues') c.wait_until_connected(5000) time.sleep(1) self.assertTrue(c.is_registered_for('TEST_ONMAIL_ACTIVE_Q')) self.assertTrue(c.is_registered_for('TEST_ONQUEUE_VAR1')) self.assertTrue(c.is_registered_for('TEST_ONQUEUE_VAR2')) self.assertTrue(c.is_registered_for('TEST_ONQUEUE2_VAR')) self.assertFalse(self.received_mail) self.assertFalse(self.received_mail_q_v1) self.assertFalse(self.received_mail_q_v2) self.assertFalse(self.received_mail_q2_v) self.assertTrue(c.notify('TEST_ONMAIL_ACTIVE_Q', 1)) self.assertTrue(c.notify('TEST_ONQUEUE_VAR1', 2)) self.assertTrue(c.notify('TEST_ONQUEUE_VAR2', 3)) self.assertTrue(c.notify('TEST_ONQUEUE2_VAR', 4)) time.sleep(1) self.assertTrue(self.received_mail) self.assertTrue(self.received_mail_q_v1) self.assertTrue(self.received_mail_q_v2) self.assertTrue(self.received_mail_q2_v) c.close(True)