def test_XmlRpcNode(self):
from roslib.xmlrpc import XmlRpcNode
# not a very comprehensive test (yet)
#port, handler
tests = [
(None, None, None),
(8080, None, 8080),
('8080', None, 8080),
(u'8080', None, 8080),
]
for port, handler, true_port in tests:
n = XmlRpcNode(port, handler)
self.assertEquals(true_port, n.port)
self.assertEquals(handler, n.handler)
self.assertEquals(None, n.uri)
self.assertEquals(None, n.server)
n.set_uri('http://fake:1234')
self.assertEquals('http://fake:1234', n.uri)
def test_XmlRpcNode(self):
from roslib.xmlrpc import XmlRpcNode
# not a very comprehensive test (yet)
#port, handler
tests = [
(None, None, None),
(8080, None, 8080),
('8080', None, 8080),
(u'8080', None, 8080),
]
for port, handler,true_port in tests:
n = XmlRpcNode(port, handler)
self.assertEquals(true_port, n.port)
self.assertEquals(handler, n.handler)
self.assertEquals(None, n.uri)
self.assertEquals(None, n.server)
n.set_uri('http://fake:1234')
self.assertEquals('http://fake:1234', n.uri)
def __init__(self, master_uri, new_topics_callback):
self.master_uri = master_uri
self.new_topics_callback = new_topics_callback
name = roslib.names.ns_join(roslib.names.get_ros_namespace(), roslib.names.anonymous_name('master_sync'))
self.master = rosgraph.masterapi.Master(name, master_uri=self.master_uri)
self._lock = threading.RLock()
self._type_cache = {}
self._subs = {}
self._pubs = {}
self._srvs = {}
self._external_node = XmlRpcNode(rpc_handler=_TopicPubListenerHandler(self._new_topics))
self._external_node.start()
timeout_t = time.time() + 5.0
while time.time() < timeout_t and self._external_node.uri is None:
time.sleep(0.01)
class _RemoteManager(object):
def __init__(self, master_uri, new_topics_callback):
self.master_uri = master_uri
self.new_topics_callback = new_topics_callback
name = roslib.names.ns_join(roslib.names.get_ros_namespace(), roslib.names.anonymous_name('master_sync'))
self.master = rosgraph.masterapi.Master(name, master_uri=self.master_uri)
self._lock = threading.RLock()
self._type_cache = {}
self._subs = {}
self._pubs = {}
self._srvs = {}
self._external_node = XmlRpcNode(rpc_handler=_TopicPubListenerHandler(self._new_topics))
self._external_node.start()
timeout_t = time.time() + 5.0
while time.time() < timeout_t and self._external_node.uri is None:
time.sleep(0.01)
def get_topic_type(self, query_topic):
query_topic = self.resolve(query_topic)
query_topic_type = self._type_cache.get(query_topic)
if query_topic_type:
return query_topic_type
for topic, topic_type in self.master.getTopicTypes():
self._type_cache[topic] = topic_type
return self._type_cache.get(query_topic, '*')
def subscribe(self, topic):
topic = self.resolve(topic)
publishers = self.master.registerSubscriber(topic, '*', self._external_node.uri)
self._subs[(topic, self._external_node.uri)] = self.master
self._new_topics(topic, publishers)
def publishers_updated(self, topic, topic_type, uris):
resolved = self.resolve(topic)
with self._lock:
# Unregister any publishers that no longer exist
uris_set = set(uris)
for t, uri in self._pubs.keys():
if t == resolved and uri not in uris_set:
self.unadvertise(t, uri)
# Register new publishers
for uri in uris:
if (resolved, uri) not in self._pubs:
# Registrations need to be anonymous so master doesn't kill us if there's a duplicate name
rospy.loginfo('Registering (%s, %s) on master %s' % (resolved, uri, self.master_uri))
anon_name = roslib.names.anonymous_name('master_sync')
master = rosgraph.masterapi.Master(anon_name, master_uri=self.master_uri)
master.registerPublisher(resolved, topic_type, uri)
self._pubs[(resolved, uri)] = master
def unadvertise(self, topic, uri):
with self._lock:
if (topic, uri) in self._pubs:
master = self._pubs[(topic, uri)]
rospy.loginfo('Unregistering (%s, %s) from master %s' % (topic, uri, master.master_uri))
master.unregisterPublisher(topic, uri)
del self._pubs[(topic, uri)]
def lookup_service(self, service_name):
service_name = self.resolve(service_name)
try:
return self.master.lookupService(service_name)
except:
return None
def advertise_service(self, service_name, uri):
# These registrations need to be anonymous so the master doesn't kill us if there is a duplicate name
anon_name = roslib.names.anonymous_name('master_sync')
master = rosgraph.masterapi.Master(anon_name, master_uri=self.master_uri)
if service_name in self._srvs:
if self._srvs[service_name][0] == uri:
return
self.unadvertise_service(service_name)
rospy.loginfo('Registering service (%s, %s) on master %s' % (service_name, uri, master.master_uri))
fake_api = 'http://%s:0' % roslib.network.get_host_name()
master.registerService(service_name, uri, fake_api)
self._srvs[service_name] = (uri, master)
def unadvertise_service(self, service_name):
if service_name in self._srvs:
uri, master = self._srvs[service_name]
rospy.loginfo('Unregistering service (%s, %s) from master %s' % (service_name, uri, master.master_uri))
master.unregisterService(service_name, uri)
del self._srvs[service_name]
def resolve(self, topic):
return roslib.names.ns_join(roslib.names.namespace(self.master.caller_id), topic)
def unsubscribe_all(self):
for (topic, uri), master in self._subs.iteritems():
master.unregisterSubscriber(topic, uri)
for topic, uri in self._pubs.keys():
self.unadvertise(topic, uri)
for service in self._srvs.keys():
self.unadvertise_service(service)
def _new_topics(self, topic, publishers):
self.new_topics_callback(topic, [p for p in publishers if (topic, p) not in self._pubs])
