def __init__(self, size):
"""
:param size: tuple
"""
self.size = size
self.running = True
self.document = Document(self.size)
self.screen_handler = ScreenHandler(self.size)
self.input_handler = InputHandler()
self.using_mode = 0
pygame.display.set_mode(size)
def init_globals(masteruri):
# initialize the global handler
global _ssh_handler
global _screen_handler
global _start_handler
global _name_resolution
global _history
global _file_watcher
global _file_watcher_param
_ssh_handler = SSHhandler()
_screen_handler = ScreenHandler()
_start_handler = StartHandler()
_name_resolution = NameResolution()
_history = History()
_file_watcher = FileWatcher()
_file_watcher_param = FileWatcher()
# test where the roscore is running (local or remote)
__is_local('localhost') ## fill cache
return __is_local(_name_resolution.getHostname(masteruri)) ## fill cache
def main():
'''
Creates and runs the ROS node.
'''
setTerminalName(NODE_NAME)
setProcessName(NODE_NAME)
try:
from PySide.QtGui import QApplication
from PySide.QtCore import QTimer
except:
print >> sys.stderr, "please install 'python-pyside' package!!"
sys.exit(-1)
rospy.init_node(NODE_NAME, log_level=rospy.DEBUG)
# Initialize Qt
global app
app = QApplication(sys.argv)
# initialize the global handler
global _ssh_handler
global _screen_handler
global _start_handler
global _name_resolution
_ssh_handler = SSHhandler()
_screen_handler = ScreenHandler()
_start_handler = StartHandler()
_name_resolution = NameResolution()
#start the gui
import main_window
mainForm = main_window.MainWindow()
if not rospy.is_shutdown():
mainForm.show()
exit_code = -1
try:
rospy.on_shutdown(finish)
exit_code = app.exec_()
mainForm.finish()
finally:
sys.exit(exit_code)
def main(name, anonymous=False):
global CFG_PATH
masteruri = masteruri_from_ros()
CFG_PATH = ''.join([get_ros_home(), os.sep, 'node_manager', os.sep])
'''
Creates and runs the ROS node.
'''
if not os.path.isdir(CFG_PATH):
os.makedirs(CFG_PATH)
args = rospy.myargv(argv=sys.argv)
# decide to show main or echo dialog
if len(args) >= 4 and args[1] == '-t':
name = ''.join([name, '_echo'])
anonymous = True
try:
from PySide.QtGui import QApplication
except:
print >> sys.stderr, "please install 'python-pyside' package!!"
sys.exit(-1)
# start ROS-Master, if not currently running
StartHandler._prepareROSMaster(masteruri)
rospy.init_node(name, anonymous=anonymous, log_level=rospy.DEBUG)
setTerminalName(rospy.get_name())
setProcessName(rospy.get_name())
# Initialize Qt
global app
app = QApplication(sys.argv)
# decide to show main or echo dialog
import main_window, echo_dialog
global main_form
if len(args) >= 4 and args[1] == '-t':
show_hz_only = (len(args) > 4 and args[4] == '--hz')
main_form = echo_dialog.EchoDialog(args[2], args[3], show_hz_only)
else:
# initialize the global handler
global _ssh_handler
global _screen_handler
global _start_handler
global _name_resolution
global _history
_ssh_handler = SSHhandler()
_screen_handler = ScreenHandler()
_start_handler = StartHandler()
_name_resolution = NameResolution()
_history = History()
# test where the roscore is running (local or remote)
__is_local('localhost') ## fill cache
__is_local(_name_resolution.getHostname(masteruri)) ## fill cache
local_master = is_local(_name_resolution.getHostname(masteruri))
#start the gui
main_form = main_window.MainWindow(args, not local_master)
if not rospy.is_shutdown():
os.chdir(PACKAGE_DIR
) # change path to be able to the images of descriptions
main_form.show()
exit_code = -1
rospy.on_shutdown(finish)
exit_code = app.exec_()
from addressbar_handler import AddressBarHandler from screen_handler import ScreenHandler from message import MessageHandler message_handler = MessageHandler() ScreenHandler(message_handler).start() AddressBarHandler(message_handler).start()
def runNode(self, node):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (item.namespace.strip('/')
== namespace):
n = item
break
if n is None:
raise StartException(''.join(["Node '", node, "' not found!"]))
env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = [
''.join(['__ns:=', n.namespace]), ''.join(['__name:=', n.name])
]
if not (n.cwd is None):
args.append(''.join(['__cwd:=', n.cwd]))
# add remaps
for remap in n.remap_args:
args.append(''.join([remap[0], ':=', remap[1]]))
masteruri = self.masteruri
if n.machine_name:
machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# set the global parameter
if not self.global_parameter_setted:
global_node_names = self.getGlobalParams(self.roscfg)
self._load_parameters(masteruri, global_node_names, [])
self.global_parameter_setted = True
# add params
nodens = ''.join([n.namespace, n.name, '/'])
params = dict()
for param, value in self.roscfg.params.items():
if param.startswith(nodens):
params[param] = value
clear_params = []
for cparam in self.roscfg.clear_params:
if cparam.startswith(nodens):
clear_params.append(param)
rospy.loginfo("register PARAMS:\n%s", '\n'.join(params))
self._load_parameters(masteruri, params, clear_params)
# nm.screen().testScreen()
try:
cmd = roslib.packages.find_node(n.package, n.type)
except roslib.packages.ROSPkgException as e:
# multiple nodes, invalid package
raise StartException(str(e))
# handle diferent result types str or array of string
import types
if isinstance(cmd, types.StringTypes):
cmd = [cmd]
if cmd is None or len(cmd) == 0:
raise StartException(' '.join(
[n.type, 'in package [', n.package, '] not found!']))
node_cmd = [prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
subprocess.Popen(popen_cmd)
def runNode(self, node, autostart=False):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
if not self.parameter_loaded:
self.loadParams()
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (
(item.namespace.strip('/') == namespace) or not namespace):
n = item
break
if n is None:
raise StartException("Node '%s' not found!" % node)
if autostart and self._get_start_exclude(
rospy.names.ns_join(n.namespace, n.name)):
# skip autostart
rospy.loginfo("%s is in exclude list, skip autostart", n.name)
return
# env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = ['__ns:=%s' % n.namespace, '__name:=%s' % n.name]
if not (n.cwd is None):
args.append('__cwd:=%s' % n.cwd)
# add remaps
for remap in n.remap_args:
args.append('%s:=%s' % (remap[0], remap[1]))
# masteruri = self.masteruri
# if n.machine_name and not n.machine_name == 'localhost':
# machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# nm.screen().testScreen()
cmd = self._get_node(n.package, n.type)
# determine the current working path, Default: the package of the node
cwd = self.get_ros_home()
if not (n.cwd is None):
if n.cwd == 'ROS_HOME':
cwd = self.get_ros_home()
elif n.cwd == 'node':
cwd = os.path.dirname(cmd[0])
respawn = ['']
if n.respawn:
respawn = self._get_node('node_manager_fkie', 'respawn')
# set the respawn environment variables
respawn_params = self._get_respawn_params(
rospy.names.ns_join(n.namespace, n.name))
if respawn_params['max'] > 0:
n.env_args.append(
('RESPAWN_MAX', '%d' % respawn_params['max']))
if respawn_params['min_runtime'] > 0:
n.env_args.append(('RESPAWN_MIN_RUNTIME',
'%d' % respawn_params['min_runtime']))
if respawn_params['delay'] > 0:
n.env_args.append(
('RESPAWN_DELAY', '%d' % respawn_params['delay']))
node_cmd = [respawn[0], prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
# remove the 'BASH_ENV' and 'ENV' from environment
new_env = dict(os.environ)
try:
for k in ['BASH_ENV', 'ENV']:
del new_env[k]
except:
pass
# add node environment parameter
for k, v in n.env_args:
new_env[k] = v
# set delayed autostart parameter
self._run_node(popen_cmd, cwd, new_env,
rospy.names.ns_join(n.namespace, n.name), autostart)
if len(cmd) > 1:
raise StartException(
'Multiple executables are found! The first one was started! Exceutables:\n%s'
% str(cmd))
def runNode(self, node):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (item.namespace.strip('/') == namespace):
n = item
break
if n is None:
raise StartException(''.join(["Node '", node, "' not found!"]))
# env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = [''.join(['__ns:=', n.namespace]), ''.join(['__name:=', n.name])]
if not (n.cwd is None):
args.append(''.join(['__cwd:=', n.cwd]))
# add remaps
for remap in n.remap_args:
args.append(''.join([remap[0], ':=', remap[1]]))
# masteruri = self.masteruri
# if n.machine_name and not n.machine_name == 'localhost':
# machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# nm.screen().testScreen()
cmd = self._get_node(n.package, n.type)
# determine the current working path, Default: the package of the node
cwd = self.get_ros_home()
if not (n.cwd is None):
if n.cwd == 'ROS_HOME':
cwd = self.get_ros_home()
elif n.cwd == 'node':
cwd = os.path.dirname(cmd[0])
respawn = ['']
if n.respawn:
respawn = self._get_node('node_manager_fkie', 'respawn')
node_cmd = [respawn[0], prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
# remove the 'BASH_ENV' and 'ENV' from environment
new_env = dict(os.environ)
try:
for k in ['BASH_ENV', 'ENV']:
del new_env[k]
except:
pass
# add node environment parameter
for k, v in n.env_args:
new_env[k] = v
ps = subprocess.Popen(popen_cmd, cwd=cwd, env=new_env)
# wait for process to avoid 'defunct' processes
thread = threading.Thread(target=ps.wait)
thread.setDaemon(True)
thread.start()
# subprocess.Popen(popen_cmd, cwd=cwd)
if len(cmd) > 1:
raise StartException('Multiple executables are found! The first one was started! Exceutables:\n' + str(cmd))
def runNode(self, node):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (item.namespace.strip('/')
== namespace):
n = item
break
if n is None:
raise StartException(''.join(["Node '", node, "' not found!"]))
env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = [
''.join(['__ns:=', n.namespace]), ''.join(['__name:=', n.name])
]
if not (n.cwd is None):
args.append(''.join(['__cwd:=', n.cwd]))
# add remaps
for remap in n.remap_args:
args.append(''.join([remap[0], ':=', remap[1]]))
masteruri = self.masteruri
if n.machine_name and not n.machine_name == 'localhost':
machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# nm.screen().testScreen()
try:
cmd = roslib.packages.find_node(n.package, n.type)
except roslib.packages.ROSPkgException as e:
# multiple nodes, invalid package
raise StartException(str(e))
# handle diferent result types str or array of string
import types
if isinstance(cmd, types.StringTypes):
cmd = [cmd]
if cmd is None or len(cmd) == 0:
raise StartException(' '.join(
[n.type, 'in package [', n.package, '] not found!']))
# determine the current working path, Default: the package of the node
cwd = self.get_ros_home()
if not (n.cwd is None):
if n.cwd == 'ROS_HOME':
cwd = self.get_ros_home()
elif n.cwd == 'node':
cwd = os.path.dirname(cmd[0])
node_cmd = [
'rosrun node_manager_fkie respawn' if n.respawn else '', prefix,
cmd[0]
]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
subprocess.Popen(popen_cmd, cwd=cwd)
def runNode(self, node):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (item.namespace.strip('/') == namespace):
n = item
break
if n is None:
raise StartException(''.join(["Node '", node, "' not found!"]))
env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = [''.join(['__ns:=', n.namespace]), ''.join(['__name:=', n.name])]
if not (n.cwd is None):
args.append(''.join(['__cwd:=', n.cwd]))
# add remaps
for remap in n.remap_args:
args.append(''.join([remap[0], ':=', remap[1]]))
masteruri = self.masteruri
if n.machine_name:
machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# set the global parameter
if not self.global_parameter_setted:
global_node_names = self.getGlobalParams(self.roscfg)
self._load_parameters(masteruri, global_node_names, [])
self.global_parameter_setted = True
# add params
nodens = ''.join([n.namespace, n.name, '/'])
params = dict()
for param, value in self.roscfg.params.items():
if param.startswith(nodens):
params[param] = value
clear_params = []
for cparam in self.roscfg.clear_params:
if cparam.startswith(nodens):
clear_params.append(param)
rospy.loginfo("register PARAMS:\n%s", '\n'.join(params))
self._load_parameters(masteruri, params, clear_params)
# nm.screen().testScreen()
try:
cmd = roslib.packages.find_node(n.package, n.type)
except roslib.packages.ROSPkgException as e:
# multiple nodes, invalid package
raise StartException(str(e))
# handle diferent result types str or array of string
import types
if isinstance(cmd, types.StringTypes):
cmd = [cmd]
if cmd is None or len(cmd) == 0:
raise StartException(' '.join([n.type, 'in package [', n.package, '] not found!']))
node_cmd = [prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
subprocess.Popen(popen_cmd)
class Main(object):
"""
Main class for 08b15.
"""
def __init__(self, size):
"""
:param size: tuple
"""
self.size = size
self.running = True
self.document = Document(self.size)
self.screen_handler = ScreenHandler(self.size)
self.input_handler = InputHandler()
self.using_mode = 0
pygame.display.set_mode(size)
def run(self):
"""
:return: None
"""
while self.running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
else:
self.input_handler.catch(event, self.screen_handler,
self.document, self)
self.update_screen()
def update_screen(self):
"""
:return: None
"""
self.screen_handler.draw_screen(self.document, self.using_mode)
pygame.display.update()
def save_screen(self):
"""
Saves screenshot into /screens
:return: None
"""
path = 'screens/output_%s.png' % str(
datetime.datetime.now())[:-7].replace(":", ",")
save_screen = pygame.Surface(
(self.screen_handler.size[0] * 2, self.screen_handler.size[1] * 2))
save_screen.blit(self.screen_handler.screen, (0, 0))
save_screen.blit(
pygame.transform.flip(self.screen_handler.screen, 0, 1),
(0, self.screen_handler.size[1]))
save_screen.blit(
pygame.transform.flip(self.screen_handler.screen, 1, 0),
(self.screen_handler.size[0], 0))
save_screen.blit(
pygame.transform.flip(self.screen_handler.screen, 1, 1),
(self.screen_handler.size[0], self.screen_handler.size[1]))
pygame.image.save(save_screen, path)
def HandleRequest(self, byteRequest):
'''
Handle request sent by client.
Request is handled, then passed to SendMessage to send a reply with appropriate data to client, this step is blocking.
Parameters:
requestString (str): the reqeust string
Returns:
int: either ServerProgram.CONTINUE or ServerProgram.QUIT_PROGRAM
'''
immediate = False
request, data = self.SplitRequest(byteRequest)
state = HandlerState.INVALID
extraInfo = None
if (type(self.currHandler) != DirectoryHandler
or request != "TRANSFER") and data:
data = data.decode(FORMAT)
print(
request, data if data and len(data) < 512 else
(len(data) if data else ''))
# FINISH request exits the current handler
# EXIT request finishes the program
if request == "FINISH":
if self.currHandler:
self.currHandler = None
state = HandlerState.SUCCEEDED
else:
self.SendMessage("INVALID", None)
elif request == "EXIT":
self.currHandler = None
self.SendMessage("SUCCEEDED", None)
return ServerProgram.QUIT_PROGRAM
# If no handler is currently active
elif not self.currHandler:
# SHUTDOWN and SCREENSHOT are immeditate handlers
if request == "SHUTDOWN":
self.currHandler = ShutdownHandler()
immediate = True
elif request == "SCREENSHOT":
self.currHandler = ScreenHandler()
immediate = True
elif request == "INFO":
self.currHandler = InfoHandler()
immediate = True
# The rest needs additional requests and looping
else:
immediate = False
state = HandlerState.SUCCEEDED
if request == "PROCESS":
self.currHandler = ProcessHandler()
elif request == "APPLICATION":
self.currHandler = ApplicationHandler()
elif request == "KEYLOG":
self.currHandler = InputHandler(KEYLOG_FILE_PATH)
elif request == "REGISTRY":
self.currHandler = RegistryHandler()
elif request == "DIRECTORY":
self.currHandler = DirectoryHandler()
elif request == "LIVESTREAM":
self.currHandler = LivestreamHandler(
self, self.serverSocket, ScreenHandler())
# Else let current handler handle request
else:
state, extraInfo = self.currHandler.Execute(request, data)
if self.currHandler and immediate:
state, extraInfo = self.currHandler.Execute("", data)
self.currHandler = None
immediate = False
print(
state, extraInfo if extraInfo and len(extraInfo) < 512 else
(len(extraInfo) if extraInfo else ''))
if request == "SHUTDOWN" and state == HandlerState.SUCCEEDED:
self.SendMessage("SUCCEEDED", extraInfo)
return ServerProgram.QUIT_PROGRAM
if state == HandlerState.SUCCEEDED:
self.SendMessage("SUCCEEDED", extraInfo)
elif state == HandlerState.FAILED:
self.SendMessage("FAILED", extraInfo)
else:
self.SendMessage("INVALID", extraInfo)
return ServerProgram.CONTINUE_PROGRAM
def runNode(self, node, autostart=False):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and ((item.namespace.strip('/') == namespace) or not namespace):
n = item
break
if n is None:
raise StartException("Node '%s' not found!"%node)
if autostart and self._get_start_exclude(rospy.names.ns_join(n.namespace, n.name)):
# skip autostart
rospy.loginfo("%s is in exclude list, skip autostart", n.name)
return
# env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = ['__ns:=%s'%n.namespace, '__name:=%s'%n.name]
if not (n.cwd is None):
args.append('__cwd:=%s'%n.cwd)
# add remaps
for remap in n.remap_args:
args.append('%s:=%s'%(remap[0], remap[1]))
# masteruri = self.masteruri
# if n.machine_name and not n.machine_name == 'localhost':
# machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# nm.screen().testScreen()
cmd = self._get_node(n.package, n.type)
# determine the current working path, Default: the package of the node
cwd = self.get_ros_home()
if not (n.cwd is None):
if n.cwd == 'ROS_HOME':
cwd = self.get_ros_home()
elif n.cwd == 'node':
cwd = os.path.dirname(cmd[0])
respawn = ['']
if n.respawn:
respawn = self._get_node('node_manager_fkie', 'respawn')
# set the respawn environment variables
respawn_params = self._get_respawn_params(rospy.names.ns_join(n.namespace, n.name))
if respawn_params['max'] > 0:
n.env_args.append(('RESPAWN_MAX', '%d'%respawn_params['max']))
if respawn_params['min_runtime'] > 0:
n.env_args.append(('RESPAWN_MIN_RUNTIME', '%d'%respawn_params['min_runtime']))
if respawn_params['delay'] > 0:
n.env_args.append(('RESPAWN_DELAY', '%d'%respawn_params['delay']))
node_cmd = [respawn[0], prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
# remove the 'BASH_ENV' and 'ENV' from environment
new_env = dict(os.environ)
try:
for k in ['BASH_ENV', 'ENV']:
del new_env[k]
except:
pass
# add node environment parameter
for k, v in n.env_args:
new_env[k] = v
# set delayed autostart parameter
self._run_node(popen_cmd, cwd, new_env, rospy.names.ns_join(n.namespace, n.name), autostart)
if len(cmd) > 1:
raise StartException('Multiple executables are found! The first one was started! Exceutables:\n%s'%str(cmd))
def runNode(self, node):
'''
Start the node with given name from the currently loaded configuration.
@param node: the name of the node
@type node: C{str}
@raise StartException: if an error occurred while start.
'''
n = None
nodename = os.path.basename(node)
namespace = os.path.dirname(node).strip('/')
for item in self.roscfg.nodes:
if (item.name == nodename) and (item.namespace.strip('/') == namespace):
n = item
break
if n is None:
raise StartException(''.join(["Node '", node, "' not found!"]))
env = n.env_args
prefix = n.launch_prefix if not n.launch_prefix is None else ''
args = [''.join(['__ns:=', n.namespace]), ''.join(['__name:=', n.name])]
if not (n.cwd is None):
args.append(''.join(['__cwd:=', n.cwd]))
# add remaps
for remap in n.remap_args:
args.append(''.join([remap[0], ':=', remap[1]]))
masteruri = self.masteruri
if n.machine_name and not n.machine_name == 'localhost':
machine = self.roscfg.machines[n.machine_name]
#TODO: env-loader support?
# if machine.env_args:
# env[len(env):] = machine.env_args
# nm.screen().testScreen()
try:
cmd = roslib.packages.find_node(n.package, n.type)
except roslib.packages.ROSPkgException as e:
# multiple nodes, invalid package
raise StartException(str(e))
# handle diferent result types str or array of string
import types
if isinstance(cmd, types.StringTypes):
cmd = [cmd]
if cmd is None or len(cmd) == 0:
raise StartException(' '.join([n.type, 'in package [', n.package, '] not found!']))
# determine the current working path, Default: the package of the node
cwd = self.get_ros_home()
if not (n.cwd is None):
if n.cwd == 'ROS_HOME':
cwd = self.get_ros_home()
elif n.cwd == 'node':
cwd = os.path.dirname(cmd[0])
node_cmd = ['rosrun node_manager_fkie respawn' if n.respawn else '', prefix, cmd[0]]
cmd_args = [ScreenHandler.getSceenCmd(node)]
cmd_args[len(cmd_args):] = node_cmd
cmd_args.append(n.args)
cmd_args[len(cmd_args):] = args
# print 'runNode: ', cmd_args
popen_cmd = shlex.split(str(' '.join(cmd_args)))
rospy.loginfo("run node '%s as': %s", node, str(' '.join(popen_cmd)))
subprocess.Popen(popen_cmd, cwd=cwd)
liveSocket, address = hostSocket.accept()
TARGET_FPS = 30
TIME_FRAME = 1 / TARGET_FPS
frame = 0
start = time.perf_counter()
while not self.livestreamEvent.is_set():
w, h, data = self.screenHandler.TakeScreenshotAsBytes(960, 540)
state = SendMessage(liveSocket,
str(w) + " " + str(h) + " " + str(frame + 1),
data)
if not state:
self.HandleMessageFault()
break
frame += 1
targetTime = frame * TIME_FRAME
end = time.perf_counter()
elapsed = (end - start)
waitTime = targetTime - elapsed if targetTime >= elapsed else 0.0
time.sleep(waitTime)
liveSocket.close()
if __name__ == "__main__":
DEBUG = True
a = ScreenHandler()
m, n = a.Execute("", "")
