def run(self):
try:
self.session_widget.display_sessions = self.session_widget.remote_connection_manager.list(
)
except Exception as e:
logger.error("Failed to reload the display sessions")
logger.error(e)
def on_save(self):
if not parser.has_section('Settings'):
parser.add_section('Settings')
# update settings values
self.update_and_apply_settings()
parser.set('Settings', 'debug_log_level',
json.dumps(self.settings['debug_log_level']))
parser.set('Settings', 'ssh_client',
json.dumps(self.settings['ssh_client']))
parser.set('Settings', 'preload_command',
json.dumps(self.settings['preload_command']))
try:
config_file_dir = os.path.dirname(config_file_name)
if not os.path.exists(config_file_dir):
os.makedirs(config_file_dir)
with open(config_file_name, 'w') as config_file:
parser.write(config_file)
except Exception:
logger.error(
"failed to dump the settings in the configuration file")
self.close()
def kill_display(self):
"""
Kill the display running on the server
:return:
"""
current_status = self.status
if self.status is Status.FINISHED:
self.terminate.emit(self.display_id)
return
try:
logger.debug("Killing remote display " + str(self.display_name))
self.status = Status.KILLING
self.update_gui()
self.kill_thread = KillThread(self.parent, self.session, self,
current_status)
self.kill_thread.finished.connect(self.on_killed)
self.kill_thread.start()
except:
logger.error("Failed to start kill remote display thread " +
str(self.display_name))
self.status = current_status
self.update_gui()
def __init__(self, display_names, platform_config):
QDialog.__init__(self)
self.display_name = ""
self.display_names = display_names
self.display_size_list = collections.deque(maxlen=5)
# current selections
self.session_queue = None
self.session_vnc = None
self.display_size = None
# combo
self.session_queue_combo = None
self.session_vnc_combo = None
self.display_combo = None
try:
self.session_queues = platform_config.config['queues'].keys()
self.session_vncs = platform_config.config['vnc_commands'].keys()
except:
self.session_queues = []
self.session_vncs = []
logger.error("Failed to parse the server platform config")
self.setWindowTitle("New display")
self.init_ui()
def run(self):
try:
self.session_widget.remote_connection_manager.kill(self.session)
self.display_widget.status = Status.FINISHED
except Exception as e:
self.display_widget.status = self.current_status
logger.error("Failed to kill the display session")
logger.error(e)
def open_vnc_session(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename, _ = QFileDialog.getOpenFileName(
self,
"Open...",
"",
"VNC Files (*.vnc);;All Files (*)",
options=options)
current_session_widget = self.main_widget.tabs.currentWidget()
if filename:
# check if session needs tunneling
file = open(filename, 'r')
if 'rcm_tunnel' in file.read():
file.seek(0)
lines = file.readlines()
for line in lines:
if 'rcm_tunnel' in line:
node = line.split('=')[1].rstrip()
if not current_session_widget.is_logged:
logger.error(
"You are not logged in the current session. Please log in."
)
return
if node == current_session_widget.host:
user = current_session_widget.user
else:
logger.error(
"The host of the current session (" +
current_session_widget.host +
") is different from the host of the vnc file ("
+ node + ")")
return
if 'host' in line:
hostname = line.split('=')[1].rstrip()
if 'port' in line:
port = line.split('=')[1].rstrip()
display = int(port) - 5900
if 'password' in line:
password = line.split('=')[1].rstrip()
session = rcm.rcm_session(node=hostname,
tunnel='y',
display=display,
nodelogin=node,
username=user,
vncpassword=password)
current_session_widget.remote_connection_manager.vncsession(
session=session)
logger.info("Connected to remote display " + str(display) +
" on " + node + " as " + str(user) +
" with tunnel")
else:
current_session_widget.remote_connection_manager.vncsession(
configFile=filename)
def connect_display(self):
try:
logger.info("Connecting to remote display " +
str(self.display_name))
self.parent.remote_connection_manager.submit(
self.session, gui_cmd=self.enable_connect_button)
except:
logger.error("Failed to connect to remote display " +
str(self.display_name))
def run(self):
try:
self.session_widget.remote_connection_manager.login_setup(
host=self.host, remoteuser=self.user, password=self.password)
self.session_widget.platform_config = self.session_widget.remote_connection_manager.get_config(
)
self.session_widget.is_logged = True
except Exception as e:
self.session_widget.is_logged = False
logger.error("Failed to login")
logger.error(e)
def kill_all_threads(self):
try:
self.kill_login_thread()
self.kill_reload_thread()
for display_session_id in self.displays.keys():
self.displays[display_session_id].kill_all_threads()
if self.remote_connection_manager:
self.remote_connection_manager.vncsession_kill()
except Exception as e:
logger.error('Failed to kill running threads')
logger.error(e)
def on_save(self):
if not parser.has_section('Settings'):
parser.add_section('Settings')
# update settings values
self.update_and_apply_settings()
for k in defaults:
parser.set('Settings', k, json.dumps(self.settings[k], indent=4))
try:
config_file_dir = os.path.dirname(config_file_name)
if not os.path.exists(config_file_dir):
os.makedirs(config_file_dir)
with open(config_file_name, 'w') as config_file:
parser.write(config_file)
except Exception:
logger.error(
"failed to dump the settings in the configuration file")
self.close()
def share_display(self):
try:
logger.info("Sharing display " + str(self.display_name))
filename_suggested = self.session.hash['session name'].replace(
' ', '_') + '.vnc'
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename, _ = QFileDialog.getSaveFileName(
self,
"Share display " + str(self.display_name),
filename_suggested,
" Vnc Files (*.vnc);;All Files (*)",
options=options)
if filename:
with open(filename, 'w') as out_file:
out_file.write("[Connection]\n")
if self.session.hash['tunnel'] == 'y':
# rcm_tunnel is a key word to know that I need to tunnel across that node
out_file.write("rcm_tunnel={0}\n".format(
self.session.hash['nodelogin']))
out_file.write("host={0}\n".format(
self.session.hash['node']))
else:
out_file.write("host={0}\n".format(
self.session.hash['nodelogin']))
try:
port = int(self.session.hash['port'])
except Exception as e:
logger.debug(
str(e) + " - " + str(traceback.format_exc()))
port = 5900 + int(self.session.hash['display'])
out_file.write("port={0}\n".format(port))
out_file.write("password={0}\n".format(
self.session.hash['vncpassword']))
except Exception as e:
logger.debug(str(e) + " - " + str(traceback.format_exc()))
logger.debug(str(self.session.hash))
logger.error("Failed to share display " + str(self.display_name))
def update_config_file(self, session_name):
"""
Update the config file with the new session name
:param session_name: name of the last session inserted by the user
:return:
"""
if not parser.has_section('LoginFields'):
parser.add_section('LoginFields')
parser.set('LoginFields', 'hostList',
json.dumps(list(self.sessions_list)))
try:
config_file_dir = os.path.dirname(config_file_name)
if not os.path.exists(config_file_dir):
os.makedirs(config_file_dir)
with open(config_file_name, 'w') as config_file:
parser.write(config_file)
except:
logger.error(
"failed to dump the session list in the configuration file")
def update_config_file(self):
"""
Update the config file with the display size list
:return:
"""
if not parser.has_section('DisplaySizeField'):
parser.add_section('DisplaySizeField')
parser.set('DisplaySizeField', 'displaysizelist',
json.dumps(list(self.display_size_list)))
try:
config_file_dir = os.path.dirname(config_file_name)
if not os.path.exists(config_file_dir):
os.makedirs(config_file_dir)
with open(config_file_name, 'w') as config_file:
parser.write(config_file)
except:
logger.error(
"failed to dump the display size list in the configuration file"
)
def run(self):
try:
logger.debug("Worker for display " + str(self.display_id) +
" started")
self.signals.status.emit(Status.PENDING)
display_session = self.remote_connection_manager.newconn(
queue=self.session_queue,
geometry=self.display_size,
sessionname=self.display_id,
vnc_id=self.session_vnc)
self.signals.status.emit(Status.RUNNING)
self.display_widget.session = display_session
self.remote_connection_manager.vncsession(
display_session,
gui_cmd=self.display_widget.enable_connect_button)
logger.debug("Worker for display " + str(self.display_id) +
" finished")
except Exception as e:
logger.error(e)
def run(self):
try:
self.session_widget.display_sessions = self.session_widget.remote_connection_manager.list(
)
except Exception as e:
logger.error("Failed to reload the display sessions")
logger.error(e)
exc_info = (type(e), e, e.__traceback__)
logger.error('Exception occurred', exc_info=exc_info)
def run(self):
try:
logger.debug("Worker for display " + str(self.display_id) +
" started")
self.signals.status.emit(Status.PENDING)
api_version = self.remote_connection_manager.api_version()
if api_version >= "1.0.0":
display_session = self.remote_connection_manager.new(
queue="dummy_queue",
geometry="dummy_display_size",
sessionname=self.display_id,
vnc_id="dummy_vnc",
choices=self.display_dlg.choices)
else:
display_session = self.remote_connection_manager.new(
queue=self.display_dlg.session_queue,
geometry=self.display_dlg.display_size,
sessionname=self.display_id,
vnc_id=self.display_dlg.session_vnc,
choices=None)
self.signals.status.emit(Status.RUNNING)
self.display_widget.session = display_session
self.remote_connection_manager.submit(
display_session,
gui_cmd=self.display_widget.enable_connect_button)
logger.debug("Worker for display " + str(self.display_id) +
" finished")
except Exception as e:
self.signals.status.emit(Status.FINISHED)
logger.error("Exception: " + str(e) + " - " +
str(traceback.format_exc()))
def on_ok(self):
"""
:return: Return accept signal if the display name is unique
"""
session_line = self.findChild(QLineEdit, 'session_line')
display_name = str(session_line.text())
# if the display_name is empty, it is set to test
# if it is not empty we validate it using a regex
if not re.match(r'^[\w\_\s]{0,16}$', display_name):
logger.error("Invalid display name: only alphanumeric "
"plus underscore plus space characters "
"are allowed for a maximum of 16 characters")
return
if display_name == "":
self.display_name = "test"
else:
self.display_name = display_name
# if the display name already exists, it returns
if self.display_name in self.display_names:
logger.error("session " + str(self.display_name) +
" already exists")
return
self.session_queue = str(self.session_queue_combo.currentText())
self.session_vnc = str(self.session_vnc_combo.currentText())
self.display_size = str(self.display_combo.currentText())
# add a new display size if it's fine for us in the combobox for the next time
if self.display_size not in list(self.display_size_list):
if re.match(r'^\d{1,5}x\d{1,5}$', self.display_size):
self.display_size_list.appendleft(self.display_size)
else:
logger.error("Invalid display size")
return
# convert full screen in the format width x height
if self.display_size == "full_screen":
screen_width = QDesktopWidget().width()
screen_height = QDesktopWidget().height()
self.display_size = str(screen_width) + "x" + str(screen_height)
logger.info("session queue: " + self.session_queue + "; " +
"session vnc: " + self.session_vnc + "; " +
"display size: " + self.display_size + ";")
self.update_config_file()
self.accept()
