def pingNode(node_name):
max_count = None
ID = '/rosnode'
master = rosgraph.Master(ID)
node_api = rosnode.get_api_uri(master, node_name)
if not node_api:
return False
timeout = 3.
socket.setdefaulttimeout(timeout)
node = ServerProxy(node_api)
lastcall = 0.
count = 0
acc = 0.
try:
while True:
try:
start = time.time()
pid = _succeed(node.getPid(ID))
end = time.time()
dur = (end - start) * 1000.
acc += dur
count += 1
# 1s between pings
except socket.error as e:
# 3786: catch ValueError on unpack as socket.error is not always a tuple
try:
# #3659
errnum, msg = e
if errnum == -2: #name/service unknown
p = urlparse.urlparse(node_api)
elif errnum == errno.ECONNREFUSED:
# check if node url has changed
new_node_api = rosnode.get_api_uri(master,
node_name,
skip_cache=True)
if not new_node_api:
return False
if new_node_api != node_api:
node_api = new_node_api
node = ServerProxy(node_api)
continue
else:
pass
return False
except ValueError:
pass
if max_count and count >= max_count:
break
time.sleep(1.0)
except KeyboardInterrupt:
pass
return True
def pingNode(node_name):
max_count=None
ID = '/rosnode'
master = rosgraph.Master(ID)
node_api = rosnode.get_api_uri(master,node_name)
if not node_api:
return False
timeout = 3.
socket.setdefaulttimeout(timeout)
node = ServerProxy(node_api)
lastcall = 0.
count = 0
acc = 0.
try:
while True:
try:
start = time.time()
pid = _succeed(node.getPid(ID))
end = time.time()
dur = (end-start)*1000.
acc += dur
count += 1
# 1s between pings
except socket.error as e:
# 3786: catch ValueError on unpack as socket.error is not always a tuple
try:
# #3659
errnum, msg = e
if errnum == -2: #name/service unknown
p = urlparse.urlparse(node_api)
elif errnum == errno.ECONNREFUSED:
# check if node url has changed
new_node_api = rosnode.get_api_uri(master,node_name, skip_cache=True)
if not new_node_api:
return False
if new_node_api != node_api:
node_api = new_node_api
node = ServerProxy(node_api)
continue
else:
pass
return False
except ValueError:
pass
if max_count and count >= max_count:
break
time.sleep(1.0)
except KeyboardInterrupt:
pass
return True
def get_node_info(self, event):
"""
Get the list of all Nodes running on the host.
Update the __node_list
"""
if not self.__is_enabled:
pass
if self.__is_enabled:
nodes = []
for node_name in rosnode.get_node_names():
try:
node_api = rosnode.get_api_uri(rospy.get_master(),
node_name,
skip_cache=True)
if self._id in node_api[2]:
nodes.append(node_name)
except:
pass
for node in nodes:
if node not in self.__node_list:
"""TODO currently not catching the exception here - master not running is a hard error so it does
not make sense to continue running.."""
node_api = rosnode.get_api_uri(rospy.get_master(),
node,
skip_cache=True)
try:
pid = self.get_node_pid(node_api, node)
if not pid:
continue
node_process = psutil.Process(pid)
new_node = NodeStatisticsHandler(
self._id, node, node_process)
self.__dict_lock.acquire(True)
self.__node_list[node] = new_node
self.__dict_lock.release()
except psutil.NoSuchProcess:
rospy.loginfo('pid of node %s could not be fetched' %
node)
continue
self.__dict_lock.acquire()
to_remove = []
for node_name in self.__node_list:
if node_name not in nodes:
rospy.logdebug('removing %s from host' % node_name)
to_remove.append(node_name)
for node_name in to_remove:
self.remove_node(node_name)
self.__dict_lock.release()
def test_rosnode_started():
master, roscore = pyros_utils.get_master()
try:
assert master.is_online()
# hack needed to wait for master until fix for https://github.com/ros/ros_comm/pull/711 is released
roslaunch.rlutil.get_or_generate_uuid(None, True)
launch = roslaunch.scriptapi.ROSLaunch()
launch.start()
assert launch.started
echo_node = roslaunch.core.Node('pyros_test', 'echo.py', name='echo')
echo_process = launch.launch(echo_node)
assert echo_process.is_alive()
node_api = None
with timeout(5) as t:
while not t.timed_out and node_api is None:
node_api = rosnode.get_api_uri(
master, 'echo'
) # would be good to find a way to do this without rosnode dependency
assert node_api is not None
launch.stop()
finally: # to make sure we always shutdown everything, even if test fails
if roscore is not None:
roscore.terminate()
rospy.signal_shutdown('test_rosnode_started done')
while roscore and roscore.is_alive():
time.sleep(0.2) # waiting for roscore to die
assert not (roscore and master.is_online())
def run(self):
ctx = self.ctx
master = self.master
actual_edges = self.actual_edges
lock = self.lock
n = self.n
try:
socket.setdefaulttimeout(3.0)
node_api = rosnode.get_api_uri(master, n)
if not node_api:
ctx.errors.append(WtfError("Master does not have lookup information for node [%s]"%n))
return
node = xmlrpclib.ServerProxy(node_api)
start = time.time()
socket.setdefaulttimeout(3.0)
code, msg, bus_info = node.getBusInfo('/roswtf')
end = time.time()
with lock:
if (end-start) > 1.:
ctx.warnings.append(WtfWarning("Communication with node [%s] is very slow"%n))
if code != 1:
ctx.warnings.append(WtfWarning("Node [%s] would not return bus info"%n))
elif not bus_info:
if not n in ctx.service_providers:
ctx.warnings.append(WtfWarning("Node [%s] is not connected to anything"%n))
else:
edges = _businfo(ctx, n, bus_info)
actual_edges.extend(edges)
except socket.error, e:
pass #ignore as we have rules to catch this
def __init__(self):
self.processes = dict() # processes are NEVER removed from this dict
self.master = rosnode.rosgraph.Master(rosnode.ID)
node_api = rosnode.get_api_uri(self.master, rospy.get_name())
self.own_hostname = rosnode.urlparse.urlparse(node_api).hostname
self.node_infos_pub = rospy.Publisher('diag/node_infos', NodeInfoArray, queue_size=10)
def get_process_ros(node_name, doprint=False):
# get the node object from ros
node_api = rosnode.get_api_uri(rospy.get_master(),
node_name,
skip_cache=True)[2]
if not node_api:
rospy.logerr("could not get api of node %s (%s)" %
(node_name, node_api))
return False
# now try to get the Pid of this process
try:
response = ServerProxy(node_api).getPid('/NODEINFO')
except:
rospy.logerr("failed to get of the pid of ros node %s (%s)" %
(node_name, node_api))
return False
# try to get the process using psutil
try:
process = psutil.Process(response[2])
if doprint:
rospy.loginfo("adding new node monitor %s (pid %d)" %
(node_name, process.pid))
return process
except:
rospy.logerr("unable to open psutil object for %s" % (response[2]))
return False
def get_node_names_and_pids(self):
process_info = dict()
node_names = rosnode.get_node_names()
master = rosnode.rosgraph.Master(rosnode.ID)
for node in node_names:
try:
node_api = rosnode.get_api_uri(master, node)
# check if node can be found
if not node_api:
rospy.logwarn("cannot find '" + node + "': unknown node")
continue
hostname = rosnode.urlparse.urlparse(node_api).hostname
# only take nodes, which are running on this machine
if hostname != self.own_hostname:
continue
# read out pid of node
code, msg, pid = rosnode.ServerProxy(node_api).getPid(rosnode.ID)
if code != 1:
rospy.logwarn("remote call failed: '" + node + "'")
process_info[pid] = [node, hostname]
except rosnode.ROSNodeIOException as error:
rospy.logerr(error)
except IOError as error:
rospy.logerr(error)
return process_info
def getnodepkg1(self, node_name):
socket.setdefaulttimeout(1.0)
master = roslib.scriptutil.get_master()
node_api = rosnode.get_api_uri(master, node_name)
host = node_api.split(':')[1].lstrip('/')
node = xmlrpclib.ServerProxy(node_api)
try:
pid = rosnode._succeed(node.getPid(rosnode.ID))
except socket.error:
print("Communication with [%s=%s] failed!"%(node_name,node_api))
return ['']
cmd = ['ps','ww','--pid',str(pid)]
if os.environ['ROS_IP'] != host and os.environ['ROS_HOSTNAME'] != host:
ssh_target = self.user + '@' + host if self.user else hostname
cmd = ['ssh', ssh_target] + cmd
self.add_pkginfo_remote(host)
ps = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()[0]
res = ps[ps.find('/'):]
node_args = res.split(' ')
parsed = node_args[0].split('/')
pkgnames = [pkg[0] for pkg in self.pkginfo[host]]
result = [dirname for dirname in parsed if (dirname in pkgnames)]
if len(result) == 0:
result = ['']
return result
def setUp(self):
self.connection_cache_node = roslaunch.core.Node(
'rocon_python_comms',
'connection_cache.py',
name='connection_cache',
remap_args=[('~list', rospy.resolve_name('~connections_list')),
('~diff', rospy.resolve_name('~connections_diff'))])
# Easier to remap the node topic to the proxy ones, instead of the opposite, since there is no dynamic remapping.
# However for normal usecase, remapping the proxy handles is preferable.
try:
self.connection_cache_proc = TestRosInterface.launch.launch(
self.connection_cache_node)
except roslaunch.RLException as rlexc:
raise nose.SkipTest(
"Connection Cache Node not found (part of rocon_python_comms pkg). Skipping test."
)
assert self.connection_cache_proc.is_alive()
# wait for node to be started
node_api = None
with timeout(5) as t:
while not t.timed_out and node_api is None:
node_api = rosnode.get_api_uri(rospy.get_master(),
'connection_cache')
assert node_api is not None # make sure the connection cache node is started before moving on.
self.strpub = rospy.Publisher('/test/string', String, queue_size=1)
self.emppub = rospy.Publisher('/test/empty', Empty, queue_size=1)
self.interface = RosInterface(True)
def get_exe_path(node_name):
ID = '/NODEINFO'
node_api = rosnode.get_api_uri(rospy.get_master(), node_name)
code, msg, pid = client.ServerProxy(node_api[2]).getPid(ID)
p = psutil.Process(pid)
#print(p.name())
return p.name()
def get_process_for_ros_node(self, node_name):
target_node = None
caller_id = '/experiment_manager'
master = rosgraph.Master(caller_id)
running_nodes = rosnode.get_node_names()
for node in running_nodes:
if node_name in node:
if target_node is None:
target_node = node
else:
rospy.logwarn("Multiple nodes found whose name "
"contains " + node_name)
return None
if target_node is None:
rospy.logwarn("Could not find a node whose name contains " +
node_name)
return None
target_node_api = rosnode.get_api_uri(master, target_node)
if not target_node_api:
rospy.logwarn("Could not connect to " + target_node + "'s API")
return None
target_node = ServerProxy(target_node_api)
target_node_pid = rosnode._succeed(
target_node.getPid(caller_id)) # NOLINT
rospy.loginfo('Registered %s node PID %i for resource '
'usage tracking' % (node_name, target_node_pid))
return psutil.Process(target_node_pid)
def main():
rospy.init_node('start_user_mon', anonymous=True)
try:
from xmlrpc.client import ServerProxy
except ImportError:
from xmlrpclib import ServerProxy
ID = '/rosnode'
master = rosgraph.Master(ID, master_uri=None)
global process, loc
process = {}
loc = rospy.get_param("/script_location")
while not rospy.is_shutdown():
nodes = rosnode.get_node_names()
for node in nodes:
name = " " + node
name = name[2:]
node_api = rosnode.get_api_uri(master, node)
if not node_api:
continue
node = ServerProxy(node_api)
pid = rosnode._succeed(node.getPid(ID))
if process.has_key(pid):
continue
process[pid] = name
print("nohup " + loc + "/usage-mon " + str(pid) + " " + name +
" &")
os.system("nohup " + loc + "/usage-mon " + str(pid) + " " + name +
" &")
def setUp(self):
# we need to speed fast enough for the tests to not fail on timeout...
rospy.set_param('/connection_cache/spin_freq', 2) # 2 Hz
self.connection_cache_node = roslaunch.core.Node(
'rocon_python_comms',
'connection_cache.py',
name='connection_cache',
remap_args=[
('~list', '/pyros_ros/connections_list'),
('~diff', '/pyros_ros/connections_diff'),
])
try:
self.connection_cache_proc = self.launch.launch(
self.connection_cache_node)
except roslaunch.RLException as rlexc:
raise nose.SkipTest(
"Connection Cache Node not found (part of rocon_python_comms pkg). Skipping test."
)
node_api = None
with Timeout(5) as t:
while not t.timed_out and node_api is None:
node_api = rosnode.get_api_uri(rospy.get_master(),
'connection_cache')
assert node_api is not None # make sure the connection cache node is started before moving on.
super(TestPyrosROSCache, self).setUp(enable_cache=True)
def run(self):
ctx = self.ctx
master = self.master
actual_edges = self.actual_edges
lock = self.lock
n = self.n
try:
socket.setdefaulttimeout(3.0)
node_api = rosnode.get_api_uri(master, n)
if not node_api:
ctx.errors.append(WtfError("Master does not have lookup information for node [%s]"%n))
return
node = xmlrpclib.ServerProxy(node_api)
start = time.time()
socket.setdefaulttimeout(3.0)
code, msg, bus_info = node.getBusInfo('/roswtf')
end = time.time()
with lock:
if (end-start) > 1.:
ctx.warnings.append(WtfWarning("Communication with node [%s] is very slow"%n))
if code != 1:
ctx.warnings.append(WtfWarning("Node [%s] would not return bus info"%n))
elif not bus_info:
if not n in ctx.service_providers:
ctx.warnings.append(WtfWarning("Node [%s] is not connected to anything"%n))
else:
edges = _businfo(ctx, n, bus_info)
actual_edges.extend(edges)
except socket.error, e:
pass #ignore as we have rules to catch this
def setUp(self):
# first we setup our publishers and our node (used by rospy.resolve_name calls to remap topics)
self.strpub = rospy.Publisher('/test/string', String, queue_size=1)
self.emppub = rospy.Publisher('/test/empty', Empty, queue_size=1)
self._master = rospy.get_master()
self.service_if_pool = RosServiceIfPool()
# we need to speed fast enough for the tests to not fail on timeout...
rospy.set_param('/connection_cache/spin_freq', 2) # 2 Hz
self.connection_cache_node = roslaunch.core.Node('rocon_python_comms', 'connection_cache.py',
name='connection_cache',
remap_args=[('~list', rospy.resolve_name('~connections_list')),
(
'~diff', rospy.resolve_name('~connections_diff'))])
# Easier to remap the node topic to the proxy ones, instead of the opposite, since there is no dynamic remapping.
# However for normal usecase, remapping the proxy handles is preferable.
try:
self.connection_cache_proc = self.launch.launch(self.connection_cache_node)
except roslaunch.RLException as rlexc:
raise nose.SkipTest("Connection Cache Node not found (part of rocon_python_comms pkg). Skipping test.")
assert self.connection_cache_proc.is_alive()
# wait for node to be started
node_api = None
with Timeout(5) as t:
while not t.timed_out and node_api is None:
node_api = rosnode.get_api_uri(rospy.get_master(), 'connection_cache')
assert node_api is not None # make sure the connection cache node is started before moving on.
self.connection_cache = connection_cache_proxy_create()
def getnodepkg1(self, node_name):
socket.setdefaulttimeout(1.0)
master = roslib.scriptutil.get_master()
node_api = rosnode.get_api_uri(master, node_name)
host = node_api.split(':')[1].lstrip('/')
node = xmlrpclib.ServerProxy(node_api)
try:
pid = rosnode._succeed(node.getPid(rosnode.ID))
except socket.error:
print("Communication with [%s=%s] failed!" % (node_name, node_api))
return ['']
cmd = ['ps', 'ww', '--pid', str(pid)]
if os.environ['ROS_IP'] != host and os.environ['ROS_HOSTNAME'] != host:
ssh_target = self.user + '@' + host if self.user else hostname
cmd = ['ssh', ssh_target] + cmd
self.add_pkginfo_remote(host)
ps = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()[0]
res = ps[ps.find('/'):]
node_args = res.split(' ')
parsed = node_args[0].split('/')
pkgnames = [pkg[0] for pkg in self.pkginfo[host]]
result = [dirname for dirname in parsed if (dirname in pkgnames)]
if len(result) == 0:
result = ['']
return result
def get_node_list():
"""
List all ROS Nodes
Return: List containing ROS Nodes(name, pid)
"""
rospy.logdebug("GET_NODE_LIST:")
node_array_temp = rosnode.get_node_names()
node_list = []
j = 0
for node_name in node_array_temp:
try:
node_api = rosnode.get_api_uri(rospy.get_master(), node_name)
if socket.gethostname() not in node_api[2] and socket.gethostbyname(socket.gethostname()) not in node_api[2]: # Only Get Info for Local Nodes
continue
code, msg, pid = xmlrpclib.ServerProxy(node_api[2]).getPid(ID)
node_list.append(NODE(node_name, pid))
rospy.logdebug("Node_name: " + node_list[j].name + " Node_PID: " + str(node_list[j].pid))
j += 1
except socket_error as serr:
pass
rospy.logdebug("=============================")
return node_list
def get_node_info(self, event):
"""
Get the list of all Nodes running on the host.
Update the __node_list
"""
if not self.__is_enabled:
pass
if self.__is_enabled:
nodes = []
for node_name in rosnode.get_node_names():
try:
node_api = rosnode.get_api_uri(rospy.get_master(), node_name, skip_cache=True)
if self._id in node_api[2]:
nodes.append(node_name)
except :
pass
for node in nodes:
if node not in self.__node_list:
"""TODO currently not catching the exception here - master not running is a hard error so it does
not make sense to continue running.."""
node_api = rosnode.get_api_uri(rospy.get_master(), node, skip_cache=True)
try:
pid = self.get_node_pid(node_api, node)
if not pid:
continue
node_process = psutil.Process(pid)
new_node = NodeStatisticsHandler(
self._id, node, node_process)
self.__dict_lock.acquire(True)
self.__node_list[node] = new_node
self.__dict_lock.release()
except psutil.NoSuchProcess:
rospy.loginfo('pid of node %s could not be fetched' % node)
continue
self.__dict_lock.acquire()
to_remove = []
for node_name in self.__node_list:
if node_name not in nodes:
rospy.logdebug('removing %s from host' % node_name)
to_remove.append(node_name)
for node_name in to_remove:
self.remove_node(node_name)
self.__dict_lock.release()
def get_node_info(self, node_name):
node_api_uri = rosnode.get_api_uri(self.master, node_name)
node = xmlrpclib.ServerProxy(node_api_uri)
code, status_message, pid = node.getPid(rospy.get_name())
netloc = urlparse.urlparse(node_api_uri).netloc
host, api_port = netloc.split(':')
return {'pid': pid, 'host': host}
def testNodePing(self, node_name):
#Simplemente una funcion que devuelve bool de nodo si activo o no. SI NECESITA PALITO.
master = rosgraph.Master('/rosnode')
node_api = rosnode.get_api_uri(master, node_name)
node_is_active = False
if node_api:
node_is_active = rosnode.rosnode_ping(
node_name, 1, verbose=False) #1: max ping request count
return node_is_active
def get_hostname_of_nodes(node_name,
master=rosnode.rosgraph.Master(rosnode.ID)):
# check if master is available
node_api = rosnode.get_api_uri(master, node_name, skip_cache=True)
# check if node can be found
if not node_api:
raise rosnode.ROSNodeException("cannot find node '" + str(node_name) +
"'; maybe its not running any more")
return rosnode.urlparse.urlparse(node_api).hostname, node_api
def get_info_text(selection_url):
if selection_url is None:
return ''
if selection_url.startswith('node:'):
try:
node_name = selection_url[5:]
master = roslib.scriptutil.get_master()
node_api = rosnode.get_api_uri(master, node_name)
return rosnode.get_node_info_description(node_name) + rosnode.get_node_connection_info_description(node_api)
except rosnode.ROSNodeException, e:
return "ERROR: %s"%str(e)
def get_api_uri(master, caller_id):
res = None
while res is None:
try:
res = rosnode.get_api_uri(master, caller_id)
except (socket.error, socket.herror, socket.gaierror) as e:
rospy.logerr(
"Pyros : got socket error calling get_api_uri({master}, {caller_id}). Retrying..."
.format(**locals()))
time.sleep(retry_timeout)
else:
return res
def get_node_info(self, node_name):
node_api = rosnode.get_api_uri(rospy.get_master(), node_name)
code, msg, pid = xmlrpclib.ServerProxy(node_api[2]).getPid(ID)
if node_name in self.nodes:
return self.nodes[node_name]
else:
try:
p = psutil.Process(pid)
self.nodes[node_name] = p
return p
except:
return False
def get_node_info(self, node_name):
node_api = rosnode.get_api_uri(rospy.get_master(), node_name)
code, msg, pid = xmlrpclib.ServerProxy(node_api[2]).getPid(ID)
if node_name in self.nodes:
return self.nodes[node_name]
else:
try:
p = psutil.Process(pid)
self.nodes[node_name] = p
return p
except:
return False
def get_info_text(selection_url):
if selection_url is None:
return ''
if selection_url.startswith('node:'):
try:
node_name = selection_url[5:]
master = rosgraph.Master('/rxgraph')
node_api = rosnode.get_api_uri(master, node_name)
return rosnode.get_node_info_description(
node_name) + rosnode.get_node_connection_info_description(
node_api, master)
except rosnode.ROSNodeException, e:
return "ERROR: %s" % str(e)
def __init__(self, node_name): super(ProcessInfoDisplay, self).__init__() self.node_name = node_name self.node_api = rosnode.get_api_uri(rospy.get_master(), node_name) code, msg, self.pid = xmlrpclib.ServerProxy(self.node_api[2]).getPid(ID) try: self.process = psutil.Process(self.pid) except: print 'Bad PID: %s, name: %s, code: %s, msg: %s' % (self.pid, self.node_name, code, msg) self.initUI() self.timer = QtCore.QTimer(self.parent()) self.timer.setInterval(1000) self.timer.timeout.connect(self.update_live_info) self.timer.start()
def nodes_ready():
try:
pids = {
node: ServerProxy(
rosnode.get_api_uri(self.master, node,
skip_cache=True)).getPid(self.name)
for node in self.critical_nodes
}
if all([pid[0] for pid in pids.values()]):
self.pids = {node: pid[2] for node, pid in pids.items()}
return True
except Exception:
pass
return False
def _init_node_table(self):
nodes = rosnode._sub_rosnode_listnodes()
nodelist = nodes.split('\n')
for i in range(len(nodelist)):
uri = rosnode.get_api_uri(self._master, nodelist[i])
uri = uri.replace('/','')
uri = '/'+uri.split(':')[1]
self._add_node(uri, nodelist[i], i)
self._qtable_index = len(nodelist)
self._parent._table_monitor.resizeColumnsToContents()
self._parent._table_monitor.resizeRowsToContents()
def start_eval(self):
rate = rospy.Rate(2)
while self.node_names is not None and not rospy.is_shutdown():
rate.sleep()
all_node_names = rosnode.get_node_names()
for node_name in self.node_names:
# check if node is running
if node_name not in all_node_names:
rospy.logwarn('Node %s is not running' % node_name)
continue
if node_name in self.node_pid:
continue
rospy.loginfo('Looking for pid of node %s' % node_name)
node_api = rosnode.get_api_uri(self.master, node_name)
while True:
try:
node_con_info = rosnode.get_node_connection_info_description(
node_api, self.master)
except rosnode.ROSNodeIOException as e:
time.sleep(0.1)
rospy.loginfo_throttle(1, e)
continue
else:
break
pid_match = re.search('Pid: (\d+)', node_con_info)
if pid_match is None:
rospy.logwarn('Not found pid in description of node %s' %
node_name)
continue
self.node_pid[node_name] = int(pid_match.group(1))
rospy.loginfo('Pid: %d' % self.node_pid[node_name])
if len(self.node_pid) == len(self.node_names):
break
rospy.loginfo('Catched pid of every node, start evaluating')
self._start_eval_threads()
rospy.on_shutdown(self.stop_threads)
self._plot_loop()
def discover_ros_nodes(self):
self.nodes = {}
node_names = rosnode.get_node_names()
logging.info("Known nodes: " + ', '.join(node_names))
for node_name in node_names:
logging.info(" " + node_name)
node_api = rosnode.get_api_uri(self.master, node_name)
if not node_api:
sys.stderr.write(" API URI: error (unknown node: %s)" %
str(node_name))
continue
logging.info(" API URI: " + node_api)
node = ServerProxy(node_api)
pid = rosnode._succeed(node.getPid(ID))
logging.info(" PID : " + str(pid))
self.nodes[node_name] = {}
self.nodes[node_name]['uri'] = node_api
self.nodes[node_name]['pid'] = pid
def get_node_info(self, node_name, skip_cache=False):
node_api = rosnode.get_api_uri(rospy.get_master(), node_name, skip_cache=skip_cache)
try:
code, msg, pid = xmlrpclib.ServerProxy(node_api[2]).getPid(ID)
if node_name in self.nodes:
return self.nodes[node_name]
else:
try:
p = psutil.Process(pid)
self.nodes[node_name] = p
return p
except:
return False
except xmlrpclib.socket.error:
if not skip_cache:
return self.get_node_info(node_name, skip_cache=True)
else:
return False
def _update_node_table(self, alive_nodes):
for node in alive_nodes.keys():
if node not in self._table_dict.keys():
uri = rosnode.get_api_uri(self._master, node)
uri = uri.replace('/','')
uri = '/'+uri.split(':')[1]
self._add_node(uri, node, self._qtable_index)
self._qtable_index += 1
for node in self._table_dict.keys():
if node not in alive_nodes.keys():
self._table_dict[node].refresh(NodeItem.SHUTDOWN)
if node not in self._deaded_nodes_alarm_register:
self._deaded_nodes_alarm_register.append(node)
self._parent.sendAlarm(Alarm.WARNING, "The node %s is dead !"%node)
self._parent._table_monitor.resizeColumnsToContents()
self._parent._table_monitor.resizeRowsToContents()
def get_node_info(self, node_name, skip_cache=False):
node_api = rosnode.get_api_uri(
rospy.get_master(), node_name, skip_cache=skip_cache
) #we need the PID but rosnode only provide XMLRPC URI
try:
code, msg, pid = ServerProxy(node_api[2]).getPid(
ID) #get PID via XMLRPC URI
if node_name in self.nodes:
return self.nodes[node_name]
else:
try:
p = psutil.Process(pid)
self.nodes[node_name] = p
return p
except:
return False
except (SocketError, IOError) as e:
if not skip_cache:
return self.get_node_info(node_name, skip_cache=True)
else:
return False
def setUp(self, cacheproxy=None):
cacheproxy = cacheproxy or partial(rocon_python_comms.ConnectionCacheProxy, user_callback=self.user_cb, diff_opt=False, handle_actions=True)
# We prepare our data structure for checking messages
self.conn_list_msgq = deque()
self.conn_diff_msgq = deque()
self.spin_freq = 0.0
self.cleanup_user_cb_ss()
# Then we hookup to its topics and prepare a service proxy
self.conn_list = rospy.Subscriber('/connection_cache/list', rocon_std_msgs.ConnectionsList, self._list_cb)
self.conn_diff = rospy.Subscriber('/connection_cache/diff', rocon_std_msgs.ConnectionsDiff, self._diff_cb)
self.set_spin = rospy.Publisher('/connection_cache/spin', rocon_std_msgs.ConnectionCacheSpin, queue_size=1)
self.get_spin = rospy.Subscriber('/connection_cache/spin', rocon_std_msgs.ConnectionCacheSpin, self._spin_cb)
# connecting to the master via proxy object
self._master = rospy.get_master()
self.node_default_spin_freq = 1 # change this to test different spin speed for the connection cache node
rospy.set_param("/connection_cache/spin_freq", self.node_default_spin_freq)
cache_node = roslaunch.core.Node('rocon_python_comms', 'connection_cache.py', name='connection_cache')
self.cache_process = self.launch.launch(cache_node)
node_api = None
with timeout(5) as t:
while not t.timed_out and node_api is None:
node_api = rosnode.get_api_uri(self._master, 'connection_cache')
assert node_api is not None # make sure the connection cache node is started before moving on.
# This will block until the cache node is available and has sent latched system state
self.proxy = cacheproxy(
list_sub='/connection_cache/list',
diff_sub='/connection_cache/diff'
)
# Making sure System state is set after proxy initialized
assert self.proxy._system_state is not None
assert not t.timed_out
def get_pid(name):
try:
pid = [p.pid for p in psutil.process_iter() if name in str(p.name)]
return pid[0]
except IndexError:
pass
try:
node_id = '/NODEINFO'
node_api = rosnode.get_api_uri(rospy.get_master(), name)
code, msg, pid = xmlrpclib.ServerProxy(node_api[2]).getPid(node_id)
except IOError:
pass
else:
return pid
try:
return int(check_output(["pidof", "-s", name]))
except CalledProcessError:
pass
rospy.logerr("Node '" + name + "' is not running!")
return None
def getROSNodes(self):
nodes = []
try:
nodenames = rosnode.get_node_names(None)
except Exception as inst:
print "ERROR:[getROSNodes-01] ", inst
return nodes
for nodename in nodenames:
#rosnode.rosnode_info(nodename)
api = rosnode.get_api_uri(rosgraph.Master("/rosnode"), nodename)
if api:
try:
node = ServerProxy(api)
code, msg, pid = node.getPid("/rosnode")
if code == 1:
res = re.search("^(.*)_[0-9]+$", nodename)
while res is not None:
nodename = res.group(1)
res = re.search("^(.*)_[0-9]+$", nodename)
nodes.append((nodename, pid))
except:
pass
return nodes
def _init_uri(self):
if self._name and self._uri is None:
try:
self._uri = rosnode.get_api_uri(self._config.master.handle, self._name)
except:
pass
