[X2Go-Commits] python-x2go.git - build-baikal (branch) updated: aaeba00c384aaf023617de8619c8668055550c93

X2Go dev team git-admin at x2go.org
Wed Jan 8 15:27:15 CET 2014


The branch, build-baikal has been updated
       via  aaeba00c384aaf023617de8619c8668055550c93 (commit)
      from  f4ff086c8d81ca375bc2f96e60a85138544b9b6b (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   |  393 +++++++++++++++++++++++++++++-------------------------
 x2go/printing.py |    2 +-
 x2go/profiles.py |    9 +-
 x2go/registry.py |  270 ++++++++++++++++++++++++++++++++++++-
 4 files changed, 489 insertions(+), 185 deletions(-)

The diff of changes is:
diff --git a/x2go/client.py b/x2go/client.py
index 8298b2f..1f5233f 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -40,7 +40,9 @@ from session import X2goSession, _X2GO_SESSION_OPTIONS
 import log
 import utils
 
+# we hide the default values from epydoc (that's why we transform them to _UNDERSCORE variables)
 from defaults import LOCAL_HOME as _LOCAL_HOME
+from defaults import CURRENT_LOCAL_USER as _CURRENT_LOCAL_USER
 from defaults import X2GO_CLIENT_ROOTDIR as _X2GO_CLIENT_ROOTDIR
 
 class X2goClient(object):
@@ -99,7 +101,10 @@ class X2goClient(object):
         x2go_client.terminate_session(x2go_profile_id)
 
     """
+    session_profiles = None
     session_registry = None
+    client_settings = None
+    client_printing = None
 
     def __init__(self, loglevel=log.loglevel_DEFAULT, logger=None, *args, **kwargs):
         """\
@@ -122,41 +127,22 @@ class X2goClient(object):
         self.client_settings = X2goClientSettings(logger=self.logger)
         self.client_printing = X2goClientPrinting(logger=self.logger)
 
-    def __get_username(self, session_hash):
+    def __get_client_username(self):
         """\
-        After a session has been setup up you can query the 
-        username the sessions runs as.
-
-        @param session_hash: the X2go session's UUID registry hash
-        @type session_hash: str
+        Query the local user's username.
 
-        @return: the remote username the X2go session runs as
+        @return: the local username this X2goClient instance runs as
         @rtype: str
 
         """
-        return self.session_registry(session_hash).session_object.get_transport().get_username()
-    get_username = __get_username
-
-    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 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(session_hash).session_object.get_transport().getpeername()
-    get_server = __get_server
+        return _CURRENT_LOCAL_USER
+    get_client_username = __get_client_username
 
     def __register_session(self, server=None, profile_id=None, profile_name=None, custom_profile_name=None, 
-                         printing=False, share_local_folders=[], **kwargs):
+                           printing=False, share_local_folders=[], return_object=False, **kwargs):
         """\
+        DOCUMENTATION OUT OF DATE
+
         Register a new X2go client session. Within one X2goClient 
         instance you can manage several sessions on serveral
         remote X2go servers under different user names.
@@ -209,9 +195,48 @@ class X2goClient(object):
         session_options = self.session_registry(session_uuid).session_options
 
         self.logger('initializing X2go session...', log.loglevel_NOTICE)
-        return session_uuid
+        if return_object:
+            return self(session_uuid)
+        else:
+            return session_uuid
     register_session = __register_session
 
+    ###
+    ### WRAPPER METHODS FOR X2goRegisteredSession objects
+    ###
+
+    def __get_session_username(self, session_uuid):
+        """\
+        After an X2go session has been setup up you can query the 
+        username the remote sessions runs as.
+
+        @param session_uuid: the X2go session's UUID registry hash
+        @type session_uuid: str
+
+        @return: the remote username the X2go session runs as
+        @rtype: str
+
+        """
+        return self.session_registry(session_uuid).get_username()
+    get_session_username = __get_session_username
+
+    def __get_session_server(self, session_uuid):
+        """\
+        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 session_uuid: the X2go sessions UUID registry hash
+        @type session_uuid: str
+
+        @return: the host an X2go session is connected to 
+            (as an C{(addr,port)} tuple) 
+        @rtype: tuple
+
+        """
+        return self.session_registry(session_uuid).get_server()
+    get_session_server = __get_session_server
+
     def __get_session(self, session_uuid):
         """\
         Retrieve the complete X2goSession object that has been 
