def retrieveMasters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: L{master_discovery_fkie.interface_finder.get_listmaster_service()} ''' service_names = interface_finder.get_listmaster_service( self.getMasteruri()) for service_name in service_names: rospy.loginfo("service 'list_masters' found on %s", service_name) self.__lock.acquire() try: rospy.wait_for_service(service_name) try: discoverMasters = rospy.ServiceProxy( service_name, DiscoverMasters) resp = discoverMasters() masters = [] for m in resp.masters: if not m.name in self.ignore: # do not sync to the master, if it is in ignore list masters.append(m.name) self.updateMaster(m.name, m.uri, m.timestamp, m.discoverer_name, m.monitoruri) for key in set(self.masters.keys()) - set(masters): self.removeMaster(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn( "ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: self.__lock.release()
def obtain_masters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: U{master_discovery_fkie.interface_finder.get_listmaster_service() <http://docs.ros.org/api/master_discovery_fkie/html/modules.html#interface-finder-module>} ''' if not rospy.is_shutdown(): service_names = interface_finder.get_listmaster_service(masteruri_from_master(), False) for service_name in service_names: try: with self.__lock: try: socket.setdefaulttimeout(5) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) resp = discoverMasters() masters = [] master_names = [m.name for m in resp.masters] rospy.loginfo("ROS masters obtained from '%s': %s", service_name, master_names) for m in resp.masters: if self._can_sync(m.name): # do not sync to the master, if it is in ignore list or not in filled sync list masters.append(m.name) self.update_master(m.name, m.uri, m.timestamp, m.timestamp_local, m.discoverer_name, m.monitoruri, m.online) for key in set(self.masters.keys()) - set(masters): self.remove_master(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: socket.setdefaulttimeout(None) self.update_timer = threading.Timer(self.UPDATE_INTERVALL, self.obtain_masters) self.update_timer.start()
def run(self): ''' ''' if self._masteruri: found = False service_names = interface_finder.get_listmaster_service(self._masteruri, self._wait) err_msg = '' for service_name in service_names: rospy.logdebug("service 'list_masters' found on %s as %s", self._masteruri, service_name) if self._wait: rospy.wait_for_service(service_name) socket.setdefaulttimeout(3) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) try: resp = discoverMasters() except rospy.ServiceException, e: err_msg = "Service call 'list_masters' failed: %s" % utf8(e) rospy.logwarn(err_msg) self.err_signal.emit(self._masteruri, "Service call '%s' failed: %s" % (service_name, err_msg), False) else: if resp.masters: self.master_list_signal.emit(self._masteruri, service_name, resp.masters) found = True else: self.err_signal.emit(self._masteruri, "local 'master_discovery' reports empty master list, it seems he has a problem", False) finally: socket.setdefaulttimeout(None)
def retrieveMasters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: L{master_discovery_fkie.interface_finder.get_listmaster_service()} ''' service_names = interface_finder.get_listmaster_service(self.getMasteruri(), False) for service_name in service_names: rospy.loginfo("service 'list_masters' found on %s", service_name) self.__lock.acquire() try: # rospy.wait_for_service(service_name) try: discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) resp = discoverMasters() masters = [] for m in resp.masters: if not m.name in self.ignore: # do not sync to the master, if it is in ignore list masters.append(m.name) self.updateMaster(m.name, m.uri, m.timestamp, m.discoverer_name, m.monitoruri) for key in set(self.masters.keys()) - set(masters): self.removeMaster(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: self.__lock.release() self.update_timer = threading.Timer(15.0, self.retrieveMasters) self.update_timer.start()
def run(self): ''' ''' if self._masteruri: found = False service_names = interface_finder.get_listmaster_service( self._masteruri, self._wait) err_msg = '' for service_name in service_names: rospy.logdebug("service 'list_masters' found on %s as %s", self._masteruri, service_name) if self._wait: rospy.wait_for_service(service_name) socket.setdefaulttimeout(3) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) try: resp = discoverMasters() except rospy.ServiceException, e: rospy.logwarn( "ERROR Service call 'list_masters' failed: %s", str(e)) err_msg = ''.join( [err_msg, '\n', service_name, ': ', str(e)]) else: self.master_list_signal.emit(self._masteruri, service_name, resp.masters) if resp.masters: found = True finally: socket.setdefaulttimeout(None)
def retrieveMasters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: L{master_discovery_fkie.interface_finder.get_listmaster_service()} ''' if not rospy.is_shutdown(): rospy.loginfo("Update ROS master list...") service_names = interface_finder.get_listmaster_service(self.getMasteruri(), False) for service_name in service_names: rospy.loginfo("service 'list_masters' found on %s", service_name) try: with self.__lock: # rospy.wait_for_service(service_name) try: socket.setdefaulttimeout(5) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) resp = discoverMasters() masters = [] for m in resp.masters: # if not self._re_ignore_hosts.match(m.name) or self._re_sync_hosts.match(m.name): # do not sync to the master, if it is in ignore list # masters.append(m.name) self.updateMaster(m.name, m.uri, m.timestamp, m.timestamp_local, m.discoverer_name, m.monitoruri) for key in set(self.masters.keys()) - set(masters): self.removeMaster(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: socket.setdefaulttimeout(None) self.update_timer = threading.Timer(self.UPDATE_INTERVALL, self.retrieveMasters) self.update_timer.start()
def retrieveMasters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: L{master_discovery_fkie.interface_finder.get_listmaster_service()} ''' if not rospy.is_shutdown(): rospy.loginfo("Update ROS master list...") service_names = interface_finder.get_listmaster_service(self.getMasteruri(), False) for service_name in service_names: rospy.loginfo("service 'list_masters' found on %s", service_name) try: with self.__lock: # rospy.wait_for_service(service_name) try: socket.setdefaulttimeout(5) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) resp = discoverMasters() masters = [] for m in resp.masters: if not self._re_ignore_hosts.match(m.name) or self._re_sync_hosts.match(m.name): # do not sync to the master, if it is in ignore list masters.append(m.name) self.updateMaster(m.name, m.uri, m.timestamp, m.timestamp_local, m.discoverer_name, m.monitoruri) for key in set(self.masters.keys()) - set(masters): self.removeMaster(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: socket.setdefaulttimeout(None) self.update_timer = threading.Timer(self.UPDATE_INTERVALL, self.retrieveMasters) self.update_timer.start()
def obtain_masters(self): ''' This method use the service 'list_masters' of the master_discoverer to get the list of discovered ROS master. Based on this list the L{SyncThread} for synchronization will be created. @see: U{master_discovery_fkie.interface_finder.get_listmaster_service() <http://docs.ros.org/api/master_discovery_fkie/html/modules.html#interface-finder-module>} ''' if not rospy.is_shutdown(): service_names = interface_finder.get_listmaster_service( masteruri_from_master(), False) for service_name in service_names: try: with self.__lock: try: socket.setdefaulttimeout(5) discoverMasters = rospy.ServiceProxy( service_name, DiscoverMasters) resp = discoverMasters() masters = [] master_names = [m.name for m in resp.masters] rospy.loginfo("ROS masters obtained from '%s': %s", service_name, master_names) for m in resp.masters: if not self._re_ignore_hosts.match( m.name ) or self._re_sync_hosts.match( m.name ): # do not sync to the master, if it is in ignore list masters.append(m.name) self.update_master(m.name, m.uri, m.timestamp, m.timestamp_local, m.discoverer_name, m.monitoruri, m.online) for key in set(self.masters.keys()) - set(masters): self.remove_master(self.masters[key].name) except rospy.ServiceException, e: rospy.logwarn( "ERROR Service call 'list_masters' failed: %s", str(e)) except: import traceback rospy.logwarn("ERROR while initial list masters: %s", traceback.format_exc()) finally: socket.setdefaulttimeout(None) self.update_timer = threading.Timer(self.UPDATE_INTERVALL, self.obtain_masters) self.update_timer.start()
def run(self): ''' ''' if self._masteruri: found = False service_names = interface_finder.get_listmaster_service( self._masteruri, self._wait) err_msg = '' for service_name in service_names: rospy.logdebug("service 'list_masters' found on %s as %s", self._masteruri, service_name) if self._wait: rospy.wait_for_service(service_name) socket.setdefaulttimeout(3) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) try: resp = discoverMasters() except rospy.ServiceException, e: err_msg = "Service call 'list_masters' failed: %s" % utf8( e) rospy.logwarn(err_msg) self.err_signal.emit( self._masteruri, "Service call '%s' failed: %s" % (service_name, err_msg), False) else: if resp.masters: self.master_list_signal.emit(self._masteruri, service_name, resp.masters) found = True else: self.err_signal.emit( self._masteruri, "local 'master_discovery' reports empty master list, it seems he has a problem", False) finally: socket.setdefaulttimeout(None)
def run(self): ''' ''' if self._masteruri: found = False service_names = interface_finder.get_listmaster_service(self._masteruri, self._wait) err_msg = '' for service_name in service_names: rospy.logdebug("service 'list_masters' found on %s as %s", self._masteruri, service_name) if self._wait: rospy.wait_for_service(service_name) socket.setdefaulttimeout(3) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) try: resp = discoverMasters() except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) err_msg = ''.join([err_msg, '\n', service_name, ': ', str(e)]) else: self.master_list_signal.emit(self._masteruri, service_name, resp.masters) if resp.masters: found = True finally: socket.setdefaulttimeout(None)
def retrieveMasterList(self, masteruri, wait=True): ''' This method use the service 'list_masters' of the master_discovery to get the list of discovered ROS master. The retrieved list will be emitted as masterlist_signal. @param masteruri: the ROS master URI @type masteruri: C{str} @param wait: wait for the service @type wait: C{boolean} ''' found = False service_names = interface_finder.get_listmaster_service(masteruri, wait) for service_name in service_names: rospy.loginfo("service 'list_masters' found on %s as %s", masteruri, service_name) rospy.wait_for_service(service_name) discoverMasters = rospy.ServiceProxy(service_name, DiscoverMasters) try: resp = discoverMasters() except rospy.ServiceException, e: rospy.logwarn("ERROR Service call 'list_masters' failed: %s", str(e)) self.masterlist_err_signal.emit("ERROR Service call 'list_masters' failed: %s", str(e)) else: self.masterlist_signal.emit(resp.masters) found = True