[X2Go-Commits] python-x2go.git - build-baikal (branch) updated: 78f0a40ac8dc79a9338cc949ddbacf213421ab31
X2Go dev team
git-admin at x2go.org
Wed Jan 8 15:25:13 CET 2014
The branch, build-baikal has been updated
via 78f0a40ac8dc79a9338cc949ddbacf213421ab31 (commit)
from 2b25b15c90cf861d8f20bb5ab8706fbf82f7124e (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 | 452 ++++++++++++++++++++++++++++++++++++++------------------
1 file changed, 310 insertions(+), 142 deletions(-)
The diff of changes is:
diff --git a/x2go/client.py b/x2go/client.py
index e6db32c..dfe9aa8 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -19,78 +19,93 @@
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
"""\
-X2goClient class - use this class in your Python-based X2go applications.
+X2goClient class - use this class as parent class in your Python-based
+X2go applications.
-The X2goClient class supports registry based multiple sessions, parsing of
-configuration files and managing X2go session profiles.
+The X2goClient class supports registry based multiple sessions, with it you
+can gain access to you X2go client's configuration files.
-"""
-__NAME__ = 'x2goclient-pylib'
-
-#modules
-import uuid
-import copy
-
-# Python X2go modules
-from settings import X2goClientSettings
-from printing import X2goClientPrinting
-from profiles import X2goSessionProfiles
-from registry import X2goSessionRegistry
-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):
- """\
- The X2goClient implements the functionality of the graphical and the Perl based
- X2go command line client (x2goclient, x2goclient-cli) in Python.
+Supported Features
+==================
Supported features are:
- X2go multi-session management
- keep track of initiated sessions
- - read and parse X2go client config files: settings, printing, sessions
+ - grant access to X2go client config files: settings, printing, sessions
as normally found in C{~/.x2goclient}
- - load session profiles from sessions file
- - load and start session as pre-configured in sessions file
- - enable X2go printing (NOT IMPLEMENTED YET)
- - LDAP support (NOT IMPLEMENTED YET)
-
- A new non-config based X2go session in an X2goClient instance is initiated in the
+ - instantiate an X2go session by a set of Python parameters
+ - load a session profile from x2goclient's »sessions« configuration file
+ and start the in this way pre-configured session
+ - sharing of local folders with remote X2go sessions
+ - enabling and mangaging X2go printing (real printing, viewing as PDF, saving
+ to a local folder or executing a custom »print« command
+ - LDAP support for X2go server clusters (NOT IMPLEMENTED YET)
+
+Non-Profile Sessions
+====================
+ A new non-profile based X2go session within an X2goClient instance is setup in the
following way:
- - import Python X2go module and call the session constructor::
+ - import the Python X2go module and call the session constructor::
import x2go
x2go_client = x2go.X2goClient()
- - register a new X2goClient session, this creates an X2goSession instance
+ - register a new X2goClient session; this creates an X2goRegisteredSession instance
and calls its constructor method::
- x2go_profile_id = x2go_client.register_session(<many-options>)
+ x2go_sess_uuid = x2go_client.register_session(<many-options>)
- connect to the session's remote X2go server (SSH/Paramiko)::
- x2go_client.connect_session(x2go_profile_id)
+ x2go_client.connect_session(x2go_sess_uuid)
- - with the connected X2go client session you can start or resume a remote
+ - via the connected X2go client session you can start or resume a remote
X-windows session on an X2go server now::
- x2go_client.start_session(x2go_profile_id)
+ x2go_client.start_session(x2go_sess_uuid)
resp.::
- x2go_client.start_session(x2go_profile_id, session_name=<session_name_of_resumable_session>)
+ x2go_client.resume_session(x2go_sess_uuid, session_name=<session_name_of_resumable_session>)
+
+ - a list of available sessions on the respective server (for resuming) can be obtained in
+ this way::
+
+ x2go_client.list_sessions(x2go_sess_uuid, session_name=<session_name_of_resumable_session>)
+
+Profiled Sessions
+=================
+ A new profile based (i.e. using pre-defined session profiles) X2go session within an
+ X2goClient instance is setup in a much easier way:
- A new config based (i.e. using pre-defined session profiles) X2go session in an X2goClient instance
- is initiated in a slightly different way:
+ - import the Python X2go module and call the session constructor::
+
+ import x2go
+ x2go_client = x2go.X2goClient()
- - NOT IMPLEMENTED YET
+ - register an X2goClient session based on a pre-configured session profile::
+
+ x2go_sess_uuid = x2go_client.register_session(profile_name=<session_profile_name>)
+
+ - or alternatively by the profile id in the »sessions« file (the name of the [<section>]
+ in the »sessions« file::
+
+ x2go_sess_uuid = x2go_client.register_session(profile_id=<session_profile_id>)
+
+ - now you proceed in a similar way as shown above::
+
+ x2go_client.connect_session(x2go_sess_uuid)
+ x2go_client.start_session(x2go_sess_uuid)
+
+ resp.::
+
+ x2go_client.resume_session(x2go_sess_uuid, session_name=<session_name_of_resumable_session>)
+
+
+Session Suspending/Terminating
+==============================
You can suspend or terminate your sessions by calling the follwing commands::
@@ -100,13 +115,39 @@ class X2goClient(object):
x2go_client.terminate_session(x2go_profile_id)
+"""
+__NAME__ = 'x2goclient-pylib'
+
+#modules
+import uuid
+import copy
+import sys
+
+# Python X2go modules
+from settings import X2goClientSettings
+from printing import X2goClientPrinting
+from profiles import X2goSessionProfiles
+from registry import X2goSessionRegistry
+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):
+ """\
+ The X2goClient implements is THE public Python X2go API. With it you can
+ construct your own X2go client application in Python.
"""
session_profiles = None
session_registry = None
client_settings = None
client_printing = None
- def __init__(self, loglevel=log.loglevel_DEFAULT, logger=None, *args, **kwargs):
+ def __init__(self, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param logger: you can pass an L{X2goLogger} object to the
L{X2goClient} constructor
@@ -120,7 +161,9 @@ class X2goClient(object):
self.logger = log.X2goLogger(loglevel=loglevel)
else:
self.logger = copy.deepcopy(logger)
- self.logger.tag = __NAME__
+ self._logger_tag = __NAME__
+ if self.logger.tag is None:
+ self.logger.tag = self._logger_tag
self.session_profiles = X2goSessionProfiles(logger=self.logger)
self.session_registry = X2goSessionRegistry(logger=self.logger)
@@ -129,7 +172,7 @@ class X2goClient(object):
def __get_client_username(self):
"""\
- Query the local user's username.
+ Query the local user's username (i.e. the user running the X2go client).
@return: the local username this X2goClient instance runs as
@rtype: str
@@ -138,31 +181,53 @@ class X2goClient(object):
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,
+ def register_session(self, server=None, profile_id=None, profile_name=None,
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.
+ These sessions can have been instantiated by passing direct X2goSession
+ parameters to this method or by naming a session profile.
+
+ A profile is
+ a pre-defined set of session options stored in a sessions
+ profile file (i.e. a configuration file). Normally such a session profiles are
+ is stored in C{~/.x2goclient/sessions} or globally (for all users on the
+ client) in /etc/x2goclient/sessions. If needed, you can also create multiple
+ X2go sessions from one session profile.
+
L{X2goClient.register_session()} accepts the same set of parameters
- as the L{X2goSession} constructor.
+ as the L{X2goSession} constructor.
- Additionally, you can also pass a profile name to this method. A profile
- is a pre-defined set of session options stored in a sessions
- profile file (i.e. a configuration file). Normally such a file
- is stored in C{~/.x2goclient/sessions}. This feature, however, is NOT
- IMPLEMENTED YET.
+ Alternatively, you can also pass a profile name or a profile id
+ to this method. When this is done, all session parameters are first derived
+ from the session's profile. Additional X2goSession parameters passed to
+ this method will override the option value in the session profile.
@param server: hostname of the remote X2go server
@type server: str
+ @param profile_id: id (config section name) of a session profile to load
+ from your session config
+ @type profile_id: str
@param profile_name: name of a session profile to load from your session
config
@type profile_name: str
-
- @return: a unique identifier (UUID) for the newly registered X2go session
+ @param printing: enable X2go printing support for the to-be-registered X2go session
+ @type printing: bool
+ @param share_local_folders: a list of local folders (as strings) to be shared directly
+ after session start up
+ @type printing: list
+ @param return_object: normally this method returns a unique session UUID. If
+ C{return_object} is set to C{True} an X2goRegisteredSession object will be returned
+ instead
+ @type printing: bool
+ @param kwargs: any option that is also valid for L{X2goSession.__init__()}
+ @type kwargs: dict
+
+ @return: a unique identifier (UUID) for the newly registered X2go session (or an
+ X2goRegisteredSession object if C{return_object} is set to True
@rtype: str
"""
@@ -179,11 +244,16 @@ class X2goClient(object):
_params = self.session_profiles.to_session_params(_profile_id)
del _params['profile_name']
+ # override any available session parameter passed to this method
+ for k in _params.keys():
+ if k in kwargs.keys():
+ _params[k] = kwargs[k]
+
else:
if server is None:
return None
_profile_id = utils._genSessionProfileId()
- _profile_name = profile_name or custom_profile_name or sys.args[0]
+ _profile_name = profile_name or sys.argv[0]
_params = kwargs
_params['server'] = server
_params['printing'] = printing
@@ -194,18 +264,18 @@ class X2goClient(object):
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)
+ self.logger('initializing X2go session...', log.loglevel_NOTICE, tag=self._logger_tag)
if return_object:
return self(session_uuid)
else:
return session_uuid
- register_session = __register_session
+ __register_session = register_session
###
### WRAPPER METHODS FOR X2goRegisteredSession objects
###
- def __get_session_username(self, session_uuid):
+ 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.
@@ -218,12 +288,12 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).get_username()
- get_session_username = __get_session_username
+ __get_session_username = get_session_username
- def __get_session_server(self, session_uuid):
+ 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
+ hostname of the host the session is connected to (or
about to connect to).
@param session_uuid: the X2go sessions UUID registry hash
@@ -235,25 +305,52 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).get_server()
- get_session_server = __get_session_server
+ __get_session_server = get_session_server
- def __get_session(self, session_uuid):
+ def get_session(self, session_uuid):
"""\
Retrieve the complete X2goSession object that has been
- registry under the given sesion registry hash.
+ registered under the given session registry hash.
+
+ This method exist mainly for debugging. The returned
+ X2goSession class is not a Python X2go public API class.
+ If you use it in your applications, note that method names
+ options or syntax might change in the future.
+
+ To retrieve a public API based session object, use the
+ L{get_registered_session()}.
@param session_uuid: the X2go session's UUID registry hash
@type session_uuid: str
- @return: the L{X2goRegisteredSession} instance
+ @return: the L{X2goSession} instance
@rtype: obj
"""
return self.session_registry(session_uuid).session_object
- get_session = __get_session
+ __get_session = get_session
with_session = __get_session
- def __get_session_name(self, session_uuid):
+ def get_registered_session(self, session_uuid):
+ """\
+ Retrieve the complete X2goRegisteredSession object that has been
+ registered under the given session registry hash.
+
+ X2goRegisteredSession is one of Python X2go's public API classes
+ and may safely be used in user applications.
+
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
+
+ @return: the L{X2goRegisteredSession} instance
+ @rtype: obj
+
+ """
+ return self.session_registry(session_uuid)
+ __get_registered_session = get_registered_session
+ with_registered_session = __get_registered_session
+
+ def get_session_name(self, session_uuid):
"""\
Retrieve the server-side X2go session name for the session that has
been registered under C{session_uuid}.
@@ -266,9 +363,9 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).get_session_name()
- get_session_name = __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):
+ 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{<session_uuid>}.
This method basically wraps around paramiko.SSHClient.connect() for the
@@ -279,7 +376,7 @@ class X2goClient(object):
@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()
+ @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
@@ -287,89 +384,139 @@ class X2goClient(object):
completely
@type force_password_auth: bool
+ @return: returns True if this method has been successful
+ @rtype: bool
+
"""
- 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
+ return 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):
+ def set_session_print_action(self, session_uuid, print_action, **kwargs):
"""\
- STILL UNDOCUMENTED
+ If X2go client-side printing is enable within an X2go session you can use
+ this method to alter the way how incoming print spool jobs are handled/processed.
+
+ Currently, there are four different print actions available, define as individual
+ print action classes:
+
+ - B{PDFVIEW} (L{X2goPrintActionPDFVIEW}): view incoming spool jobs (a PDF file)
+ locally in a PDF viewer
+ - B{PDFSAVE} (L{X2goPrintActionPDFSAVE}): save incoming spool jobs (a PDF file)
+ under a nice name in a designated folder
+ - B{PRINT} (L{X2goPrintActionPRINT}): really print the incoming spool job
+ - B{PRINTCMD} L{X2goPrintActionPRINTCMD}: on each incoming spool job execute an
+ external command that lets the client user handle the further processing of the
+ print job file (PDF file)
+
+ Each of the print action classes accepts different print action arguments. For detail
+ information on this please refer to the constructor methods of each class individually.
+
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: str
+ @param print_action: the user's password for the X2go server that is going to be
+ connected to
+ @type password: str
+ @param kwargs: additional information for the given print action (print
+ action arguments), for possible options and values see above
+ @param type: dict
"""
self.session_registry(session_uuid).set_print_action(print_action=print_action, **kwargs)
- set_session_print_action = __set_session_print_action
+ __set_session_print_action = set_session_print_action
- def __start_session(self, session_uuid):
+ def start_session(self, session_uuid):
"""\
- Start a new X2go session on the remote X2go server.
+ Start a new X2go session on the remote X2go server. This method
+ will open---if everything has been successful till here--the X2go
+ session window.
+
+ Before calling this method you have to register your desired session
+ with L{register_session} (initialization of session parameters) and
+ connect to it with L{connect_session} (authentication).
@param session_uuid: the X2go sessions UUID registry hash
@type session_uuid: str
+ @return: returns True if this method has been successful
+ @rtype: bool
+
"""
- self.session_registry(session_uuid).start()
- start_session = __start_session
+ return self.session_registry(session_uuid).start()
+ __start_session = start_session
- def __resume_session(self, session_uuid, session_name):
+ def resume_session(self, session_uuid, session_name):
"""\
- Resume or continue a suspended / running X2go session on the
- remote X2go server.
+ Resume or continue a suspended / running X2go session on a
+ remote X2go server (as specified when L{register_session} was
+ called).
@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(session_uuid).session_object
- session.associate(session_name)
- session.resume()
-
- if session.params.snd_system is not 'none':
- session.start_sound()
-
- session.start_sshfs()
- if self.session_registry(session_uuid).printing:
- session.start_printing()
+ @return: returns True if this method has been successful
+ @rtype: bool
- self.session_registry(session_uuid).running = True
- resume_session = __resume_session
+ """
+ return self.session_registry(session_uuid).resume(session_name)
+ __resume_session = resume_session
- def __suspend_session(self, session_uuid, session_name=None):
+ def suspend_session(self, session_uuid, session_name=None):
"""\
- Suspend an X2go session.
+ Suspend an X2go session.
- You can either suspend a session that you have formerly
- started/resumed the current X2goClient instance.
+ Normally you will use this method to suspend a registered session that you
+ have formerly started/resumed from within your recent
+ X2goClient instance. For this you simply call this method
+ using the sessions C{session_uuid}, leave the C{session_name}
+ empty.
- 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.
+ Alternatively, you can suspend a non-associated X2go session:
+ To do this you simply neeed to register (L{register_session})
+ an X2go session on the to-be-addressed remote X2go server and
+ connect (L{connect_session}) to it. Then call this method with
+ the freshly obtained C{session_uuid} and the remote X2go session
+ name (as shown e.g. in x2golistsessions output).
@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
+ @param session_name: the server-side name of an X2go session (for
+ non-associated session suspend)
@type session_name: str
+ @return: returns True if this method has been successful
+ @rtype: bool
+
"""
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)
+ return session.suspend(session_name=session_name)
else:
- self.session_registry(session_uuid).suspend()
- suspend_session = __suspend_session
+ return self.session_registry(session_uuid).suspend()
+ __suspend_session = suspend_session
- def __terminate_session(self, session_uuid, session_name=None):
+ def terminate_session(self, session_uuid, session_name=None):
"""\
Terminate an X2go session.
- You can either terminate a session that you have formerly
- started/resumed within the current X2goClient instance.
+ Normally you will use this method to terminate a registered session that you
+ have formerly started/resumed from within your recent
+ X2goClient instance. For this you simply call this method
+ using the sessions C{session_uuid}, leave the C{session_name}
+ empty.
+
+ Alternatively, you can terminate a non-associated X2go session:
+ To do this you simply neeed to register (L{register_session})
+ an X2go session on the to-be-addressed remote X2go server and
+ connect (L{connect_session}) to it. Then call this method with
+ the freshly obtained C{session_uuid} and the remote X2go session
+ name (as shown in e.g. x2golistsessions output).
Or you can terminate a non-attached session by simply
registering an X2go server session and then passing the
@@ -380,48 +527,66 @@ class X2goClient(object):
@param session_name: the server-side name of an X2go session
@type session_name: str
+ @return: returns True if this method has been successful
+ @rtype: bool
+
"""
if session_name:
# 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)
+ return session.terminate(session_name=session_name)
else:
- self.session_registry(session_uuid).terminate()
- terminate_session = __terminate_session
+ return self.session_registry(session_uuid).terminate()
+ __terminate_session = terminate_session
- def __get_session_profile_name(self, session_uuid):
+ def get_session_profile_name(self, session_uuid):
"""\
Retrieve the profile name of the session that has been registered
- under C{session_uuid}
+ under C{session_uuid}.
+
+ For profile based sessions this will be the profile named as used
+ in x2goclient's »sessions« configuration file.
+
+ For non-profile based session this will either be a C{profile_name} that
+ was passed to L{register_session} or it will be the application that
+ instantiated this X2goClient object.
@param session_uuid: the X2go session's UUID registry hash
@type session_uuid: str
- @return: X2go client profile name of the session
+ @return: X2go session profile name
@rtype: str
"""
return self.session_registry(session_uuid).get_profile_name()
- get_session_profile_name = __get_session_profile_name
+ __get_session_profile_name = get_session_profile_name
- def __get_session_profile_id(self, session_uuid):
+ def get_session_profile_id(self, session_uuid):
"""\
Retrieve the profile id of the session that has been registered
- under C{session_uuid}
+ under C{session_uuid}.
+
+ For profile based sessions this will be the profile id as used
+ in x2goclient's »sessions« configuration file (section header of
+ a session profile in the config, normally a time stamp created on
+ session profile creation/modification).
+
+ For non-profile based session this will be a timestamp created on
+ X2go session registration by C{register_session}.
@param session_uuid: the session profile name
@type session_uuid: str
- @return: the session profile's id as in the sessions configuration file
+ @return: the X2go session profile's id
@rtype: str
"""
return self.session_registry(session_uuid).profile_id
- get_session_profile_id = __get_session_profile_id
+ __get_session_profile_id = get_session_profile_id
- def __session_ok(self, session_uuid):
- """\
+ def session_ok(self, session_uuid):
+ """\
Test if the X2go session registered as C{session_uuid} is
in a healthy state.
@@ -433,9 +598,9 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).session_ok()
- session_ok = __session_ok
+ __session_ok = session_ok
- def __is_session_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.
@@ -448,9 +613,9 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).is_running()
- is_session_running = __is_session_running
+ __is_session_running = is_session_running
- def __is_session_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.
@@ -463,9 +628,9 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).is_suspended()
- is_session_suspended = __is_session_suspended
+ __is_session_suspended = is_session_suspended
- def __has_session_terminated(self, session_uuid):
+ def has_session_terminated(self, session_uuid):
"""\
Test if the X2go session registered as C{session_uuid}
has terminated.
@@ -478,25 +643,28 @@ class X2goClient(object):
"""
return self.session_registry(session_uuid).has_terminated()
- has_session_terminated = __has_session_terminated
+ __has_session_terminated = has_session_terminated
- def __share_local_folder_with_session(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}.
+ When calling this method the given client-side folder is mounted
+ on the X2go server (via sshfs) and (if in desktop mode) provided as a
+ desktop icon on your remote session's desktop.
+
@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
+ @param folder_name: the full path to an existing folder on the local (client-side)
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}
+ @return: returns C{True} if the local folder has been successfully mounted
@rtype: bool
"""
return self.session_registry(session_uuid).share_local_folder(folder_name=folder_name)
- share_local_folder_with_session = __share_local_folder_with_session
+ __share_local_folder_with_session = share_local_folder_with_session
###
### CLIENT OPERATIONS ON SESSIONS (listing sessions, terminating non-associated sessions etc.)
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