@@ -233,14 +258,14 @@ class X2goClient(object):
         Retrieve the server-side X2go session name for the session that has
         been registered under C{profile_id}.
 
-        @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: X2go session name
         @rtype: str
 
         """
-        return self.session_registry(session_uuid).session_object.session_info
+        return self.session_registry(session_uuid).get_session_name()
     get_session_name = __get_session_name
 
     def __connect_session(self, session_uuid, password=None, add_to_known_hosts=False, force_password_auth=False):
@@ -263,13 +288,10 @@ class X2goClient(object):
         @type force_password_auth: bool
 
         """
-        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(session_uuid).connected = True
+        self.session_registry(session_uuid).connect(password=password, 
+                                                    add_to_known_hosts=add_to_known_hosts, 
+                                                    force_password_auth=force_password_auth
+                                                   )
     connect_session = __connect_session
 
     def __set_session_print_action(self, session_uuid, print_action, **kwargs):
@@ -277,9 +299,7 @@ class X2goClient(object):
         STILL UNDOCUMENTED
 
         """
-        if type(print_action) is not types.StringType:
-            return False
-        self.with_session(session_uuid).set_print_action(print_action, **kwargs)
+        self.session_registry(session_uuid).set_print_action(print_action=print_action, **kwargs)
     set_session_print_action = __set_session_print_action
 
     def __start_session(self, session_uuid):
@@ -290,55 +310,9 @@ class X2goClient(object):
         @type session_uuid: str
 
         """
-        session = self.session_registry(session_uuid).session_object
-
-        session.start()
-
-        if session.params.snd_system is not 'none':
-            session.start_sound()
-
-        session.start_sshfs()
-        if self.session_registry(session_uuid).printing:
-            session.start_printing()
-
-        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(session_uuid).share_local_folders:
-                    session.share_local_folder(_folder)
-
-        session.run_command()
-        self.session_registry(session_uuid).running = True
+        self.session_registry(session_uuid).start()
     start_session = __start_session
 
-    def __clean_sessions(self, session_uuid):
-        """\
-        Find running X2go sessions that have been standard by the connected
-        user and terminate them.
-
-        @param session_uuid: the X2go session's UUID registry hash
-        @type session_uuid: str
-
-        """
-        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, session_uuid):
-        """\
-        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 session_uuid: the X2go session's UUID registry hash
-        @type session_uuid: str
-
-        """
-        session = self.session_registry(session_uuid).session_object
-        return session.list_sessions()
-    list_sessions = __list_sessions
-
     def __resume_session(self, session_uuid, session_name):
         """\
         Resume or continue a suspended / running X2go session on the 
@@ -381,13 +355,13 @@ class X2goClient(object):
         @type session_name: str
 
         """
-        session = self.session_registry(session_uuid).session_object
         if session_name:
+            # suspend a non-registered session by session name
+            session = self.session_registry(session_uuid).session_object
             session.associate(session_name)
-        session.suspend(session_name=session_name)
-        if session_name is None:
-            self.session_registry(session_uuid).running = False
-            self.session_registry(session_uuid).suspended = True
+            session.suspend(session_name=session_name)
+        else:
+            self.session_registry(session_uuid).suspend()
     suspend_session = __suspend_session
 
     def __terminate_session(self, session_uuid, session_name=None):
