[X2Go-Commits] python-x2go.git - build-baikal (branch) updated: eff06124e17bf39b855097080cc6a851ba8fff46
X2Go dev team
git-admin at x2go.org
Wed Jan 8 15:29:08 CET 2014
The branch, build-baikal has been updated
via eff06124e17bf39b855097080cc6a851ba8fff46 (commit)
from 18385858e6fef356682e81f668faddfac864c395 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
-----------------------------------------------------------------------
Summary of changes:
x2go/client.py | 238 ++++++++++++++++++++--------------------
x2go/inifiles.py | 1 +
x2go/printing.py | 12 +--
x2go/profiles.py | 99 ++++++++++++++---
x2go/registry.py | 317 +++++++++---------------------------------------------
x2go/session.py | 5 +-
x2go/utils.py | 20 ++--
7 files changed, 274 insertions(+), 418 deletions(-)
The diff of changes is:
diff --git a/x2go/client.py b/x2go/client.py
index 4e97fa5..2eeee42 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -34,10 +34,11 @@ import copy
# Python X2go modules
from settings import X2goClientSettings
from printing import X2goClientPrinting
-from profiles import X2goClientSessions
+from profiles import X2goSessionProfiles
from registry import X2goSessionRegistry
from session import X2goSession, _X2GO_SESSION_OPTIONS
import log
+import utils
from defaults import LOCAL_HOME as _LOCAL_HOME
from defaults import X2GO_CLIENT_ROOTDIR as _X2GO_CLIENT_ROOTDIR
@@ -116,41 +117,38 @@ class X2goClient(object):
self.logger = copy.deepcopy(logger)
self.logger.tag = __NAME__
- self.session_registry = X2goSessionRegistry()
+ self.session_profiles = X2goSessionProfiles(logger=self.logger)
+ self.session_registry = X2goSessionRegistry(logger=self.logger)
- def get_username(self, profile_id):
+ def get_username(self, session_hash):
"""\
After a session has been setup up you can query the
username the sessions runs as.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_hash: the X2go session's UUID registry hash
+ @type session_hash: str
@return: the remote username the X2go session runs as
@rtype: str
"""
- return self.session_registry(profile_id).session_object.get_transport().get_username()
+ return self.session_registry(session_hash).session_object.get_transport().get_username()
- def get_server(self, profile_id):
+ def get_server(self, session_hash):
"""\
After a session has been setup up you can query the
hostname of the host the sessions is connected to (or
about to connect to).
- @param profile_id: the X2go sessions UUID registry hash
- @type profile_id: str
+ @param session_hash: the X2go sessions UUID registry hash
+ @type session_hash: str
@return: the host an X2go session is connected to
(as an C{(addr,port)} tuple)
@rtype: tuple
"""
- return self.session_registry(profile_id).session_object.get_transport().getpeername()
-
- ###
- ### SESSION ORIENTED CODE
- ###
+ return self.session_registry(session_hash).session_object.get_transport().getpeername()
def register_session(self, server=None, profile_id=None, profile_name=None, custom_profile_name=None,
printing=False, share_local_folders=[], **kwargs):
@@ -178,44 +176,38 @@ class X2goClient(object):
@rtype: str
"""
- if profile_id and self.session_registry.has_profile_id(profile_id):
+ if profile_id and self.session_profiles.has_profile_id(profile_id):
_p = profile_id
- elif profile_name and self.session_registry.has_profile_name(profile_name):
+ elif profile_name and self.session_profiles.has_profile_name(profile_name):
_p = profile_name
else:
_p = None
if _p:
- kwargs = self.session_registry.get_session_params(_p)
- profile_id = self.session_registry(_p).profile_id
+ _profile_id = self.session_profiles.check_profile_id_or_name(_p)
+ _profile_name = self.session_profiles.to_profile_name(_profile_id)
+ _params = self.session_profiles.to_session_params(_profile_id)
+ del _params['profile_name']
+
else:
if server is None:
return None
+ _profile_id = utils._genSessionProfileId()
_profile_name = profile_name or custom_profile_name or sys.args[0]
- kwargs['server'] = server
- kwargs['printing'] = printing
- kwargs['share_local_folders'] = share_local_folders
+ _params = kwargs
+ _params['server'] = server
+ _params['printing'] = printing
+ _params['share_local_folders'] = share_local_folders
- profile_id = self.session_registry.register_by_session_params(_profile_name, **kwargs)
+ session_uuid = self.session_registry.register(_profile_id, _profile_name, **_params )
- connect_options = self.session_registry(profile_id).connect_options
- session_options = self.session_registry(profile_id).session_options
+ connect_options = self.session_registry(session_uuid).connect_options
+ session_options = self.session_registry(session_uuid).session_options
self.logger('initializing X2go session...', log.loglevel_NOTICE)
+ return session_uuid
- self.logger('X2go session options are:', log.loglevel_DEBUG)
- for k in session_options:
- self.logger(' %s: %s' % (k, session_options[k]), log.loglevel_DEBUG)
-
- self.logger('Paramiko connect options are:', log.loglevel_DEBUG)
- for k in connect_options:
- self.logger(' %s: %s' % (k,connect_options[k]), log.loglevel_DEBUG)
-
- # setup X2go session
- session = X2goSession(logger=self.logger, **session_options)
- return self.session_registry(profile_id).uuid
-
- def get_session(self, profile_id):
+ def get_session(self, session_uuid):
"""\
Retrieve the complete X2goSession object that has been
registry under the given sesion registry hash.
@@ -227,10 +219,10 @@ class X2goClient(object):
@rtype: obj
"""
- return self.session_registry(profile_id).session_object
+ return self.session_registry(session_uuid).session_object
with_session = get_session
- def get_session_name(self, profile_id):
+ def get_session_name(self, session_uuid):
"""\
Retrieve the server-side X2go session name for the session that has
been registered under C{profile_id}.
@@ -242,16 +234,16 @@ class X2goClient(object):
@rtype: str
"""
- return self.session_registry(profile_id).session_object.session_info
+ return self.session_registry(session_uuid).session_object.session_info
- def __connect_session(self, profile_id, password=None, add_to_known_hosts=False, force_password_auth=False):
+ def __connect_session(self, session_uuid, password=None, add_to_known_hosts=False, force_password_auth=False):
"""\
- Connect to a registered X2go session with registry hash C{<profile_id>}.
+ Connect to a registered X2go session with registry hash C{<session_uuid>}.
This method basically wraps around paramiko.SSHClient.connect() for the
corresponding session.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@param password: the user's password for the X2go server that is going to be
connected to
@type password: str
@@ -264,34 +256,34 @@ class X2goClient(object):
@type force_password_auth: bool
"""
- session = self.session_registry(profile_id).session_object
- server = self.session_registry(profile_id).server
- connect_options = self.session_registry(profile_id).connect_options
+ session = self.session_registry(session_uuid).session_object
+ server = self.session_registry(session_uuid).server
+ connect_options = self.session_registry(session_uuid).connect_options
connect_options['password'] = password
connect_options['force_password_auth'] = force_password_auth
session.connect(server, **connect_options)
- self.session_registry(profile_id).connected = True
+ self.session_registry(session_uuid).connected = True
connect_session = __connect_session
- def __session_print_action(self, profile_id, print_action, **kwargs):
+ def __session_print_action(self, session_uuid, print_action, **kwargs):
"""\
STILL UNDOCUMENTED
"""
if type(print_action) is not types.StringType:
return False
- self.with_session(profile_id).set_print_action(print_action, **kwargs)
+ self.with_session(session_uuid).set_print_action(print_action, **kwargs)
session_print_action = __session_print_action
- def __start_session(self, profile_id):
+ def __start_session(self, session_uuid):
"""\
Start a new X2go session on the remote X2go server.
- @param profile_id: the X2go sessions UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go sessions UUID registry hash
+ @type session_uuid: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
session.start()
@@ -299,59 +291,59 @@ class X2goClient(object):
session.start_sound()
session.start_sshfs()
- if self.session_registry(profile_id).printing:
+ if self.session_registry(session_uuid).printing:
session.start_printing()
- if self.session_registry(profile_id).share_local_folders:
+ if self.session_registry(session_uuid).share_local_folders:
if session.get_transport().reverse_tunnels['sshfs'][1] is not None:
- for _folder in self.session_registry(profile_id).share_local_folders:
+ for _folder in self.session_registry(session_uuid).share_local_folders:
session.share_local_folder(_folder)
session.run_command()
- self.session_registry(profile_id).running = True
+ self.session_registry(session_uuid).running = True
start_session = __start_session
- def __clean_sessions(self, profile_id):
+ def __clean_sessions(self, session_uuid):
"""\
Find running X2go sessions that have been standard by the connected
user and terminate them.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
session_infos = session.list_sessions()
for session_info in session_infos.values():
session.terminate(session_name=session_info)
clean_sessions = __clean_sessions
- def __list_sessions(self, profile_id):
+ def __list_sessions(self, session_uuid):
"""\
- Use the X2go session registered under C{profile_id} to
+ Use the X2go session registered under C{session_uuid} to
retrieve a list of running or suspended X2go sessions on the
connected X2go server (for the authenticated user).
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
return session.list_sessions()
list_sessions = __list_sessions
- def __resume_session(self, profile_id, session_name):
+ def __resume_session(self, session_uuid, session_name):
"""\
Resume or continue a suspended / running X2go session on the
remote X2go server.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@param session_name: the server-side name of an X2go session
@type session_name: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
session.associate(session_name)
session.resume()
@@ -359,13 +351,13 @@ class X2goClient(object):
session.start_sound()
session.start_sshfs()
- if self.session_registry(profile_id).printing:
+ if self.session_registry(session_uuid).printing:
session.start_printing()
- self.session_registry(profile_id).running = True
+ self.session_registry(session_uuid).running = True
resume_session = __resume_session
- def __suspend_session(self, profile_id, session_name=None):
+ def __suspend_session(self, session_uuid, session_name=None):
"""\
Suspend an X2go session.
@@ -376,22 +368,22 @@ class X2goClient(object):
registering an X2go server session and then passing the
server-side X2go session name to this method.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@param session_name: the server-side name of an X2go session
@type session_name: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
if session_name:
session.associate(session_name)
session.suspend(session_name=session_name)
if session_name is None:
- self.session_registry(profile_id).running = False
- self.session_registry(profile_id).suspended = True
+ self.session_registry(session_uuid).running = False
+ self.session_registry(session_uuid).suspended = True
suspend_session = __suspend_session
- def __terminate_session(self, profile_id, session_name=None):
+ def __terminate_session(self, session_uuid, session_name=None):
"""\
Terminate an X2go session.
@@ -402,34 +394,46 @@ class X2goClient(object):
registering an X2go server session and then passing the
server-side X2go session name to this method.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@param session_name: the server-side name of an X2go session
@type session_name: str
"""
- session = self.session_registry(profile_id).session_object
+ session = self.session_registry(session_uuid).session_object
if session_name:
session.associate(session_name=session_name)
session.terminate()
if session_name is None:
- self.session_registry(profile_id).running = False
- self.session_registry(profile_id).suspended = False
- self.session_registry(profile_id).terminated = True
+ self.session_registry(session_uuid).running = False
+ self.session_registry(session_uuid).suspended = False
+ self.session_registry(session_uuid).terminated = True
terminate_session = __terminate_session
###
### PROFILE ORIENTED CODE
###
- def __load_session_profiles(self):
+ def __has_session_profile(self, profile_name):
+ """\
+ STILL UNDOCUMENTED
+
+
+ """
+ return self.session_profiles.has_profile(profile_name)
+ has_session_profile = __has_session_profile
+
+ def __get_session_profiles(self):
"""\
STILL UNDOCUMENTED
"""
- self.session_registry.read_session_profiles()
- load_session_profiles = __load_session_profiles
+ _ret = {}
+ for _profile_id in self.session_profiles.profile_ids:
+ _ret[_profile_id] = self.session_profiles.get_profile_config()
+ return _ret
+ get_session_profiles = __get_session_profiles
# def new_session_profile(self, profile_name='NEW_SESSION_PROFILE', **kwargs):
# """\
@@ -461,7 +465,7 @@ class X2goClient(object):
# return self.session_registry[session_hash]['profile']
# with_profile = get_session_profile
#
- def get_session_profile_name(self, profile_id):
+ def get_session_profile_name(self, session_uuid):
"""\
Retrieve the profile name of the session that has been registered
under C{session_hash}
@@ -474,7 +478,7 @@ class X2goClient(object):
@rtype: str
"""
- return self.session_registry(profile_id).profile_name
+ return self.session_registry(session_uuid).profile_name
get_profile_name = get_session_profile_name
def get_session_profile_id(self, profile_name):
@@ -496,80 +500,80 @@ class X2goClient(object):
### QUERYING INFORMATION
###
- def __session_ok(self, profile_id):
+ def __session_ok(self, session_uuid):
"""\
- Test if the X2go session registered as C{profile_id} is
+ Test if the X2go session registered as C{session_uuid} is
in a healthy state.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@return: C{True} if session is ok, C{False} otherwise
@rtype: bool
"""
- return self.with_session(profile_id).ok()
+ return self.with_session(session_uuid).ok()
session_ok = __session_ok
- def __is_running(self, profile_id):
+ def __is_running(self, session_uuid):
"""\
- Test if the X2go session registered as C{profile_id} is up
+ Test if the X2go session registered as C{session_uuid} is up
and running.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@return: C{True} if session is running, C{False} otherwise
@rtype: bool
"""
- return self.with_session(profile_id).is_running()
+ return self.with_session(session_uuid).is_running()
is_running = __is_running
- def __is_suspended(self, profile_id):
+ def __is_suspended(self, session_uuid):
"""\
- Test if the X2go session registered as C{profile_id}
+ Test if the X2go session registered as C{session_uuid}
is in suspended state.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@return: C{True} if session is suspended, C{False} otherwise
@rtype: bool
"""
- return self.with_session(profile_id).is_suspended()
+ return self.with_session(session_uuid).is_suspended()
is_suspended = __is_suspended
- def __has_terminated(self, profile_id):
+ def __has_terminated(self, session_uuid):
"""\
- Test if the X2go session registered as C{profile_id}
+ Test if the X2go session registered as C{session_uuid}
has terminated.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@return: C{True} if session has terminated, C{False} otherwise
@rtype: bool
"""
- return self.with_session(profile_id).has_terminated()
+ return self.with_session(session_uuid).has_terminated()
has_terminated = __has_terminated
- def __share_local_folder(self, profile_id, folder_name):
+ def __share_local_folder(self, session_uuid, folder_name):
"""\
- Share a local folder with the X2go session registered as C{profile_id}.
+ Share a local folder with the X2go session registered as C{session_uuid}.
- @param profile_id: the X2go session's UUID registry hash
- @type profile_id: str
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
@param folder_name: the full path to an existing folder on the local
file system
@type folder_name: str
@return: returns C{True} if the local folder has been successfully mounted within the
- X2go server session registerd as UUID C{profile_id}
+ X2go server session registerd as UUID C{session_uuid}
@rtype: bool
"""
- return self.with_session(profile_id).share_local_folder(folder_name=folder_name)
+ return self.with_session(session_uuid).share_local_folder(folder_name=folder_name)
share_local_folder = __share_local_folder
diff --git a/x2go/inifiles.py b/x2go/inifiles.py
index e0a8c2a..fead74c 100644
--- a/x2go/inifiles.py
+++ b/x2go/inifiles.py
@@ -34,6 +34,7 @@ import os
import ConfigParser
import types
import cStringIO
+import copy
# Python X2go modules
from defaults import LOCAL_HOME as _current_home
diff --git a/x2go/printing.py b/x2go/printing.py
index b39c960..ccf373f 100644
--- a/x2go/printing.py
+++ b/x2go/printing.py
@@ -87,23 +87,23 @@ class X2goClientPrinting(inifiles.X2goIniFile):
STILL UNDOCUMENTED
"""
- _general_pdfview = self.getValue('General', 'pdfview', key_type=types.BooleanType)
- _view_open = self.getValue('view', 'open', key_type=types.BooleanType)
- _print_startcmd = self.getValue('print', 'startcmd', key_type=types.BooleanType)
+ _general_pdfview = self.get('General', 'pdfview', key_type=types.BooleanType)
+ _view_open = self.get('view', 'open', key_type=types.BooleanType)
+ _print_startcmd = self.get('print', 'startcmd', key_type=types.BooleanType)
if _general_pdfview and _view_open:
- _view_command = self.getValue('view', 'command')
+ _view_command = self.get('view', 'command')
self._print_action = X2goPrintActionPDFVIEW(pdf_viewer_command=_view_command, logger=self.logger)
elif _general_pdfview and not _view_open:
self._print_action = X2goPrintActionPDFSAVE(logger=self.logger)
elif not _general_pdfview and not _print_startcmd:
- _cups_defaultprinter = self.getValue('CUPS', 'defaultprinter')
+ _cups_defaultprinter = self.get('CUPS', 'defaultprinter')
self._print_action = X2goPrintActionPRINT(default_printer=_cups_defaultprinter, logger=self.logger)
elif not _general_pdfview and _print_startcmd:
- _print_command = self.getValue('print', 'command')
+ _print_command = self.get('print', 'command')
self._print_action = X2goPrintActionPRINTCMD(print_cmd=_print_command, logger=self.logger)
@property
diff --git a/x2go/profiles.py b/x2go/profiles.py
index 2ba13dc..81c0c2f 100644
--- a/x2go/profiles.py
+++ b/x2go/profiles.py
@@ -22,6 +22,7 @@ X2goClientSessionProfile class - managing x2goclient session profiles.
"""
__NAME__ = 'x2gosessionprofiles-pylib'
+import copy
# Python X2go modules
from defaults import X2GO_SESSIONPROFILES_CONFIGFILES
@@ -32,7 +33,7 @@ import utils
from x2go_exceptions import X2goProfileException
-class X2goClientSessions(inifiles.X2goIniFile):
+class X2goSessionProfiles(inifiles.X2goIniFile):
defaultValues = {}
defaultSessionProfile = X2GO_SESSIONPROFILE_DEFAULTS
@@ -43,6 +44,12 @@ class X2goClientSessions(inifiles.X2goIniFile):
STILL UNDOCUMENTED
"""
+ if logger is None:
+ self.logger = log.X2goLogger(loglevel=loglevel)
+ else:
+ self.logger = copy.deepcopy(logger)
+ self.logger.tag = __NAME__
+
# providing defaults for an X2goSessionProfiles instance will---in the worst case---override your
# existing sessions file in your home directory once you write the sessions back to file...
inifiles.X2goIniFile.__init__(self, config_files, defaults=defaults, logger=logger, loglevel=loglevel)
@@ -57,24 +64,38 @@ class X2goClientSessions(inifiles.X2goIniFile):
self._storeValue(session_profile, key, default_value)
self._updateDataObject()
- def get_profile_config(self, profile_id):
+ def __call__(self, profile_id_or_name):
"""\
STILL UNDOCUMENTED
"""
- if (not profile_id in self.profile_ids) or (profile_id in self._non_profile_sections):
- raise X2goProfileException('No X2go session profile with Id %s' % profile_id)
- _profile_config = {}
- for key in self.iniConfig.options(profile_id):
- _profile_config[key] = self.get(profile_id, key, key_type=self.get_type(key))
- return _profile_config or None
+ _profile_id = check_profile_id_or_name(self, profile_id_or_name)
+ return self.get_profile_config(_profile_id)
+
+ def get_profile_option_type(self, option):
+ """\
+ STILL UNDOCUMENTED
- def get_type(self, key):
+ """
+ return type(self.defaultSessionProfile[option])
+
+ def get_profile_config(self, profile_id_or_name):
"""\
STILL UNDOCUMENTED
"""
- return type(self.defaultSessionProfile[key])
+ _profile_id = self.check_profile_id_or_name(profile_id_or_name)
+ _profile_config = {}
+ for option in self.iniConfig.options(_profile_id):
+ _profile_config[option] = self.get(_profile_id, option, key_type=self.get_profile_option_type(option))
+ return _profile_config or None
+
+ def has_profile(self, profile_id_or_name):
+ try:
+ _profile_id = self.check_profile_id_or_name(profile_id_or_name)
+ return True
+ except X2goProfileException:
+ return False
@property
def profile_ids(self):
@@ -84,20 +105,34 @@ class X2goClientSessions(inifiles.X2goIniFile):
"""
return [ s for s in self.iniConfig.sections() if s not in self._non_profile_sections ]
+ def has_profile_id(self, profile_id):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ return profile_id in self.profile_ids
+
@property
def profile_names(self):
"""\
STILL UNDOCUMENTED
"""
- return [ self.get_profile_name(p) for p in self.profile_ids ]
+ return [ self.to_profile_name(p) for p in self.profile_ids ]
- def get_profile_id(self, profile_name):
+ def has_profile_name(self, profile_name):
"""\
STILL UNDOCUMENTED
"""
- _profile_ids = [ p for p in self.profile_ids if self.get_profile_name(p) == profile_name ]
+ return profile_name in self.profile_names
+
+ def to_profile_id(self, profile_name):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ _profile_ids = [ p for p in self.profile_ids if self.to_profile_name(p) == profile_name ]
if len(_profile_ids) == 1:
return _profile_ids[0]
elif len(_profile_ids) == 0:
@@ -105,7 +140,7 @@ class X2goClientSessions(inifiles.X2goIniFile):
else:
raise X2goProfileException('The sessions config file contains multiple session profiles with name: %s' % profile_name)
- def get_profile_name(self, profile_id):
+ def to_profile_name(self, profile_id):
"""\
STILL UNDOCUMENTED
@@ -136,4 +171,40 @@ class X2goClientSessions(inifiles.X2goIniFile):
self.write_user_config = True
self.writeIniFile()
+ def has_default_profile(self):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ return self.get_default_profile() and True or False
+ def get_default_profile(self):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ return '...'
+
+ def check_profile_id_or_name(self, profile_id_or_name):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ _profile_id = None
+ if self.has_profile_id(profile_id_or_name):
+ # we were given a session profile id...
+ _profile_id = profile_id_or_name
+ elif self.has_profile_name(profile_id_or_name):
+ # we were given a sesion profile name...
+ _profile_id = self.to_profile_id(profile_id_or_name)
+ if not _profile_id:
+ raise X2goProfileException('No session profile with id or name %s exists.' % profile_id_or_name)
+ return _profile_id
+
+ def to_session_params(self, profile_id_or_name):
+ """\
+ STILL UNDOCUMENTED
+
+ """
+ _profile_id = self.check_profile_id_or_name(profile_id_or_name)
+ return utils._convert_SessionProfileOptions_2_SessionParams(self.get_profile_config(_profile_id))
\ No newline at end of file
diff --git a/x2go/registry.py b/x2go/registry.py
index feaee77..cb2e178 100644
--- a/x2go/registry.py
+++ b/x2go/registry.py
@@ -34,13 +34,13 @@ import session
from x2go_exceptions import *
-class X2goRegistryProfile(object):
+class X2goRegisteredSession(object):
def __init__(self):
self.uuid = uuid.uuid1()
def __str__(self):
- return '%s - %s (%s)' % (self.uuid, self.profile_name, self.profile_id, )
+ return self.uuid
def __repr__(self):
- result = 'X2goRegistryProfile('
+ result = 'X2goRegistrySession('
for p in dir(self):
if '__' in p or not p in self.__dict__ or type(p) is types.InstanceType: continue
result += p + '=' + str(self.__dict__[p]) + ', '
@@ -60,11 +60,10 @@ class X2goSessionRegistry(object):
if logger is None:
self.logger = log.X2goLogger(loglevel=loglevel)
else:
- self.logger = logger
+ self.logger = copy.deepcopy(logger)
self.logger.tag = __NAME__
self.registry = {}
- self.profiles = profiles.X2goClientSessions(logger=logger)
def __repr__(self):
result = 'X2goSessionRegistry('
@@ -73,17 +72,6 @@ class X2goSessionRegistry(object):
result += p + '=' + str(self.__dict__[p])
return result + ')'
- def read_session_profiles(self):
- """\
- STILL UNDOCUMENTED
-
- """
- # import sessions file into registry
- for profile_id in self.profiles.profile_ids:
- profile_name = self.profiles.get_profile_name(profile_id)
- profile_config = self.profiles.get_profile_config(profile_id)
- self.register_by_profile_config(profile_name, profile_id=profile_id, **profile_config)
-
def __call__(self, session_uuid):
"""\
STILL UNDOCUMENTED
@@ -96,227 +84,62 @@ class X2goSessionRegistry(object):
STILL UNDOCUMENTED
"""
- _profile_ids = [ p for p in self.profile_ids if self.get_profile_name(p) == profile_name ]
- if len(_profile_ids) == 1:
- return _profile_ids[0]
- elif len(_profile_ids) == 0:
- return None
- else:
- raise X2goProfileException('The session registry contains multiple session profiles with name: %s.' % profile_name)
+ return self(session_uid).profile.profile_id
def get_profile_name(self, session_uuid):
"""\
STILL UNDOCUMENTED
"""
- return self.registry[profile_id].profile_name
-
- @property
- def profile_names(self):
- """\
- STILL UNDOCUMENTED
-
- """
- return [ self.registry[profile_id].profile_name for profile_id in self.registry.keys() ]
-
- @property
- def profile_ids(self):
- """\
- STILL UNDOCUMENTED
-
- """
- return self.registry.keys()
-
- def has_profile_name(self, profile_name):
- """\
- STILL UNDOCUMENTED
-
- """
- return profile_name in self.profile_names
-
- def has_profile_id(self, profile_id):
- """\
- STILL UNDOCUMENTED
-
- """
- return profile_id in self.registry.keys()
-
- def _check_profile_id_or_name(self, profile_id_or_name):
- """\
- STILL UNDOCUMENTED
-
- """
- _profile_id = None
- if self.has_profile_id(profile_id_or_name):
- # we were given a session profile id...
- _profile_id = profile_id_or_name
- elif self.has_profile_name(profile_id_or_name):
- # we were given a sesion profile name...
- _profile_id = self.get_profile_id(profile_id_or_name)
- if not _profile_id:
- raise X2goProfileException('No session profile with id or name %s exists.' % profile_id_or_name)
- return _profile_id
-
- def get_profile_config(self, profile_id_or_name):
- """\
- STILL UNDOCUMENTED
-
- """
- _profile_id = self._check_profile_id_or_name(profile_id_or_name)
- return self.registry[_profile_id].config
-
- def get_session_params(self, profile_id_or_name):
- """\
- STILL UNDOCUMENTED
-
- """
- _profile_id = self._check_profile_id_or_name(profile_id_or_name)
- return self.registry[_profile_id].session_params
+ return self(session_uuid).profile.profile_name
- def has_default_profile(self):
- """\
- STILL UNDOCUMENTED
+ def register(self, profile_id, profile_name, **kwargs):
- """
- return self.get_default() and True or False
+ _r = X2goRegisteredSession()
+ session_uuid = _r.uuid
+ self.registry[session_uuid] = _r
+ self(session_uuid).profile_id = profile_id
+ self(session_uuid).profile_name = profile_name
+ self(session_uuid).session_params = kwargs
+ self(session_uuid).server = kwargs['server']
+ del kwargs['server']
+ self(session_uuid).printing = kwargs['printing']
+ del kwargs['printing']
+ self(session_uuid).share_local_folders = kwargs['share_local_folders']
+ del kwargs['share_local_folders']
+ self(session_uuid).session_params = kwargs
+ # differentiate SSH options from X2go options
+ _session_options = copy.deepcopy(kwargs)
+ _connect_options = copy.deepcopy(kwargs)
- def get_default_profile(self):
- """\
- STILL UNDOCUMENTED
+ for k in kwargs.keys():
+ if k in session._X2GO_SESSION_OPTIONS:
+ del _connect_options[k]
+ else:
+ del _session_options[k]
- """
- return '...'
+ self.logger('registering X2go session %s...' % profile_name, log.loglevel_NOTICE)
+ self.logger('registering X2go session with UUID %s' % session_uuid, log.loglevel_DEBUG)
+ self.logger('X2go session options for profile %s:' % profile_name, log.loglevel_DEBUG)
+ for k in _session_options:
+ self.logger(' %s: %s' % (k, _session_options[k]), log.loglevel_DEBUG)
- def register_by_profile_config(self, profile_name, profile_id=None, **config):
- """\
- STILL UNDOCUMENTED
+ self.logger('Paramiko connect options for profile %s are:' % profile_name, log.loglevel_DEBUG)
+ for k in _connect_options:
+ self.logger(' %s: %s' % (k,_connect_options[k]), log.loglevel_DEBUG)
- """
- if self.has_profile_name(profile_name):
- raise X2goProfileException('X2go session profile %s already exists.' % profile_name)
- else:
- if not profile_id:
- profile_id = utils._genSessionProfileId()
- self.profiles.add_profile(profile_id, **config)
- _config = self.profiles.get_profile_config(profile_id)
- self.registry[profile_id] = X2goRegistryProfile()
- self.registry[profile_id].profile_id = profile_id
- self.registry[profile_id].profile_name = profile_name
- self.registry[profile_id].profile_config = _config
- _params = utils._convert_config2params(config)
- self.registry[profile_id].server = _params['server']
- del _params['server']
- self.registry[profile_id].printing = _params['printing']
- del _params['printing']
- self.registry[profile_id].share_local_folders = _params['share_local_folders']
- del _params['share_local_folders']
- self.registry[profile_id].session_params = _params
- # differentiate SSH options from X2go options
- _session_options = copy.deepcopy(_params)
- _connect_options = copy.deepcopy(_params)
-
- for k in _params.keys():
- if k in session._X2GO_SESSION_OPTIONS:
- del _connect_options[k]
- else:
- del _session_options[k]
-
- self.logger('loading X2go profile %s...' % profile_name, log.loglevel_NOTICE)
-
- self.logger('X2go session options for profile %s:' % profile_name, log.loglevel_DEBUG)
- for k in _session_options:
- self.logger(' %s: %s' % (k, _session_options[k]), log.loglevel_DEBUG)
-
- self.logger('Paramiko connect options for profile %s are:' % profile_name, log.loglevel_DEBUG)
- for k in _connect_options:
- self.logger(' %s: %s' % (k,_connect_options[k]), log.loglevel_DEBUG)
-
- self.registry[profile_id].session_object = session.X2goSession(**_session_options)
- self.registry[profile_id].connected = False
- self.registry[profile_id].running = False
- self.registry[profile_id].suspended = False
- self.registry[profile_id].terminated = False
- self.registry[profile_id].connect_options = _connect_options
- self.registry[profile_id].session_options = _session_options
-
- return self.registry[profile_id].uuid
-
- def register_by_session_params(self, profile_name, profile_id=None, **params):
- """\
- STILL UNDOCUMENTED
+ self(session_uuid).session_object = session.X2goSession(logger=self.logger, **_session_options)
+ self(session_uuid).connected = False
+ self(session_uuid).running = False
+ self(session_uuid).suspended = False
+ self(session_uuid).terminated = False
+ self(session_uuid).connect_options = _connect_options
+ self(session_uuid).session_options = _session_options
- """
- if self.has_profile_name(profile_name):
- raise X2goProfileException('X2go session profile %s already exists.' % profile_name)
- else:
- if not profile_id:
- profile_id = utils._genSessionProfileId()
- ### TODO
- #_config = utils._convert_params2config(params)
- #self.profiles.add_profile(profile_id, **_config)
- _config = None
- self.registry[profile_id] = X2goRegistryProfile()
- self.registry[profile_id].profile_id = profile_id
- self.registry[profile_id].profile_name = profile_name
- self.registry[profile_id].profile_config = _config
- self.registry[profile_id].server = params['server']
- del params['server']
- self.registry[profile_id].printing = params['printing']
- del params['printing']
- self.registry[profile_id].share_local_folders = params['share_local_folders']
- del params['share_local_folders']
- self.registry[profile_id].session_params = params
- # differentiate SSH options from X2go options
- _session_options = copy.deepcopy(params)
- _connect_options = copy.deepcopy(params)
-
- for k in params.keys():
- if k in session._X2GO_SESSION_OPTIONS:
- del _connect_options[k]
- else:
- del _session_options[k]
-
- self.logger('initializing X2go profile %s...' % profile_name, log.loglevel_NOTICE)
-
- self.logger('X2go session options for profile %s:' % profile_name, log.loglevel_DEBUG)
- for k in _session_options:
- self.logger(' %s: %s' % (k, _session_options[k]), log.loglevel_DEBUG)
-
- self.logger('Paramiko connect options for profile %s are:' % profile_name, log.loglevel_DEBUG)
- for k in _connect_options:
- self.logger(' %s: %s' % (k,_connect_options[k]), log.loglevel_DEBUG)
-
- self.registry[profile_id].session_object = session.X2goSession(**_session_options)
- self.registry[profile_id].connected = False
- self.registry[profile_id].running = False
- self.registry[profile_id].suspended = False
- self.registry[profile_id].terminated = False
- self.registry[profile_id].connect_options = _connect_options
- self.registry[profile_id].session_options = _session_options
-
- return self.registry[profile_id].uuid
-
- def del_profile(self, profile_name):
- """\
- STILL UNDOCUMENTED
-
- """
- if not self.has_profile_name(profile_name):
- raise X2goProfileException('X2go session profile %s does not exist.' % profile_name)
- else:
- if self.registry[profile_id].connected:
- raise X2goProfileException('Cannot delete, X2go session profile is connected.' % profile_name)
- elif self.registry[profile_id].running:
- raise X2goProfileException('Cannot delete, X2go session profile is running.' % profile_name)
- else:
- del self.registry[profile_id]
+ return session_uuid
def _sessionsWithState(self, state):
- _x2go_single_profiles = []
- for p in self.registry.items():
- if getattr(p, state, False):
- _x2go_single_profiles.append(p)
- return _x2go_single_profiles
+ return [ session for session in self.registry.values() if eval('session.%s' % state) ]
@property
def connected_sessions(self):
@@ -359,15 +182,12 @@ class X2goSessionRegistry(object):
return len(self.running_sessions) > 0
@property
- def list_sessions(self):
+ def registered_sessions(self):
"""\
STILL UNDOCUMENTED
"""
- _available_sessions_profiles = []
- for p in self.registry.items():
- _available_session_profiles.append([p.name, p.running, p.isAlive ])
- return _available_session_profiles
+ return self.registry.values()
@property
def non_running_sessions(self):
@@ -375,46 +195,5 @@ class X2goSessionRegistry(object):
STILL UNDOCUMENTED
"""
- _non_running = []
- _running = self.runningSessions
- for p in self.registry.items():
- if p not in _running:
- _non_running.append(p)
- return _non_running
-
- @property
- def list_non_running_sessions_by_profile_id(self):
- """\
- STILL UNDOCUMENTED
-
- """
- return [ p.name for p in self.non_running_sessions ]
+ return [ s for s in self.registry.values() if s not in self.running_sessions ]
- def getX2goSessionByName(self, profile_name):
- """\
- STILL UNDOCUMENTED
-
- """
- return self.registry[self._profileName2ProfileIds(profile_name)].session
-
- def getX2goSessionById(self, profile_id):
- """\
- STILL UNDOCUMENTED
-
- """
- return self.registry[profile_id].session
-
- #def updProfileByNumber(self, profile):
- # """\
- # STILL UNDOCUMENTED
- #
- # """
- # counter = 0
- # for nameKeys in self.x2gonames.keys():
- # if counter == self.current_selected_profile_nr:
- # oldName = nameKeys
- # break
- # counter += 1
- # del self.x2gonames[oldName]
- # self.x2goprofs[self.current_selected_profile_nr] = profile
- # self.x2gonames[profile.name] = self.current_selected_profile_nr
\ No newline at end of file
diff --git a/x2go/session.py b/x2go/session.py
index 766d53b..7ea83e5 100644
--- a/x2go/session.py
+++ b/x2go/session.py
@@ -31,6 +31,7 @@ import gevent
import threading
import signal
import cStringIO
+import copy
# Python X2go modules
import proxy
@@ -359,7 +360,7 @@ class X2goSession(paramiko.SSHClient):
if logger is None:
self.logger = log.X2goLogger(loglevel=loglevel)
else:
- self.logger = logger
+ self.logger = copy.deepcopy(logger)
self.logger.tag = __NAME__
if proxy_class is None:
@@ -810,7 +811,7 @@ class X2goSession(paramiko.SSHClient):
_tmp_io_object.write('----BEGIN RSA IDENTITY----')
_tmp_io_object.write('%s %s' % (_host_rsakey.get_name(),_host_rsakey.get_base64(),))
- _x2go_key_fname = os.path.join(self.params.rootdir, 'ssh', 'key.z%s' % self.session_info.agent_pid)
+ _x2go_key_fname = os.path.join(os.path.dirname(self.session_info.remote_container), 'ssh', 'key.z%s' % self.session_info.agent_pid)
_x2go_key_bundle = _tmp_io_object.getvalue()
self._x2go_sftp_write(_x2go_key_fname, _x2go_key_bundle)
diff --git a/x2go/utils.py b/x2go/utils.py
index 0a822ba..cb5a2c7 100644
--- a/x2go/utils.py
+++ b/x2go/utils.py
@@ -105,9 +105,9 @@ def _checkSessionProfileDefaults(defaults):
return True
-def _convert_config2params(_config):
+def _convert_SessionProfileOptions_2_SessionParams(_options):
- _params = copy.deepcopy(_config)
+ _params = copy.deepcopy(_options)
_rename_dict = {
'host': 'server',
@@ -131,7 +131,7 @@ def _convert_config2params(_config):
'5': 'lan',
}
- for opt, val in _config.iteritems():
+ for opt, val in _options.iteritems():
# rename options if necessary
if opt in _rename_dict.keys():
@@ -155,7 +155,7 @@ def _convert_config2params(_config):
else:
_params[opt] = []
#del _params['export']
- if not _config['fstunnel']:
+ if not _options['fstunnel']:
_params[opt] = None
if not val:
@@ -168,26 +168,26 @@ def _convert_config2params(_config):
del _params['fstunnel']
- if not _config['fullscreen']:
- _params['geometry'] = '%sx%s' % (_config['width'], _config['height'])
+ if not _options['fullscreen']:
+ _params['geometry'] = '%sx%s' % (_options['width'], _options['height'])
else:
_params['geometry'] = 'fullscreen'
del _params['width']
del _params['height']
del _params['fullscreen']
- if not _config['sound']:
+ if not _options['sound']:
snd_system = 'none'
del _params['sound']
- if _config['rootless']:
+ if _options['rootless']:
_params['session_type'] = 'application'
else:
_params['session_type'] = 'desktop'
del _params['rootless']
# currently ignored in Python X2go, use it for client implementations
- _ignored_config_options = [
+ _ignored_options = [
'iconvto',
'iconvfrom',
'useiconv',
@@ -205,6 +205,6 @@ def _convert_config2params(_config):
'xdmcpserver',
'default',
]
- for i in _ignored_config_options:
+ for i in _ignored_options:
del _params[i]
return _params
\ No newline at end of file
hooks/post-receive
--
python-x2go.git (Python X2Go Client API)
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "python-x2go.git" (Python X2Go Client API).
More information about the x2go-commits
mailing list