[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