@@ -407,100 +381,44 @@ class X2goClient(object):
         @type session_name: str
 
         """
-        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(session_uuid).running = False
-            self.session_registry(session_uuid).suspended = False
-            self.session_registry(session_uuid).terminated = True
+            # terminate a non-registered session by session name
+            session = self.session_registry(session_uuid).session_object
+            session.associate(session_name)
+            session.terminate(session_name=session_name)
+        else:
+            self.session_registry(session_uuid).terminate()
     terminate_session = __terminate_session
 
-    ###
-    ### Session profile oriented methods
-    ### 
-
-    def __get_profile(self, session_uuid):
+    def __get_session_profile_name(self, session_uuid):
         """\
-        Retrieve the complete X2goSession object that has been 
-        registry under the given sesion registry hash.
+        Retrieve the profile name of the session that has been registered
+        under C{session_uuid}
 
         @param session_uuid: the X2go session's UUID registry hash
         @type session_uuid: str
 
-        @return: the L{X2goSession} object
-        @rtype: obj
-
-        """
-        return self.session_registry[session_hash]['profile']
-    get_profile = __get_profile
-    with_profile = __get_profile
-
-    def __get_profile_name(self, session_uuid):
-        """\
-        Retrieve the profile name of the session that has been registered
-        under C{session_hash}
-
-
-        @param session_hash: the X2go session's UUID registry hash
-        @type session_hash: str
-
         @return: X2go client profile name of the session
         @rtype: str
 
         """
-        return self.session_registry(session_uuid).profile_name
-    get_profile_name = __get_profile_name
+        return self.session_registry(session_uuid).get_profile_name()
+    get_session_profile_name = __get_session_profile_name
 
-    def __get_profile_id(self, profile_name):
+    def __get_session_profile_id(self, session_uuid):
         """\
-        Retrieve the session profile id of the session whose profile name
-        is C{profile_name}
+        Retrieve the profile id of the session that has been registered
+        under C{session_uuid}
 
-        @param profile_name: the session profile name
-        @type profile_name: str
+        @param session_uuid: the session profile name
+        @type session_uuid: str
 
-        @return: the session profile's id
+        @return: the session profile's id as in the sessions configuration file
         @rtype: str
 
         """
-        return self.session_registry(profile_name).profile_id
-    get_profile_id = __get_profile_id
-
-    ###
-    ### Provide access to config file class objects
-    ### 
-
-    def __get_session_profiles(self):
-        """\
-        STILL UNDOCUMENTED
-
-        """
-        return self.session_profiles
-    get_session_profiles = __get_session_profiles
-    __get_profiles = __get_session_profiles
-    get_profiles = __get_profiles
-
-    def __get_client_settings(self):
-        """\
-        STILL UNDOCUMENTED
-
-        """
-        return self.client_settings
-    get_client_settings = __get_client_settings
-
-    def __get_client_printing(self):
-        """\
-        STILL UNDOCUMENTED
-
-        """
-        return self.client_printing
-    get_client_printing = __get_client_printing
-
-    ###
-    ### QUERYING INFORMATION
-    ###
+        return self.session_registry(session_uuid).profile_id
+    get_session_profile_id = __get_session_profile_id
 
     def __session_ok(self, session_uuid):
         """\                                     
@@ -514,10 +432,10 @@ class X2goClient(object):
         @rtype: bool
 
         """
-        return self.with_session(session_uuid).ok()
+        return self.session_registry(session_uuid).session_ok()
     session_ok = __session_ok
 
-    def __is_running(self, session_uuid):
+    def __is_session_running(self, session_uuid):
         """\
         Test if the X2go session registered as C{session_uuid} is up 
         and running.
@@ -529,10 +447,10 @@ class X2goClient(object):
         @rtype: bool
 
         """
-        return self.with_session(session_uuid).is_running()
-    is_running = __is_running
+        return self.session_registry(session_uuid).is_running()
+    is_session_running = __is_session_running
 
-    def __is_suspended(self, session_uuid):
+    def __is_session_suspended(self, session_uuid):
         """\
         Test if the X2go session registered as C{session_uuid} 
         is in suspended state.
@@ -544,10 +462,10 @@ class X2goClient(object):
         @rtype: bool
 
         """
-        return self.with_session(session_uuid).is_suspended()
-    is_suspended = __is_suspended
+        return self.session_registry(session_uuid).is_suspended()
+    is_session_suspended = __is_session_suspended
 
-    def __has_terminated(self, session_uuid):
+    def __has_session_terminated(self, session_uuid):
         """\
         Test if the X2go session registered as C{session_uuid} 
         has terminated.
@@ -559,10 +477,10 @@ class X2goClient(object):
         @rtype: bool
 
         """
-        return self.with_session(session_uuid).has_terminated()
-    has_terminated = __has_terminated
+        return self.session_registry(session_uuid).has_terminated()
+    has_session_terminated = __has_session_terminated
 
-    def __share_local_folder(self, session_uuid, folder_name):
+    def __share_local_folder_with_session(self, session_uuid, folder_name):
         """\
         Share a local folder with the X2go session registered as C{session_uuid}.
 
@@ -577,5 +495,118 @@ class X2goClient(object):
         @rtype: bool
 
         """
-        return self.with_session(session_uuid).share_local_folder(folder_name=folder_name)
-    share_local_folder = __share_local_folder
+        return self.session_registry(session_uuid).share_local_folder(folder_name=folder_name)
+    share_local_folder_with_session = __share_local_folder_with_session
+
+    ###
+    ### CLIENT OPERATIONS ON SESSIONS (listing sessions, terminating non-associated sessions etc.)
+    ###
+
+    def __clean_sessions(self, session_uuid):
+        """\
+        Find running X2go sessions that have been standard by the connected
+        user and terminate them.
+
+        @param session_uuid: the X2go session's UUID registry hash
+        @type session_uuid: str
+
+        """
+        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, session_uuid):
+        """\
+        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 session_uuid: the X2go session's UUID registry hash
+        @type session_uuid: str
+
+        """
+        session = self.session_registry(session_uuid).session_object
+        return session.list_sessions()
+    list_sessions = __list_sessions
+
+    ###
+    ### Provide access to config file class objects
+    ### 
+
+    def __get_profiles(self):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        return self.session_profiles
+    get_profiles = __get_profiles
+
+    def __get_client_settings(self):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        return self.client_settings
+    get_client_settings = __get_client_settings
+
+    def __get_client_printing(self):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        return self.client_printing
+    get_client_printing = __get_client_printing
+
+    ###
+    ### Session profile oriented methods
+    ### 
+
+    def __get_profile_config(self, profile_id_or_name):
+        """\
+        Retrieve the complete X2goSession object that has been 
+        registry under the given sesion registry hash.
+
+        @param profile_id_or_name: name or id of an X2go session profile as found
+            in the sessions configuration file
+        @type profile_id_or_name: str
+
+        @return: a Python dictionary with session profile options
+        @rtype: dict
+
+        """
+        return self.session_profiles.get_profile_config(profile_id_or_name)
+    get_profile_config = __get_profile_config
+    with_profile_config = __get_profile_config
+
+    def __to_profile_id(self, profile_name):
+        """\
+        Retrieve the session profile id of the session whose profile name
+        is C{profile_name}
+
+        @param profile_name: the session profile name
+        @type profile_name: str
+
+        @return: the session profile's id
+        @rtype: str
+
+        """
+        return self.session_profiles.get_profile_id(profile_name)
+    to_profile_id = __to_profile_id
+
+    def __to_profile_name(self, profile_id):
+        """\
+        Retrieve the session profile name of the session whose profile id
+        is C{profile_id}
+
+        @param profile_id: the session profile id
+        @type profile_id: str
+
+        @return: the session profile's name
+        @rtype: str
+
+        """
+        return self.session_profiles.get_profile_name(profile_id)
+    to_profile_name = __to_profile_name
+
diff --git a/x2go/printing.py b/x2go/printing.py
index a3341a7..423a0c5 100644
--- a/x2go/printing.py
+++ b/x2go/printing.py
@@ -49,7 +49,7 @@ if sys.platform == 'win32':
 # Python X2go modules
 import log
 import defaults
-# we have to import the X2GO_PRINT_ACTIONS in this awkward way, otherwise we create an import loop
+# we hide the default values from epydoc (that's why we transform them to _UNDERSCORE variables)
 from defaults import LOCAL_HOME as _LOCAL_HOME
 from defaults import X2GO_CLIENT_ROOTDIR as _X2GO_CLIENT_ROOTDIR
 from defaults import X2GO_CLIENTPRINTING_DEFAULTS as _X2GO_CLIENTPRINTING_DEFAULTS
diff --git a/x2go/profiles.py b/x2go/profiles.py
index 81c0c2f..749198c 100644
--- a/x2go/profiles.py
+++ b/x2go/profiles.py
@@ -207,4 +207,11 @@ class X2goSessionProfiles(inifiles.X2goIniFile):
 
         """
         _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
+        return utils._convert_SessionProfileOptions_2_SessionParams(self.get_profile_config(_profile_id))
+
+    def get_session_param(self, profile_id_or_name, param):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        return self.to_session_params(profile_id_or_name)[param]
\ No newline at end of file
diff --git a/x2go/registry.py b/x2go/registry.py
index 72f3c58..672bcba 100644
--- a/x2go/registry.py
+++ b/x2go/registry.py
@@ -35,17 +35,283 @@ from x2go_exceptions import *
 
 
 class X2goRegisteredSession(object):
+
     def __init__(self):
         self.uuid = uuid.uuid1()
     def __str__(self):
-        return self.uuid
+        return self.__get_uuid()
     def __repr__(self):
-        result = 'X2goRegistrySession('
+        result = 'X2goRegisteredSession('
         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]) + ', '
         return result + ')'
 
+    def __get_uuid(self):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        return self.uuid
+    get_uuid = __get_uuid
+
+    def __get_username(self):
+        """\
+        After a session has been setup up you can query the 
+        username the sessions runs as.
+
+        @return: the remote username the X2go session runs as
+        @rtype: str
+
+        """
+        return self.session_object.get_transport().get_username()
+    get_username = __get_username
+
+    def __get_server(self):
+        """\
+        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).
+
+        @return: the hostname of the server the X2go session is 
+            connected to (as an C{(addr,port)} tuple) 
+        @rtype: tuple
+
+        """
+        return self.session_object.get_transport().getpeername()
+    get_server = __get_server
+
+    def __get_session_name(self):
+        """\
+        Retrieve the server-side X2go session name for the session that has
+        been registered under C{profile_id}.
+
+        @return: X2go session name
+        @rtype: str
+
+        """
+        return self.session_object.session_info
+    get_session_name = __get_session_name
+
+    def __connect(self, password=None, add_to_known_hosts=False, force_password_auth=False):
+        """\
+        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 password: the user's password for the X2go server that is going to be 
+            connected to
+        @type password: str
+        @param add_to_known_hosts: non-paramiko option, if C{True} paramiko.AutoAddPolicy() 
+            is used as missing-host-key-policy. If set to C{False} paramiko.RejectPolicy() 
+            is used
+        @type add_to_known_hosts: bool
+        @param force_password_auth: disable SSH pub/priv key authentication mechanisms
+            completely
+        @type force_password_auth: bool
+
+        """
+        connect_options = self.connect_options
+        connect_options['password'] = password
+        connect_options['force_password_auth'] = force_password_auth
+        self.session_object.connect(self.server, **connect_options)
+        self.connected = True
+    connect = __connect
+
+    def __set_print_action(self, session_uuid, print_action, **kwargs):
+        """\
+        STILL UNDOCUMENTED
+
+        """
+        if type(print_action) is not types.StringType:
+            return False
+        self.session_object.set_print_action(print_action, **kwargs)
+    set_print_action = __set_print_action
+
+    def __start(self):
+        """\
+        Start a new X2go session on the remote X2go server.
+
+        """
+        session = self.session_object
+
+        session.start()
+
+        if session.params.snd_system is not 'none':
+            session.start_sound()
+
+        session.start_sshfs()
+        if self.printing:
+            session.start_printing()
+
+        if self.share_local_folders:
+            if session.get_transport().reverse_tunnels['sshfs'][1] is not None:
+                for _folder in self.share_local_folders:
+                    session.share_local_folder(_folder)
+
+        session.run_command()
+        self.running = True
+    start = __start
+
+    def __resume(self, session_name):
+        """\
+        Resume or continue a suspended / running X2go session on the 
+        remote X2go server.
+
+        @param session_name: the server-side name of an X2go session
+        @type session_name: str
+
+        """
+        self.session_object.associate(session_name)
+        self.session_object.resume()
+
+        if self.session_object.params.snd_system is not 'none':
+            self.session_object.start_sound()
+
+        self.session_object.start_sshfs()
+        if self.printing:
+            session.start_printing()
+
+        self.running = True
+    resume = __resume
+
+    def __suspend(self):
+        """\
+        Suspend an X2go session. 
+
+        You can either suspend a session that you have formerly 
+        started/resumed the current X2goClient instance.
+
+        Or you can suspend a non-attached session by simply
+        registering an X2go server session and then passing the 
+        server-side X2go session name to this method.
+
+        """
+        self.session_object.suspend()
+        self.running = False
+        self.suspended = True
+    suspend = __suspend
+
+    def __terminate(self):
+        """\
+        Terminate an X2go session. 
+
+        You can either terminate a session that you have formerly 
+        started/resumed within the current X2goClient instance.
+
+        Or you can terminate a non-attached session by simply
+        registering an X2go server session and then passing the 
+        server-side X2go session name to this method.
+
+        """
+        self.session_object.terminate()
+        self.running = False
+        self.suspended = False
+        self.terminated = True
+    terminate = __terminate
+
+    def __get_profile_name(self):
+        """\
+        Retrieve the profile name of the session that has been registered
+        under C{session_hash}
+
+
+        @param session_hash: the X2go session's UUID registry hash
+        @type session_hash: str
+
+        @return: X2go client profile name of the session
+        @rtype: str
+
+        """
+        return self.profile_name
+    get_profile_name = __get_profile_name
+
+    def __get_profile_id(self):
+        """\
+        Retrieve the session profile id of the session whose profile name
+        is C{profile_name}
+
+        @param profile_name: the session profile name
+        @type profile_name: str
+
+        @return: the session profile's id
+        @rtype: str
+
+        """
+        return self.profile_id
+    get_profile_id = __get_profile_id
+
+    ###
+    ### QUERYING INFORMATION
+    ###
+
+    def __session_ok(self):
+        """\                                     
+        Test if the X2go session registered as C{session_uuid} is
+        in a healthy state.
+
+        @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.session_object.ok()
+    session_ok = __session_ok
+
+    def __is_running(self):
+        """\
+        Test if the X2go session registered as C{session_uuid} is up 
+        and running.
+
+        @return: C{True} if session is running, C{False} otherwise
+        @rtype: bool
+
+        """
+        return self.session_object.is_running()
+    is_running = __is_running
+
+    def __is_suspended(self):
+        """\
+        Test if the X2go session registered as C{session_uuid} 
+        is in suspended state.
+
+        @return: C{True} if session is suspended, C{False} otherwise
+        @rtype: bool
+
+        """
+        return self.session_object.is_suspended()
+    is_suspended = __is_suspended
+
+    def __has_terminated(self):
+        """\
+        Test if the X2go session registered as C{session_uuid} 
+        has terminated.
+
+        @return: C{True} if session has terminated, C{False} otherwise
+        @rtype: bool
+
+        """
+        return self.session_object.has_terminated()
+    has_terminated = __has_terminated
+
+    def __share_local_folder(self, folder_name):
+        """\
+        Share a local folder with the X2go session registered as C{session_uuid}.
+
+        @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{session_uuid}
+        @rtype: bool
+
+        """
+        return self.session_object.share_local_folder(folder_name=folder_name)
+    share_local_folder = __share_local_folder
+
 
 class X2goSessionRegistry(object):
     """\


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