[X2Go-Commits] [python-x2go] 05/07: API Epydoc2Sphinx conversion: Replace 'C{...}' by ... (monospaced text).
git-admin at x2go.org
git-admin at x2go.org
Mon Mar 5 22:32:52 CET 2018
This is an automated email from the git hooks/post-receive script.
x2go pushed a commit to branch master
in repository python-x2go.
commit 8e7a9397823720c36bad4f0838f77d87c3a4afb2
Author: Mike Gabriel <mike.gabriel at das-netzwerkteam.de>
Date: Mon Mar 5 22:23:03 2018 +0100
API Epydoc2Sphinx conversion: Replace 'C{...}' by ... (monospaced text).
---
x2go/__init__.py | 2 +-
x2go/_paramiko.py | 10 +-
x2go/backends/control/plain.py | 378 ++++++------
x2go/backends/info/plain.py | 60 +-
x2go/backends/printing/file.py | 38 +-
x2go/backends/printing/winreg.py | 6 +-
x2go/backends/profiles/base.py | 166 +++---
x2go/backends/profiles/file.py | 18 +-
x2go/backends/profiles/httpbroker.py | 62 +-
x2go/backends/profiles/sshbroker.py | 4 +-
x2go/backends/profiles/winreg.py | 4 +-
x2go/backends/proxy/base.py | 22 +-
x2go/backends/proxy/nx3.py | 4 +-
x2go/backends/settings/file.py | 4 +-
x2go/backends/terminal/plain.py | 304 +++++-----
x2go/cache.py | 68 +--
x2go/checkhosts.py | 40 +-
x2go/cleanup.py | 8 +-
x2go/client.py | 1062 +++++++++++++++++-----------------
x2go/forward.py | 50 +-
x2go/guardian.py | 20 +-
x2go/inifiles.py | 34 +-
x2go/log.py | 16 +-
x2go/mimebox.py | 32 +-
x2go/mimeboxactions.py | 52 +-
x2go/printactions.py | 106 ++--
x2go/printqueue.py | 42 +-
x2go/pulseaudio.py | 8 +-
x2go/registry.py | 322 +++++------
x2go/rforward.py | 28 +-
x2go/session.py | 568 +++++++++---------
x2go/sftpserver.py | 118 ++--
x2go/sshproxy.py | 98 ++--
x2go/telekinesis.py | 22 +-
x2go/utils.py | 126 ++--
x2go/xserver.py | 40 +-
36 files changed, 1971 insertions(+), 1971 deletions(-)
diff --git a/x2go/__init__.py b/x2go/__init__.py
index 0faa4cf..82f6745 100644
--- a/x2go/__init__.py
+++ b/x2go/__init__.py
@@ -87,7 +87,7 @@ API Structure
NOTE: Doing so is--herewith--fully disrecommended.
The L{X2GoClient} class flattens the complex structure of Python X2Go into
- many L{X2GoClient} methods that you can use in your own C{MyX2GoClient} instance.
+ many L{X2GoClient} methods that you can use in your own ``MyX2GoClient`` instance.
However, it might be handy to retrieve a whole X2Go session instance
from the L{X2GoClient} instance. This can be achieved by the
diff --git a/x2go/_paramiko.py b/x2go/_paramiko.py
index f74b0dd..aa66761 100644
--- a/x2go/_paramiko.py
+++ b/x2go/_paramiko.py
@@ -85,10 +85,10 @@ def _HostKeys_load(self, filename):
Read a file of known SSH host keys, in the format used by openssh.
This type of file unfortunately doesn't exist on Windows, but on
posix, it will usually be stored in
- C{os.path.expanduser("~/.ssh/known_hosts")}.
+ ``os.path.expanduser("~/.ssh/known_hosts")``.
If this method is called multiple times, the host keys are merged,
- not cleared. So multiple calls to C{load} will just call L{add},
+ not cleared. So multiple calls to ``load`` will just call L{add},
replacing any existing entries and adding new ones.
:param filename: name of the file to read host keys from
@@ -115,16 +115,16 @@ def _HostKeys_load(self, filename):
def _HostKeys_add(self, hostname, keytype, key, hash_hostname=True):
"""\
Add a host key entry to the table. Any existing entry for a
- C{(hostname, keytype)} pair will be replaced.
+ ``(hostname, keytype)`` pair will be replaced.
:param hostname: the hostname (or IP) to add
:type hostname: str
- :param keytype: key type (C{"ssh-rsa"}, C{"ssh-dss"} or C{"ecdsa-sha2-nistp256"})
+ :param keytype: key type (``"ssh-rsa"``, ``"ssh-dss"`` or ``"ecdsa-sha2-nistp256"``)
:type keytype: str
:param key: the key to add
:type key: L{PKey}
:param hash_hostname: hash the system's hostname (Default value = True)
- :type hash_hostname: C{bool}
+ :type hash_hostname: ``bool``
"""
# IPv4 and IPv6 addresses using the SSH default port need to be stripped off the port number
diff --git a/x2go/backends/control/plain.py b/x2go/backends/control/plain.py
index 202c5a0..d4a9f71 100644
--- a/x2go/backends/control/plain.py
+++ b/x2go/backends/control/plain.py
@@ -68,9 +68,9 @@ def _rerewrite_blanks(cmd):
displaying command string in log output.
:param cmd: command that has to be rewritten for log output
- :type cmd: C{str}
+ :type cmd: ``str``
:returns: the command with ,,X2GO_SPACE_CHAR'' re-replaced by blanks
- :rtype: C{str}
+ :rtype: ``str``
"""
# X2Go run command replace X2GO_SPACE_CHAR string with blanks
@@ -88,13 +88,13 @@ def _rewrite_password(cmd, user=None, password=None):
Both macros can be used to on-the-fly authenticate via RDP.
:param cmd: command that is to be sent to an X2Go server script
- :type cmd: C{str}
+ :type cmd: ``str``
:param user: the SSH authenticated user name (Default value = None)
- :type user: C{str}
+ :type user: ``str``
:param password: the password being used for SSH authentication (Default value = None)
- :type password: C{str}
+ :type password: ``str``
:returns: the command with macros replaced
- :rtype: C{str}
+ :rtype: ``str``
"""
# if there is a ,,-u X2GO_USER'' parameter in RDP options then we will replace
@@ -113,7 +113,7 @@ class X2GoControlSession(paramiko.SSHClient):
In the Python X2Go concept, X2Go sessions fall into two parts: a control session and one to many terminal sessions.
The control session handles the SSH based communication between server and client. It is mainly derived from
- C{paramiko.SSHClient} and adds on X2Go related functionality.
+ ``paramiko.SSHClient`` and adds on X2Go related functionality.
"""
@@ -142,43 +142,43 @@ class X2GoControlSession(paramiko.SSHClient):
A control session normally gets set up by an L{X2GoSession} instance. Do not use it directly!!!
@param profile_name: the profile name of the session profile this control session works for
- @type profile_name: C{str}
+ @type profile_name: ``str``
@param add_to_known_hosts: Auto-accept server host validity?
- @type add_to_known_hosts: C{bool}
- @param known_hosts: the underlying Paramiko/SSH systems C{known_hosts} file
- @type known_hosts: C{str}
+ @type add_to_known_hosts: ``bool``
+ @param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
+ @type known_hosts: ``str``
@param forward_sshagent: forward SSH agent authentication requests to the X2Go client-side
- @type forward_sshagent: C{bool}
+ @type forward_sshagent: ``bool``
@param unique_hostkey_aliases: instead of storing [<hostname>]:<port> in known_hosts file, use the
(unique-by-design) profile ID
- @type unique_hostkey_aliases: C{bool}
+ @type unique_hostkey_aliases: ``bool``
@param terminal_backend: X2Go terminal session backend to use
- @type terminal_backend: C{str}
+ @type terminal_backend: ``str``
@param info_backend: backend for handling storage of server session information
- @type info_backend: C{X2GoServerSessionInfo*} instance
+ @type info_backend: ``X2GoServerSessionInfo*`` instance
@param list_backend: backend for handling storage of session list information
- @type list_backend: C{X2GoServerSessionList*} instance
+ @type list_backend: ``X2GoServerSessionList*`` instance
@param proxy_backend: backend for handling the X-proxy connections
- @type proxy_backend: C{X2GoProxy*} instance
+ @type proxy_backend: ``X2GoProxy*`` instance
@param client_rootdir: client base dir (default: ~/.x2goclient)
- @type client_rootdir: C{str}
+ @type client_rootdir: ``str``
@param sessions_rootdir: sessions base dir (default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param ssh_rootdir: ssh base dir (default: ~/.ssh)
- @type ssh_rootdir: C{str}
- @param published_applications_no_submenus: published applications menus with less items than C{published_applications_no_submenus}
+ @type ssh_rootdir: ``str``
+ @param published_applications_no_submenus: published applications menus with less items than ``published_applications_no_submenus``
are rendered without submenus
- @type published_applications_no_submenus: C{int}
+ @type published_applications_no_submenus: ``int``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoControlSession} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
@param low_latency: set this boolean switch for weak connections, it will double all timeout values.
- @type low_latency: C{bool}
- @param kwargs: catch any non-defined parameters in C{kwargs}
- @type kwargs: C{dict}
+ @type low_latency: ``bool``
+ @param kwargs: catch any non-defined parameters in ``kwargs``
+ @type kwargs: ``dict``
"""
self.associated_terminals = {}
@@ -244,7 +244,7 @@ class X2GoControlSession(paramiko.SSHClient):
:returns: the hostname of the connected X2Go server
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.hostname
@@ -256,14 +256,14 @@ class X2GoControlSession(paramiko.SSHClient):
:returns: the server-side port number of the control session's SSH connection
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.port
def load_session_host_keys(self):
"""\
- Load known SSH host keys from the C{known_hosts} file.
+ Load known SSH host keys from the ``known_hosts`` file.
If the file does not exist, create it first.
@@ -294,11 +294,11 @@ class X2GoControlSession(paramiko.SSHClient):
During sFTP operations, remote command execution gets blocked.
:param local_path: full local path name of the file to be put on the server
- :type local_path: C{str}
+ :type local_path: ``str``
:param remote_path: full remote path name of the server-side target location, path names have to be Unix-compliant
- :type remote_path: C{str}
+ :type remote_path: ``str``
:param timeout: this SFTP put action should not take longer then the given value (Default value = 20)
- :type timeout: C{int}
+ :type timeout: ``int``
:raises X2GoControlSessionException: if the SSH connection dropped out
"""
@@ -345,11 +345,11 @@ class X2GoControlSession(paramiko.SSHClient):
During sFTP operations, remote command execution gets blocked.
:param remote_path: full remote path name of the server-side target location, path names have to be Unix-compliant
- :type remote_path: C{str}
+ :type remote_path: ``str``
:param content: a text file, multi-line files use Unix-link EOL style
- :type content: C{str}
+ :type content: ``str``
:param timeout: this SFTP write action should not take longer then the given value (Default value = 20)
- :type timeout: C{int}
+ :type timeout: ``int``
:raises X2GoControlSessionException: if the SSH connection dropped out
"""
@@ -401,9 +401,9 @@ class X2GoControlSession(paramiko.SSHClient):
During sFTP operations, remote command execution gets blocked.
:param remote_path: full remote path name of the server-side file to be removed, path names have to be Unix-compliant
- :type remote_path: C{str}
+ :type remote_path: ``str``
:param timeout: this SFTP remove action should not take longer then the given value (Default value = 20)
- :type timeout: C{int}
+ :type timeout: ``int``
:raises X2GoControlSessionException: if the SSH connection dropped out
"""
@@ -452,17 +452,17 @@ class X2GoControlSession(paramiko.SSHClient):
During SSH command executions, sFTP operations get blocked.
:param cmd_line: the command to be executed on the remote server
- :type cmd_line: C{str} or C{list}
+ :type cmd_line: ``str`` or ``list``
:param loglevel: use this loglevel for reporting about remote command execution (Default value = log.loglevel_INFO)
- :type loglevel: C{int}
- :param timeout: if commands take longer than C{<timeout>} to be executed, consider the control session connection
+ :type loglevel: ``int``
+ :param timeout: if commands take longer than ``<timeout>`` to be executed, consider the control session connection
to have died. (Default value = 20)
- :type timeout: C{int}
- :param kwargs: parameters that get passed through to the C{paramiko.SSHClient.exec_command()} method.
- :type kwargs: C{dict}
+ :type timeout: ``int``
+ :param kwargs: parameters that get passed through to the ``paramiko.SSHClient.exec_command()`` method.
+ :type kwargs: ``dict``
:param **kwargs:
- :returns: C{True} if the command could be successfully executed on the remote X2Go server
- :rtype: C{bool}
+ :returns: ``True`` if the command could be successfully executed on the remote X2Go server
+ :rtype: ``bool``
:raises X2GoControlSessionException: if the command execution failed (due to a lost connection)
"""
@@ -586,9 +586,9 @@ class X2GoControlSession(paramiko.SSHClient):
Do a query for the server-side list of X2Go components and their versions.
:param force: do not use the cached component list, really ask the server (again) (Default value = False)
- :type force: C{bool}
+ :type force: ``bool``
:returns: dictionary of X2Go components (as keys) and their versions (as values)
- :rtype: C{list}
+ :rtype: ``list``
"""
if force:
@@ -616,9 +616,9 @@ class X2GoControlSession(paramiko.SSHClient):
Do a query for the server-side list of X2Go features.
:param force: do not use the cached feature list, really ask the server (again) (Default value = False)
- :type force: C{bool}
+ :type force: ``bool``
:returns: list of X2Go feature names
- :rtype: C{list}
+ :rtype: ``list``
"""
if force:
@@ -648,9 +648,9 @@ class X2GoControlSession(paramiko.SSHClient):
Retrieve and cache the members of a server-side POSIX group.
:param group: remote POSIX group name
- :type group: C{str}
+ :type group: ``str``
:returns: list of POSIX group members
- :rtype: C{list}
+ :rtype: ``list``
"""
if group not in self._remote_group:
@@ -668,9 +668,9 @@ class X2GoControlSession(paramiko.SSHClient):
FIXME: this method is currently non-functional.
:param username: remote user name
- :type username: C{str}
- :returns: C{True} if the remote user is allowed to launch X2Go sessions
- :rtype: C{bool}
+ :type username: ``str``
+ :returns: ``True`` if the remote user is allowed to launch X2Go sessions
+ :rtype: ``bool``
"""
###
@@ -686,9 +686,9 @@ class X2GoControlSession(paramiko.SSHClient):
Check if the remote user is allowed to use SSHFS mounts.
- :returns: C{True} if the user is allowed to connect client-side shares to the X2Go session
+ :returns: ``True`` if the user is allowed to connect client-side shares to the X2Go session
- :rtype: C{bool}
+ :rtype: ``bool``
"""
(stdin, stdout, stderr) = self._x2go_exec_command('which fusermount')
@@ -703,7 +703,7 @@ class X2GoControlSession(paramiko.SSHClient):
:returns: SSH transport's user name
- :rtype: C{str}
+ :rtype: ``str``
:raises X2GoControlSessionException: on SSH connection loss
"""
@@ -723,7 +723,7 @@ class X2GoControlSession(paramiko.SSHClient):
:returns: SSH transport's peer name
- :rtype: C{tuple}
+ :rtype: ``tuple``
:raises X2GoControlSessionException: on SSH connection loss
"""
@@ -752,7 +752,7 @@ class X2GoControlSession(paramiko.SSHClient):
Manipulate the control session's profile name.
:param profile_name: new profile name for this control session
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.profile_name = profile_name
@@ -762,11 +762,11 @@ class X2GoControlSession(paramiko.SSHClient):
Wraps around a Paramiko/SSH host key check.
:param hostname: the remote X2Go server's hostname
- :type hostname: C{str}
+ :type hostname: ``str``
:param port: the SSH port of the remote X2Go server (Default value = 22)
- :type port: C{int}
- :returns: C{True} if the host key check succeeded, C{False} otherwise
- :rtype: C{bool}
+ :type port: ``int``
+ :returns: ``True`` if the host key check succeeded, ``False`` otherwise
+ :rtype: ``bool``
"""
# trailing whitespace tolerance
@@ -791,100 +791,100 @@ class X2GoControlSession(paramiko.SSHClient):
):
"""\
Connect to an X2Go server and authenticate to it. This method is directly
- inherited from the C{paramiko.SSHClient} class. The features of the Paramiko
- SSH client connect method are recited here. The parameters C{add_to_known_hosts},
- C{force_password_auth}, C{session_instance} and all SSH proxy related parameters
+ inherited from the ``paramiko.SSHClient`` class. The features of the Paramiko
+ SSH client connect method are recited here. The parameters ``add_to_known_hosts``,
+ ``force_password_auth``, ``session_instance`` and all SSH proxy related parameters
have been added as X2Go specific parameters
The server's host key is checked against the system host keys
- (see C{load_system_host_keys}) and any local host keys (C{load_host_keys}).
+ (see ``load_system_host_keys``) and any local host keys (``load_host_keys``).
If the server's hostname is not found in either set of host keys, the missing host
- key policy is used (see C{set_missing_host_key_policy}). The default policy is
- to reject the key and raise an C{SSHException}.
+ key policy is used (see ``set_missing_host_key_policy``). The default policy is
+ to reject the key and raise an ``SSHException``.
Authentication is attempted in the following order of priority:
- - The C{pkey} or C{key_filename} passed in (if any)
+ - The ``pkey`` or ``key_filename`` passed in (if any)
- Any key we can find through an SSH agent
- - Any "id_rsa" or "id_dsa" key discoverable in C{~/.ssh/}
+ - Any "id_rsa" or "id_dsa" key discoverable in ``~/.ssh/``
- Plain username/password auth, if a password was given
If a private key requires a password to unlock it, and a password is
passed in, that password will be used to attempt to unlock the key.
:param hostname: the server to connect to
- :type hostname: C{str}
+ :type hostname: ``str``
:param port: the server port to connect to (Default value = 22)
- :type port: C{int}
+ :type port: ``int``
:param username: the username to authenticate as (defaults to the
current local username)
- :type username: C{str}
+ :type username: ``str``
:param password: a password to use for authentication or for unlocking
a private key (Default value = None)
- :type password: C{str}
+ :type password: ``str``
:param passphrase: a passphrase to use for unlocking
a private key in case the password is already needed for two-factor
authentication (Default value = None)
- :type passphrase: C{str}
+ :type passphrase: ``str``
:param key_filename: the filename, or list of filenames, of optional
private key(s) to try for authentication (Default value = None)
- :type key_filename: C{str} or list(str)
+ :type key_filename: ``str`` or list(str)
:param pkey: an optional private key to use for authentication (Default value = None)
- :type pkey: C{PKey}
+ :type pkey: ``PKey``
:param forward_sshagent: forward SSH agent authentication requests to the X2Go client-side
(will update the class property of the same name) (Default value = None)
- :type forward_sshagent: C{bool}
+ :type forward_sshagent: ``bool``
:param unique_hostkey_aliases: update the unique_hostkey_aliases class property (Default value = None)
- :type unique_hostkey_aliases: C{bool}
+ :type unique_hostkey_aliases: ``bool``
:param timeout: an optional timeout (in seconds) for the TCP connect (Default value = None)
:type timeout: float
- :param look_for_keys: set to C{True} to enable searching for discoverable
- private key files in C{~/.ssh/} (Default value = False)
- :type look_for_keys: C{bool}
- :param allow_agent: set to C{True} to enable connecting to a local SSH agent
+ :param look_for_keys: set to ``True`` to enable searching for discoverable
+ private key files in ``~/.ssh/`` (Default value = False)
+ :type look_for_keys: ``bool``
+ :param allow_agent: set to ``True`` to enable connecting to a local SSH agent
for acquiring authentication information (Default value = False)
- :type allow_agent: C{bool}
- :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()
+ :type allow_agent: ``bool``
+ :param add_to_known_hosts: non-paramiko option, if ``True`` paramiko.AutoAddPolicy()
+ is used as missing-host-key-policy. If set to ``False`` paramiko.RejectPolicy()
is used (Default value = None)
- :type add_to_known_hosts: C{bool}
+ :type add_to_known_hosts: ``bool``
:param force_password_auth: non-paramiko option, disable pub/priv key authentication
- completely, even if the C{pkey} or the C{key_filename} parameter is given (Default value = False)
- :type force_password_auth: C{bool}
+ completely, even if the ``pkey`` or the ``key_filename`` parameter is given (Default value = False)
+ :type force_password_auth: ``bool``
:param session_instance: an instance L{X2GoSession} using this L{X2GoControlSession}
instance. (Default value = None)
- :type session_instance: C{obj}
+ :type session_instance: ``obj``
:param use_sshproxy: connect through an SSH proxy (Default value = False)
- :type use_sshproxy: C{True} if an SSH proxy is to be used for tunneling the connection
+ :type use_sshproxy: ``True`` if an SSH proxy is to be used for tunneling the connection
:param sshproxy_host: hostname of the SSH proxy server (Default value = None)
- :type sshproxy_host: C{str}
+ :type sshproxy_host: ``str``
:param sshproxy_port: port of the SSH proxy server (Default value = 22)
- :type sshproxy_port: C{int}
- :param sshproxy_user: username that we use for authenticating against C{<sshproxy_host>} (Default value = None)
- :type sshproxy_user: C{str}
+ :type sshproxy_port: ``int``
+ :param sshproxy_user: username that we use for authenticating against ``<sshproxy_host>`` (Default value = None)
+ :type sshproxy_user: ``str``
:param sshproxy_password: a password to use for SSH proxy authentication or for unlocking
a private key (Default value = None)
- :type sshproxy_password: C{str}
+ :type sshproxy_password: ``str``
:param sshproxy_passphrase: a passphrase to use for unlocking
a private key needed for the SSH proxy host in case the sshproxy_password is already needed for
two-factor authentication (Default value = '')
- :type sshproxy_passphrase: C{str}
- :param sshproxy_force_password_auth: enforce using a given C{sshproxy_password} even if a key(file) is given (Default value = False)
- :type sshproxy_force_password_auth: C{bool}
+ :type sshproxy_passphrase: ``str``
+ :param sshproxy_force_password_auth: enforce using a given ``sshproxy_password`` even if a key(file) is given (Default value = False)
+ :type sshproxy_force_password_auth: ``bool``
:param sshproxy_key_filename: local file location of the private key file (Default value = None)
- :type sshproxy_key_filename: C{str}
+ :type sshproxy_key_filename: ``str``
:param sshproxy_pkey: an optional private key to use for SSH proxy authentication (Default value = None)
- :type sshproxy_pkey: C{PKey}
- :param sshproxy_look_for_keys: set to C{True} to enable connecting to a local SSH agent
+ :type sshproxy_pkey: ``PKey``
+ :param sshproxy_look_for_keys: set to ``True`` to enable connecting to a local SSH agent
for acquiring authentication information (for SSH proxy authentication) (Default value = False)
- :type sshproxy_look_for_keys: C{bool}
- :param sshproxy_allow_agent: set to C{True} to enable connecting to a local SSH agent
+ :type sshproxy_look_for_keys: ``bool``
+ :param sshproxy_allow_agent: set to ``True`` to enable connecting to a local SSH agent
for acquiring authentication information (for SSH proxy authentication) (Default value = False)
- :type sshproxy_allow_agent: C{bool}
+ :type sshproxy_allow_agent: ``bool``
:param sshproxy_tunnel: the SSH proxy tunneling parameters, format is: <local-address>:<local-port>:<remote-address>:<remote-port> (Default value = None)
- :type sshproxy_tunnel: C{str}
- :returns: C{True} if an authenticated SSH transport could be retrieved by this method
- :rtype: C{bool}
+ :type sshproxy_tunnel: ``str``
+ :returns: ``True`` if an authenticated SSH transport could be retrieved by this method
+ :rtype: ``bool``
:raises BadHostKeyException: if the server's host key could not be
verified
:raises AuthenticationException: if authentication failed
@@ -1180,7 +1180,7 @@ class X2GoControlSession(paramiko.SSHClient):
Drop an associated terminal session.
:param terminal_session: the terminal session object to remove from the list of associated terminals
- :type terminal_session: C{X2GoTerminalSession*}
+ :type terminal_session: ``X2GoTerminalSession*``
"""
for t_name in list(self.associated_terminals.keys()):
@@ -1196,7 +1196,7 @@ class X2GoControlSession(paramiko.SSHClient):
:returns: report success or failure after having disconnected
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.associated_terminals:
@@ -1259,9 +1259,9 @@ class X2GoControlSession(paramiko.SSHClient):
Test if the remote home directory exists.
- :returns: C{True} if the home directory exists, C{False} otherwise
+ :returns: ``True`` if the home directory exists, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
(_stdin, _stdout, _stderr) = self._x2go_exec_command('stat -tL "%s"' % self._x2go_remote_home, loglevel=log.loglevel_DEBUG)
@@ -1275,9 +1275,9 @@ class X2GoControlSession(paramiko.SSHClient):
Test if the connection to the remote X2Go server is still alive.
- :returns: C{True} if the connection is still alive, C{False} otherwise
+ :returns: ``True`` if the connection is still alive, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
try:
@@ -1293,9 +1293,9 @@ class X2GoControlSession(paramiko.SSHClient):
Test if the connection to the remote X2Go server died on the way.
- :returns: C{True} if the connection has died, C{False} otherwise
+ :returns: ``True`` if the connection has died, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.session_died
@@ -1304,25 +1304,25 @@ class X2GoControlSession(paramiko.SSHClient):
"""\
Retrieve the menu tree of published applications from the remote X2Go server.
- The C{raw} option lets this method return a C{list} of C{dict} elements. Each C{dict} elements has a
- C{desktop} key containing a shortened version of the text output of a .desktop file and an C{icon} key
+ The ``raw`` option lets this method return a ``list`` of ``dict`` elements. Each ``dict`` elements has a
+ ``desktop`` key containing a shortened version of the text output of a .desktop file and an ``icon`` key
which contains the desktop base64-encoded icon data.
- The {very_raw} lets this method return the output of the C{x2gogetapps} script as is.
+ The {very_raw} lets this method return the output of the ``x2gogetapps`` script as is.
:param lang: locale/language identifier (Default value = None)
- :type lang: C{str}
+ :type lang: ``str``
:param refresh: force reload of the menu tree from X2Go server (Default value = False)
- :type refresh: C{bool}
+ :type refresh: ``bool``
:param raw: retrieve a raw output of the server list of published applications (Default value = False)
- :type raw: C{bool}
+ :type raw: ``bool``
:param very_raw: retrieve a very raw output of the server list of published applications (Default value = False)
- :type very_raw: C{bool}
+ :type very_raw: ``bool``
:param max_no_submenus: Number of applications before applications are put into XDG category submenus
(Default value = defaults.PUBAPP_MAX_NO_SUBMENUS)
- :type max_no_submenus: C{int}
+ :type max_no_submenus: ``int``
:returns: an i18n capable menu tree packed as a Python dictionary
- :rtype: C{list}
+ :rtype: ``list``
"""
self._already_querying_published_applications.acquire()
@@ -1503,17 +1503,17 @@ class X2GoControlSession(paramiko.SSHClient):
Start a new X2Go session.
The L{X2GoControlSession.start()} method accepts any parameter
- that can be passed to any of the C{X2GoTerminalSession} backend class
+ that can be passed to any of the ``X2GoTerminalSession`` backend class
constructors.
:param kwargs: parameters that get passed through to the control session's
- L{resume()} method, only the C{session_name} parameter will get removed
+ L{resume()} method, only the ``session_name`` parameter will get removed
before pass-through
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
:returns: return: return value of the cascaded L{resume()} method, denoting the success or failure
of the session startup
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if 'session_name' in list(kwargs.keys()):
@@ -1525,18 +1525,18 @@ class X2GoControlSession(paramiko.SSHClient):
Resume a running/suspended X2Go session.
The L{X2GoControlSession.resume()} method accepts any parameter
- that can be passed to any of the C{X2GoTerminalSession*} backend class constructors.
+ that can be passed to any of the ``X2GoTerminalSession*`` backend class constructors.
:param session_name: the X2Go session name (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param session_instance: a Python X2Go session instance (Default value = None)
:type session_instance: L{X2GoSession}
:param session_list: Default value = None)
:param kwargs: catch any non-defined param in kwargs
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
:returns: True if the session could be successfully resumed
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoUserException: if the remote user is not allowed to launch/resume X2Go sessions.
"""
@@ -1595,20 +1595,20 @@ class X2GoControlSession(paramiko.SSHClient):
Share another already running desktop session. Desktop sharing can be run
in two different modes: view-only and full-access mode.
- :param desktop: desktop ID of a sharable desktop in format C{<user>@<display>} (Default value = None)
- :type desktop: C{str}
+ :param desktop: desktop ID of a sharable desktop in format ``<user>@<display>`` (Default value = None)
+ :type desktop: ``str``
:param user: user name and display number can be given separately, here give the
name of the user who wants to share a session with you (Default value = None)
- :type user: C{str}
+ :type user: ``str``
:param display: user name and display number can be given separately, here give the
number of the display that a user allows you to be shared with (Default value = None)
- :type display: C{str}
+ :type display: ``str``
:param share_mode: desktop sharing mode, 0 stands for VIEW-ONLY, 1 for FULL-ACCESS mode (Default value = 0)
- :type share_mode: C{int}
+ :type share_mode: ``int``
:param **kwargs:
:returns: True if the session could be successfully shared
- :rtype: C{bool}
- :raises X2GoDesktopSharingException: if C{username} and C{dislpay} do not relate to a
+ :rtype: ``bool``
+ :raises X2GoDesktopSharingException: if ``username`` and ``dislpay`` do not relate to a
sharable desktop session
"""
@@ -1630,14 +1630,14 @@ class X2GoControlSession(paramiko.SSHClient):
List all desktop-like sessions of current user (or of users that have
granted desktop sharing) on the connected server.
- :param raw: if C{True}, the raw output of the server-side X2Go command
- C{x2golistdesktops} is returned. (Default value = False)
- :type raw: C{bool}
+ :param raw: if ``True``, the raw output of the server-side X2Go command
+ ``x2golistdesktops`` is returned. (Default value = False)
+ :type raw: ``bool``
:param maxwait: time in secs to wait for server query to reply (Default value = 20)
- :type maxwait: C{int}
+ :type maxwait: ``int``
:returns: a list of X2Go desktops available for sharing
- :rtype: C{list}
- :raises X2GoTimeOutException: on command execution timeouts, with the server-side C{x2golistdesktops}
+ :rtype: ``list``
+ :raises X2GoTimeOutException: on command execution timeouts, with the server-side ``x2golistdesktops``
command this can sometimes happen. Make sure you ignore these time-outs and to try again
"""
@@ -1674,16 +1674,16 @@ class X2GoControlSession(paramiko.SSHClient):
List all mounts for a given session of the current user on the connected server.
:param session_name: name of a session to query a list of mounts for
- :type session_name: C{str}
- :param raw: if C{True}, the raw output of the server-side X2Go command
- C{x2golistmounts} is returned. (Default value = False)
- :type raw: C{bool}
- :param maxwait: stop processing C{x2golistmounts} after C{<maxwait>} seconds (Default value = 20)
- :type maxwait: C{int}
- :returns: a list of client-side mounts for X2Go session C{<session_name>} on the server
- :rtype: C{list}
+ :type session_name: ``str``
+ :param raw: if ``True``, the raw output of the server-side X2Go command
+ ``x2golistmounts`` is returned. (Default value = False)
+ :type raw: ``bool``
+ :param maxwait: stop processing ``x2golistmounts`` after ``<maxwait>`` seconds (Default value = 20)
+ :type maxwait: ``int``
+ :returns: a list of client-side mounts for X2Go session ``<session_name>`` on the server
+ :rtype: ``list``
:raises X2GoTimeOutException: on command execution timeouts, queries with the server-side
- C{x2golistmounts} query should normally be processed quickly, a time-out may hint that the
+ ``x2golistmounts`` query should normally be processed quickly, a time-out may hint that the
control session has lost its connection to the X2Go server
"""
@@ -1717,13 +1717,13 @@ class X2GoControlSession(paramiko.SSHClient):
"""\
List all sessions of current user on the connected server.
- :param raw: if C{True}, the raw output of the server-side X2Go command
- C{x2golistsessions} is returned. (Default value = False)
- :type raw: C{bool}
- :returns: normally an instance of a C{X2GoServerSessionList*} backend is returned. However,
- if the raw argument is set, the plain text output of the server-side C{x2golistsessions}
+ :param raw: if ``True``, the raw output of the server-side X2Go command
+ ``x2golistsessions`` is returned. (Default value = False)
+ :type raw: ``bool``
+ :returns: normally an instance of a ``X2GoServerSessionList*`` backend is returned. However,
+ if the raw argument is set, the plain text output of the server-side ``x2golistsessions``
command is returned
- :rtype: C{X2GoServerSessionList} instance or str
+ :rtype: ``X2GoServerSessionList`` instance or str
:raises X2GoControlSessionException: on command execution timeouts, if this happens the control session will
be interpreted as disconnected due to connection loss
@@ -1793,9 +1793,9 @@ class X2GoControlSession(paramiko.SSHClient):
connected user on the remote X2Go server and terminate them.
:param destroy_terminals: destroy the terminal session instances after cleanup (Default value = True)
- :type destroy_terminals: C{bool}
+ :type destroy_terminals: ``bool``
:param published_applications: also clean up published applications providing sessions (Default value = False)
- :type published_applications: C{bool}
+ :type published_applications: ``bool``
"""
session_list = self.list_sessions()
@@ -1816,26 +1816,26 @@ class X2GoControlSession(paramiko.SSHClient):
def is_connected(self):
"""\
- Returns C{True} if this control session is connected to the remote server (that
+ Returns ``True`` if this control session is connected to the remote server (that
is: if it has a valid Paramiko/SSH transport object).
:returns: X2Go session connected?
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.get_transport() is not None and self.get_transport().is_authenticated()
def is_running(self, session_name):
"""\
- Returns C{True} if the given X2Go session is in running state,
- C{False} else.
+ Returns ``True`` if the given X2Go session is in running state,
+ ``False`` else.
:param session_name: X2Go name of the session to be queried
- :type session_name: C{str}
- :returns: X2Go session running? If C{<session_name>} is not listable by the L{list_sessions()} method then C{None} is returned
- :rtype: C{bool} or C{None}
+ :type session_name: ``str``
+ :returns: X2Go session running? If ``<session_name>`` is not listable by the L{list_sessions()} method then ``None`` is returned
+ :rtype: ``bool`` or ``None``
"""
session_infos = self.list_sessions()
@@ -1845,13 +1845,13 @@ class X2GoControlSession(paramiko.SSHClient):
def is_suspended(self, session_name):
"""\
- Returns C{True} if the given X2Go session is in suspended state,
- C{False} else.
+ Returns ``True`` if the given X2Go session is in suspended state,
+ ``False`` else.
:param session_name: X2Go name of the session to be queried
- :type session_name: C{str}
- :returns: X2Go session suspended? If C{<session_name>} is not listable by the L{list_sessions()} method then C{None} is returned
- :rtype: C{bool} or C{None}
+ :type session_name: ``str``
+ :returns: X2Go session suspended? If ``<session_name>`` is not listable by the L{list_sessions()} method then ``None`` is returned
+ :rtype: ``bool`` or ``None``
"""
session_infos = self.list_sessions()
@@ -1861,15 +1861,15 @@ class X2GoControlSession(paramiko.SSHClient):
def has_terminated(self, session_name):
"""\
- Returns C{True} if the X2Go session with name C{<session_name>} has been seen
+ Returns ``True`` if the X2Go session with name ``<session_name>`` has been seen
by this control session and--in the meantime--has been terminated.
- If C{<session_name>} has not been seen, yet, the method will return C{None}.
+ If ``<session_name>`` has not been seen, yet, the method will return ``None``.
:param session_name: X2Go name of the session to be queried
- :type session_name: C{str}
+ :type session_name: ``str``
:returns: X2Go session has terminated?
- :rtype: C{bool} or C{None}
+ :rtype: ``bool`` or ``None``
"""
session_infos = self.list_sessions()
@@ -1886,13 +1886,13 @@ class X2GoControlSession(paramiko.SSHClient):
def suspend(self, session_name):
"""\
- Suspend X2Go session with name C{<session_name>} on the connected
+ Suspend X2Go session with name ``<session_name>`` on the connected
server.
:param session_name: X2Go name of the session to be suspended
- :type session_name: C{str}
- :returns: C{True} if the session could be successfully suspended
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True`` if the session could be successfully suspended
+ :rtype: ``bool``
"""
_ret = False
@@ -1922,15 +1922,15 @@ class X2GoControlSession(paramiko.SSHClient):
def terminate(self, session_name, destroy_terminals=True):
"""\
- Terminate X2Go session with name C{<session_name>} on the connected
+ Terminate X2Go session with name ``<session_name>`` on the connected
server.
:param session_name: X2Go name of the session to be terminated
- :type session_name: C{str}
+ :type session_name: ``str``
:param destroy_terminals: destroy all terminal sessions associated to this control session (Default value = True)
- :type destroy_terminals: C{bool}
- :returns: C{True} if the session could be successfully terminated
- :rtype: C{bool}
+ :type destroy_terminals: ``bool``
+ :returns: ``True`` if the session could be successfully terminated
+ :rtype: ``bool``
"""
diff --git a/x2go/backends/info/plain.py b/x2go/backends/info/plain.py
index 659a177..2671e30 100644
--- a/x2go/backends/info/plain.py
+++ b/x2go/backends/info/plain.py
@@ -42,7 +42,7 @@ class X2GoServerSessionInfo(object):
"""\
L{X2GoServerSessionInfo} is used to store all information
that is retrieved from the connected X2Go server on
- C{X2GoTerminalSession.start()} resp. C{X2GoTerminalSession.resume()}.
+ ``X2GoTerminalSession.start()`` resp. ``X2GoTerminalSession.resume()``.
"""
@@ -60,7 +60,7 @@ class X2GoServerSessionInfo(object):
Parse a single line of X2Go's listsessions output.
:param x2go_output: output from ,,x2golistsessions'' command (as list of strings/lines)
- :type x2go_output: C{list}
+ :type x2go_output: ``list``
"""
try:
@@ -102,9 +102,9 @@ class X2GoServerSessionInfo(object):
Detect from session info if this session is a published applications provider.
- :returns: returns C{True} if this session is a published applications provider
+ :returns: returns ``True`` if this session is a published applications provider
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return bool(re.match('.*_stRPUBLISHED_.*', self.name))
@@ -114,9 +114,9 @@ class X2GoServerSessionInfo(object):
Is this session running?
- :returns: C{True} if the session is running, C{False} otherwise
+ :returns: ``True`` if the session is running, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.status == 'R'
@@ -128,7 +128,7 @@ class X2GoServerSessionInfo(object):
:returns: session type
- :rtype: C{str}
+ :rtype: ``str``
"""
cmd = self.name.split('_')[1]
@@ -143,9 +143,9 @@ class X2GoServerSessionInfo(object):
Get the share mode of a shadow session.
- :returns: share mode (0: view-only, 1: full access), C{None} when used for non-desktop-sharing sessions
+ :returns: share mode (0: view-only, 1: full access), ``None`` when used for non-desktop-sharing sessions
- :rtype: C{str}
+ :rtype: ``str``
"""
share_mode = None
@@ -160,9 +160,9 @@ class X2GoServerSessionInfo(object):
Is this session suspended?
- :returns: C{True} if the session is suspended, C{False} otherwise
+ :returns: ``True`` if the session is suspended, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.status == 'S'
@@ -172,9 +172,9 @@ class X2GoServerSessionInfo(object):
Is this session a desktop session?
- :returns: C{True} if this session is a desktop session, C{False} otherwise
+ :returns: ``True`` if this session is a desktop session, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.get_session_type() == 'D'
@@ -184,7 +184,7 @@ class X2GoServerSessionInfo(object):
Parse x2gostartagent output.
:param x2go_output: output from ,,x2gostartagent'' command (as list of strings/lines)
- :type x2go_output: C{list}
+ :type x2go_output: ``list``
"""
try:
@@ -224,9 +224,9 @@ class X2GoServerSessionInfo(object):
def initialize(self, x2go_output, username='', hostname='', local_container='', remote_container=''):
"""\
- Setup a a session info data block, includes parsing of X2Go server's C{x2gostartagent} stdout values.
+ Setup a a session info data block, includes parsing of X2Go server's ``x2gostartagent`` stdout values.
- :param x2go_output: X2Go server's C{x2gostartagent} command output, each value
+ :param x2go_output: X2Go server's ``x2gostartagent`` command output, each value
separated by a newline character.
:type x2go_output: str
:param username: session user name (Default value = '')
@@ -277,7 +277,7 @@ class X2GoServerSessionInfo(object):
:returns: session status
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.status
@@ -311,7 +311,7 @@ class X2GoServerSessionInfo(object):
Update all properties of a L{X2GoServerSessionInfo} object.
:param session_info: a provided session info data structure
- :type session_info: C{X2GoServerSessionInfo*}
+ :type session_info: ``X2GoServerSessionInfo*``
"""
if type(session_info) == type(self):
@@ -334,18 +334,18 @@ class X2GoServerSessionList(object):
"""\
L{X2GoServerSessionList} is used to store all information
that is retrieved from a connected X2Go server on a
- C{X2GoControlSession.list_sessions()} call.
+ ``X2GoControlSession.list_sessions()`` call.
"""
def __init__(self, x2go_output=None, info_backend=X2GoServerSessionInfo):
"""\
- @param x2go_output: X2Go server's C{x2golistsessions} command output, each
+ @param x2go_output: X2Go server's ``x2golistsessions`` command output, each
session separated by a newline character. Session values are separated
by Unix Pipe Symbols ('|')
@type x2go_output: str
@param info_backend: the session info backend to use
- @type info_backend: C{X2GoServerSessionInfo*}
+ @type info_backend: ``X2GoServerSessionInfo*``
"""
self.sessions = {}
@@ -366,19 +366,19 @@ class X2GoServerSessionList(object):
Set the sessions property directly by parsing a complete data structure.
:param sessions: set this instance's list of sessions directly
- :type sessions: C{dict}
+ :type sessions: ``dict``
"""
self.sessions = sessions
def get_session_info(self, session_name):
"""\
- Retrieve the session information for C{<session_name>}.
+ Retrieve the session information for ``<session_name>``.
:param session_name: the queried session name
- :type session_name: C{str}
- :returns: the session info of C{<session_name>}
- :rtype: C{X2GoServerSessionInfo*} or C{None}
+ :type session_name: ``str``
+ :returns: the session info of ``<session_name>``
+ :rtype: ``X2GoServerSessionInfo*`` or ``None``
"""
try:
@@ -391,11 +391,11 @@ class X2GoServerSessionList(object):
Find session with a given display number on a given host.
:param property_name: match a session based on this property name
- :type property_name: C{str}
- :param value: the resulting session has to match this value for C{<property_name>}
- :type value: C{str}
+ :type property_name: ``str``
+ :param value: the resulting session has to match this value for ``<property_name>``
+ :type value: ``str``
:param hostname: the result has to match this hostname (Default value = None)
- :type hostname: C{str}
+ :type hostname: ``str``
"""
if property_name == 'display':
diff --git a/x2go/backends/printing/file.py b/x2go/backends/printing/file.py
index d2f2bd6..aeaedf9 100644
--- a/x2go/backends/printing/file.py
+++ b/x2go/backends/printing/file.py
@@ -66,8 +66,8 @@ _print_property_map = {
class X2GoClientPrinting(inifiles.X2GoIniFile):
"""\
L{x2go.backends.printing.file.X2GoClientPrinting} provides access to the X2Go ini-like file
- »printing« as stored in C{~/.x2goclient/printing} resp. globally
- C{/etc/x2goclient/printing}.
+ »printing« as stored in ``~/.x2goclient/printing`` resp. globally
+ ``/etc/x2goclient/printing``.
An instance of L{x2go.backends.printing.file.X2GoClientPrinting} is created on each incoming
print job. This facilitates that on every print job the print action
@@ -84,16 +84,16 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
"""\
@param config_files: a list of configuration files names (e.g. a global filename and a user's home
directory filename)
- @type config_files: C{list}
+ @type config_files: ``list``
@param defaults: a cascaded Python dicitionary structure with ini file defaults (to override
Python X2Go's hard coded defaults in L{defaults}
- @type defaults: C{dict}
+ @type defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintAction} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.client_instance = client_instance
@@ -142,7 +142,7 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
:returns: Returns the print action object
- :rtype: C{obj} or C{str}
+ :rtype: ``obj`` or ``str``
"""
return self.get_print_action()
@@ -152,13 +152,13 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
Return the print action described by the »printing« configuration file.
:param reload: reload the configuration file before retrieving the print action? (Default value = False)
- :type reload: C{bool}
+ :type reload: ``bool``
:param reinit: re-detect the print action from what is stored in cache? (Default value = False)
- :type reinit: C{bool}
+ :type reinit: ``bool``
:param return_name: return the print action name, not the class (Default value = False)
- :type return_name: C{bool}
+ :type return_name: ``bool``
:returns: the configured print action
- :rtype: C{obj} or C{str}
+ :rtype: ``obj`` or ``str``
"""
if reload:
@@ -177,9 +177,9 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
Retrieve a printing property as mapped by the L{_print_property_map} dictionary.
:param print_property: a printing property
- :type print_property: C{str}
- :returns: the stored value for C{<print_property>}
- :rtype: C{str}
+ :type print_property: ``str``
+ :returns: the stored value for ``<print_property>``
+ :rtype: ``str``
:raises X2GoClientPrintingException: if the printing property does not exist
"""
@@ -195,9 +195,9 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
Set a printing property as mapped by the L{_print_property_map} dictionary.
:param print_property: a printing property
- :type print_property: C{str}
- :param value: the value to be stored as C{<print_property>}
- :type value: C{str}
+ :type print_property: ``str``
+ :param value: the value to be stored as ``<print_property>``
+ :type value: ``str``
:raises X2GoClientPrintingException: if the printing property does not exist or if there is a type mismatch
"""
@@ -220,9 +220,9 @@ class X2GoClientPrinting(inifiles.X2GoIniFile):
as mapped by the L{_print_property_map} dictionary.
:param print_action: the print action name
- :type print_action: C{str}
+ :type print_action: ``str``
:param print_properties: the printing properties to set for the given print action
- :type print_properties: C{dict}
+ :type print_properties: ``dict``
:param **print_properties:
"""
diff --git a/x2go/backends/printing/winreg.py b/x2go/backends/printing/winreg.py
index 75109bd..303d545 100644
--- a/x2go/backends/printing/winreg.py
+++ b/x2go/backends/printing/winreg.py
@@ -62,13 +62,13 @@ class X2GoClientPrinting(object):
"""\
@param defaults: a cascaded Python dicitionary structure with ini file defaults (to override
Python X2Go's hard coded defaults in L{defaults}
- @type defaults: C{dict}
+ @type defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintAction} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
raise X2GoNotImplementedYetException('WINREG backend support is not implemented yet')
diff --git a/x2go/backends/profiles/base.py b/x2go/backends/profiles/base.py
index fde4abc..d200f00 100644
--- a/x2go/backends/profiles/base.py
+++ b/x2go/backends/profiles/base.py
@@ -55,13 +55,13 @@ class X2GoSessionProfiles(object):
configuration backends.
@param session_profile_defaults: a default session profile
- @type session_profile_defaults: C{dict}
+ @type session_profile_defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{x2go.backends.profiles.httpbroker.X2GoSessionProfiles} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.defaultValues = {}
@@ -87,10 +87,10 @@ class X2GoSessionProfiles(object):
Retrieve the session profile configuration for a given session profile ID (or name)
@param profile_id_or_name: profile ID or profile name
- @type profile_id_or_name: C{str}
+ @type profile_id_or_name: ``str``
@return: the profile ID's / name's profile configuration
- @rtype: C{dict}
+ @rtype: ``dict``
"""
_profile_id = self.check_profile_id_or_name(self, profile_id_or_name)
@@ -103,7 +103,7 @@ class X2GoSessionProfiles(object):
recommented to (re-)initialize these caches.
:param profile_id_or_name: profile ID or profile name
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
"""
profile_id = self.check_profile_id_or_name(profile_id_or_name)
@@ -117,7 +117,7 @@ class X2GoSessionProfiles(object):
cache storage.
:param profile_id: profile ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
"""
pass
@@ -130,7 +130,7 @@ class X2GoSessionProfiles(object):
:returns: a set of session profiles
- :rtype: C{dict}
+ :rtype: ``dict``
"""
self.session_profiles = self. _populate_session_profiles()
@@ -161,7 +161,7 @@ class X2GoSessionProfiles(object):
:returns: a set of session profiles
- :rtype: C{dict}
+ :rtype: ``dict``
"""
return {}
@@ -171,11 +171,11 @@ class X2GoSessionProfiles(object):
Detect a human readable session profile type from the session profile configuration.
:param profile_id_or_name: profile ID or profile name
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:param force: re-detect the meta type, otherwise use a cached result (Default value = False)
- :type force: C{bool}
+ :type force: ``bool``
:returns: the profile ID's / name's meta type
- :rtype: C{str}
+ :rtype: ``str``
"""
_profile_id = self.check_profile_id_or_name(profile_id_or_name)
@@ -214,12 +214,12 @@ class X2GoSessionProfiles(object):
Check if a given profile name (or ID) is mutable or not.
:param profile_id_or_name: profile name or profile ID (Default value = None)
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:param profile_id: if the profile ID is known, pass it in directly and skip
the L{check_profile_id_or_name()} call (Default value = None)
- :type profile_id: C{str}
- :returns: C{True} if the session profile of the specified name/ID is mutable
- :rtype: C{bool}
+ :type profile_id: ``str``
+ :returns: ``True`` if the session profile of the specified name/ID is mutable
+ :rtype: ``bool``
:raises X2GoProfileException: if no such session profile exists
"""
@@ -235,9 +235,9 @@ class X2GoSessionProfiles(object):
code here if a given profile ID is mutable or not.
:param profile_id: profile ID
- :type profile_id: C{str}
- :returns: C{True} if the session profile of the specified ID is mutable
- :rtype: C{bool}
+ :type profile_id: ``str``
+ :returns: ``True`` if the session profile of the specified ID is mutable
+ :rtype: ``bool``
"""
return False
@@ -250,7 +250,7 @@ class X2GoSessionProfiles(object):
:returns: list of mutable profiles
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._supports_mutable_profiles()
@@ -264,7 +264,7 @@ class X2GoSessionProfiles(object):
:returns: list of mutable profiles
- :rtype: C{list}
+ :rtype: ``list``
"""
return False
@@ -276,7 +276,7 @@ class X2GoSessionProfiles(object):
:returns: List up all session profile IDs of mutable session profiles.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return [ p for p in self.profile_ids if self._is_mutable(p) ]
@@ -286,9 +286,9 @@ class X2GoSessionProfiles(object):
Store session profile data to the storage backend.
- :returns: C{True} if the write process has been successfull, C{False} otherwise
+ :returns: ``True`` if the write process has been successfull, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
# then update profile IDs for profiles that have a renamed host attribute...
@@ -321,8 +321,8 @@ class X2GoSessionProfiles(object):
:param option: the option to get the data type for
:type option: will be detected by this method
- :returns: the data type of C{option}
- :rtype: C{type}
+ :returns: the data type of ``option``
+ :rtype: ``type``
"""
try:
@@ -335,13 +335,13 @@ class X2GoSessionProfiles(object):
The configuration options for a single session profile.
:param profile_id_or_name: either profile ID or profile name is accepted (Default value = None)
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:param parameter: if specified, only the value for the given parameter is returned (Default value = None)
- :type parameter: C{str}
- :param profile_id: profile ID (faster than specifying C{profile_id_or_name}) (Default value = None)
- :type profile_id: C{str}
+ :type parameter: ``str``
+ :param profile_id: profile ID (faster than specifying ``profile_id_or_name``) (Default value = None)
+ :type profile_id: ``str``
:returns: the session profile configuration for the given profile ID (or name)
- :rtype: C{dict}
+ :rtype: ``dict``
"""
_profile_id = profile_id or self.check_profile_id_or_name(profile_id_or_name)
@@ -387,7 +387,7 @@ class X2GoSessionProfiles(object):
:returns: default session profile
- :rtype: C{dict}
+ :rtype: ``dict``
"""
return copy.deepcopy(self.defaultSessionProfile)
@@ -397,9 +397,9 @@ class X2GoSessionProfiles(object):
Does a session profile of a given profile ID or profile name exist?
:param profile_id_or_name: profile ID or profile name
- :type profile_id_or_name: C{str}
- :returns: C{True} if there is such a session profile, C{False} otherwise
- :rtype: C{bool}
+ :type profile_id_or_name: ``str``
+ :returns: ``True`` if there is such a session profile, ``False`` otherwise
+ :rtype: ``bool``
"""
try:
@@ -432,7 +432,7 @@ class X2GoSessionProfiles(object):
:returns: list of available session profile IDs
- :rtype: C{list}
+ :rtype: ``list``
"""
return []
@@ -442,9 +442,9 @@ class X2GoSessionProfiles(object):
Does a session profile of a given profile ID exist? (Faster than L{has_profile()}.)
:param profile_id: profile ID
- :type profile_id: C{str}
- :returns: C{True} if there is such a session profile, C{False} otherwise
- :rtype: C{bool}
+ :type profile_id: ``str``
+ :returns: ``True`` if there is such a session profile, ``False`` otherwise
+ :rtype: ``bool``
"""
return str(profile_id) in self.profile_ids
@@ -465,9 +465,9 @@ class X2GoSessionProfiles(object):
Does a session profile of a given profile name exist? (Faster than L{has_profile()}.)
:param profile_name: profile name
- :type profile_name: C{str}
- :returns: C{True} if there is such a session profile, C{False} otherwise
- :rtype: C{bool}
+ :type profile_name: ``str``
+ :returns: ``True`` if there is such a session profile, ``False`` otherwise
+ :rtype: ``bool``
"""
return str(profile_name) in self.profile_names
@@ -477,9 +477,9 @@ class X2GoSessionProfiles(object):
Convert profile name to profile ID.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: profile ID
- :rtype: C{str}
+ :rtype: ``str``
"""
_profile_ids = [ p for p in self.profile_ids if self._cached_profile_ids[p] == profile_name ]
@@ -495,9 +495,9 @@ class X2GoSessionProfiles(object):
Convert profile ID to profile name.
:param profile_id: profile ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: profile name
- :rtype: C{str}
+ :rtype: ``str``
"""
try:
@@ -511,14 +511,14 @@ class X2GoSessionProfiles(object):
Add a new session profile.
:param profile_id: a custom profile ID--if left empty a profile ID will be auto-generated (Default value = None)
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param kwargs: session profile options for this new session profile
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param force_add: enforce adding of the given profile (Default value = False)
- :type force_add: C{bool}
+ :type force_add: ``bool``
:param **kwargs:
:returns: the (auto-generated) profile ID of the new session profile
- :rtype: C{str}
+ :rtype: ``str``
"""
if profile_id is None or profile_id in self.profile_ids:
@@ -550,7 +550,7 @@ class X2GoSessionProfiles(object):
Delete a session profile from the configuration file.
:param profile_id_or_name: profile ID or profile name
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
"""
_profile_id = self.check_profile_id_or_name(profile_id_or_name)
@@ -567,7 +567,7 @@ class X2GoSessionProfiles(object):
a complete session profile from the storage backend via this method.
:param profile_id: Profile ID of the profile to be deleted
- :type profile_id: C{str}
+ :type profile_id: ``str``
"""
pass
@@ -577,14 +577,14 @@ class X2GoSessionProfiles(object):
Update a value in a session profile.
:param profile_id_or_name: the profile ID
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:param option: the session profile option of the given profile ID
- :type option: C{str}
+ :type option: ``str``
:param value: the value to update the session profile option with
:type value: any type, depends on the session profile option
:param profile_id: if the profile ID is known, pass it in directly and skip
the L{check_profile_id_or_name()} call (Default value = None)
- :type profile_id: C{str}
+ :type profile_id: ``str``
"""
try:
@@ -633,11 +633,11 @@ class X2GoSessionProfiles(object):
a session profile's value in the storage backend via this method.
:param profile_id: the profile ID of the profile to be updated
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param option: the option to be updated
- :type option: C{str}
+ :type option: ``str``
:param value: the value to be updated for the given option
- :type value: C{str} or C{list} or C{int} or C{bool}
+ :type value: ``str`` or ``list`` or ``int`` or ``bool``
"""
pass
@@ -647,9 +647,9 @@ class X2GoSessionProfiles(object):
Detect the profile ID from a given string which maybe profile ID or profile name.
:param profile_id_or_name: profile ID or profile name
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:returns: profile ID
- :rtype: C{str}
+ :rtype: ``str``
:raises X2GoProfileException: if no such session profile exists
"""
@@ -671,11 +671,11 @@ class X2GoSessionProfiles(object):
Convert session profile options to L{X2GoSession} constructor method parameters.
:param profile_id_or_name: either profile ID or profile name is accepted (Default value = None)
- :type profile_id_or_name: C{str}
- :param profile_id: profile ID (fast than specifying C{profile_id_or_name}) (Default value = None)
- :type profile_id: C{str}
+ :type profile_id_or_name: ``str``
+ :param profile_id: profile ID (fast than specifying ``profile_id_or_name``) (Default value = None)
+ :type profile_id: ``str``
:returns: a dictionary of L{X2GoSession} constructor method parameters
- :rtype: C{dict}
+ :rtype: ``dict``
"""
_profile_id = profile_id or self.check_profile_id_or_name(profile_id_or_name)
@@ -686,10 +686,10 @@ class X2GoSessionProfiles(object):
Get a single L{X2GoSession} parameter from a specific session profile.
:param profile_id_or_name: either profile ID or profile name is accepted
- :type profile_id_or_name: C{str}
+ :type profile_id_or_name: ``str``
:param param: the parameter name in the L{X2GoSession} constructor method
- :type param: C{str}
- :returns: the value of the session profile option represented by C{param}
+ :type param: ``str``
+ :returns: the value of the session profile option represented by ``param``
:rtype: depends on the session profile option requested
"""
@@ -701,13 +701,13 @@ class X2GoSessionProfiles(object):
the value of a specific profile parameter.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param option: the session profile option for which to retrieve its value
- :type option: C{str}
+ :type option: ``str``
:param key_type: type of the value to return
- :type key_type: C{typeobject}
+ :type key_type: ``typeobject``
:returns: value of a session profile parameter
- :rtype: C{various types}
+ :rtype: ``various types``
"""
return None
@@ -718,9 +718,9 @@ class X2GoSessionProfiles(object):
a list of available profile options of a given session profile.
:param profile_id: the profile ID of the profile to operate on
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: list of available option is the given session profile
- :rtype: C{list}
+ :rtype: ``list``
"""
return []
@@ -730,10 +730,10 @@ class X2GoSessionProfiles(object):
Retrieve host name of the X2Go Server configured in a session profile.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: the host name of the X2Go Server configured by the session profile
of the given profile ID
- :rtype: C{list}
+ :rtype: ``list``
"""
return str(self._get_server_hostname(profile_id))
@@ -744,10 +744,10 @@ class X2GoSessionProfiles(object):
a the server host name for a given profile ID.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: the host name of the X2Go Server configured by the session profile
of the given profile ID
- :rtype: C{list}
+ :rtype: ``list``
"""
return 'localhost'
@@ -757,10 +757,10 @@ class X2GoSessionProfiles(object):
Retrieve SSH port of the X2Go Server configured in a session profile.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: the SSH port of the X2Go Server configured by the session profile
of the given profile ID
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._get_server_port(profile_id)
@@ -771,10 +771,10 @@ class X2GoSessionProfiles(object):
a the server SSH port for a given profile ID.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: the SSH port of the X2Go Server configured by the session profile
of the given profile ID
- :rtype: C{list}
+ :rtype: ``list``
"""
return 22
@@ -784,9 +784,9 @@ class X2GoSessionProfiles(object):
If available, return a PKey (Paramiko/SSH private key) object.
:param profile_id: the profile's unique ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: a Paramiko/SSH PKey object
- :rtype: C{obj}
+ :rtype: ``obj``
"""
return self._get_pkey_object(profile_id)
@@ -797,7 +797,7 @@ class X2GoSessionProfiles(object):
providing such a PKey object.
:param profile_id: the profile ID for which to retrieve the PKey object
- :type profile_id: C{str}
+ :type profile_id: ``str``
"""
return None
diff --git a/x2go/backends/profiles/file.py b/x2go/backends/profiles/file.py
index c4a0761..4e3f5de 100644
--- a/x2go/backends/profiles/file.py
+++ b/x2go/backends/profiles/file.py
@@ -41,18 +41,18 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles, inifiles.X2GoIniFile):
def __init__(self, config_files=_X2GO_SESSIONPROFILES_CONFIGFILES, session_profile_defaults=None, logger=None, loglevel=log.loglevel_DEFAULT, **kwargs):
"""\
- Retrieve X2Go session profiles from a file, typically C{~/.x2goclient/sessions}.
+ Retrieve X2Go session profiles from a file, typically ``~/.x2goclient/sessions``.
:param config_files: a list of config file locations, the first file name in this list the user has write access to will be the user configuration file
- :type config_files: C{list}
+ :type config_files: ``list``
:param session_profile_defaults: a default session profile
- :type session_profile_defaults: C{dict}
+ :type session_profile_defaults: ``dict``
:param logger: you can pass an L{X2GoLogger} object to the
L{x2go.backends.profiles.file.X2GoSessionProfiles} constructor
:type logger: L{X2GoLogger} instance
:param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- :type loglevel: C{int}
+ :type loglevel: ``int``
"""
# providing defaults for an X2GoSessionProfiles instance will---in the worst case---override your
@@ -66,11 +66,11 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles, inifiles.X2GoIniFile):
class.
:param section: INI file section
- :type section: C{str}
+ :type section: ``str``
:param key: key in INI file section
- :type key: C{str}
- :returns: the data type of C{key} in C{section}
- :rtype: C{type}
+ :type key: ``str``
+ :returns: the data type of ``key`` in ``section``
+ :rtype: ``type``
"""
# we have to handle the get_type method separately...
@@ -84,7 +84,7 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles, inifiles.X2GoIniFile):
:returns: a set of session profiles
- :rtype: C{dict}
+ :rtype: ``dict``
"""
session_profiles = [ p for p in self.iniConfig.sections() if p not in self._non_profile_sections and p != 'none' ]
diff --git a/x2go/backends/profiles/httpbroker.py b/x2go/backends/profiles/httpbroker.py
index 60cd7f4..b86f293 100644
--- a/x2go/backends/profiles/httpbroker.py
+++ b/x2go/backends/profiles/httpbroker.py
@@ -62,18 +62,18 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
Retrieve X2Go session profiles from a HTTP(S) session broker.
@param session_profile_defaults: a default session profile
- @type session_profile_defaults: C{dict}
+ @type session_profile_defaults: ``dict``
@param broker_url: URL for accessing the X2Go Session Broker
- @type broker_url: C{str}
+ @type broker_url: ``str``
@param broker_password: use this password for authentication against the X2Go Session Broker (avoid
- password string in the C{broker_URL} parameter is highly recommended)
- @type broker_password: C{str}
+ password string in the ``broker_URL`` parameter is highly recommended)
+ @type broker_password: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{x2go.backends.profiles.httpbroker.X2GoSessionProfiles} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if broker_url.upper() != "HTTP":
@@ -121,50 +121,50 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
def get_broker_noauth(self):
"""\
- Accessor for the class's C{broker_noauth} property.
+ Accessor for the class's ``broker_noauth`` property.
- :returns: C{True} if the broker probably does not expect authentication.
+ :returns: ``True`` if the broker probably does not expect authentication.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.broker_noauth
def get_broker_username(self):
"""\
- Accessor for the class's C{broker_username} property.
+ Accessor for the class's ``broker_username`` property.
:returns: the username used for authentication against the session broker URL
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.broker_username
def get_broker_url(self):
"""\
- Accessor for the class's C{broker_url} property.
+ Accessor for the class's ``broker_url`` property.
:returns: the session broker URL that was used at broker session instantiation
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.broker_url
def set_broker_url(self, broker_url):
"""\
- Mutator for the class's C{broker_url} property.
+ Mutator for the class's ``broker_url`` property.
:param broker_url: A new broker URL to use with this instance. Format is
- C{<protocol>://<hostname>:<port>/<path>} (where protocol has to be C{http}
- or C{https}.
- :type broker_url: C{str}
+ ``<protocol>://<hostname>:<port>/<path>`` (where protocol has to be ``http``
+ or ``https``.
+ :type broker_url: ``str``
:returns: the session broker URL that was used at broker session instantiation
- :rtype: C{str}
+ :rtype: ``str``
"""
self.broker_url = broker_url
@@ -174,9 +174,9 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
Accessor of the class's {_broker_type} property.
- :returns: either C{http} or C{https}.
+ :returns: either ``http`` or ``https``.
- :rtype: C{str}
+ :rtype: ``str``
"""
return self._broker_type
@@ -187,11 +187,11 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
broker URL.
:param broker_username: username to use for authentication
- :type broker_username: C{str}
+ :type broker_username: ``str``
:param broker_password: password to use for authentication
- :type broker_password: C{str}
- :returns: C{True} if authentication has been successful
- :rtype: C{bool}
+ :type broker_password: ``str``
+ :returns: ``True`` if authentication has been successful
+ :rtype: ``bool``
:raises X2GoBrokerConnectionException: Raised on any kind of connection /
authentication failure.
@@ -265,10 +265,10 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
valid.
- :returns: C{True} if the broker session has already been authenticated
+ :returns: ``True`` if the broker session has already been authenticated
and user credentials are known / valid
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self._broker_auth_successful is None:
@@ -286,7 +286,7 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
:returns: session profiles as a Python dictionary.
- :rtype: C{dict}
+ :rtype: ``dict``
"""
if self.broker_url is not None:
@@ -325,13 +325,13 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
Select a session from the list of available session profiles (presented by
L{broker_listprofiles}). This method requests a session information dictionary
(server, port, SSH keys, already running / suspended sessions, etc.) from the
- session broker for the provided C{profile_id}.
+ session broker for the provided ``profile_id``.
:param profile_id: profile ID of the selected session profile
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: session information (server, port, SSH keys, etc.) for a selected
- session profile (i.e. C{profile_id})
- :rtype: C{dict}
+ session profile (i.e. ``profile_id``)
+ :rtype: ``dict``
"""
if self.broker_url is not None:
@@ -381,7 +381,7 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
:returns: a set of session profiles
- :rtype: C{dict}
+ :rtype: ``dict``
"""
if self.is_broker_authenticated() and \
diff --git a/x2go/backends/profiles/sshbroker.py b/x2go/backends/profiles/sshbroker.py
index d8814be..99e68da 100644
--- a/x2go/backends/profiles/sshbroker.py
+++ b/x2go/backends/profiles/sshbroker.py
@@ -50,13 +50,13 @@ class X2GoSessionProfiles(base.X2GoSessionProfiles):
Retrieve X2Go session profiles from a SSH session broker.
@param session_profile_defaults: a default session profile
- @type session_profile_defaults: C{dict}
+ @type session_profile_defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{x2go.backends.profiles.httpbroker.X2GoSessionProfiles} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
raise X2GoNotImplementedYetException('HTTPSBROKER backend support is not implemented yet')
diff --git a/x2go/backends/profiles/winreg.py b/x2go/backends/profiles/winreg.py
index 01ad34e..4b34172 100644
--- a/x2go/backends/profiles/winreg.py
+++ b/x2go/backends/profiles/winreg.py
@@ -49,13 +49,13 @@ class X2GoSessionProfilesWINREG(base.X2GoSessionProfiles):
Retrieve X2Go session profiles from the Windows registry.
@param session_profile_defaults: a default session profile
- @type session_profile_defaults: C{dict}
+ @type session_profile_defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoSessionProfilesWINREG} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
raise X2GoNotImplementedYetException('WINREG backend support is not implemented yet')
diff --git a/x2go/backends/proxy/base.py b/x2go/backends/proxy/base.py
index 403fead..03d56c0 100644
--- a/x2go/backends/proxy/base.py
+++ b/x2go/backends/proxy/base.py
@@ -80,18 +80,18 @@ class X2GoProxy(threading.Thread):
session_instance=None,
logger=None, loglevel=log.loglevel_DEFAULT, ):
"""\
- @param session_info: session information provided as an C{X2GoServerSessionInfo*} backend
+ @param session_info: session information provided as an ``X2GoServerSessionInfo*`` backend
instance
- @type session_info: C{X2GoServerSessionInfo*} instance
- @param ssh_transport: SSH transport object from C{paramiko.SSHClient}
- @type ssh_transport: C{paramiko.Transport} instance
+ @type session_info: ``X2GoServerSessionInfo*`` instance
+ @param ssh_transport: SSH transport object from ``paramiko.SSHClient``
+ @type ssh_transport: ``paramiko.Transport`` instance
@param session_log: name of the proxy's session logfile
- @type session_log: C{str}
+ @type session_log: ``str``
@param sessions_rootdir: base dir where X2Go session files are stored (by default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param proxy_options: a set of very L{base.X2GoProxy} backend specific options; any option that is not known
to the L{base.X2GoProxy} backend will simply be ignored
- @type proxy_options: C{dict}
+ @type proxy_options: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{base.X2GoProxy} constructor
@param session_instance: the L{X2GoSession} instance this L{base.X2GoProxy} instance belongs to
@@ -249,7 +249,7 @@ class X2GoProxy(threading.Thread):
def process_proxy_options(self):
"""\
- Override this method to incorporate elements from C{proxy_options}
+ Override this method to incorporate elements from ``proxy_options``
into actual proxy subprocess execution.
This method (if overridden) should (by design) never fail nor raise an exception.
@@ -280,7 +280,7 @@ class X2GoProxy(threading.Thread):
:returns: a subprocess instance that knows about the externally started proxy command.
- :rtype: C{obj}
+ :rtype: ``obj``
"""
threading.Thread.start(self)
@@ -310,9 +310,9 @@ class X2GoProxy(threading.Thread):
Check if a proxy instance is up and running.
- :returns: Proxy state, C{True} for proxy being up-and-running, C{False} otherwise
+ :returns: Proxy state, ``True`` for proxy being up-and-running, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return bool(self.proxy and self.proxy.poll() is None) and self.fw_tunnel.is_active
diff --git a/x2go/backends/proxy/nx3.py b/x2go/backends/proxy/nx3.py
index 0660667..42b699d 100644
--- a/x2go/backends/proxy/nx3.py
+++ b/x2go/backends/proxy/nx3.py
@@ -103,7 +103,7 @@ class X2GoProxy(base.X2GoProxy):
Update the local proxy socket on port changes due to already-bound-to local TCP/IP port sockets.
:param port: new local TCP/IP socket port
- :type port: C{int}
+ :type port: ``int``
"""
@@ -140,7 +140,7 @@ class X2GoProxy(base.X2GoProxy):
:returns: a subprocess instance that knows about the externally started proxy command.
- :rtype: C{obj}
+ :rtype: ``obj``
"""
self.logger('starting local NX3 proxy...', loglevel=log.loglevel_INFO)
diff --git a/x2go/backends/settings/file.py b/x2go/backends/settings/file.py
index 1ed6753..ed34316 100644
--- a/x2go/backends/settings/file.py
+++ b/x2go/backends/settings/file.py
@@ -56,8 +56,8 @@ class X2GoClientSettings(inifiles.X2GoIniFile):
~/.x2goclient/settings
The files are read in the specified order and config options of both files are merged. Options
- set in the user configuration file (C{~/.x2goclient/settings}) override global options set in
- C{/etc/x2goclient/settings}.
+ set in the user configuration file (``~/.x2goclient/settings``) override global options set in
+ ``/etc/x2goclient/settings``.
"""
inifiles.X2GoIniFile.__init__(self, config_files, defaults=defaults, logger=logger, loglevel=loglevel)
diff --git a/x2go/backends/terminal/plain.py b/x2go/backends/terminal/plain.py
index e7a7e69..822cdb6 100644
--- a/x2go/backends/terminal/plain.py
+++ b/x2go/backends/terminal/plain.py
@@ -68,14 +68,14 @@ _local_color_depth = utils.local_color_depth()
def _rewrite_cmd(cmd, params=None):
"""\
Mechansim that rewrites X2Go server commands into something that gets understood by
- the server-side script C{x2goruncommand}.
+ the server-side script ``x2goruncommand``.
- :param cmd: the current command for execution (as found in the session profile parameter C{cmd})
- :type cmd: C{str}
+ :param cmd: the current command for execution (as found in the session profile parameter ``cmd``)
+ :type cmd: ``str``
:param params: an session paramter object (Default value = None)
:type params: L{X2GoSessionParams}
:returns: the rewritten command for server-side execution
- :rtype: C{str}
+ :rtype: ``str``
"""
# start with an empty string
@@ -109,9 +109,9 @@ def _rewrite_blanks(cmd):
In command strings X2Go server scripts expect blanks being rewritten to ,,X2GO_SPACE_CHAR''.
:param cmd: command that has to be rewritten for passing to the server
- :type cmd: C{str}
+ :type cmd: ``str``
:returns: the command with blanks rewritten to ,,X2GO_SPACE_CHAR''
- :rtype: C{str}
+ :rtype: ``str``
"""
# X2Go run command replace X2GO_SPACE_CHAR string with blanks
@@ -123,16 +123,16 @@ def _rewrite_blanks(cmd):
class X2GoSessionParams(object):
"""\
The L{X2GoSessionParams} class is used to store all parameters that
- C{X2GoTerminalSession} backend objects are constructed with.
+ ``X2GoTerminalSession`` backend objects are constructed with.
"""
def rewrite_session_type(self):
"""\
Rewrite the X2Go session type, so that the X2Go server
- can understand it (C{desktop} -> C{D}, etc.).
+ can understand it (``desktop`` -> ``D``, etc.).
- Also if the object's C{command} property is a known window
+ Also if the object's ``command`` property is a known window
manager, the session type will be set to 'D'
(i.e. desktop).
@@ -141,7 +141,7 @@ class X2GoSessionParams(object):
'R' for rootless sessions, 'P' for sessions providing published
applications, and 'S' for desktop sharing sessions
- :rtype: C{str}
+ :rtype: ``str``
"""
cmd = self.cmd
@@ -180,7 +180,7 @@ class X2GoSessionParams(object):
:param properties_to_be_updated: a dictionary with L{X2GoSessionParams}
property names as keys und their values to be update in
L{X2GoSessionParams} object.
- :type properties_to_be_updated: C{dict}
+ :type properties_to_be_updated: ``dict``
:param **properties_to_be_updated:
"""
@@ -202,7 +202,7 @@ class X2GoTerminalSession(object):
- L{X2GoSessionParams}: stores all parameters that have been passed to the
constructor method.
- - C{X2GoServerSessionInfo*} backend class: when starting or resuming a session, an object of this class
+ - ``X2GoServerSessionInfo*`` backend class: when starting or resuming a session, an object of this class
will be used to store all information retrieved from the X2Go server.
The terminal session instance works closely together (i.e. depends on) a connected control
@@ -238,93 +238,93 @@ class X2GoTerminalSession(object):
new X2Go sessions, resume suspended sessions or suspend resp. terminate
currently running sessions on a connected X2Go server.
- @param geometry: screen geometry of the X2Go session. Can be either C{<width>x<height>},
- C{maximize} or C{fullscreen}
- @type geometry: C{str}
- @param depth: color depth in bits (common values: C{16}, C{24})
- @type depth: C{int}
- @param link: network link quality (either one of C{modem}, C{isdn}, C{adsl}, C{wan} or C{lan})
- @type link: C{str}
+ @param geometry: screen geometry of the X2Go session. Can be either ``<width>x<height>``,
+ ``maximize`` or ``fullscreen``
+ @type geometry: ``str``
+ @param depth: color depth in bits (common values: ``16``, ``24``)
+ @type depth: ``int``
+ @param link: network link quality (either one of ``modem``, ``isdn``, ``adsl``, ``wan`` or ``lan``)
+ @type link: ``str``
@param pack: compression method for NX based session proxying
- @type pack: C{str}
+ @type pack: ``str``
@param dpi: dots-per-inch value for the session screen (has an impact on the font size on screen)
- @type dpi: C{str}
+ @type dpi: ``str``
@param cache_type: a dummy parameter that is passed to the L{x2go.backends.proxy.base.X2GoProxy}. In NX Proxy
- (class C{X2GoProxyNX3}) this originally is the session name. With X2Go it
+ (class ``X2GoProxyNX3``) this originally is the session name. With X2Go it
defines the name of the NX cache directory. Best is to leave it untouched.
- @type cache_type: C{str}
- @param kbtype: keyboard type, e.g. C{pc105/us} (default), C{pc105/de}, ...
- @type kbtype: C{str}
- @param kblayout: keyboard layout, e.g. C{us} (default), C{de}, C{fr}, ...
- @type kblayout: C{str}
- @param kbvariant: keyboard variant, e.g. C{nodeadkeys} (for C{de} layout), C{intl} (for C{us} layout), etc.
- @type kbvariant: C{str}
- @param clipboard: clipboard mode (C{both}: bidirectional copy+paste, C{server}: copy+paste from server to
- client, C{client}: copy+paste from client to server, C{none}: disable clipboard completely
- @type clipboard: C{str}
- @param session_type: either C{desktop}, C{application} (rootless session) or C{shared}
- @type session_type: C{str}
- @param snd_system: sound system to be used on server (C{none}, C{pulse} (default),
- C{arts} (obsolete) or C{esd})
- @type snd_system: C{str}
+ @type cache_type: ``str``
+ @param kbtype: keyboard type, e.g. ``pc105/us`` (default), ``pc105/de``, ...
+ @type kbtype: ``str``
+ @param kblayout: keyboard layout, e.g. ``us`` (default), ``de``, ``fr``, ...
+ @type kblayout: ``str``
+ @param kbvariant: keyboard variant, e.g. ``nodeadkeys`` (for ``de`` layout), ``intl`` (for ``us`` layout), etc.
+ @type kbvariant: ``str``
+ @param clipboard: clipboard mode (``both``: bidirectional copy+paste, ``server``: copy+paste from server to
+ client, ``client``: copy+paste from client to server, ``none``: disable clipboard completely
+ @type clipboard: ``str``
+ @param session_type: either ``desktop``, ``application`` (rootless session) or ``shared``
+ @type session_type: ``str``
+ @param snd_system: sound system to be used on server (``none``, ``pulse`` (default),
+ ``arts`` (obsolete) or ``esd``)
+ @type snd_system: ``str``
@param snd_port: local sound port for network capable audio system
- @type snd_port: C{int}
+ @type snd_port: ``int``
@param cmd: command to be run on X2Go server after session start (only used
when L{x2go.backends.terminal.plain.X2GoTerminalSession.start()} is called, ignored on resume, suspend etc.
- @type cmd: C{str}
+ @type cmd: ``str``
@param published_applications: session is published applications provider
- @type published_applications: C{bool}
+ @type published_applications: ``bool``
@param set_session_title: modify the session title (i.e. the Window title) of desktop or shared desktop sessions
- @type set_session_title: C{bool}
+ @type set_session_title: ``bool``
@param session_title: session title for this (desktop or shared desktop) session
- @type session_title: C{str}
+ @type session_title: ``str``
@param applications: applications available for rootless application execution
- @type applications: C{list}
+ @type applications: ``list``
@param rdp_server: host name of server-side RDP server
- @type rdp_server: C{str}
- @param rdp_options: options for the C{rdesktop} command executed on the X2Go server (RDP proxy mode of X2Go)
- @type rdp_options: C{str}
+ @type rdp_server: ``str``
+ @param rdp_options: options for the ``rdesktop`` command executed on the X2Go server (RDP proxy mode of X2Go)
+ @type rdp_options: ``str``
@param xdmcp_server: XDMCP server to connect to
- @type xdmcp_server: C{str}
+ @type xdmcp_server: ``str``
@param convert_encoding: convert file system encodings between server and client (for client-side shared folders)
- @type convert_encoding: C{bool}
+ @type convert_encoding: ``bool``
@param server_encoding: server-side file system / session encoding
- @type server_encoding: C{str}
+ @type server_encoding: ``str``
@param client_encoding: client-side file system encoding (if client-side is MS Windows, this parameter gets overwritten to WINDOWS-1252)
- @type client_encoding: C{str}
- @param rootdir: X2Go session directory, normally C{~/.x2go}
- @type rootdir: C{str}
+ @type client_encoding: ``str``
+ @param rootdir: X2Go session directory, normally ``~/.x2go``
+ @type rootdir: ``str``
@param profile_name: the session profile name for this terminal session
- @type profile_name: C{str}
+ @type profile_name: ``str``
@param profile_id: the session profile ID for this terminal session
- @type profile_id: C{str}
+ @type profile_id: ``str``
@param print_action: either a print action short name (PDFVIEW, PDFSAVE, PRINT, PRINTCMD) or the
- resp. C{X2GoPrintActionXXX} class (where XXX equals one of the given short names)
- @type print_action: C{str} or C{class}
+ resp. ``X2GoPrintActionXXX`` class (where XXX equals one of the given short names)
+ @type print_action: ``str`` or ``class``
@param print_action_args: optional arguments for a given print_action (for further info refer to
L{X2GoPrintActionPDFVIEW}, L{X2GoPrintActionPDFSAVE}, L{X2GoPrintActionPRINT} and L{X2GoPrintActionPRINTCMD})
- @type print_action_args: C{dict}
+ @type print_action_args: ``dict``
@param info_backend: backend for handling storage of server session information
- @type info_backend: C{X2GoServerSessionInfo*} instance
+ @type info_backend: ``X2GoServerSessionInfo*`` instance
@param list_backend: backend for handling storage of session list information
- @type list_backend: C{X2GoServerSessionList*} instance
+ @type list_backend: ``X2GoServerSessionList*`` instance
@param proxy_backend: backend for handling the X-proxy connections
- @type proxy_backend: C{X2GoProxy*} instance
- @param proxy_options: a set of very C{X2GoProxy} backend specific options; any option that is not known
- to the C{X2GoProxy} backend will simply be ignored
- @type proxy_options: C{dict}
+ @type proxy_backend: ``X2GoProxy*`` instance
+ @param proxy_options: a set of very ``X2GoProxy`` backend specific options; any option that is not known
+ to the ``X2GoProxy`` backend will simply be ignored
+ @type proxy_options: ``dict``
@param client_rootdir: client base dir (default: ~/.x2goclient)
- @type client_rootdir: C{str}
+ @type client_rootdir: ``str``
@param sessions_rootdir: sessions base dir (default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param session_instance: the L{X2GoSession} instance that is parent to this terminal session
- @type session_instance: C{obj}
+ @type session_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{x2go.backends.terminal.plain.X2GoTerminalSession} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.proxy = None
@@ -464,7 +464,7 @@ class X2GoTerminalSession(object):
Create the server-side session root dir (normally ~/.x2go).
:param rootdir: server-side session root directory
- :type rootdir: C{str}
+ :type rootdir: ``str``
"""
try:
@@ -501,7 +501,7 @@ class X2GoTerminalSession(object):
:returns: the session name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_info.name
@@ -513,7 +513,7 @@ class X2GoTerminalSession(object):
:returns: the session info object
- :rtype: C{X2GoServerSessionInfo*}
+ :rtype: ``X2GoServerSessionInfo*``
"""
return self.session_info
@@ -525,7 +525,7 @@ class X2GoTerminalSession(object):
:returns: the session command
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.params.cmd
@@ -537,7 +537,7 @@ class X2GoTerminalSession(object):
:returns: the session type
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.params.session_type
@@ -654,8 +654,8 @@ class X2GoTerminalSession(object):
"""\
Pause reverse SSH tunnel of name <name>.
- :param name: tunnel name (either of C{sshfs}, C{snd})
- :type name: C{str}
+ :param name: tunnel name (either of ``sshfs``, ``snd``)
+ :type name: ``str``
"""
_tunnel = self.reverse_tunnels[self.session_info.name][name][1]
@@ -709,12 +709,12 @@ class X2GoTerminalSession(object):
"""\
Set a print action for the next incoming print jobs.
- This method is a wrapper for L{X2GoPrintQueue}C{.set_print_action()}.
+ This method is a wrapper for L{X2GoPrintQueue}``.set_print_action()``.
- :param print_action: print action name or object (i.e. an instance of C{X2GoPrintAction*} classes)
- :type print_action: C{str} or C{X2GoPrintAction*}
+ :param print_action: print action name or object (i.e. an instance of ``X2GoPrintAction*`` classes)
+ :type print_action: ``str`` or ``X2GoPrintAction*``
:param kwargs: print action specific parameters
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -736,7 +736,7 @@ class X2GoTerminalSession(object):
:returns: the directory for remote print job spooling
- :rtype: C{str}
+ :rtype: ``str``
"""
return '%s/%s' % (self.session_info.remote_container, 'spool')
@@ -746,9 +746,9 @@ class X2GoTerminalSession(object):
Initialize the X2Go MIME box. Open/process incoming files from the server-side locally.
:param mimebox_extensions: file name extensions that are allowed for local opening/processing (Default value = [])
- :type mimebox_extensions: C{list}
- :param mimebox_action: MIME box action given as name or object (i.e. an instance of C{X2GoMIMEboxAction*} classes). (Default value = None)
- :type mimebox_action: C{str} or C{obj}
+ :type mimebox_extensions: ``list``
+ :param mimebox_action: MIME box action given as name or object (i.e. an instance of ``X2GoMIMEboxAction*`` classes). (Default value = None)
+ :type mimebox_action: ``str`` or ``obj``
:raises X2GoUserException: if the X2Go MIME box feature is not available to this user
"""
@@ -774,12 +774,12 @@ class X2GoTerminalSession(object):
"""\
Set a MIME box action for the next incoming MIME jobs.
- This method is a wrapper for L{X2GoMIMEboxQueue}C{set_mimebox_action()}.
+ This method is a wrapper for L{X2GoMIMEboxQueue}``set_mimebox_action()``.
- :param mimebox_action: MIME box action name or object (i.e. an instance of C{X2GoMIMEboxAction*} classes)
- :type mimebox_action: C{str} or C{X2GoMIMEboxAction*}
+ :param mimebox_action: MIME box action name or object (i.e. an instance of ``X2GoMIMEboxAction*`` classes)
+ :type mimebox_action: ``str`` or ``X2GoMIMEboxAction*``
:param kwargs: MIME box action specific parameters
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -801,7 +801,7 @@ class X2GoTerminalSession(object):
:returns: the directory where remote MIME box jobs are placed
- :rtype: C{str}
+ :rtype: ``str``
"""
return '%s/%s' % (self.session_info.remote_container, 'mimebox')
@@ -834,9 +834,9 @@ class X2GoTerminalSession(object):
Test if this terminal's session info object is write-protected.
- :returns: C{True}, if session info object is read-only, C{False} for read-write.
+ :returns: ``True``, if session info object is read-only, ``False`` for read-write.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.session_info.is_protected()
@@ -863,12 +863,12 @@ class X2GoTerminalSession(object):
:param local_path: the full path to an existing folder on the local
file system (Default value = None)
- :type local_path: C{str}
+ :type local_path: ``str``
:param folder_type: one of 'disk' (a folder on your local hard drive), 'rm' (removeable device),
'cdrom' (CD/DVD Rom) or 'spool' (for X2Go print spooling) (Default value = 'disk')
- :type folder_type: C{str}
- :returns: returns C{True} if the local folder has been successfully mounted within the X2Go server session
- :rtype: C{bool}
+ :type folder_type: ``str``
+ :returns: returns ``True`` if the local folder has been successfully mounted within the X2Go server session
+ :rtype: ``bool``
:raises X2GoUserException: if local folder sharing is not available to this user
:raises Exception: any other exception occuring on the way is passed through by this method
@@ -991,9 +991,9 @@ class X2GoTerminalSession(object):
Unshare all local folders mount in the X2Go session.
- :returns: returns C{True} if all local folders could be successfully unmounted from the X2Go server session
+ :returns: returns ``True`` if all local folders could be successfully unmounted from the X2Go server session
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.logger('unsharing all local folders from session %s' % self.session_info, log.loglevel_INFO)
@@ -1017,8 +1017,8 @@ class X2GoTerminalSession(object):
:param local_path: the full path to an existing folder on the local
file system (Default value = None)
- :returns: returns C{True} if the local folder <local_path> could be successfully unmounted from the X2Go server session
- :rtype: C{bool}
+ :returns: returns ``True`` if the local folder <local_path> could be successfully unmounted from the X2Go server session
+ :rtype: ``bool``
"""
self.logger('unsharing local folder from session %s' % self.session_info, log.loglevel_INFO)
@@ -1044,7 +1044,7 @@ class X2GoTerminalSession(object):
:returns: the session's color depth
- :rtype: C{int}
+ :rtype: ``int``
"""
return self.params.depth
@@ -1053,11 +1053,11 @@ class X2GoTerminalSession(object):
"""\
Automatically generate an appropriate human-readable session window title.
- The session window title will be provider in the C{session_title} property of
+ The session window title will be provider in the ``session_title`` property of
this method.
:param dont_set: generate the session window title, but do not actually set it (Default value = False)
- :type dont_set: C{bool}
+ :type dont_set: ``bool``
"""
_generic_title = 'X2GO-%s' % self.session_info.name
@@ -1102,7 +1102,7 @@ class X2GoTerminalSession(object):
A background thread will get spawned for this operation.
:param timeout: try for <timeout> seconds to find the session window (Default value = 60)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
gevent.spawn(self._find_session_window, timeout=timeout)
@@ -1113,7 +1113,7 @@ class X2GoTerminalSession(object):
terminal session.
:param timeout: try for <timeout> seconds to find the session window (Default value = 0)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
self.session_window = None
@@ -1171,9 +1171,9 @@ class X2GoTerminalSession(object):
A background thread will get spawned for this operation.
:param title: new title for the terminal session's session window
- :type title: C{str}
+ :type title: ``str``
:param timeout: try for <timeout> seconds to find the session window (Default value = 60)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
gevent.spawn(self._set_session_window_title, title=title.strip(), timeout=timeout)
@@ -1183,9 +1183,9 @@ class X2GoTerminalSession(object):
Modify the session window title.
:param title: new title for the terminal session's session window
- :type title: C{str}
+ :type title: ``str``
:param timeout: try for <timeout> seconds to find the session window (Default value = 0)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
self.session_title = title
@@ -1213,7 +1213,7 @@ class X2GoTerminalSession(object):
A background thread will get spawned for this operation.
:param timeout: try for <timeout> seconds to raise the session window (Default value = 60)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
gevent.spawn(self._raise_session_window, timeout=timeout)
@@ -1224,7 +1224,7 @@ class X2GoTerminalSession(object):
terminal session to the top and bring it to focus.
:param timeout: try for <timeout> seconds to raise the session window (Default value = 0)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
timeout += 1
@@ -1241,14 +1241,14 @@ class X2GoTerminalSession(object):
def has_command(self, cmd):
"""\
- ,,Guess'' if the command C{<cmd>} exists on the X2Go server and is executable.
+ ,,Guess'' if the command ``<cmd>`` exists on the X2Go server and is executable.
The expected result is not 100% safe, however, it comes with a high probability to
be correct.
:param cmd: session command
- :type cmd: C{str}
- :returns: C{True} if this method reckons that the command is executable on the remote X2Go server
- :rtype: C{bool}
+ :type cmd: ``str``
+ :returns: ``True`` if this method reckons that the command is executable on the remote X2Go server
+ :rtype: ``bool``
"""
test_cmd = None;
@@ -1288,12 +1288,12 @@ class X2GoTerminalSession(object):
within the current X2Go session.
:param cmd: Command to be run (Default value = None)
- :type cmd: C{str}
+ :type cmd: ``str``
:param env: add server-side environment variables (Default value = {})
- :type env: C{dict}
+ :type env: ``dict``
:returns: stdout.read() and stderr.read() as returned by the run command
on the X2Go server
- :rtype: C{tuple} of C{str}
+ :rtype: ``tuple`` of ``str``
"""
if not self.has_command(_rewrite_cmd(str(self.params.cmd), params=self.params)):
@@ -1351,9 +1351,9 @@ class X2GoTerminalSession(object):
Is this (terminal) session a desktop session?
- :returns: Returns C{True} is this session is a desktop session.
+ :returns: Returns ``True`` is this session is a desktop session.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.session_info:
@@ -1365,9 +1365,9 @@ class X2GoTerminalSession(object):
Is this (terminal) session a published applications provider?
- :returns: Returns C{True} is this session is a provider session for published applications.
+ :returns: Returns ``True`` is this session is a provider session for published applications.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.session_info and self.is_running():
@@ -1379,11 +1379,11 @@ class X2GoTerminalSession(object):
Set the keyboard layout and variant for this (running) session.
:param layout: keyboard layout to be set (Default value = 'null')
- :type layout: C{str}
+ :type layout: ``str``
:param variant: keyboard variant to be set (Default value = 'null')
- :type variant: C{str}
- :returns: returns C{True} if the {setxkbmap} command could be executed successfully.
- :rtype: C{bool}
+ :type variant: ``str``
+ :returns: returns ``True`` if the {setxkbmap} command could be executed successfully.
+ :rtype: ``bool``
"""
if not self.is_running():
@@ -1416,11 +1416,11 @@ class X2GoTerminalSession(object):
Executed a published application.
:param exec_name: application to be executed
- :type exec_name: C{str}
+ :type exec_name: ``str``
:param timeout: execution timeout (Default value = 20)
- :type timeout: C{int}
+ :type timeout: ``int``
:param env: session environment dictionary (Default value = {})
- :type env: C{dict}
+ :type env: ``dict``
"""
cmd_line = [
@@ -1450,10 +1450,10 @@ class X2GoTerminalSession(object):
X2Go session OK?
- :returns: Returns C{True} if this X2Go (terminal) session is up and running,
- C{False} otherwise.
+ :returns: Returns ``True`` if this X2Go (terminal) session is up and running,
+ ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
_ok = bool(self.session_info.name and self.proxy.ok())
@@ -1464,10 +1464,10 @@ class X2GoTerminalSession(object):
X2Go session running?
- :returns: Returns C{True} if this X2Go (terminal) session is in running state,
- C{False} otherwise.
+ :returns: Returns ``True`` if this X2Go (terminal) session is in running state,
+ ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.session_info.is_running()
@@ -1477,10 +1477,10 @@ class X2GoTerminalSession(object):
X2Go session suspended?
- :returns: Returns C{True} if this X2Go (terminal) session is in suspended state,
- C{False} otherwise.
+ :returns: Returns ``True`` if this X2Go (terminal) session is in suspended state,
+ ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.session_info.is_suspended()
@@ -1490,10 +1490,10 @@ class X2GoTerminalSession(object):
X2Go session connected?
- :returns: Returns C{True} if this X2Go session's Paramiko/SSH transport is
- connected/authenticated, C{False} else.
+ :returns: Returns ``True`` if this X2Go session's Paramiko/SSH transport is
+ connected/authenticated, ``False`` else.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.control_session.is_connected()
@@ -1503,9 +1503,9 @@ class X2GoTerminalSession(object):
Start a new X2Go session.
- :returns: C{True} if session startup has been successful and the X2Go proxy is up-and-running
+ :returns: ``True`` if session startup has been successful and the X2Go proxy is up-and-running
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoTerminalSessionException: if the session startup failed
:raises X2GoDesktopSharingDenied: if desktop sharing fails because of denial by the user running the desktop to be shared
@@ -1623,9 +1623,9 @@ class X2GoTerminalSession(object):
Resume a running/suspended X2Go session.
- :returns: C{True} if the session could successfully be resumed
+ :returns: ``True`` if the session could successfully be resumed
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoTerminalSessionException: if the terminal session failed to update server-side reported port changes
"""
@@ -1730,9 +1730,9 @@ class X2GoTerminalSession(object):
Suspend this X2Go (terminal) session.
- :returns: C{True} if the session terminal could be successfully suspended
+ :returns: ``True`` if the session terminal could be successfully suspended
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.release_telekinesis()
@@ -1749,9 +1749,9 @@ class X2GoTerminalSession(object):
Terminate this X2Go (terminal) session.
- :returns: C{True} if the session could be successfully terminated
+ :returns: ``True`` if the session could be successfully terminated
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.release_telekinesis()
@@ -1812,9 +1812,9 @@ class X2GoTerminalSession(object):
Test if this terminal session is a rootless session.
- :returns: C{True} if this session is of session type rootless ('R').
+ :returns: ``True`` if this session is of session type rootless ('R').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.params.rewrite_session_type()
@@ -1825,9 +1825,9 @@ class X2GoTerminalSession(object):
Test if this terminal session is a desktop sharing (aka shadow) session.
- :returns: C{True} if this session is of session type shadow ('S').
+ :returns: ``True`` if this session is of session type shadow ('S').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.params.rewrite_session_type()
@@ -1838,9 +1838,9 @@ class X2GoTerminalSession(object):
Test if this terminal session is a published applications session.
- :returns: C{True} if this session is of session type published applications ('P').
+ :returns: ``True`` if this session is of session type published applications ('P').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.params.rewrite_session_type()
diff --git a/x2go/cache.py b/x2go/cache.py
index d092ec3..7422103 100644
--- a/x2go/cache.py
+++ b/x2go/cache.py
@@ -44,7 +44,7 @@ class X2GoListSessionsCache(object):
The session list and desktop cache gets updated in regular intervals by a threaded
L{X2GoSessionGuardian} instance. For the session list and desktop list update, the
- X2Go server commands C{x2golistsessions} and C{x2godesktopsessions} are called and
+ X2Go server commands ``x2golistsessions`` and ``x2godesktopsessions`` are called and
the command's stdout is cached in the session list cache.
Whenever your client application needs access to either the server's session list
@@ -59,12 +59,12 @@ class X2GoListSessionsCache(object):
def __init__(self, client_instance, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the L{X2GoClient} instance that uses this L{X2GoListSessionsCache}
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoListSessionsCache} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.x2go_listsessions_cache = {}
@@ -84,7 +84,7 @@ class X2GoListSessionsCache(object):
Remove session list from cache for a given profile.
:param profile_name: name of profile to operate on
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
while self.protected:
@@ -109,9 +109,9 @@ class X2GoListSessionsCache(object):
Update L{X2GoListSessionsCache} for all connected session profiles.
:param update_sessions: cache recent session lists from all connected servers (Default value = True)
- :type update_sessions: C{bool}
+ :type update_sessions: ``bool``
:param update_desktops: cache recent desktop lists from all connected servers (Default value = False)
- :type update_desktops: C{bool}
+ :type update_desktops: ``bool``
"""
for profile_name in self.client_instance.client_connected_profiles(return_profile_names=True):
@@ -121,16 +121,16 @@ class X2GoListSessionsCache(object):
def update(self, profile_name, update_sessions=True, update_desktops=False, update_mounts=False):
"""\
- Update L{X2GoListSessionsCache} (i.e. session/desktops) for session profile C{profile_name}.
+ Update L{X2GoListSessionsCache} (i.e. session/desktops) for session profile ``profile_name``.
:param profile_name: name of profile to update
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param update_sessions: cache recent session list from server (Default value = True)
- :type update_sessions: C{bool}
+ :type update_sessions: ``bool``
:param update_desktops: cache recent desktop list from server (Default value = False)
- :type update_desktops: C{bool}
+ :type update_desktops: ``bool``
:param update_mounts: cache list of client-side mounts on server (Default value = False)
- :type update_mounts: C{bool}
+ :type update_mounts: ``bool``
"""
self.protected = True
@@ -148,12 +148,12 @@ class X2GoListSessionsCache(object):
def _update_mounts(self, profile_name, control_session):
"""\
- Update mounts list of L{X2GoListSessionsCache} for session profile C{profile_name}.
+ Update mounts list of L{X2GoListSessionsCache} for session profile ``profile_name``.
:param profile_name: name of profile to update
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param control_session: X2Go control session instance
- :raises X2GoControlSessionException: if the control session's C{list_mounts} method fails
+ :raises X2GoControlSessionException: if the control session's ``list_mounts`` method fails
"""
try:
@@ -176,13 +176,13 @@ class X2GoListSessionsCache(object):
def _update_desktops(self, profile_name, control_session):
"""\
- Update session lists of L{X2GoListSessionsCache} for session profile C{profile_name}.
+ Update session lists of L{X2GoListSessionsCache} for session profile ``profile_name``.
:param profile_name: name of profile to update
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param control_session: X2Go control session instance
- :type control_session: C{obj}
- :raises X2GoControlSessionException: if the control session's C{list_desktop} method fails
+ :type control_session: ``obj``
+ :raises X2GoControlSessionException: if the control session's ``list_desktop`` method fails
"""
try:
@@ -200,13 +200,13 @@ class X2GoListSessionsCache(object):
def _update_sessions(self, profile_name, control_session):
"""\
- Update desktop list of L{X2GoListSessionsCache} for session profile C{profile_name}.
+ Update desktop list of L{X2GoListSessionsCache} for session profile ``profile_name``.
:param profile_name: name of profile to update
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param control_session: X2Go control session instance
- :type control_session: C{obj}
- :raises X2GoControlSessionException: if the control session's C{list_sessions} method fails
+ :type control_session: ``obj``
+ :raises X2GoControlSessionException: if the control session's ``list_sessions`` method fails
"""
try:
@@ -226,9 +226,9 @@ class X2GoListSessionsCache(object):
for a given L{X2GoSession} instance (specified by its unique session UUID).
:param session_uuid: unique identifier of session to query cache for
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: a data object containing available session information
- :rtype: C{X2GoServerSessionList*} instance (or C{None})
+ :rtype: ``X2GoServerSessionList*`` instance (or ``None``)
"""
profile_name = self.client_instance.get_session_profile_name(session_uuid)
@@ -244,9 +244,9 @@ class X2GoListSessionsCache(object):
unique session UUID).
:param session_uuid: unique identifier of session to query cache for
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: a list of strings representing X2Go desktop sessions available for sharing
- :rtype: C{list} (or C{None})
+ :rtype: ``list`` (or ``None``)
"""
profile_name = self.client_instance.get_session_profile_name(session_uuid)
@@ -262,9 +262,9 @@ class X2GoListSessionsCache(object):
unique session UUID).
:param session_uuid: unique identifier of session to query cache for
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: a list of strings representing mounted client shares
- :rtype: C{list} (or C{None})
+ :rtype: ``list`` (or ``None``)
"""
profile_name = self.client_instance.get_session_profile_name(session_uuid)
@@ -278,13 +278,13 @@ class X2GoListSessionsCache(object):
Check if session information is cached.
:param profile_name: name of profile to update (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_uuid: unique identifier of session to query cache for (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param cache_type: cache type (e.g. 'mounts', 'desktops', 'sessions') (Default value = None)
- :type cache_type: C{str}
- :returns: C{True} if session information is cached
- :rtype: C{bool}
+ :type cache_type: ``str``
+ :returns: ``True`` if session information is cached
+ :rtype: ``bool``
"""
if profile_name is None and session_uuid and self.client_instance:
diff --git a/x2go/checkhosts.py b/x2go/checkhosts.py
index ed21b76..7be1a1a 100644
--- a/x2go/checkhosts.py
+++ b/x2go/checkhosts.py
@@ -18,7 +18,7 @@
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
"""\
-Providing mechanisms to C{X2GoControlSession*} backends for checking host validity.
+Providing mechanisms to ``X2GoControlSession*`` backends for checking host validity.
"""
from builtins import str
@@ -47,7 +47,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
def __init__(self, caller=None, session_instance=None, fake_hostname=None):
"""\
@param caller: calling instance
- @type caller: C{class}
+ @type caller: ``class``
@param session_instance: an X2Go session instance
@type session_instance: L{X2GoSession} instance
@@ -63,7 +63,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: the associated X2Go control session instance.
- :rtype: C{X2GoControlSession*} instance
+ :rtype: ``X2GoControlSession*`` instance
"""
return self.client
@@ -75,7 +75,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: hostname:port
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.fake_hostname or self.hostname
@@ -87,7 +87,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: hostname
- :rtype: C{str}
+ :rtype: ``str``
"""
if ":" in self.get_hostname():
@@ -102,7 +102,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: port
- :rtype: C{str}
+ :rtype: ``str``
"""
if ":" in self.get_hostname():
@@ -129,7 +129,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: host key name (RSA, DSA, ECDSA...)
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.key.get_name().upper()
@@ -141,7 +141,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: host key fingerprint
- :rtype: C{str}
+ :rtype: ``str``
"""
return binascii.hexlify(self.key.get_fingerprint())
@@ -154,7 +154,7 @@ class X2GoMissingHostKeyPolicy(paramiko.MissingHostKeyPolicy):
:returns: host key fingerprint (with colons)
- :rtype: C{str}
+ :rtype: ``str``
"""
_fingerprint = self.get_key_fingerprint()
@@ -193,7 +193,7 @@ class X2GoInteractiveAddPolicy(X2GoMissingHostKeyPolicy):
Once called, the L{missing_host_key} method of this class will try to call
L{X2GoSession.HOOK_check_host_dialog()}. This hook method---if not re-defined
in your application---will then try to call the L{X2GoClient.HOOK_check_host_dialog()},
- which then will return C{True} by default if not customized in your application.
+ which then will return ``True`` by default if not customized in your application.
To accept host key checks, make sure to either customize the
L{X2GoClient.HOOK_check_host_dialog()} method or the L{X2GoSession.HOOK_check_host_dialog()}
@@ -208,20 +208,20 @@ class X2GoInteractiveAddPolicy(X2GoMissingHostKeyPolicy):
Once called, the L{missing_host_key} method will try to call
L{X2GoSession.HOOK_check_host_dialog()}. This hook method---if not re-defined
in your application---will then try to call the L{X2GoClient.HOOK_check_host_dialog()},
- which then will return C{True} by default if not customized in your application.
+ which then will return ``True`` by default if not customized in your application.
To accept host key checks, make sure to either customize the
L{X2GoClient.HOOK_check_host_dialog()} method or the L{X2GoSession.HOOK_check_host_dialog()}
method and hook some interactive user dialog to either of them.
- :param client: SSH client (C{X2GoControlSession*}) instance
- :type client: C{X2GoControlSession*} instance
+ :param client: SSH client (``X2GoControlSession*``) instance
+ :type client: ``X2GoControlSession*`` instance
:param hostname: remote hostname
- :type hostname: C{str}
+ :type hostname: ``str``
:param key: host key to validate
:type key: Paramiko/SSH key instance
- :raises X2GoHostKeyException: if the X2Go server host key is not in the C{known_hosts} file
- :raises X2GoSSHProxyHostKeyException: if the SSH proxy host key is not in the C{known_hosts} file
+ :raises X2GoHostKeyException: if the X2Go server host key is not in the ``known_hosts`` file
+ :raises X2GoSSHProxyHostKeyException: if the SSH proxy host key is not in the ``known_hosts`` file
:raises SSHException: if this instance does not know its {self.session_instance}
"""
@@ -279,13 +279,13 @@ def check_ssh_host_key(x2go_sshclient_instance, hostname, port=22):
connect process).
:param x2go_sshclient_instance: a Paramiko/SSH client instance to be used for testing host key validity.
- :type x2go_sshclient_instance: C{X2GoControlSession*} instance
+ :type x2go_sshclient_instance: ``X2GoControlSession*`` instance
:param hostname: hostname of server to validate
- :type hostname: C{str}
+ :type hostname: ``str``
:param port: port of server to validate (Default value = 22)
- :type port: C{int}
+ :type port: ``int``
:returns: returns a tuple with the following components (<host_ok>, <hostname>, <port>, <fingerprint>, <fingerprint_type>)
- :rtype: C{tuple}
+ :rtype: ``tuple``
:raises SSHException: if an SSH exception occurred, that we did not provocate in L{X2GoInteractiveAddPolicy.missing_host_key()}
"""
diff --git a/x2go/cleanup.py b/x2go/cleanup.py
index a4b1704..0c511ce 100644
--- a/x2go/cleanup.py
+++ b/x2go/cleanup.py
@@ -40,7 +40,7 @@ if _X2GOCLIENT_OS == 'Windows':
def x2go_cleanup(e=None, threads=None):
"""\
For every Python X2Go application you write, please make sure to
- capture the C{KeyboardInterrupt} and the C{SystemExit} exceptions and
+ capture the ``KeyboardInterrupt`` and the ``SystemExit`` exceptions and
call this function if either of the exceptions occurs.
Example::
@@ -57,11 +57,11 @@ def x2go_cleanup(e=None, threads=None):
x2go.x2go_cleanup()
:param e: if L{x2go_cleanup} got called as you caught an exception in your code this can be the
- C{Exception} that we will process at the end of the clean-up (or if clean-up failed or was not
+ ``Exception`` that we will process at the end of the clean-up (or if clean-up failed or was not
appropriate) (Default value = None)
- :type e: C{exception}
+ :type e: ``exception``
:param threads: a list of threads to clean up (Default value = None)
- :type threads: C{list}
+ :type threads: ``list``
"""
try:
diff --git a/x2go/client.py b/x2go/client.py
index aa3f43f..b84c8f5 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -29,10 +29,10 @@ Supported Features
- X2Go multi-session management
- keep track of initiated sessions
- - grant access to X2Go client config files: C{settings}, C{printing}, C{sessions}
- and C{xconfig} (Windows only) as normally found in C{~/.x2goclient}
+ - grant access to X2Go client config files: ``settings``, ``printing``, ``sessions``
+ and ``xconfig`` (Windows only) as normally found in ``~/.x2goclient``
- instantiate an X2Go session by a set of Python parameters
- - load a session profile from x2goclient's C{sessions} configuration file
+ - load a session profile from x2goclient's ``sessions`` configuration file
and start the---profile-based pre-configured---session
- sharing of local folders with remote X2Go sessions
- enabling and mangaging X2Go printing (real printing, viewing as PDF, saving
@@ -201,63 +201,63 @@ class X2GoClient(object):
logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param control_backend: X2Go control session backend to use
- @type control_backend: C{str}
+ @type control_backend: ``str``
@param terminal_backend: X2Go terminal session backend to use
- @type terminal_backend: C{str}
+ @type terminal_backend: ``str``
@param info_backend: X2Go session info backend to use
- @type info_backend: C{str}
+ @type info_backend: ``str``
@param list_backend: X2Go session list backend to use
- @type list_backend: C{str}
+ @type list_backend: ``str``
@param proxy_backend: X2Go proxy backend to use
- @type proxy_backend: C{str}
+ @type proxy_backend: ``str``
@param profiles_backend: X2Go session profiles backend to use
- @type profiles_backend: C{str}
+ @type profiles_backend: ``str``
@param settings_backend: X2Go client settings backend to use
- @type settings_backend: C{str}
+ @type settings_backend: ``str``
@param printing_backend: X2Go client printing backend to use
- @type printing_backend: C{str}
+ @type printing_backend: ``str``
@param broker_url: URL pointing to the X2Go Session Broker
- @type broker_url: C{str}
+ @type broker_url: ``str``
@param broker_password: use this password for authentication against the X2Go Session Broker
- @type broker_password: C{str}
+ @type broker_password: ``str``
@param broker_noauth: accessing the X2Go Session Broker works without credentials
- @type broker_noauth: C{bool}
+ @type broker_noauth: ``bool``
@param client_rootdir: client base dir (default: ~/.x2goclient)
- @type client_rootdir: C{str}
+ @type client_rootdir: ``str``
@param sessions_rootdir: sessions base dir (default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param ssh_rootdir: ssh base dir (default: ~/.ssh)
- @type ssh_rootdir: C{str}
+ @type ssh_rootdir: ``str``
@param start_xserver: start XServer when registering an L{X2GoClient} instance
- @type start_xserver: C{bool}
+ @type start_xserver: ``bool``
@param start_pulseaudio: start Pulseaudio daemon when registering an L{X2GoClient} instance
- @type start_pulseaudio: C{bool}
- @param use_cache: alias for C{use_listsessions_cache}
- @type use_cache: C{bool}
+ @type start_pulseaudio: ``bool``
+ @param use_cache: alias for ``use_listsessions_cache``
+ @type use_cache: ``bool``
@param use_listsessions_cache: activate the X2Go session list cache in (L{X2GoListSessionsCache})
- @type use_listsessions_cache: C{bool}
+ @type use_listsessions_cache: ``bool``
@param auto_update_listsessions_cache: activate automatic updates of the X2Go session list cache (L{X2GoListSessionsCache})
- @type auto_update_listsessions_cache: C{bool}
+ @type auto_update_listsessions_cache: ``bool``
@param auto_update_listdesktops_cache: activate automatic updates of desktop lists in (L{X2GoListSessionsCache})
- @type auto_update_listdesktops_cache: C{bool}
+ @type auto_update_listdesktops_cache: ``bool``
@param auto_update_listmounts_cache: activate automatic updates of mount lists in (L{X2GoListSessionsCache})
- @type auto_update_listmounts_cache: C{bool}
+ @type auto_update_listmounts_cache: ``bool``
@param auto_update_sessionregistry: activate automatic updates of the X2Go session registry
- @type auto_update_sessionregistry: C{bool}
+ @type auto_update_sessionregistry: ``bool``
@param auto_register_sessions: activate automatic X2Go session registration
- @type auto_register_sessions: C{bool}
+ @type auto_register_sessions: ``bool``
@param no_auto_reg_pubapp_sessions: skip automatic X2Go session registration for suspended/running published applications sessions
- @type no_auto_reg_pubapp_sessions: C{bool}
- @param refresh_interval: refresh session list cache and session status every C{refresh_interval} seconds
- @type refresh_interval: C{int}
+ @type no_auto_reg_pubapp_sessions: ``bool``
+ @param refresh_interval: refresh session list cache and session status every ``refresh_interval`` seconds
+ @type refresh_interval: ``int``
@param pulseaudio_installdir: install path of Pulseaudio binary
- @type pulseaudio_installdir: C{str}
+ @type pulseaudio_installdir: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoClient} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no X2GoLogger object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.listsessions_cache = None
@@ -380,7 +380,7 @@ class X2GoClient(object):
HOOK method: called if a session demands to auto connect the session profile.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_profile_auto_connect: profile ,,%s'' wants to be auto-connected to the X2Go server.' % profile_name, loglevel=log.loglevel_WARN)
@@ -390,7 +390,7 @@ class X2GoClient(object):
HOOK method: called if a session demands to auto connect the session profile.
:param profile_name: profile name of a session that triggered this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_broker_connection_exception: a broker connection problem occurred triggered by an action on profile ,,%s''.' % profile_name, loglevel=log.loglevel_WARN)
@@ -401,12 +401,12 @@ class X2GoClient(object):
be used to allow the user to decide how to proceed after connection problems with the broker.
:param profile_name: profile name of a session that triggered this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
- :param is_profile_connected: C{True} if the given session profile is already conneced to the server (Default value = False)
- :type is_profile_connected: C{bool}
- :returns: If this hook returns C{True}, the session startup/resumption will be continued, even if the
+ :type profile_name: ``str``
+ :param is_profile_connected: ``True`` if the given session profile is already conneced to the server (Default value = False)
+ :type is_profile_connected: ``bool``
+ :returns: If this hook returns ``True``, the session startup/resumption will be continued, even if the
broker connection is down. (Default: broker connection problems cause session start-up to fail).
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.logger('HOOK_broker_ignore_connection_problems: use this hook to let the user to decide how to proceed on connection failures (profile name: %s, connected: %s)' % (profile_name, is_profile_connected), loglevel=log.loglevel_WARN)
@@ -417,7 +417,7 @@ class X2GoClient(object):
HOOK method: called if the startup of a session failed.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_session_startup_failed: session startup for session profile ,,%s'' failed.' % profile_name, loglevel=log.loglevel_WARN)
@@ -427,7 +427,7 @@ class X2GoClient(object):
HOOK method: called if the startup of a shadow session was denied by the other user.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_desktop_sharing_failed: desktop sharing for profile ,,%s'' was denied by the other user.' % profile_name, loglevel=log.loglevel_WARN)
@@ -437,7 +437,7 @@ class X2GoClient(object):
HOOK method: called if the x2golistdesktops command generates a timeout due to long execution time.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_list_desktops_timeout: the server-side x2golistdesktops command for session profile %s took too long to return results. This can happen from time to time, please try again.' % profile_name, loglevel=log.loglevel_WARN)
@@ -447,9 +447,9 @@ class X2GoClient(object):
HOOK method: called if it is tried to connect to a (seen before) sharable desktop that's not available (anymore).
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param desktop: desktop identifier (the X session's $DISPLAY) (Default value = 'UNKNOWN')
- :type desktop: C{str}
+ :type desktop: ``str``
"""
self.logger('HOOK_no_such_desktop: the desktop %s (via session profile %s) is not available for sharing (anymore).' % (desktop, profile_name), loglevel=log.loglevel_WARN)
@@ -473,9 +473,9 @@ class X2GoClient(object):
requested.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_open_print_dialog: incoming print job detected by X2GoClient hook method', loglevel=log.loglevel_WARN)
@@ -485,11 +485,11 @@ class X2GoClient(object):
HOOK: the command <cmd> is not available on the connected X2Go server.
:param cmd: the command that failed
- :type cmd: C{str}
+ :type cmd: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_no_such_command: the command %s is not available for X2Go server (profile: %s, session: %s)' % (cmd, profile_name, session_name), loglevel=log.loglevel_WARN)
@@ -499,11 +499,11 @@ class X2GoClient(object):
HOOK method: called on detection of an incoming MIME box job ,,<filename>''.
:param filename: file name of the incoming MIME box job
- :type filename: C{str}
+ :type filename: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_open_mimebox_saveas_dialog: incoming MIME box job ,, %s'' detected by X2GoClient hook method' % filename, loglevel=log.loglevel_WARN)
@@ -513,15 +513,15 @@ class X2GoClient(object):
HOOK method: called if an incoming print job caused an error.
:param filename: file name of the print job that failed
- :type filename: C{str}
+ :type filename: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
:param err_msg: if available, an appropriate error message (Default value = 'GENERIC_ERROR')
- :type err_msg: C{str}
+ :type err_msg: ``str``
:param printer: if available, the printer name the print job failed on (Default value = None)
- :type printer: C{str}
+ :type printer: ``str``
"""
if printer:
@@ -531,20 +531,20 @@ class X2GoClient(object):
def HOOK_check_host_dialog(self, profile_name='UNKNOWN', host='UNKNOWN', port=22, fingerprint='no fingerprint', fingerprint_type='UNKNOWN'):
"""\
- HOOK method: called if a host check is requested. This hook has to either return C{True} (default) or C{False}.
+ HOOK method: called if a host check is requested. This hook has to either return ``True`` (default) or ``False``.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param host: SSH server name to validate (Default value = 'UNKNOWN')
- :type host: C{str}
+ :type host: ``str``
:param port: SSH server port to validate (Default value = 22)
- :type port: C{int}
+ :type port: ``int``
:param fingerprint: the server's fingerprint (Default value = 'no fingerprint')
- :type fingerprint: C{str}
+ :type fingerprint: ``str``
:param fingerprint_type: finger print type (like RSA, DSA, ...) (Default value = 'UNKNOWN')
- :type fingerprint_type: C{str}
- :returns: if host validity is verified, this hook method should return C{True}
- :rtype: C{bool}
+ :type fingerprint_type: ``str``
+ :returns: if host validity is verified, this hook method should return ``True``
+ :rtype: ``bool``
"""
self.logger('HOOK_check_host_dialog: host check requested for session profile %s: Automatically adding host [%s]:%s with fingerprint: ,,%s\'\' as a known host.' % (profile_name, host, port, fingerprint), loglevel=log.loglevel_WARN)
@@ -556,7 +556,7 @@ class X2GoClient(object):
HOOK method: called if a control session (server connection) has unexpectedly encountered a failure.
:param profile_name: profile name of session that called this hook method
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.logger('HOOK_on_control_session_death: the control session of profile %s has died unexpectedly' % profile_name, loglevel=log.loglevel_WARN)
@@ -566,9 +566,9 @@ class X2GoClient(object):
HOOK method: called SFTP client support is unavailable for the session.
:param profile_name: profile name of the session that experiences failing SFTP client support
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: name of session experiencing failing SFTP client support
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_failing_SFTP_client: new session for profile %s will lack SFTP client support. Check your server setup. Avoid echoing ~/.bashrc files on server.' % profile_name, loglevel=log.loglevel_ERROR)
@@ -590,9 +590,9 @@ class X2GoClient(object):
HOOK method: called if a sound tunnel setup failed.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_sound_tunnel_failed: setting up X2Go sound for %s (%s) support failed' % (profile_name, session_name))
@@ -602,11 +602,11 @@ class X2GoClient(object):
HOOK method: called if a reverse port forwarding request has been denied.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
:param server_port: remote server port (starting point of reverse forwarding tunnel) (Default value = 0)
- :type server_port: C{str}
+ :type server_port: ``str``
"""
self.logger('TCP port (reverse) forwarding request for session %s to server port %s has been denied by the X2Go server. This is a common issue with SSH, it might help to restart the X2Go server\'s SSH daemon.' % (session_name, server_port), loglevel=log.loglevel_WARN)
@@ -616,15 +616,15 @@ class X2GoClient(object):
HOOK method: called if a port forwarding tunnel setup failed.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
:param chain_host: hostname of chain host (forwarding tunnel end point) (Default value = 'UNKNOWN')
- :type chain_host: C{str}
+ :type chain_host: ``str``
:param chain_port: port of chain host (forwarding tunnel end point) (Default value = 0)
- :type chain_port: C{str}
+ :type chain_port: ``str``
:param subsystem: information on the subsystem that provoked this hook call (Default value = None)
- :type subsystem: C{str}
+ :type subsystem: ``str``
"""
if type(subsystem) in (bytes, str):
@@ -639,25 +639,25 @@ class X2GoClient(object):
HOOK method: called if a session has been started by this instance of L{X2GoClient}.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_started_by_me (session_uuid: %s, profile_name: %s): a new session %s has been started by this application' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
def HOOK_on_session_has_started_by_other(self, session_uuid='UNKNOWN', profile_name='UNKNOWN', session_name='UNKNOWN'):
"""\
- HOOK method: called if a session has been started by another C{x2goclient}.
+ HOOK method: called if a session has been started by another ``x2goclient``.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_started (session_uuid: %s, profile_name: %s): a new session %s has started been started by other application' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
@@ -667,25 +667,25 @@ class X2GoClient(object):
HOOK method: called if a session has been resumed by this instance of L{X2GoClient}.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_resumed_by_me (session_uuid: %s, profile_name: %s): suspended session %s has been resumed by this application' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
def HOOK_on_session_has_resumed_by_other(self, session_uuid='UNKNOWN', profile_name='UNKNOWN', session_name='UNKNOWN'):
"""\
- HOOK method: called if a session has been resumed by another C{x2goclient}.
+ HOOK method: called if a session has been resumed by another ``x2goclient``.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_resumed_by_other (session_uuid: %s, profile_name: %s): suspended session %s has been resumed by other application' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
@@ -695,11 +695,11 @@ class X2GoClient(object):
HOOK method: called after server connect if an already running session has been found.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_found_session_running_after_connect (session_uuid: %s, profile_name: %s): running session %s has been found after connecting to session profile %s' % (session_uuid, profile_name, session_name, profile_name), loglevel=log.loglevel_NOTICE)
@@ -709,25 +709,25 @@ class X2GoClient(object):
HOOK method: called if a session has been suspended by this instance of L{X2GoClient}.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_been_suspended (session_uuid: %s, profile_name: %s): session %s has been suspended' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
def HOOK_on_session_has_terminated(self, session_uuid='UNKNOWN', profile_name='UNKNOWN', session_name='UNKNOWN'):
"""\
- HOOK method: called if a session has been suspended by another C{x2goclient}.
+ HOOK method: called if a session has been suspended by another ``x2goclient``.
:param session_uuid: unique session identifier of the calling session (Default value = 'UNKNOWN')
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_on_session_has_terminated (session_uuid: %s, profile_name: %s): session %s has terminated' % (session_uuid, profile_name, session_name), loglevel=log.loglevel_NOTICE)
@@ -737,9 +737,9 @@ class X2GoClient(object):
HOOK method: called if X2Go client-side printing is not available.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_foldersharing_not_available: X2Go\'s client-side printing feature is not available with this session (%s) of profile %s.' % (session_name, profile_name), loglevel=log.loglevel_WARN)
@@ -749,9 +749,9 @@ class X2GoClient(object):
HOOK method: called if the X2Go MIME box is not available.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_mimebox_not_available: X2Go\'s MIME box feature is not available with this session (%s) of profile %s.' % (session_name, profile_name), loglevel=log.loglevel_WARN)
@@ -761,9 +761,9 @@ class X2GoClient(object):
HOOK method: called if X2Go client-side folder-sharing is not available.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_foldersharing_not_available: X2Go\'s client-side folder sharing feature is not available with this session (%s) of profile %s.' % (session_name, profile_name), loglevel=log.loglevel_WARN)
@@ -773,9 +773,9 @@ class X2GoClient(object):
HOOK method: called if the X2Go server denies SSHFS access.
:param profile_name: profile name of session that called this hook method (Default value = 'UNKNOWN')
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: X2Go session name (Default value = 'UNKNOWN')
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.logger('HOOK_sshfs_not_available: the remote X2Go server (%s) denies SSHFS access for session %s. This will result in client-side folder sharing, printing and the MIME box feature being unavailable' % (session_name, profile_name), loglevel=log.loglevel_WARN)
@@ -787,7 +787,7 @@ class X2GoClient(object):
:returns: X2Go client root directory
- :rtype: C{str}
+ :rtype: ``str``
"""
return os.path.normpath(self.client_rootdir)
@@ -797,7 +797,7 @@ class X2GoClient(object):
def has_custom_client_rootdir(self):
"""\
Does this L{X2GoClient} instance have a customized root dir path?
- Equals C{True} in case it has.
+ Equals ``True`` in case it has.
"""
@@ -811,7 +811,7 @@ class X2GoClient(object):
:returns: X2Go sessions root directory
- :rtype: C{str}
+ :rtype: ``str``
"""
return os.path.normpath(self.sessions_rootdir)
@@ -824,7 +824,7 @@ class X2GoClient(object):
:returns: SSH client root directory
- :rtype: C{str}
+ :rtype: ``str``
"""
return os.path.normpath(self.ssh_rootdir)
@@ -837,7 +837,7 @@ class X2GoClient(object):
:returns: the local username this L{X2GoClient} instance runs as
- :rtype: C{str}
+ :rtype: ``str``
"""
return _CURRENT_LOCAL_USER
@@ -845,17 +845,17 @@ class X2GoClient(object):
def register_all_session_profiles(self, return_objects=False):
"""\
- Register all session profiles found in the C{sessions} configuration node
+ Register all session profiles found in the ``sessions`` configuration node
as potential X2Go sessions.
- :param return_objects: if set to C{True} this methods returns a list of L{X2GoSession}
+ :param return_objects: if set to ``True`` this methods returns a list of L{X2GoSession}
instances, otherwise a list of session UUIDs representing the corresponding
registered sessions is returned (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:returns: a Python dictionary containing one registered session for each available session profile
configuration, whereas the profile names are used as dictionary keys and L{X2GoSession}
instances as their values
- :rtype: C{list}
+ :rtype: ``list``
"""
sessions = {}
@@ -879,12 +879,12 @@ class X2GoClient(object):
These sessions can be instantiated by passing direct L{X2GoSession}
parameters to this method or by specifying the name of an existing session profile
- (as found in the L{X2GoClient}'s C{sessions} configuration node.
+ (as found in the L{X2GoClient}'s ``sessions`` configuration node.
A session profile is a pre-defined set of session options stored in a sessions
profile node (e.g. a configuration file). With the FILE backend such session
- profiles are stored as a file (by default: C{~/.x2goclient/sessions} or globally (for all users on the
- client) in C{/etc/x2goclient/sessions}).
+ profiles are stored as a file (by default: ``~/.x2goclient/sessions`` or globally (for all users on the
+ client) in ``/etc/x2goclient/sessions``).
Python X2Go also supports starting multiple X2Go sessions for the same
session profile simultaneously.
@@ -895,54 +895,54 @@ class X2GoClient(object):
Alternatively, you can also pass a profile name or a profile id
to this method. If you do this, Python X2Go tries to find the specified session
- in the C{sessions} configuration node and then derives the necessary session parameters
+ in the ``sessions`` configuration node and then derives the necessary session parameters
from the session profile configuration. Additional L{X2GoSession} parameters can
also be passed to this method---they will override the option values retrieved from
the session profile.
:param server: hostname of the remote X2Go server (Default value = None)
- :type server: C{str}
+ :type server: ``str``
:param profile_id: id (config section name) of a session profile to load
from your session config (Default value = None)
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param profile_name: name of a session profile to load from your session
config (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: session name to register (by its name) (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param allow_printing: enable X2Go printing support for the to-be-registered X2Go session (Default value = False)
- :type allow_printing: C{bool}
+ :type allow_printing: ``bool``
:param allow_share_local_folders: set local folder sharing to enabled/disabled (Default value = False)
- :type allow_share_local_folders: C{bool}
+ :type allow_share_local_folders: ``bool``
:param share_local_folders: a list of local folders (as strings) to be shared directly
after session start up (Default value = [])
- :type share_local_folders: C{list}
+ :type share_local_folders: ``list``
:param allow_mimebox: enable X2Go MIME box support for the to-be-registered X2Go session (Default value = False)
- :type allow_mimebox: C{bool}
+ :type allow_mimebox: ``bool``
:param mimebox_extensions: MIME box support is only allowed for the given file extensions (Default value = [])
- :type mimebox_extensions: C{list}
+ :type mimebox_extensions: ``list``
:param mimebox_action: MIME box action to use on incoming MIME job files (Default value = 'OPEN')
- :type mimebox_action: C{str}
- :param add_to_known_hosts: add unknown host keys to the C{known_hosts} file and accept the connection
+ :type mimebox_action: ``str``
+ :param add_to_known_hosts: add unknown host keys to the ``known_hosts`` file and accept the connection
automatically (Default value = False)
- :type add_to_known_hosts: C{bool}
- :param known_hosts: full path to C{known_hosts} file (Default value = None)
- :type known_hosts: C{str}
+ :type add_to_known_hosts: ``bool``
+ :param known_hosts: full path to ``known_hosts`` file (Default value = None)
+ :type known_hosts: ``str``
:param forward_sshagent: forward SSH agent authentication requests to the X2Go client-side (Default value = False)
- :type forward_sshagent: C{bool}
- :param proxy_options: a set of very C{X2GoProxy*} backend specific options; any option that is not known
- to the C{X2GoProxy*} backend will simply be ignored (Default value = {})
- :type proxy_options: C{dict}
+ :type forward_sshagent: ``bool``
+ :param proxy_options: a set of very ``X2GoProxy*`` backend specific options; any option that is not known
+ to the ``X2GoProxy*`` backend will simply be ignored (Default value = {})
+ :type proxy_options: ``dict``
:param return_object: normally this method returns a unique session UUID. If
- C{return_object} is set to C{True} an X2GoSession object will be returned
+ ``return_object`` is set to ``True`` an X2GoSession object will be returned
instead (Default value = False)
- :type return_object: C{bool}
+ :type return_object: ``bool``
:param kwargs: any option that is also valid for the L{X2GoSession} constructor
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
:returns: a unique identifier (UUID) for the newly registered X2Go session (or an
- X2GoSession object if C{return_object} is set to True
- :rtype: C{str}
+ X2GoSession object if ``return_object`` is set to True
+ :rtype: ``str``
"""
_p = None
@@ -1063,7 +1063,7 @@ class X2GoClient(object):
Retrieves a Python dictionary, containing a short session summary (session status, names, etc.)
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
return self.session_registry.session_summary(session_uuid)
@@ -1079,9 +1079,9 @@ class X2GoClient(object):
username that the remote sessions runs as.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: the remote username the X2Go session runs as
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_registry(session_uuid).get_username()
@@ -1094,9 +1094,9 @@ class X2GoClient(object):
about to connect to).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: the host an X2Go session is connected to
- (as an C{(addr,port)} tuple)
+ (as an ``(addr,port)`` tuple)
:rtype: tuple
"""
@@ -1110,7 +1110,7 @@ class X2GoClient(object):
profile).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: the hostname for the queried X2Go session as specified
by the calling application
:rtype: str
@@ -1125,7 +1125,7 @@ class X2GoClient(object):
registered under the given session registry hash.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: the L{X2GoSession} instance
:rtype: obj
@@ -1141,13 +1141,13 @@ class X2GoClient(object):
<session_name> from the session registry.
:param session_name: the X2Go session's UUID registry hash
- :type session_name: C{str}
+ :type session_name: ``str``
:param return_object: session UUID hash or L{X2GoSession} instance wanted? (Default value = False)
- :type return_object: C{bool}
+ :type return_object: ``bool``
:param match_profile_name: only return sessions that match this profile name (Default value = None)
- :type match_profile_name: C{str}
+ :type match_profile_name: ``str``
:returns: the X2Go session's UUID registry hash or L{X2GoSession} instance
- :rtype: C{str} or L{X2GoSession} instance
+ :rtype: ``str`` or L{X2GoSession} instance
"""
try:
@@ -1159,12 +1159,12 @@ class X2GoClient(object):
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}.
+ been registered under ``session_uuid``.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: X2Go session name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_registry(session_uuid).get_session_name()
@@ -1173,12 +1173,12 @@ class X2GoClient(object):
def get_session_info(self, session_uuid):
"""\
Retrieve the server-side X2Go session information object for the session that has
- been registered under C{session_uuid}.
+ been registered under ``session_uuid``.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: X2Go session info
- :rtype: C{obj}
+ :rtype: ``obj``
"""
return self.session_registry(session_uuid).get_session_info()
@@ -1187,25 +1187,25 @@ class X2GoClient(object):
def get_published_applications(self, session_uuid=None, profile_name=None, lang=None, refresh=False, raw=False, very_raw=False, max_no_submenus=_PUBAPP_MAX_NO_SUBMENUS):
"""\
Retrieve the server-side X2Go published applications menu for the session
- registered under C{session_uuid} or for profile name C{profile_name}.
+ registered under ``session_uuid`` or for profile name ``profile_name``.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: a valid session profile name (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param lang: locale/language identifier (Default value = None)
- :type lang: C{str}
+ :type lang: ``str``
:param refresh: force reload of the menu tree from X2Go server (Default value = False)
- :type refresh: C{bool}
+ :type refresh: ``bool``
:param raw: retrieve a raw output of the server list of published applications (Default value = False)
- :type raw: C{bool}
+ :type raw: ``bool``
:param very_raw: retrieve a very raw output of the server list of published applications (Default value = False)
- :type very_raw: C{bool}
+ :type very_raw: ``bool``
:param max_no_submenus: Number of applications before applications are put into XDG category submenus
(Default value = defaults.PUBAPP_MAX_NO_SUBMENUS)
- :type max_no_submenus: C{int}
+ :type max_no_submenus: ``int``
:returns: an i18n capable menu tree packed as a Python dictionary
- :rtype: C{list}
+ :rtype: ``list``
"""
if session_uuid is None and profile_name:
@@ -1226,15 +1226,15 @@ class X2GoClient(object):
def set_session_username(self, session_uuid, username):
"""\
- Set the session username for the L{X2GoSession} that has been registered under C{session_uuid}.
+ Set the session username for the L{X2GoSession} that has been registered under ``session_uuid``.
This can be helpful for modifying user credentials during an authentication phase.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param username: new user name to be used for session authentication
- :type username: C{str}
- :returns: returns C{True} on success
- :rtype: C{bool}
+ :type username: ``str``
+ :returns: returns ``True`` on success
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).set_username(username=username)
@@ -1245,9 +1245,9 @@ class X2GoClient(object):
Provide a mechanism to evaluate the validity of an X2Go server host.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if host validation has been successful.
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if host validation has been successful.
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).check_host()
@@ -1259,9 +1259,9 @@ class X2GoClient(object):
password / key for proxy authentication, as well.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if the session is configured to re-use session password / key for proxy authentication
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if the session is configured to re-use session password / key for proxy authentication
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).reuses_sshproxy_authinfo()
@@ -1273,9 +1273,9 @@ class X2GoClient(object):
intermediate SSH proxy server.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if the session is configured to use an SSH proxy, C{False} otherwise.
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if the session is configured to use an SSH proxy, ``False`` otherwise.
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).uses_sshproxy()
@@ -1287,10 +1287,10 @@ class X2GoClient(object):
to be able to auto-connect to the SSH proxy server (e.g. by public key authentication).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if the session's SSH proxy can auto-connect, C{False} otherwise, C{None}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if the session's SSH proxy can auto-connect, ``False`` otherwise, ``None``
if no control session has been set up yet.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).can_sshproxy_auto_connect()
@@ -1302,10 +1302,10 @@ class X2GoClient(object):
to be able to auto-connect to the X2Go server (e.g. by public key authentication).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if the session can auto-connect, C{False} otherwise, C{None}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if the session can auto-connect, ``False`` otherwise, ``None``
if no control session has been set up yet.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).can_auto_connect()
@@ -1319,9 +1319,9 @@ class X2GoClient(object):
client implementation.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: returns C{True} if the session could be auto-connected.
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: returns ``True`` if the session could be auto-connected.
+ :rtype: ``bool``
"""
self.session_registry(session_uuid).do_auto_connect(redirect_to_client=False)
@@ -1339,41 +1339,41 @@ class X2GoClient(object):
sshproxy_force_password_auth=False,
):
"""\
- Connect to a registered X2Go session with registry hash C{session_uuid}
+ Connect to a registered X2Go session with registry hash ``session_uuid``
This method basically wraps around paramiko.SSHClient.connect() for the
corresponding session.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param username: user name to be used for session authentication (Default value = None)
- :type username: C{str}
+ :type username: ``str``
:param password: the user's password for the X2Go server that is going to be
connected to (Default value = None)
- :type password: C{str}
+ :type password: ``str``
:param passphrase: a passphrase to use for unlocking
a private key in case the password is already needed for
two-factor authentication (Default value = None)
- :type passphrase: C{str}
+ :type passphrase: ``str``
:param sshproxy_user: user name to be used for SSH proxy authentication (Default value = None)
- :type sshproxy_user: C{str}
+ :type sshproxy_user: ``str``
:param sshproxy_password: the SSH proxy user's password (Default value = None)
- :type sshproxy_password: C{str}
+ :type sshproxy_password: ``str``
:param sshproxy_passphrase: a passphrase to use for unlocking
a private key needed for the SSH proxy host in case the sshproxy_password is already needed for
two-factor authentication (Default value = None)
- :type sshproxy_passphrase: C{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} L{checkhosts.X2GoInteractiveAddPolicy()}
+ :type sshproxy_passphrase: ``str``
+ :param add_to_known_hosts: non-Paramiko option, if ``True`` paramiko.AutoAddPolicy()
+ is used as missing-host-key-policy. If set to ``False`` L{checkhosts.X2GoInteractiveAddPolicy()}
is used (Default value = False)
- :type add_to_known_hosts: C{bool}
+ :type add_to_known_hosts: ``bool``
:param force_password_auth: disable SSH pub/priv key authentication mechanisms
completely (Default value = False)
- :type force_password_auth: C{bool}
+ :type force_password_auth: ``bool``
:param sshproxy_force_password_auth: disable SSH pub/priv key authentication mechanisms
completely for SSH proxy connection (Default value = False)
- :type sshproxy_force_password_auth: C{bool}
+ :type sshproxy_force_password_auth: ``bool``
:returns: returns True if this method has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
"""
_success = self.session_registry(session_uuid).connect(username=username,
@@ -1398,7 +1398,7 @@ class X2GoClient(object):
Disconnect an L{X2GoSession} by closing down its Paramiko/SSH Transport thread.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
self.session_registry(session_uuid).disconnect()
@@ -1430,13 +1430,13 @@ class X2GoClient(object):
each class individually.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param print_action: one of the named above print actions, either as string or class instance
- :type print_action: C{str} or C{instance}
+ :type print_action: ``str`` or ``instance``
:param kwargs: additional information for the given print action (print
action arguments), for possible print action arguments and their values see each individual
print action class
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -1450,9 +1450,9 @@ class X2GoClient(object):
always contains the X2Go session ID of that window.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param title: new title for session window (Default value = '')
- :type title: C{str}
+ :type title: ``str``
"""
self.session_registry(session_uuid).set_session_window_title(title=title)
@@ -1464,7 +1464,7 @@ class X2GoClient(object):
it to focus.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
self.session_registry(session_uuid).raise_session_window()
@@ -1478,15 +1478,15 @@ class X2GoClient(object):
can be used to handle auto-start/-resume events.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param newest: if resuming, only resume newest/youngest session (Default value = True)
- :type newest: C{bool}
+ :type newest: ``bool``
:param oldest: if resuming, only resume oldest session (Default value = False)
- :type oldest: C{bool}
+ :type oldest: ``bool``
:param all_suspended: if resuming, resume all suspended sessions (Default value = False)
- :type all_suspended: C{bool}
+ :type all_suspended: ``bool``
:param start: if no session is to be resumed, start a new session (Default value = True)
- :type start: C{bool}
+ :type start: ``bool``
"""
self.session_registry(session_uuid).do_auto_start_or_resume(newest=newest, oldest=oldest, all_suspended=all_suspended, start=start, redirect_to_client=False)
@@ -1503,12 +1503,12 @@ class X2GoClient(object):
connect to it with L{connect_session} (authentication).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.start()} method
- :type sessionopts: C{dict}
+ :type sessionopts: ``dict``
:param **sessionopts:
:returns: returns True if this method has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
"""
# prevent the newly started session from being registered twice
@@ -1533,24 +1533,24 @@ class X2GoClient(object):
instance.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param desktop: desktop ID of a sharable desktop in format <user>@<display> (Default value = None)
- :type desktop: C{str}
+ :type desktop: ``str``
:param user: user name and display number can be given separately, here give the
name of the user who wants to share a session with you. (Default value = None)
- :type user: C{str}
+ :type user: ``str``
:param display: user name and display number can be given separately, here give the
number of the display that a user allows you to be shared with. (Default value = None)
- :type display: C{str}
+ :type display: ``str``
:param share_mode: desktop sharing mode, 0 is VIEW-ONLY, 1 is FULL-ACCESS. (Default value = 0)
- :type share_mode: C{int}
+ :type share_mode: ``int``
:param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.share_desktop()} method
- :type sessionopts: C{dict}
+ :type sessionopts: ``dict``
:param check_desktop_list: check if the given desktop is available on the X2Go server; handle with care as
- the server-side C{x2golistdesktops} command might block client I/O. (Default value = False)
+ the server-side ``x2golistdesktops`` command might block client I/O. (Default value = False)
:param **sessionopts:
:returns: True if the session could be successfully shared.
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoDesktopSharingException: if a given desktop ID does not specify an available desktop session
"""
@@ -1576,16 +1576,16 @@ class X2GoClient(object):
called).
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param match_profile_name: only resume a session if this profile name matches (Default value = None)
- :type match_profile_name: C{str}
+ :type match_profile_name: ``str``
:param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.resume()} method
- :type sessionopts: C{dict}
+ :type sessionopts: ``dict``
:param **sessionopts:
:returns: returns True if this method has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoClientException: if the method does not know what session to resume
"""
@@ -1612,28 +1612,28 @@ class X2GoClient(object):
Normally, you will use this method to suspend a registered session that you
have formerly started/resumed from within your recent
L{X2GoClient} instance. For this you simply call this method
- using the session's C{session_uuid}, leave the C{session_name}
+ using the session's ``session_uuid``, leave the ``session_name``
empty.
Alternatively, you can suspend a non-associated X2Go session:
To do this you simply neeed to register (with the L{register_session}
method) 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
+ the freshly obtained ``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: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (for
non-associated session suspend) (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param match_profile_name: only suspend a session if this profile name matches (Default value = None)
- :type match_profile_name: C{str}
+ :type match_profile_name: ``str``
:param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.suspend()} method
- :type sessionopts: C{dict}
+ :type sessionopts: ``dict``
:param **sessionopts:
:returns: returns True if this method has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
"""
try:
@@ -1665,27 +1665,27 @@ class X2GoClient(object):
Normally you will use this method to terminate a registered session that you
have formerly started/resumed from within your recent
L{X2GoClient} instance. For this you simply call this method
- using the session's C{session_uuid}, leave the C{session_name}
+ using the session's ``session_uuid``, leave the ``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
+ the freshly obtained ``session_uuid`` and the remote X2Go session
name (as shown in e.g. x2golistsessions output).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param match_profile_name: only terminate a session if this profile name matches (Default value = None)
- :type match_profile_name: C{str}
+ :type match_profile_name: ``str``
:param sessionopts: pass-through of options directly to the session instance's L{X2GoSession.terminate()} method
- :type sessionopts: C{dict}
+ :type sessionopts: ``dict``
:param **sessionopts:
:returns: returns True if this method has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
"""
try:
@@ -1713,19 +1713,19 @@ class X2GoClient(object):
def get_session_profile_name(self, session_uuid):
"""\
Retrieve the profile name of the session that has been registered
- under C{session_uuid}.
+ under ``session_uuid``.
For profile based sessions this will be the profile name as used
in x2goclient's »sessions« configuration file.
- For non-profile based session this will either be a C{profile_name} that
+ For non-profile based session this will either be a ``profile_name`` that
was passed to L{register_session} or it will be the application that
instantiated this L{X2GoClient} instance.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: X2Go session profile name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_registry(session_uuid).get_profile_name()
@@ -1734,7 +1734,7 @@ class X2GoClient(object):
def get_session_profile_id(self, session_uuid):
"""\
Retrieve the profile id of the session that has been registered
- under C{session_uuid}.
+ under ``session_uuid``.
For profile based sessions this will be the profile id as used
in x2goclient's »sessions« configuration node (section header of
@@ -1742,12 +1742,12 @@ class X2GoClient(object):
session profile creation/modification).
For non-profile based sessions this will be a timestamp created on
- X2Go session registration by C{register_session}.
+ X2Go session registration by ``register_session``.
:param session_uuid: the session profile name
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: the X2Go session profile's id
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_registry(session_uuid).profile_id
@@ -1755,13 +1755,13 @@ class X2GoClient(object):
def session_ok(self, session_uuid):
"""\
- Test if the X2Go session registered as C{session_uuid} is
+ Test if the X2Go session registered as ``session_uuid`` is
in a healthy state.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: C{True} if session is ok, C{False} otherwise
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: ``True`` if session is ok, ``False`` otherwise
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).session_ok()
@@ -1769,13 +1769,13 @@ class X2GoClient(object):
def is_session_connected(self, session_uuid):
"""\
- Test if the X2Go session registered as C{session_uuid} connected
+ Test if the X2Go session registered as ``session_uuid`` connected
to the X2Go server.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: C{True} if session is connected, C{False} otherwise
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: ``True`` if session is connected, ``False`` otherwise
+ :rtype: ``bool``
"""
return self.session_registry(session_uuid).is_connected()
@@ -1787,9 +1787,9 @@ class X2GoClient(object):
to the X2Go server.
:param profile_name: a valid session profile name
- :type profile_name: C{str}
- :returns: C{True} if profile has a connected session, C{False} otherwise
- :rtype: C{bool}
+ :type profile_name: ``str``
+ :returns: ``True`` if profile has a connected session, ``False`` otherwise
+ :rtype: ``bool``
"""
return bool(self.client_connected_sessions_of_profile_name(profile_name=profile_name))
@@ -1797,12 +1797,12 @@ class X2GoClient(object):
def is_session_profile(self, profile_id_or_name):
"""\
- Test if the X2Go given session profile is configured in the client's C{sessions} file.
+ Test if the X2Go given session profile is configured in the client's ``sessions`` file.
:param profile_id_or_name: test existence of this session profile name (or id)
- :type profile_id_or_name: C{str}
- :returns: C{True} if session profile exists, C{False} otherwise
- :rtype: C{bool}
+ :type profile_id_or_name: ``str``
+ :returns: ``True`` if session profile exists, ``False`` otherwise
+ :rtype: ``bool``
"""
return self.session_profiles.has_profile(profile_id_or_name)
@@ -1810,15 +1810,15 @@ class X2GoClient(object):
def is_session_running(self, session_uuid, session_name=None):
"""\
- Test if the X2Go session registered as C{session_uuid} is up
+ Test if the X2Go session registered as ``session_uuid`` is up
and running.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
- :returns: C{True} if session is running, C{False} otherwise
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True`` if session is running, ``False`` otherwise
+ :rtype: ``bool``
"""
if session_name is None:
@@ -1829,15 +1829,15 @@ class X2GoClient(object):
def is_session_suspended(self, session_uuid, session_name=None):
"""\
- Test if the X2Go session registered as C{session_uuid}
+ Test if the X2Go session registered as ``session_uuid``
is in suspended state.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
- :returns: C{True} if session is suspended, C{False} otherwise
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True`` if session is suspended, ``False`` otherwise
+ :rtype: ``bool``
"""
if session_name is None:
@@ -1848,15 +1848,15 @@ class X2GoClient(object):
def has_session_terminated(self, session_uuid, session_name=None):
"""\
- Test if the X2Go session registered as C{session_uuid}
+ Test if the X2Go session registered as ``session_uuid``
has terminated.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
- :returns: C{True} if session has terminated, C{False} otherwise
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True`` if session has terminated, ``False`` otherwise
+ :rtype: ``bool``
"""
if session_name is None:
@@ -1871,11 +1871,11 @@ class X2GoClient(object):
session profile <profile_name>.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: alternatively, the profile name can be used to perform this query (Default value = None)
- :type profile_name: C{str}
- :returns: returns C{True} if the profile/session supports local folder sharing
- :rtype: C{bool}
+ :type profile_name: ``str``
+ :returns: returns ``True`` if the profile/session supports local folder sharing
+ :rtype: ``bool``
"""
if session_uuid is None and profile_name:
@@ -1894,23 +1894,23 @@ class X2GoClient(object):
def share_local_folder(self, session_uuid=None, local_path=None, profile_name=None, folder_name=None):
"""\
- Share a local folder with the X2Go session registered as C{session_uuid}.
+ Share a local folder with the X2Go session registered as ``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 (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param local_path: the full path to an existing folder on the local (client-side)
file system (Default value = None)
- :type local_path: C{str}
- :param folder_name: synonymous to C{local_path} (Default value = None)
- :type folder_name: C{str}
+ :type local_path: ``str``
+ :param folder_name: synonymous to ``local_path`` (Default value = None)
+ :type folder_name: ``str``
:param profile_name: alternatively, the profile name can be used to share local folders (Default value = None)
- :type profile_name: C{str}
- :returns: returns C{True} if the local folder has been successfully mounted
- :rtype: C{bool}
+ :type profile_name: ``str``
+ :returns: returns ``True`` if the local folder has been successfully mounted
+ :rtype: ``bool``
"""
# compat for Python-X2Go (<=0.1.1.6)
@@ -1933,19 +1933,19 @@ class X2GoClient(object):
def unshare_all_local_folders(self, session_uuid=None, profile_name=None):
"""\
Unshare all local folders mounted in X2Go session registered as
- C{session_uuid}.
+ ``session_uuid``.
When calling this method all client-side mounted folders on the X2Go
server (via sshfs) for session with ID <session_uuid> will get
unmounted.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: alternatively, the profile name can be used to unshare
mounted folders (Default value = None)
- :type profile_name: C{str}
- :returns: returns C{True} if all local folders could be successfully unmounted
- :rtype: C{bool}
+ :type profile_name: ``str``
+ :returns: returns ``True`` if all local folders could be successfully unmounted
+ :rtype: ``bool``
"""
if session_uuid is None and profile_name:
@@ -1963,23 +1963,23 @@ class X2GoClient(object):
def unshare_local_folder(self, session_uuid=None, profile_name=None, local_path=None):
"""\
Unshare local folder that is mounted in the X2Go session registered as
- C{session_uuid}.
+ ``session_uuid``.
When calling this method the given client-side mounted folder on the X2Go
server (via sshfs) for session with ID <session_uuid> will get
unmounted.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: alternatively, the profile name can be used to unshare
mounted folders (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param local_path: the full path of a local folder that is mounted within X2Go
session with session ID <session_uuid> (or recognized via profile name) and that
shall be unmounted from that session. (Default value = None)
- :type local_path: C{str}
- :returns: returns C{True} if all local folders could be successfully unmounted
- :rtype: C{bool}
+ :type local_path: ``str``
+ :returns: returns ``True`` if all local folders could be successfully unmounted
+ :rtype: ``bool``
"""
if session_uuid is None and profile_name:
@@ -2000,13 +2000,13 @@ class X2GoClient(object):
from this client.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: alternatively, the profile name can be used to get mounted folders of a session connected profile (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param check_list_mounts: query the server-side mount list for up-to-date information (Default value = False)
- :type check_list_mounts: C{bool}
- :returns: returns a C{list} of those local folder names that are mounted within X2Go session <session_uuid>.
- :rtype: C{list}
+ :type check_list_mounts: ``bool``
+ :returns: returns a ``list`` of those local folder names that are mounted within X2Go session <session_uuid>.
+ :rtype: ``list``
"""
if session_uuid is None and profile_name:
@@ -2036,13 +2036,13 @@ class X2GoClient(object):
Retrieve the master session of a specific profile.
:param profile_name: the profile name that we query the master session of
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_object: return L{X2GoSession} instance (Default value = True)
- :type return_object: C{bool}
+ :type return_object: ``bool``
:param return_session_name: return X2Go session name (Default value = False)
- :type return_session_name: C{bool}
+ :type return_session_name: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.get_master_session(profile_name, return_object=return_object, return_session_name=return_session_name)
@@ -2059,15 +2059,15 @@ class X2GoClient(object):
Retrieve a list of X2Go sessions that this L{X2GoClient} instance is connected to.
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of session profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of connected sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.connected_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -2076,7 +2076,7 @@ class X2GoClient(object):
@property
def client_has_connected_sessions(self):
"""\
- Equals C{True} if there are any connected sessions with this L{X2GoClient} instance.
+ Equals ``True`` if there are any connected sessions with this L{X2GoClient} instance.
"""
@@ -2088,15 +2088,15 @@ class X2GoClient(object):
Retrieve a list of X2Go sessions associated to this L{X2GoClient} instance.
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of session profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of associated sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.associated_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -2105,7 +2105,7 @@ class X2GoClient(object):
@property
def client_has_associated_sessions(self):
"""\
- Equals C{True} if there are any associated sessions with this L{X2GoClient} instance.
+ Equals ``True`` if there are any associated sessions with this L{X2GoClient} instance.
"""
@@ -2117,15 +2117,15 @@ class X2GoClient(object):
Retrieve a list of running X2Go sessions.
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of session profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of running sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.running_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -2134,7 +2134,7 @@ class X2GoClient(object):
@property
def client_has_running_sessions(self):
"""\
- Equals C{True} if there are any running sessions with this L{X2GoClient} instance.
+ Equals ``True`` if there are any running sessions with this L{X2GoClient} instance.
"""
@@ -2146,15 +2146,15 @@ class X2GoClient(object):
Retrieve a list of suspended X2Go sessions.
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of session profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of suspended sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.running_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -2163,7 +2163,7 @@ class X2GoClient(object):
@property
def client_has_suspended_sessions(self):
"""\
- Equals C{True} if there are any suspended sessions with this L{X2GoClient} instance.
+ Equals ``True`` if there are any suspended sessions with this L{X2GoClient} instance.
"""
@@ -2175,15 +2175,15 @@ class X2GoClient(object):
Retrieve a list of registered X2Go sessions.
:param return_objects: return as list of X2Go session objects (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of session profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of registered sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.registered_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -2204,9 +2204,9 @@ class X2GoClient(object):
Retrieve control session for profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: control session instance
- :rtype: C{X2GoControlSession} instance
+ :rtype: ``X2GoControlSession`` instance
"""
return self.session_registry.control_session_of_profile_name(profile_name)
@@ -2218,13 +2218,13 @@ class X2GoClient(object):
and its versions.
:param profile_name: use the control session of this profile to query the X2Go server for its component list
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param component: only return the version of a specific component (Default value = None)
- :type component: C{str}
+ :type component: ``str``
:param force: refresh component/version data by a query to the server (Default value = False)
- :type force: C{bool}
+ :type force: ``bool``
:returns: dictionary of server components (as keys) and their versions (as values) or the version of the given <component>
- :rtype: C{dict} or C{str}
+ :rtype: ``dict`` or ``str``
:raises X2GoClientException: if component is not available on the X2Go Server.
"""
@@ -2246,11 +2246,11 @@ class X2GoClient(object):
X2Go features.
:param profile_name: use the control session of this profile to query the X2Go server for its feature list
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param force: refresh feature list by a query to the server (Default value = False)
- :type force: C{bool}
+ :type force: ``bool``
:returns: list of server feature names (as returned by server-side command ,,x2gofeaturelist''
- :rtype: C{list}
+ :rtype: ``list``
"""
control_session = self.client_control_session_of_profile_name(profile_name)
@@ -2263,11 +2263,11 @@ class X2GoClient(object):
of a certain server feature.
:param profile_name: use the control session of this profile to query the X2Go server for its feature
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param feature: test the availability of this feature on the X2Go server
- :type feature: C{str}
- :returns: C{True} if the feature is available on the queried server
- :rtype: C{bool}
+ :type feature: ``str``
+ :returns: ``True`` if the feature is available on the queried server
+ :rtype: ``bool``
"""
control_session = self.client_control_session_of_profile_name(profile_name)
@@ -2279,11 +2279,11 @@ class X2GoClient(object):
Retrieve X2Go session of a given session name.
:param session_name: session name
- :type session_name: C{str}
+ :type session_name: ``str``
:param return_object: return as X2Go session object (Default value = False)
- :type return_object: C{bool}
+ :type return_object: ``bool``
:returns: session instance of the given name
- :rtype: C{X2GoSession} or C{str}
+ :rtype: ``X2GoSession`` or ``str``
"""
return self.session_registry.get_session_of_session_name(session_name, return_object=return_object)
@@ -2291,12 +2291,12 @@ class X2GoClient(object):
def client_has_registered_session_of_name(self, session_name):
"""\
- Equals C{True} if there is a registered session of name <session_name>.
+ Equals ``True`` if there is a registered session of name <session_name>.
:param session_name: session name
- :type session_name: C{str}
- :returns: C{True} if the given session is registered
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True`` if the given session is registered
+ :rtype: ``bool``
"""
return self.client_registered_session_of_name(session_name) is not None
@@ -2307,13 +2307,13 @@ class X2GoClient(object):
Retrieve registered X2Go sessions of profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of registered sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.registered_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2324,13 +2324,13 @@ class X2GoClient(object):
Retrieve connected X2Go sessions of profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of connected sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.connected_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2341,13 +2341,13 @@ class X2GoClient(object):
Retrieve associated X2Go sessions of profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of associated sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.associated_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2358,13 +2358,13 @@ class X2GoClient(object):
Retrieve X2Go sessions of profile name <profile_name> that provide published applications.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of application publishing sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.pubapp_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2376,13 +2376,13 @@ class X2GoClient(object):
Retrieve running X2Go sessions of profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of running sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.running_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2393,13 +2393,13 @@ class X2GoClient(object):
Retrieve suspended X2Go sessions of profile name <profile_name>.
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of X2Go session objects (Default value = False)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: list of suspended sessions of profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.session_registry.suspended_sessions_of_profile_name(profile_name, return_objects=return_objects, return_session_names=return_session_names)
@@ -2411,14 +2411,14 @@ class X2GoClient(object):
def server_is_alive(self, session_uuid):
"""\
- Test if server that corresponds to the terminal session C{session_uuid} is alive.
+ Test if server that corresponds to the terminal session ``session_uuid`` is alive.
If the session is not connected anymore the L{X2GoClient.HOOK_on_control_session_death()} gets called.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: C{True} if X2Go server connection for L{X2GoSession} instance with <session_uuid> is alive.
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: ``True`` if X2Go server connection for L{X2GoSession} instance with <session_uuid> is alive.
+ :rtype: ``bool``
:raises X2GoControlSessionException: if the session is not connected anymore; in that case the L{HOOK_on_control_session_death} gets called.
"""
@@ -2436,9 +2436,9 @@ class X2GoClient(object):
Test vitality of all connected X2Go servers.
- :returns: C{True} if all connected X2Go servers are alive.
+ :returns: ``True`` if all connected X2Go servers are alive.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
_all_alive = True
@@ -2452,11 +2452,11 @@ class X2GoClient(object):
Check if user is allowed to start an X2Go session on a remote server.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param username: user name to test validity for (Default value = None)
- :type username: C{str}
+ :type username: ``str``
:returns: Is remote user allowed to start an X2Go session?
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_registry(session_uuid).user_is_x2gouser(username=username)
@@ -2468,10 +2468,10 @@ class X2GoClient(object):
instantiated by our L{X2GoClient} instance).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: list of session names
- :rtype: C{list}
- :raises X2GoClientException: if the session with UUID C{session_uuid} is not connected
+ :rtype: ``list``
+ :raises X2GoClientException: if the session with UUID ``session_uuid`` is not connected
"""
if self._X2GoClient__is_session_connected(session_uuid):
@@ -2483,12 +2483,12 @@ class X2GoClient(object):
def server_has_running_sessions(self, session_uuid):
"""\
- Equals C{True} if the X2Go server has any running sessions.
+ Equals ``True`` if the X2Go server has any running sessions.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :returns: C{True}, if there are running sessions
- :rtype: C{bool}
+ :type session_uuid: ``str``
+ :returns: ``True``, if there are running sessions
+ :rtype: ``bool``
"""
return len(self._X2GoClient__server_running_sessions(session_uuid)) > 0
@@ -2496,12 +2496,12 @@ class X2GoClient(object):
def server_has_running_session_of_name(self, session_uuid, session_name):
"""\
- Equals C{True} if the X2Go server has a running session of name <session_name>.
+ Equals ``True`` if the X2Go server has a running session of name <session_name>.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: session name
- :type session_name: C{str}
+ :type session_name: ``str``
"""
return session_name in self._X2GoClient__server_running_sessions(session_uuid)
@@ -2513,10 +2513,10 @@ class X2GoClient(object):
instantiated by our L{X2GoClient} instance).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: list of session names
- :rtype: C{list}
- :raises X2GoClientException: if the session with UUID C{session_uuid} is not connected
+ :rtype: ``list``
+ :raises X2GoClientException: if the session with UUID ``session_uuid`` is not connected
"""
if self._X2GoClient__is_session_connected(session_uuid):
@@ -2528,10 +2528,10 @@ class X2GoClient(object):
def server_has_suspended_sessions(self, session_uuid):
"""\
- Equals C{True} if the X2Go server has any suspended sessions.
+ Equals ``True`` if the X2Go server has any suspended sessions.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
return len(self._X2GoClient__server_suspended_sessions(session_uuid)) > 0
@@ -2539,14 +2539,14 @@ class X2GoClient(object):
def server_has_suspended_session_of_name(self, session_uuid, session_name):
"""\
- Equals C{True} if the X2Go server has a suspended session of name <session_name>.
+ Equals ``True`` if the X2Go server has a suspended session of name <session_name>.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param session_name: session name
- :type session_name: C{str}
- :returns: C{True}, if there are running sessions
- :rtype: C{bool}
+ :type session_name: ``str``
+ :returns: ``True``, if there are running sessions
+ :rtype: ``bool``
"""
return session_name in self._X2GoClient__server_suspended_sessions(session_uuid)
@@ -2567,10 +2567,10 @@ class X2GoClient(object):
L{X2GoClient.connect_session()}.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :param published_applications: if C{True}, also terminate sessions that are published applications
+ :type session_uuid: ``str``
+ :param published_applications: if ``True``, also terminate sessions that are published applications
provider (Default value = False)
- :type published_applications: C{bool}
+ :type published_applications: ``bool``
"""
_destroy_terminals = not ( self.auto_update_sessionregistry == True)
@@ -2589,7 +2589,7 @@ class X2GoClient(object):
register_sessions=False,
raw=False):
"""\
- Use the X2Go session registered under C{session_uuid} to
+ Use the X2Go session registered under ``session_uuid`` to
retrieve a list of running or suspended X2Go sessions from the
connected X2Go server (for the authenticated user).
@@ -2599,25 +2599,25 @@ class X2GoClient(object):
L{X2GoClient.connect_session()}.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: use profile name instead of <session_uuid> (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param profile_id: use profile id instead of <profile_name> or <session_uuid> (Default value = None)
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param no_cache: do not get the session list from cache, query the X2Go server directly (Default value = False)
- :type no_cache: C{bool}
+ :type no_cache: ``bool``
:param refresh_cache: query the X2Go server directly and update the session list cache
with the new information (Default value = False)
- :type refresh_cache: C{bool}
+ :type refresh_cache: ``bool``
:param update_sessionregistry: query the X2Go server directly and update the
session registry according to the obtained information (Default value = True)
- :type update_sessionregistry: C{bool}
+ :type update_sessionregistry: ``bool``
:param register_sessions: query the X2Go server directly and register newly found X2Go session
as L{X2GoSession} instances associated to this L{X2GoClient} instance (Default value = False)
- :type register_sessions: C{bool}
- :param raw: output the session list in X2Go's raw C{x2golistsessions} format (Default value = False)
- :type raw: C{bool}
- :raises X2GoClientException: if the session profile specified by C{session_uuid}, C{profile_name} or C{profile_id} is not connected
+ :type register_sessions: ``bool``
+ :param raw: output the session list in X2Go's raw ``x2golistsessions`` format (Default value = False)
+ :type raw: ``bool``
+ :raises X2GoClientException: if the session profile specified by ``session_uuid``, ``profile_name`` or ``profile_id`` is not connected
or if none of the named parameters has been specified
"""
@@ -2670,7 +2670,7 @@ class X2GoClient(object):
exclude_session_types=[],
raw=False):
"""\
- Use the X2Go session registered under C{session_uuid} to
+ Use the X2Go session registered under ``session_uuid`` to
retrieve a list of X2Go desktop sessions that are available
for desktop sharing.
@@ -2680,25 +2680,25 @@ class X2GoClient(object):
L{X2GoClient.connect_session()}.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: use profile name instead of <session_uuid> (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param profile_id: use profile id instead of <profile_name> or <session_uuid> (Default value = None)
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param no_cache: do not get the desktop list from cache, query the X2Go server directly (Default value = False)
- :type no_cache: C{bool}
+ :type no_cache: ``bool``
:param refresh_cache: query the X2Go server directly and update the desktop list cache
with the new information (Default value = False)
- :type refresh_cache: C{bool}
+ :type refresh_cache: ``bool``
:param exclude_session_types: session types (e.g. "D", "R", "S" or "P") to be excluded from the
returned list of sharable desktops (this only works for sharing someone's own sessions, for
sharing other users' sessions, the X2Go Desktop Sharing decides on what is sharable and what not). (Default value = [])
- :type exclude_session_types: C{list}
- :param raw: output the session list in X2Go's raw C{x2golistdesktops} format (Default value = False)
- :type raw: C{bool}
+ :type exclude_session_types: ``list``
+ :param raw: output the session list in X2Go's raw ``x2golistdesktops`` format (Default value = False)
+ :type raw: ``bool``
:returns: a list of available desktops to be shared
- :rtype: C{list}
- :raises X2GoClientException: if the session profile specified by C{session_uuid}, C{profile_name} or C{profile_id} is not connected
+ :rtype: ``list``
+ :raises X2GoClientException: if the session profile specified by ``session_uuid``, ``profile_name`` or ``profile_id`` is not connected
or if none of the named parameters has been specified
"""
@@ -2754,18 +2754,18 @@ class X2GoClient(object):
no_cache=False, refresh_cache=False,
raw=False):
"""\
- For a given profil C{profile_name} to
+ For a given profil ``profile_name`` to
retrieve its list of mounted client shares for that session.
:param profile_name: a valid profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param no_cache: do not get the session list from cache, query the X2Go server directly (Default value = False)
- :type no_cache: C{bool}
- :param raw: output the session list in X2Go's raw C{x2golistmounts} format (Default value = False)
- :type raw: C{bool}
+ :type no_cache: ``bool``
+ :param raw: output the session list in X2Go's raw ``x2golistmounts`` format (Default value = False)
+ :type raw: ``bool``
:param refresh_cache: Default value = False)
:returns: list of server-side mounted shares for a given profile name
- :rtype: C{list}
+ :rtype: ``list``
"""
sessions = [ s for s in self.client_running_sessions(return_objects=True) if s.get_profile_name() == profile_name ]
@@ -2785,18 +2785,18 @@ class X2GoClient(object):
no_cache=False, refresh_cache=False,
raw=False):
"""\
- Use the X2Go session registered under C{session_uuid} to
+ Use the X2Go session registered under ``session_uuid`` to
retrieve its list of mounted client shares for that session.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param no_cache: do not get the session list from cache, query the X2Go server directly (Default value = False)
- :type no_cache: C{bool}
- :param raw: output the session list in X2Go's raw C{x2golistmounts} format (Default value = False)
- :type raw: C{bool}
+ :type no_cache: ``bool``
+ :param raw: output the session list in X2Go's raw ``x2golistmounts`` format (Default value = False)
+ :type raw: ``bool``
:param refresh_cache: Default value = False)
:returns: list of server-side mounted shares for a given session UUID
- :rtype: C{list}
+ :rtype: ``list``
"""
if raw:
@@ -2818,16 +2818,16 @@ class X2GoClient(object):
def get_profiles(self):
"""\
- Returns the L{X2GoClient} instance's C{X2GoSessionProfiles*} object.
+ Returns the L{X2GoClient} instance's ``X2GoSessionProfiles*`` object.
Use this method for object retrieval if you want to modify the »sessions«
configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
Python X2Go based application.
- :returns: a C{X2GoSessionProfiles*} instance
+ :returns: a ``X2GoSessionProfiles*`` instance
- :rtype: C{obj}
+ :rtype: ``obj``
"""
return self.session_profiles
@@ -2847,16 +2847,16 @@ class X2GoClient(object):
def get_client_settings(self):
"""\
- Returns the L{X2GoClient} instance's C{X2GoClientSettings*} object.
+ Returns the L{X2GoClient} instance's ``X2GoClientSettings*`` object.
Use this method for object retrieval if you want to modify the »settings«
configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
Python X2Go based application.
- :returns: a C{X2GoClientSettings*} instance
+ :returns: a ``X2GoClientSettings*`` instance
- :rtype: C{obj}
+ :rtype: ``obj``
"""
return self.client_settings
@@ -2864,16 +2864,16 @@ class X2GoClient(object):
def get_client_printing(self):
"""\
- Returns the L{X2GoClient} instance's C{X2GoClientPrinting*} object.
+ Returns the L{X2GoClient} instance's ``X2GoClientPrinting*`` object.
Use this method for object retrieval if you want to modify the printing
configuration node (e.g. in ~/.x2goclient with the FILE backend) from within your
Python X2Go based application.
- :returns: a C{X2GoClientPrinting*} instance
+ :returns: a ``X2GoClientPrinting*`` instance
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.client_printing
@@ -2886,15 +2886,15 @@ class X2GoClient(object):
def get_profile_config(self, profile_id_or_name, parameter=None):
"""\
Returns a dictionary with session options and values that represent
- the session profile for C{profile_id_or_name}.
+ the session profile for ``profile_id_or_name``.
: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: C{str}
+ :type profile_id_or_name: ``str``
:param parameter: if specified, only the value for the given parameter is returned (Default value = None)
- :type parameter: C{str}
+ :type parameter: ``str``
:returns: a Python dictionary with session profile options
- :rtype: C{dict} or C{bool}, C{int}, C{str}
+ :rtype: ``dict`` or ``bool``, ``int``, ``str``
"""
return self.session_profiles.get_profile_config(profile_id_or_name, parameter=parameter)
@@ -2903,17 +2903,17 @@ class X2GoClient(object):
def set_profile_config(self, profile_id_or_name, parameter, value):
"""\
- Set individual session profile parameters for session profile C{profile_id_or_name}.
+ Set individual session profile parameters for session profile ``profile_id_or_name``.
: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: C{str}
- :param parameter: set this parameter with the given C{value}
- :type parameter: C{str}
- :param value: set this value for the given C{parameter}
- :type value: C{bool}, C{int}, C{str}, C{list} or C{dict}
- :returns: returns C{True} if this operation has been successful
- :rtype: C{dict}
+ :type profile_id_or_name: ``str``
+ :param parameter: set this parameter with the given ``value``
+ :type parameter: ``str``
+ :param value: set this value for the given ``parameter``
+ :type value: ``bool``, ``int``, ``str``, ``list`` or ``dict``
+ :returns: returns ``True`` if this operation has been successful
+ :rtype: ``dict``
"""
self.session_profiles.update_value(profile_id_or_name, parameter, value)
@@ -2924,12 +2924,12 @@ class X2GoClient(object):
def to_profile_id(self, profile_name):
"""\
Retrieve the session profile ID of the session whose profile name
- is C{profile_name}
+ is ``profile_name``
:param profile_name: the session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: the session profile's ID
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_profiles.to_profile_id(profile_name)
@@ -2938,12 +2938,12 @@ class X2GoClient(object):
def to_profile_name(self, profile_id):
"""\
Retrieve the session profile name of the session whose profile ID
- is C{profile_id}
+ is ``profile_id``
:param profile_id: the session profile ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:returns: the session profile's name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_profiles.to_profile_name(profile_id)
@@ -2952,12 +2952,12 @@ class X2GoClient(object):
def get_profile_metatype(self, profile_name):
"""\
Evaluate a session profile and return a human readable meta type
- (classification) for the session profile C{profile_name}.
+ (classification) for the session profile ``profile_name``.
:param profile_name: a profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: the profile's meta type
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_profiles.get_profile_metatype(profile_name)
@@ -2968,9 +2968,9 @@ class X2GoClient(object):
Retrieve a list of session profiles that are currently connected to an X2Go server.
:param return_profile_names: return as list of session profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:returns: a list of profile names or IDs
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_profile_names:
@@ -2981,13 +2981,13 @@ class X2GoClient(object):
def disconnect_profile(self, profile_name):
"""\
- Disconnect all L{X2GoSession} instances that relate to C{profile_name} by closing down their
+ Disconnect all L{X2GoSession} instances that relate to ``profile_name`` by closing down their
Paramiko/SSH Transport thread.
:param profile_name: the X2Go session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: a return value
- :rtype: C{bool}
+ :rtype: ``bool``
"""
_retval = False
@@ -3012,9 +3012,9 @@ class X2GoClient(object):
Update the session registry stati by profile name.
:param profile_name: the X2Go session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_list: a manually passed on list of X2Go sessions (Default value = None)
- :type session_list: C{X2GoServerList*} instances
+ :type session_list: ``X2GoServerList*`` instances
"""
session_uuids = self.client_registered_sessions_of_profile_name(profile_name, return_objects=False)
@@ -3037,7 +3037,7 @@ class X2GoClient(object):
session identifier <session_uuid>.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
session_list = self._X2GoClient__list_sessions(session_uuid, update_sessionregistry=False, register_sessions=False)
@@ -3061,18 +3061,18 @@ class X2GoClient(object):
Update the session list cache by profile name.
:param profile_name: the X2Go session profile name
- :type profile_name: C{str}
- :param cache_types: specify what cache type to update (available: C{sessions}, C{desktops}, C{mounts}) (Default value = ('sessions')
- :type cache_types: C{tuple} or C{list}
- :param update_sessions: instead of giving a list of cache types, plainly say C{True} here, if
+ :type profile_name: ``str``
+ :param cache_types: specify what cache type to update (available: ``sessions``, ``desktops``, ``mounts``) (Default value = ('sessions')
+ :type cache_types: ``tuple`` or ``list``
+ :param update_sessions: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update sessions in the session list cache.
- :type update_sessions: C{bool}
- :param update_desktops: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_sessions: ``bool``
+ :param update_desktops: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update available desktops in the desktop list cache.
- :type update_desktops: C{bool}
- :param update_mounts: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_desktops: ``bool``
+ :param update_mounts: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update mounted shares in the mount list cache.
- :type update_mounts: C{bool}
+ :type update_mounts: ``bool``
"""
if self.listsessions_cache is not None:
@@ -3093,18 +3093,18 @@ class X2GoClient(object):
session identifier <session_uuid>.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
- :param cache_types: specify what cache type to update (available: C{sessions}, C{desktops}, C{mounts}) (Default value = ('sessions')
- :type cache_types: C{tuple} or C{list}
- :param update_sessions: instead of giving a list of cache types, plainly say C{True} here, if
+ :type session_uuid: ``str``
+ :param cache_types: specify what cache type to update (available: ``sessions``, ``desktops``, ``mounts``) (Default value = ('sessions')
+ :type cache_types: ``tuple`` or ``list``
+ :param update_sessions: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update sessions in the session list cache.
- :type update_sessions: C{bool}
- :param update_desktops: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_sessions: ``bool``
+ :param update_desktops: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update available desktops in the desktop list cache.
- :type update_desktops: C{bool}
- :param update_mounts: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_desktops: ``bool``
+ :param update_mounts: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update mounted shares in the mount list cache.
- :type update_mounts: C{bool}
+ :type update_mounts: ``bool``
"""
profile_name = self.get_session_profile_name(session_uuid)
@@ -3120,17 +3120,17 @@ class X2GoClient(object):
"""\
Update the session list cache of all session profiles.
- :param cache_types: specify what cache type to update (available: C{sessions}, C{desktops}, C{mounts}) (Default value = ('sessions')
- :type cache_types: C{tuple} or C{list}
- :param update_sessions: instead of giving a list of cache types, plainly say C{True} here, if
+ :param cache_types: specify what cache type to update (available: ``sessions``, ``desktops``, ``mounts``) (Default value = ('sessions')
+ :type cache_types: ``tuple`` or ``list``
+ :param update_sessions: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update sessions in the session list cache.
- :type update_sessions: C{bool}
- :param update_desktops: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_sessions: ``bool``
+ :param update_desktops: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update available desktops in the desktop list cache.
- :type update_desktops: C{bool}
- :param update_mounts: instead of giving a list of cache types, plainly say C{True} here, if
+ :type update_desktops: ``bool``
+ :param update_mounts: instead of giving a list of cache types, plainly say ``True`` here, if
you want to update mounted shares in the mount list cache.
- :type update_mounts: C{bool}
+ :type update_mounts: ``bool``
"""
if self.listsessions_cache is not None:
@@ -3150,14 +3150,14 @@ class X2GoClient(object):
def register_available_server_sessions_by_profile_name(self, profile_name, re_register=False, skip_pubapp_sessions=False):
"""\
Register available sessions that are found on the X2Go server the profile
- of name C{profile_name} is connected to.
+ of name ``profile_name`` is connected to.
:param profile_name: the X2Go session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param re_register: re-register available sessions, needs to be done after session profile changes (Default value = False)
- :type re_register: C{bool}
+ :type re_register: ``bool``
:param skip_pubapp_sessions: Do not auto-register published applications sessions. (Default value = False)
- :type skip_pubapp_sessions: C{bool}
+ :type skip_pubapp_sessions: ``bool``
"""
if profile_name not in self.client_connected_profiles(return_profile_names=True):
@@ -3181,9 +3181,9 @@ class X2GoClient(object):
with session identifier <session_uuid> is connected to.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param skip_pubapp_sessions: Do not auto-register published applications sessions. (Default value = False)
- :type skip_pubapp_sessions: C{bool}
+ :type skip_pubapp_sessions: ``bool``
"""
profile_name = self.get_session_profile_name(session_uuid)
@@ -3195,7 +3195,7 @@ class X2GoClient(object):
Register all available sessions found on an X2Go server for each session profile.
:param skip_pubapp_sessions: Do not auto-register published applications sessions. (Default value = False)
- :type skip_pubapp_sessions: C{bool}
+ :type skip_pubapp_sessions: ``bool``
"""
for profile_name in self.client_connected_profiles(return_profile_names=True):
diff --git a/x2go/forward.py b/x2go/forward.py
index 1e10b17..a70b22a 100644
--- a/x2go/forward.py
+++ b/x2go/forward.py
@@ -43,7 +43,7 @@ class X2GoFwServer(StreamServer):
forwarding server.
An L{X2GoFwServer} class object is used to tunnel graphical trafic
- through an external proxy command launched by a C{X2GoProxy*} backend.
+ through an external proxy command launched by a ``X2GoProxy*`` backend.
"""
@@ -52,25 +52,25 @@ class X2GoFwServer(StreamServer):
ssh_transport, session_instance=None, session_name=None,
subsystem=None, logger=None, loglevel=log.loglevel_DEFAULT,):
"""\
- @param listener: listen on TCP/IP socket C{(<IP>, <Port>)}
- @type listener: C{tuple}
+ @param listener: listen on TCP/IP socket ``(<IP>, <Port>)``
+ @type listener: ``tuple``
@param remote_host: hostname or IP of remote host (in case of X2Go mostly 127.0.0.1)
- @type remote_host: C{str}
+ @type remote_host: ``str``
@param remote_port: port of remote host
- @type remote_port: C{int}
+ @type remote_port: ``int``
@param ssh_transport: a valid Paramiko/SSH transport object
- @type ssh_transport: C{obj}
+ @type ssh_transport: ``obj``
@param session_instance: the complete L{X2GoSession} instance of the X2Go session this port forwarding server belongs to.
Note: for new L{X2GoSession} instances the object has the session name not yet set(!!!)
- @type session_instance: C{obj}
+ @type session_instance: ``obj``
@param session_name: the session name of the X2Go session this port forwarding server belongs to
- @type session_name: C{str}
+ @type session_name: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoFwServer} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -104,9 +104,9 @@ class X2GoFwServer(StreamServer):
Handle for SSH/Paramiko forwarding tunnel.
:param fw_socket: local end of the forwarding tunnel
- :type fw_socket: C{obj}
+ :type fw_socket: ``obj``
:param address: unused/ignored
- :type address: C{tuple}
+ :type address: ``tuple``
"""
self.fw_socket = fw_socket
@@ -241,25 +241,25 @@ def start_forward_tunnel(local_host='127.0.0.1', local_port=22022,
The tunnel is used to transport X2Go graphics data through a proxy application like nxproxy.
:param local_host: local starting point of the forwarding tunnel (Default value = '127.0.0.1')
- :type local_host: C{int}
+ :type local_host: ``int``
:param local_port: listen port of the local starting point (Default value = 22022)
- :type local_port: C{int}
- :param remote_host: from the endpoint of the tunnel, connect to host C{<remote_host>}... (Default value = '127.0.0.1')
- :type remote_host: C{str}
- :param remote_port: on port C{<remote_port>} (Default value = 22)
- :type remote_port: C{int}
+ :type local_port: ``int``
+ :param remote_host: from the endpoint of the tunnel, connect to host ``<remote_host>``... (Default value = '127.0.0.1')
+ :type remote_host: ``str``
+ :param remote_port: on port ``<remote_port>`` (Default value = 22)
+ :type remote_port: ``int``
:param ssh_transport: the Paramiko/SSH transport (i.e. the X2Go session's Paramiko/SSH transport object) (Default value = None)
- :type ssh_transport: C{obj}
+ :type ssh_transport: ``obj``
:param session_instance: the L{X2GoSession} instance that initiates this tunnel (Default value = None)
- :type session_instance: C{obj}
+ :type session_instance: ``obj``
:param session_name: the session name of the X2Go session this port forwarding server belongs to (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param subsystem: a custom string with a component name that tries to evoke a new tunnel setup (Default value = None)
- :type subsystem: C{str}
+ :type subsystem: ``str``
:param logger: an X2GoLogger object (Default value = None)
- :type logger: C{obj}
+ :type logger: ``obj``
:returns: returns an L{X2GoFwServer} instance
- :rtype: C{obj}
+ :rtype: ``obj``
"""
fw_server = X2GoFwServer(listener=(local_host, local_port),
@@ -282,7 +282,7 @@ def stop_forward_tunnel(fw_server):
Tear down a given Paramiko/SSH port forwarding tunnel.
:param fw_server: an L{X2GoFwServer} instance as returned by the L{start_forward_tunnel()} function
- :type fw_server: C{obj}
+ :type fw_server: ``obj``
"""
if fw_server is not None:
diff --git a/x2go/guardian.py b/x2go/guardian.py
index c860e91..6581c4a 100644
--- a/x2go/guardian.py
+++ b/x2go/guardian.py
@@ -59,25 +59,25 @@ class X2GoSessionGuardian(threading.Thread):
logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param auto_update_listsessions_cache: let L{X2GoSessionGuardian} refresh the session list cache for all L{X2GoSession} objects
- @type auto_update_listsessions_cache: C{bool}
+ @type auto_update_listsessions_cache: ``bool``
@param auto_update_listdesktops_cache: let L{X2GoSessionGuardian} refresh desktop lists in the session list cache for all L{X2GoSession} objects
- @type auto_update_listdesktops_cache: C{bool}
+ @type auto_update_listdesktops_cache: ``bool``
@param auto_update_listmounts_cache: let L{X2GoSessionGuardian} refresh mount lists in the session list cache for all L{X2GoSession} objects
- @type auto_update_listmounts_cache: C{bool}
- @param auto_update_sessionregistry: if set to C{True} the session status will be updated in regular intervals
- @type auto_update_sessionregistry: C{bool}
+ @type auto_update_listmounts_cache: ``bool``
+ @param auto_update_sessionregistry: if set to ``True`` the session status will be updated in regular intervals
+ @type auto_update_sessionregistry: ``bool``
@param auto_register_sessions: register new sessions automatically once they appear in the X2Go session (e.g.
instantiated by another client that is connected to the same X2Go server under same user ID)
- @type auto_register_sessions: C{bool}
+ @type auto_register_sessions: ``bool``
@param no_auto_reg_pubapp_sessions: do not auto-register published applications sessions
- @type no_auto_reg_pubapp_sessions: C{bool}
+ @type no_auto_reg_pubapp_sessions: ``bool``
@param refresh_interval: refresh cache and session registry every <refresh_interval> seconds
- @type refresh_interval: C{int}
+ @type refresh_interval: ``int``
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoSessionGuardian} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
diff --git a/x2go/inifiles.py b/x2go/inifiles.py
index 010c2d0..e4d102d 100644
--- a/x2go/inifiles.py
+++ b/x2go/inifiles.py
@@ -64,16 +64,16 @@ class X2GoIniFile(object):
"""\
@param config_files: a list of configuration file names (e.g. a global filename and a user's home
directory filename)
- @type config_files: C{list}
+ @type config_files: ``list``
@param defaults: a cascaded Python dicitionary structure with ini file defaults (to override
Python X2Go's hard coded defaults in L{defaults}
- @type defaults: C{dict}
+ @type defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoIniFile} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.user_config_file = None
@@ -155,11 +155,11 @@ class X2GoIniFile(object):
the L{write()} method.
:param section: the ini file section
- :type section: C{str}
+ :type section: ``str``
:param key: the ini file key in the given section
- :type key: C{str}
+ :type key: ``str``
:param value: the value for the given section and key
- :type value: C{str}, C{list}, C{booAl}, ...
+ :type value: ``str``, ``list``, ``booAl``, ...
"""
if type(value) is bool:
@@ -171,7 +171,7 @@ class X2GoIniFile(object):
def _fill_defaults(self):
"""\
- Fills a C{SafeConfigParser} object with the default ini file
+ Fills a ``SafeConfigParser`` object with the default ini file
values as pre-defined in Python X2Go or. This SafeConfigParser
object is held in RAM. No configuration file is affected by this
method.
@@ -191,11 +191,11 @@ class X2GoIniFile(object):
does not have any effect on configuration files.
:param section: the ini file section
- :type section: C{str}
+ :type section: ``str``
:param key: the ini file key in the given section
- :type key: C{str}
+ :type key: ``str``
:param value: the value for the given section and key
- :type value: C{str}, C{list}, C{bool}, ...
+ :type value: ``str``, ``list``, ``bool``, ...
"""
if not self.iniConfig.has_section(section):
@@ -208,13 +208,13 @@ class X2GoIniFile(object):
"""\
Write the ini file modifications (SafeConfigParser object) from RAM to disk.
- For writing the first of the C{config_files} specified on instance construction
+ For writing the first of the ``config_files`` specified on instance construction
that is writable will be used.
- :returns: C{True} if the user config file has been successfully written, C{False} otherwise.
+ :returns: ``True`` if the user config file has been successfully written, ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.user_config_file and self._write_user_config:
@@ -235,9 +235,9 @@ class X2GoIniFile(object):
value type is based on the default values dictionary.
:param section: the ini file section
- :type section: C{str}
+ :type section: ``str``
:param key: the ini file key in the given section
- :type key: C{str}
+ :type key: ``str``
:returns: a Python variable type
:rtype: class
@@ -249,9 +249,9 @@ class X2GoIniFile(object):
Retrieve a value for a given section and key.
:param section: the ini file section
- :type section: C{str}
+ :type section: ``str``
:param key: the ini file key in the given section
- :type key: C{str}
+ :type key: ``str``
:param key_type: Python data type of the given key (Default value = None)
:returns: the value for the given section and key
:rtype: class
diff --git a/x2go/log.py b/x2go/log.py
index 834750c..d0537c3 100644
--- a/x2go/log.py
+++ b/x2go/log.py
@@ -71,11 +71,11 @@ class X2GoLogger(object):
def __init__(self, name=sys.argv[0], loglevel=loglevel_DEFAULT, tag=None):
"""\
@param name: name of the programme that uses Python X2Go
- @type name: C{str}
+ @type name: ``str``
@param loglevel: log level for Python X2Go
- @type loglevel: C{int}
+ @type loglevel: ``int``
@param tag: additional tag for all log entries
- @type tag: C{str}
+ @type tag: ``str``
"""
self.name = os.path.basename(name)
@@ -88,11 +88,11 @@ class X2GoLogger(object):
Log a message.
:param msg: log message text
- :type msg: C{str}
+ :type msg: ``str``
:param loglevel: log level of this message (Default value = loglevel_NONE)
- :type loglevel: C{int}
+ :type loglevel: ``int``
:param tag: additional tag for this log entry (Default value = None)
- :type tag: C{str}
+ :type tag: ``str``
"""
if tag is None:
@@ -115,7 +115,7 @@ class X2GoLogger(object):
:returns: current log level
- :rtype: C{int}
+ :rtype: ``int``
"""
return self.loglevel
@@ -125,7 +125,7 @@ class X2GoLogger(object):
Set log level by name.
:param loglevel_name: name of loglevel to be set (Default value = 'none')
- :type loglevel_name: C{str}
+ :type loglevel_name: ``str``
"""
if type(loglevel_name) is types.IntegerType:
diff --git a/x2go/mimebox.py b/x2go/mimebox.py
index 0475e64..e9ba763 100644
--- a/x2go/mimebox.py
+++ b/x2go/mimebox.py
@@ -65,19 +65,19 @@ class X2GoMIMEboxQueue(threading.Thread):
client_instance=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param profile_name: name of the session profile this print queue belongs to
- @type profile_name: C{str}
+ @type profile_name: ``str``
@param mimebox_dir: local directory for incoming MIME box files
- @type mimebox_dir: C{str}
+ @type mimebox_dir: ``str``
@param mimebox_action: name or instance of either of the possible X2Go print action classes
- @type mimebox_action: C{str} or instance
+ @type mimebox_action: ``str`` or instance
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintQueue} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -169,9 +169,9 @@ class X2GoMIMEboxQueue(threading.Thread):
directory.
:param mimebox_action: the MIME box action to execute for incoming files
- :type mimebox_action: C{str} or C{obj}
+ :type mimebox_action: ``str`` or ``obj``
:param kwargs: extra options for the specified MIME box action
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -183,7 +183,7 @@ class X2GoMIMEboxQueue(threading.Thread):
def run(self):
"""\
- This method gets called once the L{X2GoMIMEboxQueue} thread is started by the C{X2GoMIMEboxQueue.start()} method.
+ This method gets called once the L{X2GoMIMEboxQueue} thread is started by the ``X2GoMIMEboxQueue.start()`` method.
"""
@@ -224,15 +224,15 @@ def x2go_mimeboxjob_handler(mimebox_file=None,
represented by the class L{X2GoMIMEboxJob}.
:param mimebox_file: MIME box file name as placed in to the X2Go MIME box spool directory (Default value = None)
- :type mimebox_file: C{str}
- :param mimebox_action: an instance of either of the possible C{X2GoMIMEboxActionXXX} classes (Default value = None)
- :type mimebox_action: C{X2GoMIMEboxActionXXX} nstance
+ :type mimebox_file: ``str``
+ :param mimebox_action: an instance of either of the possible ``X2GoMIMEboxActionXXX`` classes (Default value = None)
+ :type mimebox_action: ``X2GoMIMEboxActionXXX`` nstance
:param mimebox_extensions: filter out files whose file extension is not in this list (Default value = [], means: no filtering)
- :type mimebox_extensions: C{list}
+ :type mimebox_extensions: ``list``
:param parent_thread: the L{X2GoMIMEboxQueue} thread that actually created this handler's L{X2GoMIMEboxJob} instance (Default value = None)
- :type parent_thread: C{obj}
+ :type parent_thread: ``obj``
:param logger: the L{X2GoMIMEboxQueue}'s logging instance (Default value = None)
- :type logger: C{obj}
+ :type logger: ``obj``
"""
mimebox_action.profile_name = parent_thread.profile_name
@@ -282,7 +282,7 @@ class X2GoMIMEboxJob(threading.Thread):
Construct the X2Go MIME box job thread...
All parameters (**kwargs) are passed through to the constructor
- of C{threading.Thread()}.
+ of ``threading.Thread()``.
"""
threading.Thread.__init__(self, **kwargs)
diff --git a/x2go/mimeboxactions.py b/x2go/mimeboxactions.py
index fb48441..722f172 100644
--- a/x2go/mimeboxactions.py
+++ b/x2go/mimeboxactions.py
@@ -61,13 +61,13 @@ class X2GoMIMEboxAction(object):
class by »real« X2Go MIME box actions.
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoMIMEboxAction} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -90,7 +90,7 @@ class X2GoMIMEboxAction(object):
:returns: MIME box action name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.__name__
@@ -103,7 +103,7 @@ class X2GoMIMEboxAction(object):
:returns: MIME box action's description
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.__description__
@@ -113,9 +113,9 @@ class X2GoMIMEboxAction(object):
Perform the defined MIME box action (doing nothing in L{X2GoMIMEboxAction} parent class).
:param mimebox_file: file name as placed in to the X2Go MIME box directory
- :type mimebox_file: C{str}
+ :type mimebox_file: ``str``
:param mimebox_dir: location of the X2Go session's MIME box directory
- :type mimebox_dir: C{str}
+ :type mimebox_dir: ``str``
"""
pass
@@ -126,9 +126,9 @@ class X2GoMIMEboxAction(object):
box actions.
:param mimebox_file: file name as placed in to the X2Go MIME box directory
- :type mimebox_file: C{str}
+ :type mimebox_file: ``str``
:param mimebox_dir: location of the X2Go session's MIME box directory
- :type mimebox_dir: C{str}
+ :type mimebox_dir: ``str``
"""
mimebox_file = os.path.normpath(mimebox_file)
@@ -149,13 +149,13 @@ class X2GoMIMEboxActionOPEN(X2GoMIMEboxAction):
def __init__(self, client_instance=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoMIMEboxActionOPEN} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.client_instance = client_instance
@@ -166,9 +166,9 @@ class X2GoMIMEboxActionOPEN(X2GoMIMEboxAction):
Open an incoming MIME box file in the system's default application.
:param mimebox_file: file name as placed in to the MIME box directory
- :type mimebox_file: C{str}
+ :type mimebox_file: ``str``
:param mimebox_dir: location of the X2Go session's MIME box directory
- :type mimebox_dir: C{str}
+ :type mimebox_dir: ``str``
"""
mimebox_file = os.path.normpath(mimebox_file)
@@ -208,13 +208,13 @@ class X2GoMIMEboxActionOPENWITH(X2GoMIMEboxAction):
def __init__(self, client_instance=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoMIMEboxActionOPENWITH} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.client_instance = client_instance
@@ -225,9 +225,9 @@ class X2GoMIMEboxActionOPENWITH(X2GoMIMEboxAction):
Open an incoming MIME box file in the system's default application.
:param mimebox_file: file name as placed in to the MIME box directory
- :type mimebox_file: C{str}
+ :type mimebox_file: ``str``
:param mimebox_dir: location of the X2Go session's MIME box directory
- :type mimebox_dir: C{str}
+ :type mimebox_dir: ``str``
"""
mimebox_file = os.path.normpath(mimebox_file)
@@ -267,15 +267,15 @@ class X2GoMIMEboxActionSAVEAS(X2GoMIMEboxAction):
def __init__(self, client_instance=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: an L{X2GoClient} instance, within your customized L{X2GoClient} make sure
- you have a C{HOOK_open_mimebox_saveas_dialog(filename=<str>)} method defined that will actually
+ you have a ``HOOK_open_mimebox_saveas_dialog(filename=<str>)`` method defined that will actually
handle the incoming mimebox file.
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoMIMEboxActionSAVEAS} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
@raise X2GoMIMEboxActionException: if the client_instance has not been passed to the SAVEAS MIME box action
@@ -286,13 +286,13 @@ class X2GoMIMEboxActionSAVEAS(X2GoMIMEboxAction):
def _do_process(self, mimebox_file, mimebox_dir):
"""\
- Call an L{X2GoClient} hook method (C{HOOK_open_mimebox_saveas_dialog}) that
+ Call an L{X2GoClient} hook method (``HOOK_open_mimebox_saveas_dialog``) that
can handle the MIME box's SAVEAS action.
:param mimebox_file: file name as placed in to the MIME box directory
- :type mimebox_file: C{str}
+ :type mimebox_file: ``str``
:param mimebox_dir: location of the X2Go session's MIME box directory
- :type mimebox_dir: C{str}
+ :type mimebox_dir: ``str``
:param mimebox_file: PDF file name as placed in to the X2Go spool directory
"""
diff --git a/x2go/printactions.py b/x2go/printactions.py
index 459dab6..1f7d6f5 100644
--- a/x2go/printactions.py
+++ b/x2go/printactions.py
@@ -70,13 +70,13 @@ class X2GoPrintAction(object):
class by »real« X2Go print actions.
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintAction} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -99,7 +99,7 @@ class X2GoPrintAction(object):
:returns: print action name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.__name__
@@ -112,7 +112,7 @@ class X2GoPrintAction(object):
:returns: print action's description
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.__description__
@@ -122,26 +122,26 @@ class X2GoPrintAction(object):
Perform the defined print action (doing nothing in L{X2GoPrintAction} parent class).
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pass
def do_print(self, pdf_file, job_title, spool_dir, ):
"""\
- Wrap around the actual print action (C{self._do_print}) with
+ Wrap around the actual print action (``self._do_print``) with
gevent.spawn().
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pdf_file = os.path.normpath(pdf_file)
@@ -154,13 +154,13 @@ class X2GoPrintAction(object):
Extract a human readable filename for the X2Go print job file.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param target_path: target path for human readable file
- :type target_path: C{str}
+ :type target_path: ``str``
:returns: full readable file name path
- :rtype: C{str}
+ :rtype: ``str``
"""
_hr_path = os.path.normpath(os.path.expanduser(os.path.join(os.path.normpath(target_path), '%s.pdf' % utils.slugify(job_title))))
@@ -187,15 +187,15 @@ class X2GoPrintActionPDFVIEW(X2GoPrintAction):
def __init__(self, client_instance=None, pdfview_cmd=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param pdfview_cmd: command that starts the external PDF viewer application
- @type pdfview_cmd: C{str}
+ @type pdfview_cmd: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintActionPDFVIEW} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if pdfview_cmd is None:
@@ -208,12 +208,12 @@ class X2GoPrintActionPDFVIEW(X2GoPrintAction):
Open an incoming X2Go print job (PDF file) in an external PDF viewer application.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
- :raises OSError: pass through all C{OSError}s except no. 2
+ :type spool_dir: ``str``
+ :raises OSError: pass through all ``OSError``s except no. 2
"""
pdf_file = os.path.normpath(pdf_file)
@@ -265,15 +265,15 @@ class X2GoPrintActionPDFSAVE(X2GoPrintAction):
def __init__(self, client_instance=None, save_to_folder=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param save_to_folder: saving location for incoming print jobs (PDF files)
- @type save_to_folder: C{str}
+ @type save_to_folder: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintActionPDFSAVE} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if save_to_folder is None:
@@ -295,11 +295,11 @@ class X2GoPrintActionPDFSAVE(X2GoPrintAction):
Save an incoming X2Go print job (PDF file) to a local folder.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pdf_file = os.path.normpath(pdf_file)
@@ -321,15 +321,15 @@ class X2GoPrintActionPRINT(X2GoPrintAction):
def __init__(self, client_instance=None, printer=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
- @param printer: name of the preferred printer, if C{None} the system's/user's default printer will be used
- @type printer: C{str}
+ @type client_instance: ``obj``
+ @param printer: name of the preferred printer, if ``None`` the system's/user's default printer will be used
+ @type printer: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintActionPRINT} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.printer = printer
@@ -340,11 +340,11 @@ class X2GoPrintActionPRINT(X2GoPrintAction):
Really print an incoming X2Go print job (PDF file) to a local printer device.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pdf_file = os.path.normpath(pdf_file)
@@ -451,15 +451,15 @@ class X2GoPrintActionPRINTCMD(X2GoPrintAction):
def __init__(self, client_instance=None, print_cmd=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param print_cmd: external command to be called on incoming print jobs
- @type print_cmd: C{str}
+ @type print_cmd: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintActionPRINTCMD} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if print_cmd is None:
@@ -473,11 +473,11 @@ class X2GoPrintActionPRINTCMD(X2GoPrintAction):
of this L{X2GoPrintActionPRINTCMD} instance.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pdf_file = os.path.normpath(pdf_file)
@@ -512,15 +512,15 @@ class X2GoPrintActionDIALOG(X2GoPrintAction):
def __init__(self, client_instance=None, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
@param client_instance: an L{X2GoClient} instance, within your customized L{X2GoClient} make sure
- you have a C{HOOK_open_print_dialog(filename=<str>)} method defined that will actually
+ you have a ``HOOK_open_print_dialog(filename=<str>)`` method defined that will actually
open the print dialog.
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintActionDIALOG} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
@raise X2GoPrintActionException: if the client_instance has not been passed to the DIALOG print action
@@ -535,11 +535,11 @@ class X2GoPrintActionDIALOG(X2GoPrintAction):
of this L{X2GoPrintActionPRINTCMD} instance.
:param pdf_file: PDF file name as placed in to the X2Go spool directory
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title
- :type job_title: C{str}
+ :type job_title: ``str``
:param spool_dir: location of the X2Go client's spool directory
- :type spool_dir: C{str}
+ :type spool_dir: ``str``
"""
pdf_file = os.path.normpath(pdf_file)
diff --git a/x2go/printqueue.py b/x2go/printqueue.py
index b204ab6..4218146 100644
--- a/x2go/printqueue.py
+++ b/x2go/printqueue.py
@@ -69,24 +69,24 @@ class X2GoPrintQueue(threading.Thread):
loglevel=log.loglevel_DEFAULT):
"""\
@param profile_name: name of the session profile this print queue belongs to
- @type profile_name: C{str}
+ @type profile_name: ``str``
@param spool_dir: local spool directory for incoming print job files
- @type spool_dir: C{str}
+ @type spool_dir: ``str``
@param print_action: name or instance of either of the possible X2Go print action classes
- @type print_action: C{str} or instance
- @param print_action_args: depending of the chosen C{print_action} this dictionary may contain different
- values; the C{print_action_args} will be passed on to the X2Go print action instance constructor, so
+ @type print_action: ``str`` or instance
+ @param print_action_args: depending of the chosen ``print_action`` this dictionary may contain different
+ values; the ``print_action_args`` will be passed on to the X2Go print action instance constructor, so
refer to either of these: L{X2GoPrintActionPDFVIEW}, L{X2GoPrintActionPRINT} et al.
@param client_instance: the underlying L{X2GoClient} instance
- @type client_instance: C{obj}
+ @type client_instance: ``obj``
@param printing_backend: the client printing configuration backend class
- @type printing_backend: C{obj}
+ @type printing_backend: ``obj``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoPrintQueue} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -178,9 +178,9 @@ class X2GoPrintQueue(threading.Thread):
L{X2GoPrintActionPRINT}, etc.
:param print_action: new print action to be valid for incoming print jobs
- :type print_action: C{str} or C{class}
+ :type print_action: ``str`` or ``class``
:param kwargs: extra options for the specified print action
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -231,21 +231,21 @@ def x2go_printjob_handler(job_file=None, pdf_file=None, job_title=None, print_ac
represented by the class L{X2GoPrintJob}.
The handler function will (re-)read the »printing« configuration file (if no
- explicit C{print_action} is passed to this function...). It then will
- execute the C{<print_action>.do_print()} command.
+ explicit ``print_action`` is passed to this function...). It then will
+ execute the ``<print_action>.do_print()`` command.
:param job_file: file name of this print job's Job File (Default value = None)
- :type job_file: C{str}
+ :type job_file: ``str``
:param pdf_file: PDF file name as placed in to the X2Go spool directory (Default value = None)
- :type pdf_file: C{str}
+ :type pdf_file: ``str``
:param job_title: human readable print job title (Default value = None)
- :type job_title: C{str}
- :param print_action: an instance of either of the possible C{X2GoPrintActionXXX} classes (Default value = None)
- :type print_action: C{X2GoPrintActionXXX} nstance
+ :type job_title: ``str``
+ :param print_action: an instance of either of the possible ``X2GoPrintActionXXX`` classes (Default value = None)
+ :type print_action: ``X2GoPrintActionXXX`` nstance
:param parent_thread: the L{X2GoPrintQueue} thread that actually created this handler's L{X2GoPrintJob} instance (Default value = None)
- :type parent_thread: C{obj}
+ :type parent_thread: ``obj``
:param logger: the L{X2GoPrintQueue}'s logging instance (Default value = None)
- :type logger: C{obj}
+ :type logger: ``obj``
"""
if print_action is None:
@@ -300,7 +300,7 @@ class X2GoPrintJob(threading.Thread):
Construct the X2Go print job thread...
All parameters (**kwargs) are passed through to the constructor
- of C{threading.Thread()}.
+ of ``threading.Thread()``.
"""
threading.Thread.__init__(self, **kwargs)
diff --git a/x2go/pulseaudio.py b/x2go/pulseaudio.py
index 5547258..82748fe 100644
--- a/x2go/pulseaudio.py
+++ b/x2go/pulseaudio.py
@@ -60,14 +60,14 @@ class X2GoPulseAudio(threading.Thread):
Initialize a Pulse Audio daemon instance.
@param path: full path to pulseaudio.exe
- @type path: C{str}
+ @type path: ``str``
@param client_instance: the calling L{X2GoClient} instance
@type client_instance: L{X2GoClient} instance
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
@raise OSNotSupportedException: on non-Windows platforms Python X2Go presumes that pulseaudio is already launched
@@ -91,7 +91,7 @@ class X2GoPulseAudio(threading.Thread):
def run(self):
"""\
- This method is called once the C{X2GoPulseAudio.start()} method has been called. To tear
+ This method is called once the ``X2GoPulseAudio.start()`` method has been called. To tear
down the Pulseaudio daemon call the L{X2GoPulseAudio.stop_thread()} method.
diff --git a/x2go/registry.py b/x2go/registry.py
index 57e2a1d..d3e0ed8 100644
--- a/x2go/registry.py
+++ b/x2go/registry.py
@@ -63,10 +63,10 @@ class X2GoSessionRegistry(object):
@param client_instance: the L{X2GoClient} instance that instantiated this L{X2GoSessionRegistry} instance.
@type client_instance: L{X2GoClient} instance
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -92,7 +92,7 @@ class X2GoSessionRegistry(object):
:returns: session registry key list
- :rtype: C{list}
+ :rtype: ``list``
"""
return list(self.registry.keys())
@@ -110,7 +110,7 @@ class X2GoSessionRegistry(object):
Returns the L{X2GoSession} instance for a given session UUID hash.
@param session_uuid: the X2Go session's UUID registry hash
- @type session_uuid: C{str}
+ @type session_uuid: ``str``
@return: the corresponding L{X2GoSession} instance
@rtype: L{X2GoSession} instance
@@ -145,10 +145,10 @@ class X2GoSessionRegistry(object):
def forget(self, session_uuid):
"""\
- Forget the complete record for session UUID C{session_uuid}.
+ Forget the complete record for session UUID ``session_uuid``.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
"""
try:
@@ -162,9 +162,9 @@ class X2GoSessionRegistry(object):
Retrieve the profile ID of a given session UUID hash.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: profile ID
- :rtype: C{str}
+ :rtype: ``str``
"""
return self(session_uuid).get_profile_id()
@@ -174,9 +174,9 @@ class X2GoSessionRegistry(object):
Retrieve the profile name of a given session UUID hash.
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:returns: profile name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self(session_uuid).get_profile_name()
@@ -186,11 +186,11 @@ class X2GoSessionRegistry(object):
Compose a session summary (as Python dictionary).
:param session_uuid: the X2Go session's UUID registry hash
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param status_only: short summary, include session status only (Default value = False)
- :type status_only: C{bool}
+ :type status_only: ``bool``
:returns: session summary dictionary
- :rtype: C{dict}
+ :rtype: ``dict``
"""
_session_summary = {}
@@ -236,23 +236,23 @@ class X2GoSessionRegistry(object):
profile name or profile ID.
:param session_uuid: the X2Go session's UUID registry hash (Default value = None)
- :type session_uuid: C{str}
+ :type session_uuid: ``str``
:param profile_name: alternatively, a profile name can be specified (the stati of all registered sessions for this session
profile will be updated) (Default value = None)
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param profile_id: alternatively, a profile ID can be given (the stati of all registered sessions for this session
profile will be updated) (Default value = None)
- :type profile_id: C{str}
- :param session_list: an optional C{X2GoServerSessionList*} instance (as returned by the L{X2GoClient.list_sessions()} command can
+ :type profile_id: ``str``
+ :param session_list: an optional ``X2GoServerSessionList*`` instance (as returned by the L{X2GoClient.list_sessions()} command can
be passed to this method. (Default value = None)
- :type session_list: C{X2GoServerSessionList*} instance
+ :type session_list: ``X2GoServerSessionList*`` instance
:param force_update: make sure the session status gets really updated (Default value = False)
- :type force_update: C{bool}
- :param newly_connected: set this to C{True}, if the control session has just been connected (Default value = False)
- :param newly_connected: C{bool} (Default value = False)
- :returns: C{True} if this method has been successful
- :rtype: C{bool}
- :raises X2GoSessionRegistryException: if the combination of C{session_uuid}, C{profile_name} and C{profile_id} does not match the requirement:
+ :type force_update: ``bool``
+ :param newly_connected: set this to ``True``, if the control session has just been connected (Default value = False)
+ :param newly_connected: ``bool`` (Default value = False)
+ :returns: ``True`` if this method has been successful
+ :rtype: ``bool``
+ :raises X2GoSessionRegistryException: if the combination of ``session_uuid``, ``profile_name`` and ``profile_id`` does not match the requirement:
only one of them
"""
@@ -389,16 +389,16 @@ class X2GoSessionRegistry(object):
Register server-side available X2Go sessions with this L{X2GoSessionRegistry} instance for a given profile name.
:param profile_name: session profile name to register available X2Go sessions for
- :type profile_name: C{str}
- :param session_list: an optional C{X2GoServerSessionList*} instance (as returned by the L{X2GoClient.list_sessions()} command can
+ :type profile_name: ``str``
+ :param session_list: an optional ``X2GoServerSessionList*`` instance (as returned by the L{X2GoClient.list_sessions()} command can
be passed to this method. (Default value = None)
- :type session_list: C{X2GoServerSessionList*} instance
+ :type session_list: ``X2GoServerSessionList*`` instance
:param newly_connected: give a hint that the session profile got newly connected (Default value = False)
- :type newly_connected: C{bool}
+ :type newly_connected: ``bool``
:param re_register: re-register available sessions, needs to be done after changes to the session profile (Default value = False)
- :type re_register: C{bool}
+ :type re_register: ``bool``
:param skip_pubapp_sessions: Do not register published applications sessions (Default value = False)
- :type skip_pubapp_sessions: C{bool}
+ :type skip_pubapp_sessions: ``bool``
"""
if self._last_available_session_registration is not None:
@@ -483,44 +483,44 @@ class X2GoSessionRegistry(object):
Register a new L{X2GoSession} instance with this L{X2GoSessionRegistry}.
:param server: hostname of X2Go server
- :type server: C{str}
+ :type server: ``str``
:param profile_id: profile ID
- :type profile_id: C{str}
+ :type profile_id: ``str``
:param profile_name: profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param session_name: session name (if available) (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param control_backend: X2Go control session backend to use (Default value = _BACKENDS['X2GoControlSession']['default'])
- :type control_backend: C{str}
+ :type control_backend: ``str``
:param terminal_backend: X2Go terminal session backend to use (Default value = _BACKENDS['X2GoTerminalSession']['default'])
- :type terminal_backend: C{str}
+ :type terminal_backend: ``str``
:param info_backend: X2Go session info backend to use (Default value = _BACKENDS['X2GoServerSessionInfo']['default'])
- :type info_backend: C{str}
+ :type info_backend: ``str``
:param list_backend: X2Go session list backend to use (Default value = _BACKENDS['X2GoServerSessionList']['default'])
- :type list_backend: C{str}
+ :type list_backend: ``str``
:param proxy_backend: X2Go proxy backend to use (Default value = _BACKENDS['X2GoProxy']['default'])
- :type proxy_backend: C{str}
+ :type proxy_backend: ``str``
:param settings_backend: X2Go client settings backend to use (Default value = _BACKENDS['X2GoClientSettings']['default'])
- :type settings_backend: C{str}
+ :type settings_backend: ``str``
:param printing_backend: X2Go client printing backend to use (Default value = _BACKENDS['X2GoClientPrinting']['default'])
- :type printing_backend: C{str}
+ :type printing_backend: ``str``
:param client_rootdir: client base dir (default: ~/.x2goclient)
- :type client_rootdir: C{str}
+ :type client_rootdir: ``str``
:param sessions_rootdir: sessions base dir (default: ~/.x2go)
- :type sessions_rootdir: C{str}
+ :type sessions_rootdir: ``str``
:param ssh_rootdir: ssh base dir (default: ~/.ssh)
- :type ssh_rootdir: C{str}
- :param keep_controlsession_alive: On last L{X2GoSession.disconnect()} keep the associated C{X2GoControlSession} instance alive?
- @ŧype keep_controlsession_alive: C{bool}
+ :type ssh_rootdir: ``str``
+ :param keep_controlsession_alive: On last L{X2GoSession.disconnect()} keep the associated ``X2GoControlSession`` instance alive?
+ @ŧype keep_controlsession_alive: ``bool``
:param add_to_known_hosts: Auto-accept server host validity?
- :type add_to_known_hosts: C{bool}
- :param known_hosts: the underlying Paramiko/SSH systems C{known_hosts} file
- :type known_hosts: C{str}
+ :type add_to_known_hosts: ``bool``
+ :param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
+ :type known_hosts: ``str``
:param kwargs: all other options will be passed on to the constructor of the to-be-instantiated L{X2GoSession} instance
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param _X2GO_CLIENT_ROOTDIR:
:returns: the session UUID of the newly registered (or re-registered) session
- :rtype: C{str}
+ :rtype: ``str``
"""
if profile_id not in list(self._profile_locks.keys()):
@@ -612,31 +612,31 @@ class X2GoSessionRegistry(object):
def has_session_of_session_name(self, session_name, match_profile_name=None):
"""\
- Detect if we know about an L{X2GoSession} of name C{<session_name>}.
+ Detect if we know about an L{X2GoSession} of name ``<session_name>``.
:param session_name: name of session to be searched for
- :type session_name: C{str}
+ :type session_name: ``str``
:param match_profile_name: a session's profile_name must match this profile name (Default value = None)
- :type match_profile_name: C{str}
- :returns: C{True} if a session of C{<session_name>} has been found
- :rtype: C{bool}
+ :type match_profile_name: ``str``
+ :returns: ``True`` if a session of ``<session_name>`` has been found
+ :rtype: ``bool``
"""
return bool(self.get_session_of_session_name(session_name, match_profile_name=match_profile_name))
def get_session_of_session_name(self, session_name, return_object=False, match_profile_name=None):
"""\
- Retrieve the L{X2GoSession} instance with session name C{<session_name>}.
+ Retrieve the L{X2GoSession} instance with session name ``<session_name>``.
:param session_name: name of session to be retrieved
- :type session_name: C{str}
- :param return_object: if C{False} the session UUID hash will be returned, if C{True} the L{X2GoSession} instance will be returned (Default value = False)
- :type return_object: C{bool}
+ :type session_name: ``str``
+ :param return_object: if ``False`` the session UUID hash will be returned, if ``True`` the L{X2GoSession} instance will be returned (Default value = False)
+ :type return_object: ``bool``
:param match_profile_name: returned sessions must match this profile name (Default value = None)
- :type match_profile_name: C{str}
+ :type match_profile_name: ``str``
:returns: L{X2GoSession} object or its representing session UUID hash
- :rtype: L{X2GoSession} instance or C{str}
- :raises X2GoSessionRegistryException: if there is more than one L{X2GoSession} registered for C{<session_name>} within
+ :rtype: L{X2GoSession} instance or ``str``
+ :raises X2GoSessionRegistryException: if there is more than one L{X2GoSession} registered for ``<session_name>`` within
the same L{X2GoClient} instance. This should never happen!
"""
@@ -689,37 +689,37 @@ class X2GoSessionRegistry(object):
def connected_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that the underlying L{X2GoClient} instances is currently connected to.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('connected', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
def associated_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
- Retrieve a list of sessions that are currently associated by an C{X2GoTerminalSession*} to the underlying L{X2GoClient} instance.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ Retrieve a list of sessions that are currently associated by an ``X2GoTerminalSession*`` to the underlying L{X2GoClient} instance.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('associated', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -727,18 +727,18 @@ class X2GoSessionRegistry(object):
def virgin_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that are currently still in virgin state (not yet connected, associated etc.).
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('virgin', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -746,18 +746,18 @@ class X2GoSessionRegistry(object):
def running_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that are currently in running state.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('running', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -765,18 +765,18 @@ class X2GoSessionRegistry(object):
def suspended_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that are currently in suspended state.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('suspended', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -784,18 +784,18 @@ class X2GoSessionRegistry(object):
def terminated_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that have terminated recently.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('terminated', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -803,7 +803,7 @@ class X2GoSessionRegistry(object):
@property
def has_running_sessions(self):
"""\
- Equals C{True} if the underlying L{X2GoClient} instance has any running sessions at hand.
+ Equals ``True`` if the underlying L{X2GoClient} instance has any running sessions at hand.
"""
@@ -812,7 +812,7 @@ class X2GoSessionRegistry(object):
@property
def has_suspended_sessions(self):
"""\
- Equals C{True} if the underlying L{X2GoClient} instance has any suspended sessions at hand.
+ Equals ``True`` if the underlying L{X2GoClient} instance has any suspended sessions at hand.
"""
@@ -821,18 +821,18 @@ class X2GoSessionRegistry(object):
def registered_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of all registered sessions.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return self._sessionsWithState('registered', return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names)
@@ -840,18 +840,18 @@ class X2GoSessionRegistry(object):
def non_running_sessions(self, return_objects=True, return_profile_names=False, return_profile_ids=False, return_session_names=False):
"""\
Retrieve a list of sessions that are currently _NOT_ in running state.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = False)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
return [ s for s in self.registered_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names) if s not in self.running_sessions(return_objects=return_objects, return_profile_names=return_profile_names, return_profile_ids=return_profile_ids, return_session_names=return_session_names) ]
@@ -859,16 +859,16 @@ class X2GoSessionRegistry(object):
def connected_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that are currently connected to the profile's X2Go server.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -880,17 +880,17 @@ class X2GoSessionRegistry(object):
def associated_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- For a given session profile name retrieve a list of sessions that are currently associated by an C{X2GoTerminalSession*} to this L{X2GoClient} instance.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ For a given session profile name retrieve a list of sessions that are currently associated by an ``X2GoTerminalSession*`` to this L{X2GoClient} instance.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -903,16 +903,16 @@ class X2GoSessionRegistry(object):
def pubapp_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that can be providers for published application list.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -925,16 +925,16 @@ class X2GoSessionRegistry(object):
def registered_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that are currently registered with this L{X2GoClient} instance.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -947,17 +947,17 @@ class X2GoSessionRegistry(object):
def virgin_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that are registered with this L{X2GoClient} instance but have not
- yet been started (i.e. sessions that are in virgin state). If none of the C{return_*} options is specified a list of
+ yet been started (i.e. sessions that are in virgin state). If none of the ``return_*`` options is specified a list of
session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -970,16 +970,16 @@ class X2GoSessionRegistry(object):
def running_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that are currently running.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -992,16 +992,16 @@ class X2GoSessionRegistry(object):
def suspended_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
For a given session profile name retrieve a list of sessions that are currently in suspended state.
- If none of the C{return_*} options is specified a list of session UUID hashes will be returned.
+ If none of the ``return_*`` options is specified a list of session UUID hashes will be returned.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_objects: return as list of L{X2GoSession} instances (Default value = True)
- :type return_objects: C{bool}
+ :type return_objects: ``bool``
:param return_session_names: return as list of X2Go session names (Default value = False)
- :type return_session_names: C{bool}
+ :type return_session_names: ``bool``
:returns: a session list (as UUID hashes, objects or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if return_objects:
@@ -1013,12 +1013,12 @@ class X2GoSessionRegistry(object):
def control_session_of_profile_name(self, profile_name):
"""\
- For a given session profile name retrieve a the corresponding C{X2GoControlSession*} instance.
+ For a given session profile name retrieve a the corresponding ``X2GoControlSession*`` instance.
:param profile_name: session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
:returns: contol session instance
- :rtype: C{X2GoControlSession*} instance
+ :rtype: ``X2GoControlSession*`` instance
"""
_sessions = self.registered_sessions_of_profile_name(profile_name, return_objects=True)
@@ -1041,13 +1041,13 @@ class X2GoSessionRegistry(object):
Retrieve a list of all currently connected session profiles.
:param use_paramiko: send query directly to the Paramiko/SSH layer (Default value = False)
- :type use_paramiko: C{bool}
+ :type use_paramiko: ``bool``
:param return_profile_names: return as list of profile names (Default value = False)
- :type return_profile_names: C{bool}
+ :type return_profile_names: ``bool``
:param return_profile_ids: return as list of profile IDs (Default value = True)
- :type return_profile_ids: C{bool}
+ :type return_profile_ids: ``bool``
:returns: list of connected session profiles
- :rtype: C{list}
+ :rtype: ``list``
"""
if use_paramiko:
@@ -1060,13 +1060,13 @@ class X2GoSessionRegistry(object):
Retrieve the master session of a specific profile.
:param profile_name: the profile name that we query the master session of
- :type profile_name: C{str}
+ :type profile_name: ``str``
:param return_object: return L{X2GoSession} instance (Default value = True)
- :type return_object: C{bool}
+ :type return_object: ``bool``
:param return_session_name: return X2Go session name (Default value = False)
- :type return_session_name: C{bool}
+ :type return_session_name: ``bool``
:returns: a session list (as UUID hashes, objects, profile names/IDs or session names)
- :rtype: C{list}
+ :rtype: ``list``
"""
if profile_name not in self.connected_profiles(return_profile_names=True):
diff --git a/x2go/rforward.py b/x2go/rforward.py
index 50692a0..8748ad4 100644
--- a/x2go/rforward.py
+++ b/x2go/rforward.py
@@ -42,10 +42,10 @@ from . import log
def x2go_transport_tcp_handler(chan, origin, server):
"""\
- An X2Go customized TCP handler for the Paramiko/SSH C{Transport()} class.
+ An X2Go customized TCP handler for the Paramiko/SSH ``Transport()`` class.
Incoming channels will be put into Paramiko's default accept queue. This corresponds to
- the default behaviour of Paramiko's C{Transport} class.
+ the default behaviour of Paramiko's ``Transport`` class.
However, additionally this handler function checks the server port of the incoming channel
and detects if there are Paramiko/SSH reverse forwarding tunnels waiting for the incoming
@@ -57,11 +57,11 @@ def x2go_transport_tcp_handler(chan, origin, server):
started. This L{X2GoRevFwChannelThread} then takes care of the new channel's incoming data stream.
:param chan: a Paramiko channel object
- :type chan: C{paramiko.Channel} object
+ :type chan: ``paramiko.Channel`` object
:param origin: host/port tuple where a connection originates from
- :type origin: C{tuple}
+ :type origin: ``tuple``
:param server: host/port tuple where to connect to
- :type server: C{tuple}
+ :type server: ``tuple``
"""
(origin_addr, origin_port) = origin
@@ -108,7 +108,7 @@ class X2GoRevFwTunnel(threading.Thread):
normally an application's standard port (22 for SSH, 4713 for pulse audio, etc.)
@type remote_port: int
@param ssh_transport: the L{X2GoSession}'s Paramiko/SSH transport instance
- @type ssh_transport: C{paramiko.Transport} instance
+ @type ssh_transport: ``paramiko.Transport`` instance
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoRevFwTunnel} constructor
@type logger: L{X2GoLogger} instance
@@ -150,9 +150,9 @@ class X2GoRevFwTunnel(threading.Thread):
on the server the port forwarding should be unregistered.
:param address: remote server address
- :type address: C{str}
+ :type address: ``str``
:param port: remote port
- :type port: C{int}
+ :type port: ``int``
"""
timeout = Timeout(10)
@@ -197,7 +197,7 @@ class X2GoRevFwTunnel(threading.Thread):
been detected, this method gets called from the L{X2GoSession}'s transport
TCP handler.
- The sent notification will trigger a C{thread.Condition()} waiting for notification
+ The sent notification will trigger a ``thread.Condition()`` waiting for notification
in L{X2GoRevFwTunnel.run()}.
@@ -244,7 +244,7 @@ class X2GoRevFwTunnel(threading.Thread):
L{X2GoRevFwTunnel.run()} waits for notifications of an appropriate incoming
Paramiko/SSH channel (issued by L{X2GoRevFwTunnel.notify()}). Appropriate in
this context means, that its start point on the X2Go server matches the class's
- property C{server_port}.
+ property ``server_port``.
Once a new incoming channel gets announced by the L{notify()} method, a new
L{X2GoRevFwChannelThread} instance will be initialized. As a data stream handler,
@@ -303,11 +303,11 @@ def x2go_rev_forward_channel_handler(chan=None, addr='', port=0, parent_thread=N
from within a Python X2Go application.
:param chan: channel (Default value = None)
- :type chan: C{class}
+ :type chan: ``class``
:param addr: bind address (Default value = '')
- :type addr: C{str}
+ :type addr: ``str``
:param port: bind port (Default value = 0)
- :type port: C{int}
+ :type port: ``int``
:param parent_thread: the calling L{X2GoRevFwTunnel} instance (Default value = None)
:type parent_thread: L{X2GoRevFwTunnel} instance
:param logger: you can pass an L{X2GoLogger} object to the
@@ -367,7 +367,7 @@ class X2GoRevFwChannelThread(threading.Thread):
accept queue
@type channel: class
@param remote: tuple (addr, port) that specifies the data endpoint of the channel
- @type remote: C{tuple(str, int)}
+ @type remote: ``tuple(str, int)``
"""
self.channel = channel
diff --git a/x2go/session.py b/x2go/session.py
index 7acd1d4..6fcacf1 100644
--- a/x2go/session.py
+++ b/x2go/session.py
@@ -168,83 +168,83 @@ class X2GoSession(object):
**params):
"""\
@param server: hostname of X2Go server
- @type server: C{str}
- @param control_session: an already initialized C{X2GoControlSession*} instance
- @type control_session: C{X2GoControlSession*} instance
+ @type server: ``str``
+ @param control_session: an already initialized ``X2GoControlSession*`` instance
+ @type control_session: ``X2GoControlSession*`` instance
@param use_sshproxy: for communication with X2Go server use an SSH proxy host
- @type use_sshproxy: C{bool}
+ @type use_sshproxy: ``bool``
@param sshproxy_reuse_authinfo: for proxy authentication re-use the X2Go session's password / key file
- @type sshproxy_reuse_authinfo: C{bool}
+ @type sshproxy_reuse_authinfo: ``bool``
@param profile_id: profile ID
- @type profile_id: C{str}
+ @type profile_id: ``str``
@param profile_name: profile name
- @type profile_name: C{str}
+ @type profile_name: ``str``
@param session_name: session name (if available)
- @type session_name: C{str}
+ @type session_name: ``str``
@param auto_start_or_resume: automatically start a new or resume latest session after connect
- @type auto_start_or_resume: C{bool}
+ @type auto_start_or_resume: ``bool``
@param auto_connect: call a hook method that handles connecting the session profile automatically after a session for this profile has been registered
- @type auto_connect: C{bool}
+ @type auto_connect: ``bool``
@param printing: enable X2Go printing
- @type printing: C{bool}
+ @type printing: ``bool``
@param allow_mimebox: enable X2Go MIME box support
- @type allow_mimebox: C{bool}
+ @type allow_mimebox: ``bool``
@param mimebox_extensions: whitelist of allowed X2Go MIME box extensions
- @type mimebox_extensions: C{list}
+ @type mimebox_extensions: ``list``
@param mimebox_action: action for incoming X2Go MIME box files
- @type mimebox_action: C{X2GoMimeBoxAction*} or C{str}
+ @type mimebox_action: ``X2GoMimeBoxAction*`` or ``str``
@param allow_share_local_folders: enable local folder sharing support
- @type allow_share_local_folders: C{bool}
+ @type allow_share_local_folders: ``bool``
@param share_local_folders: list of local folders to share with the remote X2Go session
- @type share_local_folders: C{list}
+ @type share_local_folders: ``list``
@param restore_shared_local_folders: store actual list of shared local folders after session has been suspended or terminated
- @type restore_shared_local_folders: C{bool}
+ @type restore_shared_local_folders: ``bool``
@param control_backend: X2Go control session backend to use
- @type control_backend: C{str}
+ @type control_backend: ``str``
@param terminal_backend: X2Go terminal session backend to use
- @type terminal_backend: C{str}
+ @type terminal_backend: ``str``
@param info_backend: X2Go session info backend to use
- @type info_backend: C{str}
+ @type info_backend: ``str``
@param list_backend: X2Go session list backend to use
- @type list_backend: C{str}
+ @type list_backend: ``str``
@param proxy_backend: X2Go proxy backend to use
- @type proxy_backend: C{str}
+ @type proxy_backend: ``str``
@param settings_backend: X2Go client settings backend to use
- @type settings_backend: C{str}
+ @type settings_backend: ``str``
@param printing_backend: X2Go client printing backend to use
- @type printing_backend: C{str}
+ @type printing_backend: ``str``
@param client_rootdir: client base dir (default: ~/.x2goclient)
- @type client_rootdir: C{str}
+ @type client_rootdir: ``str``
@param sessions_rootdir: sessions base dir (default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param ssh_rootdir: ssh base dir (default: ~/.ssh)
- @type ssh_rootdir: C{str}
- @param keep_controlsession_alive: On last L{X2GoSession.disconnect()} keep the associated C{X2GoControlSession*} instance alive?
- @ŧype keep_controlsession_alive: C{bool}
+ @type ssh_rootdir: ``str``
+ @param keep_controlsession_alive: On last L{X2GoSession.disconnect()} keep the associated ``X2GoControlSession*`` instance alive?
+ @ŧype keep_controlsession_alive: ``bool``
@param add_to_known_hosts: Auto-accept server host validity?
- @type add_to_known_hosts: C{bool}
- @param known_hosts: the underlying Paramiko/SSH systems C{known_hosts} file
- @type known_hosts: C{str}
+ @type add_to_known_hosts: ``bool``
+ @param known_hosts: the underlying Paramiko/SSH systems ``known_hosts`` file
+ @type known_hosts: ``str``
@param forward_sshagent: forward SSH agent authentication requests to the SSH agent on the X2Go client-side
- @type forward_sshagent: C{bool}
+ @type forward_sshagent: ``bool``
@param connected: manipulate session state »connected« by giving a pre-set value
- @type connected: C{bool}
+ @type connected: ``bool``
@param activated: normal leave this untouched, an activated session is a session that is about to be used
- @type activated: C{bool}
+ @type activated: ``bool``
@param virgin: manipulate session state »virgin« by giving a pre-set value
- @type virgin: C{bool}
+ @type virgin: ``bool``
@param running: manipulate session state »running« by giving a pre-set value
- @type running: C{bool}
+ @type running: ``bool``
@param suspended: manipulate session state »suspended« by giving a pre-set value
- @type suspended: C{bool}
+ @type suspended: ``bool``
@param terminated: manipulate session state »terminated« by giving a pre-set value
- @type terminated: C{bool}
+ @type terminated: ``bool``
@param faulty: manipulate session state »faulty« by giving a pre-set value
- @type faulty: C{bool}
+ @type faulty: ``bool``
@param client_instance: if available, the underlying L{X2GoClient} instance
- @type client_instance: C{X2GoClient} instance
+ @type client_instance: ``X2GoClient`` instance
@param params: further control session, terminal session and SSH proxy class options
- @type params: C{dict}
+ @type params: ``dict``
"""
if logger is None:
@@ -433,7 +433,7 @@ class X2GoSession(object):
:returns: L{X2GoClient} instance this session is associated with
- :rtype: C{obj}
+ :rtype: ``obj``
"""
return self.client_instance
@@ -510,7 +510,7 @@ class X2GoSession(object):
HOOK method: called if it is tried to connect to a shared desktop that's not available (anymore).
:param desktop: the could-not-be-shared desktop's name or other identifier (Default value = 'UNKNOWN')
- :type desktop: C{str}
+ :type desktop: ``str``
"""
if self.client_instance:
@@ -523,7 +523,7 @@ class X2GoSession(object):
HOOK method: called if a reverse port forwarding request has been denied.
:param server_port: remote server port (starting point of reverse forwarding tunnel) (Default value = 0)
- :type server_port: C{str}
+ :type server_port: ``str``
"""
if self.client_instance:
@@ -536,11 +536,11 @@ class X2GoSession(object):
HOOK method: called if a port forwarding tunnel setup failed.
:param chain_host: hostname of chain host (forwarding tunnel end point) (Default value = 'UNKNOWN')
- :type chain_host: C{str}
+ :type chain_host: ``str``
:param chain_port: port of chain host (forwarding tunnel end point) (Default value = 0)
- :type chain_port: C{str}
+ :type chain_port: ``str``
:param subsystem: information on the subsystem that provoked this hook call (Default value = None)
- :type subsystem: C{str}
+ :type subsystem: ``str``
"""
if type(subsystem) in (bytes, str):
@@ -602,18 +602,18 @@ class X2GoSession(object):
def HOOK_check_host_dialog(self, host, port, fingerprint='no fingerprint', fingerprint_type='UNKNOWN'):
"""\
- HOOK method: called if a host check is requested. This hook has to either return C{True} (default) or C{False}.
+ HOOK method: called if a host check is requested. This hook has to either return ``True`` (default) or ``False``.
:param host: SSH server name to validate
- :type host: C{str}
+ :type host: ``str``
:param port: SSH server port to validate
- :type port: C{int}
+ :type port: ``int``
:param fingerprint: the server's fingerprint (Default value = 'no fingerprint')
- :type fingerprint: C{str}
+ :type fingerprint: ``str``
:param fingerprint_type: finger print type (like RSA, DSA, ...) (Default value = 'UNKNOWN')
- :type fingerprint_type: C{str}
- :returns: if host validity is verified, this hook method should return C{True}
- :rtype: C{bool}
+ :type fingerprint_type: ``str``
+ :returns: if host validity is verified, this hook method should return ``True``
+ :rtype: ``bool``
"""
if self.client_instance:
@@ -624,7 +624,7 @@ class X2GoSession(object):
def init_control_session(self):
"""\
- Initialize a new control session (C{X2GoControlSession*}).
+ Initialize a new control session (``X2GoControlSession*``).
"""
@@ -657,12 +657,12 @@ class X2GoSession(object):
it also is _the_ session that controls the client-side shared folders.
If this L{X2GoSession} instance is a standalone instance (without parent L{X2GoClient})
- this method will always return C{True}.
+ this method will always return ``True``.
- :returns: returns C{True} if this session is a master session
+ :returns: returns ``True`` if this session is a master session
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.master_session is None and self.client_instance is None:
@@ -679,9 +679,9 @@ class X2GoSession(object):
:param wait: wait for <wait> seconds before sharing local folders via the new master session
of the corresponding session profile. (Default value = 0)
- :type wait: C{int}
+ :type wait: ``int``
:param max_wait: wait for <max_wait> seconds for the terminal session to appear (Default value = 20)
- :type max_wait: C{int}
+ :type max_wait: ``int``
"""
self.logger('Using session %s as master session for profile %s.' % (self.get_session_name(), self.get_profile_name()), loglevel=log.loglevel_NOTICE)
@@ -722,7 +722,7 @@ class X2GoSession(object):
Modify server name after L{X2GoSession} has already been initialized.
:param server: new server name
- :type server: C{str}
+ :type server: ``str``
"""
self.server = server
@@ -733,7 +733,7 @@ class X2GoSession(object):
Modify server port after L{X2GoSession} has already been initialized.
:param port: socket port of server to connect to
- :type port: C{int}
+ :type port: ``int``
"""
self.port = port
@@ -744,7 +744,7 @@ class X2GoSession(object):
Modify session profile name after L{X2GoSession} has already been initialized.
:param profile_name: new session profile name
- :type profile_name: C{str}
+ :type profile_name: ``str``
"""
self.profile_name = profile_name
@@ -756,9 +756,9 @@ class X2GoSession(object):
Retrieve a specific profile parameter for this session.
:param option: name of a specific profile option to be queried.
- :type option: C{str}
- :returns: value for profile option C{<option>}
- :rtype: C{bool,str,int}
+ :type option: ``str``
+ :returns: value for profile option ``<option>``
+ :rtype: ``bool,str,int``
:raises X2GoProfileException: if the session profile option is unknown
"""
@@ -774,7 +774,7 @@ class X2GoSession(object):
L{X2GoSession} instance has already been initialized.
:param params: a Python dictionary with L{X2GoSession} parameters
- :type params: C{dict}
+ :type params: ``dict``
"""
try: del params['server']
@@ -865,7 +865,7 @@ class X2GoSession(object):
:returns: the session's UUID hash
- :rtype: C{str}
+ :rtype: ``str``
"""
return str(self.uuid)
@@ -879,7 +879,7 @@ class X2GoSession(object):
:returns: the remote username the X2Go session runs as
- :rtype: C{str}
+ :rtype: ``str``
"""
# try to retrieve the username from the control session, if already connected
@@ -897,7 +897,7 @@ class X2GoSession(object):
:returns: the remote home directory path
- :rtype: C{str}
+ :rtype: ``str``
"""
# try to retrieve the username from the control session, if already connected
@@ -912,9 +912,9 @@ class X2GoSession(object):
Check if a given user is valid server-side X2Go user.
:param username: username to check validity for (Default value = None)
- :type username: C{str}
- :returns: C{True} if the username is allowed to launch X2Go sessions
- :rtype: C{bool}
+ :type username: ``str``
+ :returns: ``True`` if the username is allowed to launch X2Go sessions
+ :rtype: ``bool``
"""
if username is None:
@@ -930,7 +930,7 @@ class X2GoSession(object):
:returns: the username's password
- :rtype: C{str}
+ :rtype: ``str``
"""
return base64.base64decode(self.control_session._session_password)
@@ -944,9 +944,9 @@ class X2GoSession(object):
:returns: the address of the server the X2Go session is
- connected to (as an C{(addr,port)} tuple)
+ connected to (as an ``(addr,port)`` tuple)
- :rtype: C{tuple}
+ :rtype: ``tuple``
"""
return self.control_session.remote_peername()
@@ -964,7 +964,7 @@ class X2GoSession(object):
:returns: the hostname of the server the X2Go session is
connected to / about to connect to
- :rtype: C{str}
+ :rtype: ``str``
"""
self.server = self.control_session.get_hostname()
@@ -980,7 +980,7 @@ class X2GoSession(object):
:returns: the server-side IP socket port that is used by the X2Go session to
connect to the server
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.control_session.get_port()
@@ -993,7 +993,7 @@ class X2GoSession(object):
:returns: X2Go session name
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.session_name
@@ -1004,7 +1004,7 @@ class X2GoSession(object):
Manipulate the L{X2GoSession}'s session name.
:param session_name: the new session name to be set
- :type session_name: C{str}
+ :type session_name: ``str``
"""
self.session_name = session_name
@@ -1017,7 +1017,7 @@ class X2GoSession(object):
:returns: X2Go session info
- :rtype: C{obj}
+ :rtype: ``obj``
"""
if self.has_terminal_session():
@@ -1032,7 +1032,7 @@ class X2GoSession(object):
:returns: server-side session command
- :rtype: C{str}
+ :rtype: ``str``
"""
if self.has_terminal_session():
@@ -1054,7 +1054,7 @@ class X2GoSession(object):
:returns: session type
- :rtype: C{str}
+ :rtype: ``str``
"""
if self.has_terminal_session():
@@ -1071,7 +1071,7 @@ class X2GoSession(object):
:returns: session window title
- :rtype: C{str}
+ :rtype: ``str``
"""
if self.has_terminal_session():
@@ -1082,12 +1082,12 @@ class X2GoSession(object):
def get_control_session(self):
"""\
- Retrieve the control session (C{X2GoControlSession*} backend) of this L{X2GoSession}.
+ Retrieve the control session (``X2GoControlSession*`` backend) of this L{X2GoSession}.
:returns: the L{X2GoSession}'s control session
- :rtype: C{X2GoControlSession*} instance
+ :rtype: ``X2GoControlSession*`` instance
"""
return self.control_session
@@ -1098,9 +1098,9 @@ class X2GoSession(object):
Check if this L{X2GoSession} instance has an associated control session.
- :returns: returns C{True} if this L{X2GoSession} has a control session associated to itself
+ :returns: returns ``True`` if this L{X2GoSession} has a control session associated to itself
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.control_session is not None
@@ -1108,12 +1108,12 @@ class X2GoSession(object):
def get_terminal_session(self):
"""\
- Retrieve the terminal session (C{X2GoTerminalSession*} backend) of this L{X2GoSession}.
+ Retrieve the terminal session (``X2GoTerminalSession*`` backend) of this L{X2GoSession}.
:returns: the L{X2GoSession}'s terminal session
- :rtype: C{X2GoControlTerminal*} instance
+ :rtype: ``X2GoControlTerminal*`` instance
"""
if self.terminal_session == 'PENDING':
@@ -1126,9 +1126,9 @@ class X2GoSession(object):
Check if this L{X2GoSession} instance has an associated terminal session.
- :returns: returns C{True} if this L{X2GoSession} has a terminal session associated to itself
+ :returns: returns ``True`` if this L{X2GoSession} has a terminal session associated to itself
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.terminal_session not in (None, 'PENDING')
@@ -1143,9 +1143,9 @@ class X2GoSession(object):
override any of these to enable user interaction on X2Go server validity checks.
- :returns: returns C{True} if an X2Go server host is valid for authentication
+ :returns: returns ``True`` if an X2Go server host is valid for authentication
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.connected:
@@ -1161,9 +1161,9 @@ class X2GoSession(object):
Check if a session is configured to use an intermediate SSH proxy server.
- :returns: returns C{True} if the session is configured to use an SSH proxy, C{False} otherwise.
+ :returns: returns ``True`` if the session is configured to use an SSH proxy, ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.use_sshproxy
@@ -1175,9 +1175,9 @@ class X2GoSession(object):
proxy authentication, as well.
- :returns: returns C{True} if the session is configured to re-use session password / key for proxy authentication
+ :returns: returns ``True`` if the session is configured to re-use session password / key for proxy authentication
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return self.sshproxy_reuse_authinfo
@@ -1189,10 +1189,10 @@ class X2GoSession(object):
to the SSH proxy server (e.g. by public key authentication).
- :returns: returns C{True} if the session's SSH proxy can auto-connect, C{False} otherwise, C{None}
- if no SSH proxy is used for this session, C{None} is returned.
+ :returns: returns ``True`` if the session's SSH proxy can auto-connect, ``False`` otherwise, ``None``
+ if no SSH proxy is used for this session, ``None`` is returned.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.use_sshproxy:
@@ -1220,10 +1220,10 @@ class X2GoSession(object):
server (e.g. public key authentication).
- :returns: returns C{True} if the session can auto-connect, C{False} otherwise, C{None}
+ :returns: returns ``True`` if the session can auto-connect, ``False`` otherwise, ``None``
if no control session has been set up yet.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.control_session is None:
@@ -1256,9 +1256,9 @@ class X2GoSession(object):
Automatically connect this session.
:param redirect_to_client: Pass this request through to the L{X2GoClient} instance, if given (Default value = True)
- :type redirect_to_client: C{True}
+ :type redirect_to_client: ``True``
:returns: Return success (or failure) of connecting this sessions
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if not self.is_connected():
@@ -1277,47 +1277,47 @@ class X2GoSession(object):
sshproxy_force_password_auth=None, sshproxy_reuse_authinfo=None, ):
"""\
Connects to the L{X2GoSession}'s server host. This method basically wraps around
- the C{X2GoControlSession*.connect()} method.
+ the ``X2GoControlSession*.connect()`` method.
:param username: the username for the X2Go server that is going to be
connected to (as a last minute way of changing the session username) (Default value = None)
- :type username: C{str}
+ :type username: ``str``
:param password: the user's password for the X2Go server that is going to be
connected to (Default value = None)
- :type password: C{str}
+ :type password: ``str``
:param passphrase: a passphrase to use for unlocking
a private key in case the password is already needed for two-factor
authentication (Default value = None)
- :type passphrase: C{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()
+ :type passphrase: ``str``
+ :param add_to_known_hosts: non-paramiko option, if ``True`` paramiko.AutoAddPolicy()
+ is used as missing-host-key-policy. If set to ``False`` paramiko.RejectPolicy()
is used (Default value = None)
- :type add_to_known_hosts: C{bool}
+ :type add_to_known_hosts: ``bool``
:param force_password_auth: disable SSH pub/priv key authentication mechanisms
completely (Default value = None)
- :type force_password_auth: C{bool}
- :param look_for_keys: set to C{True} to enable searching for discoverable
- private key files in C{~/.ssh/} (Default value = None)
- :type look_for_keys: C{bool}
- :param allow_agent: set to C{True} to enable connecting to a local SSH agent
+ :type force_password_auth: ``bool``
+ :param look_for_keys: set to ``True`` to enable searching for discoverable
+ private key files in ``~/.ssh/`` (Default value = None)
+ :type look_for_keys: ``bool``
+ :param allow_agent: set to ``True`` to enable connecting to a local SSH agent
for acquiring authentication information (Default value = None)
- :type allow_agent: C{bool}
+ :type allow_agent: ``bool``
:param use_sshproxy: use an SSH proxy host for connecting the target X2Go server (Default value = None)
- :type use_sshproxy: C{bool}
+ :type use_sshproxy: ``bool``
:param sshproxy_reuse_authinfo: for proxy authentication re-use the X2Go session's password / key file (Default value = None)
- :type sshproxy_reuse_authinfo: C{bool}
+ :type sshproxy_reuse_authinfo: ``bool``
:param sshproxy_user: username for authentication against the SSH proxy host (Default value = None)
- :type sshproxy_user: C{str}
+ :type sshproxy_user: ``str``
:param sshproxy_password: password for authentication against the SSH proxy host (Default value = None)
- :type sshproxy_password: C{str}
+ :type sshproxy_password: ``str``
:param sshproxy_passphrase: a passphrase to use for unlocking
a private key needed for the SSH proxy host in case the sshproxy_password is already needed for
two-factor authentication (Default value = None)
- :type sshproxy_passphrase: C{str}
+ :type sshproxy_passphrase: ``str``
:param sshproxy_force_password_auth: enforce password authentication even is a key(file) is present (Default value = None)
- :type sshproxy_force_password_auth: C{bool}
- :returns: returns C{True} is the connection to the X2Go server has been successful
- :rtype: C{bool}
+ :type sshproxy_force_password_auth: ``bool``
+ :returns: returns ``True`` is the connection to the X2Go server has been successful
+ :rtype: ``bool``
:raises X2GoSessionException: on control session exceptions
:raises X2GoRemoteHomeException: if the remote home directory does not exist
:raises Exception: any other exception during connecting is passed through
@@ -1426,9 +1426,9 @@ class X2GoSession(object):
Disconnect this L{X2GoSession} instance.
- :returns: returns C{True} if the disconnect operation has been successful
+ :returns: returns ``True`` if the disconnect operation has been successful
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.connected = False
@@ -1463,9 +1463,9 @@ class X2GoSession(object):
Return a list of X2Go server-sides features (supported functionalities).
- :returns: a C{list} of X2Go feature names
+ :returns: a ``list`` of X2Go feature names
- :rtype: C{list}
+ :rtype: ``list``
"""
return self.server_features
@@ -1473,12 +1473,12 @@ class X2GoSession(object):
def has_server_feature(self, feature):
"""\
- Check if C{feature} is a present feature of the connected X2Go server.
+ Check if ``feature`` is a present feature of the connected X2Go server.
- :param feature: an X2Go server feature as found in C{$SHAREDIR/x2go/feature.d/*}
- :type feature: C{str}
- :returns: returns C{True} if the feature is present
- :rtype: C{bool}
+ :param feature: an X2Go server feature as found in ``$SHAREDIR/x2go/feature.d/*``
+ :type feature: ``str``
+ :returns: returns ``True`` if the feature is present
+ :rtype: ``bool``
"""
return feature in self.get_server_features()
@@ -1491,7 +1491,7 @@ class X2GoSession(object):
always contains the X2Go session ID of that window.
:param title: new title for session window (Default value = '')
- :type title: C{str}
+ :type title: ``str``
"""
if self.terminal_session is not None:
@@ -1518,11 +1518,11 @@ class X2GoSession(object):
method.
:param print_action: one of the named above print actions, either as string or class instance
- :type print_action: C{str} or C{instance}
+ :type print_action: ``str`` or ``instance``
:param kwargs: additional information for the given print action (print
action arguments), for possible print action arguments and their values see each individual
print action class
- :type kwargs: C{dict}
+ :type kwargs: ``dict``
:param **kwargs:
"""
@@ -1536,9 +1536,9 @@ class X2GoSession(object):
Find out if this X2Go session is still alive (that is: connected to the server).
- :returns: returns C{True} if the server connection is still alive
+ :returns: returns ``True`` if the server connection is still alive
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.connected = self.control_session.is_alive()
@@ -1554,9 +1554,9 @@ class X2GoSession(object):
Clean all running sessions for the authenticated user on the remote X2Go server.
:param destroy_terminals: destroy associated terminal sessions (Default value = True)
- :type destroy_terminals: C{bool}
+ :type destroy_terminals: ``bool``
:param published_applications: clean sessions that are published applications providers, too (Default value = False)
- :type published_applications: C{bool}
+ :type published_applications: ``bool``
"""
if self.is_alive():
@@ -1574,11 +1574,11 @@ class X2GoSession(object):
"""\
List all sessions on the remote X2Go server that are owned by the authenticated user
- :param raw: if C{True} the output of this method equals
- the output of the server-side C{x2golistsessions} command (Default value = False)
- :type raw: C{bool}
- :returns: a session list (as data object or list of strings when called with C{raw=True} option)
- :rtype: C{X2GoServerSessionList*} instance or C{list}
+ :param raw: if ``True`` the output of this method equals
+ the output of the server-side ``x2golistsessions`` command (Default value = False)
+ :type raw: ``bool``
+ :returns: a session list (as data object or list of strings when called with ``raw=True`` option)
+ :rtype: ``X2GoServerSessionList*`` instance or ``list``
"""
try:
@@ -1593,11 +1593,11 @@ class X2GoSession(object):
"""\
List X2Go desktops sessions available for desktop sharing on the remote X2Go server.
- :param raw: if C{True} the output of this method equals
- the output of the server-side C{x2golistdesktops} command (Default value = False)
- :type raw: C{bool}
+ :param raw: if ``True`` the output of this method equals
+ the output of the server-side ``x2golistdesktops`` command (Default value = False)
+ :type raw: ``bool``
:returns: a list of strings representing available desktop sessions
- :rtype: C{list}
+ :rtype: ``list``
"""
try:
@@ -1613,14 +1613,14 @@ class X2GoSession(object):
def list_mounts(self, raw=False):
"""\
- Use the X2Go session registered under C{session_uuid} to
+ Use the X2Go session registered under ``session_uuid`` to
retrieve its list of mounted client shares for that session.
:param raw: output the list of mounted client shares in X2Go's
- raw C{x2golistmounts} format (Default value = False)
- :type raw: C{bool}
+ raw ``x2golistmounts`` format (Default value = False)
+ :type raw: ``bool``
:returns: a list of strings representing mounted client shares for this session
- :rtype: C{list}
+ :rtype: ``list``
"""
try:
@@ -1645,11 +1645,11 @@ class X2GoSession(object):
intervals to make sure the L{X2GoSession}'s internal status cache information
is always up-to-date.
- :param session_list: provide an C{X2GoServerSessionList*} that refers to X2Go sessions we want to update.
+ :param session_list: provide an ``X2GoServerSessionList*`` that refers to X2Go sessions we want to update.
This option is mainly for reducing server/client traffic. (Default value = None)
- :type session_list: C{X2GoServerSessionList*} instance
+ :type session_list: ``X2GoServerSessionList*`` instance
:param force_update: force a session status update, if if the last update is less then 1 second ago (Default value = False)
- :type force_update: C{bool}
+ :type force_update: ``bool``
:raises Exception: any exception is passed through in case the session disconnected surprisingly
or has been marked as faulty
@@ -1716,9 +1716,9 @@ class X2GoSession(object):
Returns true if this session runs in published applications mode.
- :returns: returns C{True} if this session is a provider session for published applications.
+ :returns: returns ``True`` if this session is a provider session for published applications.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session() and self.is_running() :
@@ -1732,20 +1732,20 @@ class X2GoSession(object):
for session type published applications.
:param lang: locale/language identifier (Default value = None)
- :type lang: C{str}
+ :type lang: ``str``
:param refresh: force reload of the menu tree from X2Go server (Default value = False)
- :type refresh: C{bool}
+ :type refresh: ``bool``
:param raw: retrieve a raw output of the server list of published applications (Default value = False)
- :type raw: C{bool}
+ :type raw: ``bool``
:param very_raw: retrieve a very raw output of the server list of published applications (as-is output of x2gogetapps script) (Default value = False)
- :type very_raw: C{bool}
+ :type very_raw: ``bool``
:param max_no_submenus: Number of applications before applications are put into XDG category submenus
(Default value = defaults.PUBAPP_MAX_NO_SUBMENUS)
- :type max_no_submenus: C{int}
- :returns: A C{list} of C{dict} elements. Each C{dict} elements has a
- C{desktop} key containing the text output of a .desktop file and
- an C{icon} key which contains the desktop icon data base64 encoded
- :rtype: C{list}
+ :type max_no_submenus: ``int``
+ :returns: A ``list`` of ``dict`` elements. Each ``dict`` elements has a
+ ``desktop`` key containing the text output of a .desktop file and
+ an ``icon`` key which contains the desktop icon data base64 encoded
+ :rtype: ``list``
"""
if self.client_instance and hasattr(self.client_instance, 'lang'):
@@ -1758,9 +1758,9 @@ class X2GoSession(object):
Execute an application while in published application mode.
:param exec_name: command to execute on server
- :type exec_name: C{str}
+ :type exec_name: ``str``
:param timeout: time in secs to wait for server query to reply (Default value = 20)
- :type timeout: C{int}
+ :type timeout: ``int``
"""
if self.terminal_session is not None:
@@ -1777,17 +1777,17 @@ class X2GoSession(object):
Sessions in published applications mode are not resumed/started by this method.
:param newest: if resuming, only resume newest/youngest session (Default value = True)
- :type newest: C{bool}
+ :type newest: ``bool``
:param oldest: if resuming, only resume oldest session (Default value = False)
- :type oldest: C{bool}
+ :type oldest: ``bool``
:param all_suspended: if resuming, resume all suspended sessions (Default value = False)
- :type all_suspended: C{bool}
+ :type all_suspended: ``bool``
:param start: is no session is to be resumed, start a new session (Default value = True)
- :type start: C{bool}
+ :type start: ``bool``
:param redirect_to_client: redirect this call to the L{X2GoClient} instance (if available) to allow frontend interaction (Default value = True)
- :type redirect_to_client: C{bool}
+ :type redirect_to_client: ``bool``
:returns: returns success (or failure) of starting/resuming this sessions
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.client_instance and redirect_to_client:
@@ -1832,9 +1832,9 @@ class X2GoSession(object):
Retrieve session startup/resumption progress status.
- :returns: returns an C{int} value between 0 and 100 reflecting the session startup/resumption status
+ :returns: returns an ``int`` value between 0 and 100 reflecting the session startup/resumption status
- :rtype: C{int}
+ :rtype: ``int``
"""
return self._progress_status
@@ -1845,17 +1845,17 @@ class X2GoSession(object):
remote X2Go server.
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param session_list: a session list to avoid a server-side session list query (Default value = None)
- :type session_list: C{dict}
+ :type session_list: ``dict``
:param cmd: if starting a new session, manually hand over the command to be launched in
the new session (Default value = None)
- :type cmd: C{str}
- :param progress_event: a C{thread.Event} object that notifies a status object like the one in
+ :type cmd: ``str``
+ :param progress_event: a ``thread.Event`` object that notifies a status object like the one in
L{utils.ProgressStatus}. (Default value = None)
- :type progress_event: C{obj}
- :returns: returns C{True} if resuming the session has been successful, C{False} otherwise
- :rtype: C{bool}
+ :type progress_event: ``obj``
+ :returns: returns ``True`` if resuming the session has been successful, ``False`` otherwise
+ :rtype: ``bool``
:raises Exception: any exception that occurs during published application menu retrieval is passed through
"""
@@ -1877,17 +1877,17 @@ class X2GoSession(object):
remote X2Go server.
:param session_name: the server-side name of an X2Go session (Default value = None)
- :type session_name: C{str}
+ :type session_name: ``str``
:param session_list: a session list to avoid a server-side session list query (Default value = None)
- :type session_list: C{dict}
+ :type session_list: ``dict``
:param cmd: if starting a new session, manually hand over the command to be launched in
the new session (Default value = None)
- :type cmd: C{str}
- :param progress_event: a C{thread.Event} object that notifies a status object like the one in
+ :type cmd: ``str``
+ :param progress_event: a ``thread.Event`` object that notifies a status object like the one in
L{utils.ProgressStatus}. (Default value = None)
- :type progress_event: C{obj}
- :returns: returns C{True} if resuming the session has been successful, C{False} otherwise
- :rtype: C{bool}
+ :type progress_event: ``obj``
+ :returns: returns ``True`` if resuming the session has been successful, ``False`` otherwise
+ :rtype: ``bool``
:raises Exception: any exception that occurs during published application menu retrieval is passed through
"""
@@ -2126,12 +2126,12 @@ class X2GoSession(object):
Start a new X2Go session on the remote X2Go server.
:param cmd: manually hand over the command that is to be launched in the new session (Default value = None)
- :type cmd: C{str}
- :param progress_event: a C{thread.Event} object that notifies a status object like the one in
+ :type cmd: ``str``
+ :param progress_event: a ``thread.Event`` object that notifies a status object like the one in
L{utils.ProgressStatus}. (Default value = None)
- :type progress_event: C{obj}
- :returns: returns C{True} if starting the session has been successful, C{False} otherwise
- :rtype: C{bool}
+ :type progress_event: ``obj``
+ :returns: returns ``True`` if starting the session has been successful, ``False`` otherwise
+ :rtype: ``bool``
"""
self.session_name = None
@@ -2144,23 +2144,23 @@ class X2GoSession(object):
owned by the same user or by a user that grants access to his/her desktop session by the local user.
:param desktop: desktop ID of a sharable desktop in format <user>@<display> (Default value = None)
- :type desktop: C{str}
+ :type desktop: ``str``
:param user: user name and display number can be given separately, here give the
name of the user who wants to share a session with you. (Default value = None)
- :type user: C{str}
+ :type user: ``str``
:param display: user name and display number can be given separately, here give the
number of the display that a user allows you to be shared with. (Default value = None)
- :type display: C{str}
+ :type display: ``str``
:param share_mode: desktop sharing mode, 0 is VIEW-ONLY, 1 is FULL-ACCESS. (Default value = 0)
- :type share_mode: C{int}
+ :type share_mode: ``int``
:param check_desktop_list: check if the given desktop is available on the X2Go server; handle with care as
- the server-side C{x2golistdesktops} command might block client I/O. (Default value = True)
- :type check_desktop_list: C{bool}
- :param progress_event: a C{thread.Event} object that notifies a status object like the one in
+ the server-side ``x2golistdesktops`` command might block client I/O. (Default value = True)
+ :type check_desktop_list: ``bool``
+ :param progress_event: a ``thread.Event`` object that notifies a status object like the one in
L{utils.ProgressStatus}. (Default value = None)
- :type progress_event: C{obj}
- :returns: returns C{True} if starting the session has been successful, C{False} otherwise
- :rtype: C{bool}
+ :type progress_event: ``obj``
+ :returns: returns ``True`` if starting the session has been successful, ``False`` otherwise
+ :rtype: ``bool``
:raises X2GoDesktopSharingException: if a given desktop ID does not specify an available desktop session
:raises X2GoSessionException: if the available desktop session appears to be dead, in fact
@@ -2183,23 +2183,23 @@ class X2GoSession(object):
owned by the same user or by a user that grants access to his/her desktop session by the local user.
:param desktop: desktop ID of a sharable desktop in format <user>@<display> (Default value = None)
- :type desktop: C{str}
+ :type desktop: ``str``
:param user: user name and display number can be given separately, here give the
name of the user who wants to share a session with you. (Default value = None)
- :type user: C{str}
+ :type user: ``str``
:param display: user name and display number can be given separately, here give the
number of the display that a user allows you to be shared with. (Default value = None)
- :type display: C{str}
+ :type display: ``str``
:param share_mode: desktop sharing mode, 0 is VIEW-ONLY, 1 is FULL-ACCESS. (Default value = 0)
- :type share_mode: C{int}
+ :type share_mode: ``int``
:param check_desktop_list: check if the given desktop is available on the X2Go server; handle with care as
- the server-side C{x2golistdesktops} command might block client I/O. (Default value = True)
- :type check_desktop_list: C{bool}
- :param progress_event: a C{thread.Event} object that notifies a status object like the one in
+ the server-side ``x2golistdesktops`` command might block client I/O. (Default value = True)
+ :type check_desktop_list: ``bool``
+ :param progress_event: a ``thread.Event`` object that notifies a status object like the one in
L{utils.ProgressStatus}. (Default value = None)
- :type progress_event: C{obj}
- :returns: returns C{True} if starting the session has been successful, C{False} otherwise
- :rtype: C{bool}
+ :type progress_event: ``obj``
+ :returns: returns ``True`` if starting the session has been successful, ``False`` otherwise
+ :rtype: ``bool``
:raises X2GoDesktopSharingException: if a given desktop ID does not specify an available desktop session
:raises X2GoSessionException: if the available desktop session appears to be dead, in fact
@@ -2312,9 +2312,9 @@ class X2GoSession(object):
Test if this X2Go session is a desktop session.
- :returns: C{True} if this session is of session type desktop ('D').
+ :returns: ``True`` if this session is of session type desktop ('D').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session():
@@ -2326,9 +2326,9 @@ class X2GoSession(object):
Test if this X2Go session is a rootless session.
- :returns: C{True} if this session is of session type rootless ('R').
+ :returns: ``True`` if this session is of session type rootless ('R').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session():
@@ -2340,9 +2340,9 @@ class X2GoSession(object):
Test if this X2Go session is a desktop sharing (aka shadow) session.
- :returns: C{True} if this session is of session type shadow ('S').
+ :returns: ``True`` if this session is of session type shadow ('S').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session():
@@ -2354,9 +2354,9 @@ class X2GoSession(object):
Test if this X2Go session is a published applications session.
- :returns: C{True} if this session is of session type published applications ('P').
+ :returns: ``True`` if this session is of session type published applications ('P').
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session():
@@ -2368,9 +2368,9 @@ class X2GoSession(object):
Suspend this X2Go session.
- :returns: returns C{True} if suspending the session has been successful, C{False} otherwise
+ :returns: returns ``True`` if suspending the session has been successful, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if the session could not be suspended
"""
@@ -2391,9 +2391,9 @@ class X2GoSession(object):
Suspend this X2Go session.
- :returns: returns C{True} if suspending the session has been successful, C{False} otherwise
+ :returns: returns ``True`` if suspending the session has been successful, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if the session could not be suspended
"""
@@ -2443,9 +2443,9 @@ class X2GoSession(object):
Terminate this X2Go session.
- :returns: returns C{True} if terminating the session has been successful, C{False} otherwise
+ :returns: returns ``True`` if terminating the session has been successful, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if the session could not be terminated
"""
@@ -2466,9 +2466,9 @@ class X2GoSession(object):
Terminate this X2Go session.
- :returns: returns C{True} if terminating the session has been successful, C{False} otherwise
+ :returns: returns ``True`` if terminating the session has been successful, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if the session could not be terminated
"""
@@ -2519,7 +2519,7 @@ class X2GoSession(object):
:returns: X2Go client profile name of the session
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.profile_name
@@ -2532,7 +2532,7 @@ class X2GoSession(object):
:returns: the session profile's id
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.profile_id
@@ -2544,13 +2544,13 @@ class X2GoSession(object):
def session_ok(self):
"""\
- Test if this C{X2GoSession} is
+ Test if this ``X2GoSession`` is
in a healthy state.
- :returns: C{True} if session is ok, C{False} otherwise
+ :returns: ``True`` if session is ok, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self.has_terminal_session():
@@ -2565,7 +2565,7 @@ class X2GoSession(object):
:returns: the session's color depth (as found in the session name)
- :rtype: C{str}
+ :rtype: ``str``
"""
try:
@@ -2579,10 +2579,10 @@ class X2GoSession(object):
Check if this session will display properly with the local screen's color depth.
- :returns: C{True} if the session will display on this client screen,
- C{False} otherwise. If no terminal session is yet registered with this session, C{None} is returned.
+ :returns: ``True`` if the session will display on this client screen,
+ ``False`` otherwise. If no terminal session is yet registered with this session, ``None`` is returned.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
_depth_local = utils.local_color_depth()
@@ -2601,9 +2601,9 @@ class X2GoSession(object):
remote X2Go server.
- :returns: C{True} if session is connected, C{False} otherwise
+ :returns: ``True`` if session is connected, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self.connected = bool(self.control_session and self.control_session.is_connected())
@@ -2619,10 +2619,10 @@ class X2GoSession(object):
"""\
Test if the L{X2GoSession}'s terminal session is up and running.
- :param update_status: if C{True}, the status is updated by a server call (Default value = False)
- :type update_status: C{bool}
- :returns: C{True} if session is running, C{False} otherwise
- :rtype: C{bool}
+ :param update_status: if ``True``, the status is updated by a server call (Default value = False)
+ :type update_status: ``bool``
+ :returns: ``True`` if session is running, ``False`` otherwise
+ :rtype: ``bool``
"""
if not update_status:
@@ -2643,10 +2643,10 @@ class X2GoSession(object):
"""\
Test if the L{X2GoSession}'s terminal session is in suspended state.
- :param update_status: if C{True}, the status is updated by a server call (Default value = False)
- :type update_status: C{bool}
- :returns: C{True} if session is suspended, C{False} otherwise
- :rtype: C{bool}
+ :param update_status: if ``True``, the status is updated by a server call (Default value = False)
+ :type update_status: ``bool``
+ :returns: ``True`` if session is suspended, ``False`` otherwise
+ :rtype: ``bool``
"""
if not update_status:
@@ -2667,10 +2667,10 @@ class X2GoSession(object):
"""\
Test if the L{X2GoSession}'s terminal session has terminated.
- :param update_status: if C{True}, the status is updated by a server call (Default value = False)
- :type update_status: C{bool}
- :returns: C{True} if session has terminated, C{False} otherwise
- :rtype: C{bool}
+ :param update_status: if ``True``, the status is updated by a server call (Default value = False)
+ :type update_status: ``bool``
+ :returns: ``True`` if session has terminated, ``False`` otherwise
+ :rtype: ``bool``
"""
if not update_status:
@@ -2692,9 +2692,9 @@ class X2GoSession(object):
Test if the remote session allows sharing of local folders with the session.
- :returns: returns C{True} if local folder sharing is available in the remote session
+ :returns: returns ``True`` if local folder sharing is available in the remote session
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if self._SUPPORTED_FOLDERSHARING and self.allow_share_local_folders:
@@ -2725,14 +2725,14 @@ class X2GoSession(object):
:param local_path: the full path to an existing folder on the local
file system (Default value = None)
- :type local_path: C{str}
- :param folder_name: synonymous to C{local_path} (Default value = None)
- :type folder_name: C{str}
+ :type local_path: ``str``
+ :param folder_name: synonymous to ``local_path`` (Default value = None)
+ :type folder_name: ``str``
:param update_exported_folders: do an update of the session profile option ,,export'' after the operation (Default value = True)
- :type update_exported_folders: C{bool}
- :returns: returns C{True} if the local folder has been successfully mounted within
+ :type update_exported_folders: ``bool``
+ :returns: returns ``True`` if the local folder has been successfully mounted within
this X2Go session
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if this L{X2GoSession} does not have an associated terminal session
"""
@@ -2788,10 +2788,10 @@ class X2GoSession(object):
Share all local folders configured to be mounted within this X2Go session.
:param update_exported_folders: do an update of the session profile option ,,export'' after the operation (Default value = True)
- :type update_exported_folders: C{bool}
- :returns: returns C{True} if all local folders could be successfully mounted
+ :type update_exported_folders: ``bool``
+ :returns: returns ``True`` if all local folders could be successfully mounted
inside this X2Go session
- :rtype: C{bool}
+ :rtype: ``bool``
"""
retval = False
@@ -2827,12 +2827,12 @@ class X2GoSession(object):
:param local_path: the full path to an existing folder on the local
file system that is mounted in this X2Go session and shall be
unmounted (Default value = None)
- :type local_path: C{str}
+ :type local_path: ``str``
:param update_exported_folders: do an update of the session profile option ,,export'' after the operation (Default value = True)
- :type update_exported_folders: C{bool}
- :returns: returns C{True} if all local folders could be successfully unmounted
+ :type update_exported_folders: ``bool``
+ :returns: returns ``True`` if all local folders could be successfully unmounted
inside this X2Go session
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if this L{X2GoSession} does not have an associated terminal session
"""
@@ -2868,12 +2868,12 @@ class X2GoSession(object):
:param force_all: Really unmount _all_ shared folders, including the print spool folder and
the MIME box spool dir (not recommended). (Default value = False)
- :type force_all: C{bool}
+ :type force_all: ``bool``
:param update_exported_folders: do an update of the session profile option ,,export'' after the operation (Default value = True)
- :type update_exported_folders: C{bool}
- :returns: returns C{True} if all local folders could be successfully unmounted
+ :type update_exported_folders: ``bool``
+ :returns: returns ``True`` if all local folders could be successfully unmounted
inside this X2Go session
- :rtype: C{bool}
+ :rtype: ``bool``
:raises X2GoSessionException: if this L{X2GoSession} does not have an associated terminal session
"""
@@ -2903,13 +2903,13 @@ class X2GoSession(object):
"""\
Get a list of local folders mounted within this X2Go session from this client.
- :param check_list_mounts: if set to C{True} the list of shared folders is referenced against
+ :param check_list_mounts: if set to ``True`` the list of shared folders is referenced against
the latest status of the server-side mount list. (Default value = False)
- :type check_list_mounts: C{bool}
+ :type check_list_mounts: ``bool``
:param mounts: a server-side dictionary of session name keys and lists of mounted shares (server-side mount points) (Default value = None)
- :type mounts: C{dict}
- :returns: returns a C{list} of those local folder names that are mounted with this X2Go session.
- :rtype: C{list}
+ :type mounts: ``dict``
+ :returns: returns a ``list`` of those local folder names that are mounted with this X2Go session.
+ :rtype: ``list``
"""
if self.is_folder_sharing_available and self.is_master_session() and self.shared_folders and check_list_mounts:
@@ -2986,9 +2986,9 @@ class X2GoSession(object):
change.
- :returns: returns C{True} if the session is locked
+ :returns: returns ``True`` if the session is locked
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self._lock.locked()
diff --git a/x2go/sftpserver.py b/x2go/sftpserver.py
index f87c7b2..bf268cf 100644
--- a/x2go/sftpserver.py
+++ b/x2go/sftpserver.py
@@ -59,14 +59,14 @@ class _SSHServer(paramiko.ServerInterface):
Initialize a new sFTP server interface.
@param auth_key: Server key that the client has to authenticate against
- @type auth_key: C{paramiko.RSAKey} instance
+ @type auth_key: ``paramiko.RSAKey`` instance
@param session_instance: the calling L{X2GoSession} instance
@type session_instance: L{X2GoSession} instance
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if logger is None:
@@ -86,11 +86,11 @@ class _SSHServer(paramiko.ServerInterface):
Only allow session requests.
:param kind: request type
- :type kind: C{str}
+ :type kind: ``str``
:param chanid: channel id (unused)
- :type chanid: C{any}
+ :type chanid: ``any``
:returns: returns a Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('detected a channel request for sFTP', loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -103,11 +103,11 @@ class _SSHServer(paramiko.ServerInterface):
Ensure proper authentication.
:param username: username of incoming authentication request
- :type username: C{str}
+ :type username: ``str``
:param key: incoming SSH key to be used for authentication
- :type key: C{paramiko.RSAKey} instance
+ :type key: ``paramiko.RSAKey`` instance
:returns: returns a Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server %s: username is %s' % (self, self.current_local_user), loglevel=log.loglevel_DEBUG)
@@ -123,9 +123,9 @@ class _SSHServer(paramiko.ServerInterface):
Only allow public key authentication.
:param username: username of incoming authentication request
- :type username: C{str}
- :returns: statically returns C{publickey} as auth mechanism
- :rtype: C{str}
+ :type username: ``str``
+ :returns: statically returns ``publickey`` as auth mechanism
+ :rtype: ``str``
"""
self.logger('sFTP client asked for support auth methods, answering: publickey', loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -143,9 +143,9 @@ class _SFTPHandle(paramiko.SFTPHandle):
Create an SFTPAttributes object from an existing stat object (an object returned by os.stat).
- :returns: new C{SFTPAttributes} object with the same attribute fields.
+ :returns: new ``SFTPAttributes`` object with the same attribute fields.
- :rtype: C{obj}
+ :rtype: ``obj``
"""
try:
@@ -164,17 +164,17 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
"""\
Make user information accessible as well as set chroot jail directory.
- @param server: a C{paramiko.ServerInterface} instance to use with this SFTP server interface
- @type server: C{paramiko.ServerInterface} instance
+ @param server: a ``paramiko.ServerInterface`` instance to use with this SFTP server interface
+ @type server: ``paramiko.ServerInterface`` instance
@param chroot: chroot environment for this SFTP interface
- @type chroot: C{str}
+ @type chroot: ``str``
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
- @param server_event: a C{threading.Event} instance that can signal SFTP session termination
- @type server_event: C{threading.Event} instance
+ @type loglevel: ``int``
+ @param server_event: a ``threading.Event`` instance that can signal SFTP session termination
+ @type server_event: ``threading.Event`` instance
"""
if logger is None:
@@ -193,9 +193,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
chroot path name (/windrive/<drive_letter>/path/to/file/or/folder).
:param path: path name within chroot
- :type path: C{str}
+ :type path: ``str``
:returns: real path name (including drive letter on Windows systems)
- :rtype: C{str}
+ :rtype: ``str``
"""
if defaults.X2GOCLIENT_OS == 'Windows' and path.startswith('/windrive'):
@@ -214,9 +214,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
List the contents of a folder.
:param path: path to folder
- :type path: C{str}
+ :type path: ``str``
:returns: returns the folder contents, on failure returns a Paramiko/SSH return code
- :rtype: C{dict} or C{int}
+ :rtype: ``dict`` or ``int``
"""
path = self._realpath(path)
@@ -246,9 +246,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Stat on a file.
:param path: path to file/folder
- :type path: C{str}
+ :type path: ``str``
:returns: returns the file's stat output, on failure: returns a Paramiko/SSH return code
- :rtype: C{class} or C{int}
+ :rtype: ``class`` or ``int``
"""
path = self._realpath(path)
@@ -264,9 +264,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
LStat on a file.
:param path: path to folder
- :type path: C{str}
+ :type path: ``str``
:returns: returns the file's lstat output, on failure: returns a Paramiko/SSH return code
- :rtype: C{class} or C{int}
+ :rtype: ``class`` or ``int``
"""
path = self._realpath(path)
@@ -282,13 +282,13 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Open a file for reading, writing, appending etc.
:param path: path to file
- :type path: C{str}
+ :type path: ``str``
:param flags: file flags
- :type flags: C{str}
+ :type flags: ``str``
:param attr: file attributes
- :type attr: C{class}
+ :type attr: ``class``
:returns: file handle/object for remote file, on failure: returns a Paramiko/SSH return code
- :rtype: L{_SFTPHandle} instance or C{int}
+ :rtype: L{_SFTPHandle} instance or ``int``
"""
path = self._realpath(path)
@@ -338,9 +338,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Remove a file.
:param path: path to file
- :type path: C{str}
+ :type path: ``str``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
path = self._realpath(path)
@@ -353,11 +353,11 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Rename/move a file.
:param oldpath: old path/location/file name
- :type oldpath: C{str}
+ :type oldpath: ``str``
:param newpath: new path/location/file name
- :type newpath: C{str}
+ :type newpath: ``str``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server %s: renaming path from %s to %s' % (self, oldpath, newpath), loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -375,11 +375,11 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Make a directory.
:param path: path to new folder
- :type path: C{str}
+ :type path: ``str``
:param attr: file attributes
- :type attr: C{class}
+ :type attr: ``class``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server: creating new dir (perms: %s): %s' % (attr.st_mode, path), loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -396,9 +396,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Remove a directory (if needed recursively).
:param path: folder to be removed
- :type path: C{str}
+ :type path: ``str``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server %s: removing dir: %s' % (self, path), loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -415,11 +415,11 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Change file attributes.
:param path: path of file/folder
- :type path: C{str}
+ :type path: ``str``
:param attr: new file attributes
- :type attr: C{class}
+ :type attr: ``class``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server %s: modifying attributes of path: %s' % (self, path), loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -439,11 +439,11 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Create a symbolic link.
:param target_path: link shall point to this path
- :type target_path: C{str}
+ :type target_path: ``str``
:param path: link location
- :type path: C{str}
+ :type path: ``str``
:returns: returns Paramiko/SSH return code
- :rtype: C{int}
+ :rtype: ``int``
"""
self.logger('sFTP server %s: creating symlink from: %s to target: %s' % (self, path, target_path), loglevel=log.loglevel_DEBUG_SFTPXFER)
@@ -462,9 +462,9 @@ class _SFTPServerInterface(paramiko.SFTPServerInterface):
Read the target of a symbolic link.
:param path: path of symbolic link
- :type path: C{str}
+ :type path: ``str``
:returns: target location of the symbolic link, on failure: returns a Paramiko/SSH return code
- :rtype: C{str} or C{int}
+ :rtype: ``str`` or ``int``
"""
path = self._realpath(path)
@@ -500,18 +500,18 @@ class X2GoRevFwTunnelToSFTP(rforward.X2GoRevFwTunnel):
@param server_port: the TCP/IP port on the X2Go server (starting point of the tunnel),
normally some number above 30000
- @type server_port: C{int}
+ @type server_port: ``int``
@param ssh_transport: the L{X2GoSession}'s Paramiko/SSH transport instance
- @type ssh_transport: C{paramiko.Transport} instance
+ @type ssh_transport: ``paramiko.Transport`` instance
@param auth_key: Paramiko/SSH RSAkey object that has to be authenticated against by
the remote sFTP client
- @type auth_key: C{paramiko.RSAKey} instance
+ @type auth_key: ``paramiko.RSAKey`` instance
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoRevFwTunnelToSFTP} constructor
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
self.ready = False
@@ -544,7 +544,7 @@ class X2GoRevFwTunnelToSFTP(rforward.X2GoRevFwTunnel):
L{X2GoRevFwTunnelToSFTP.run()} waits for notifications of an appropriate incoming
Paramiko/SSH channel (issued by L{X2GoRevFwTunnelToSFTP.notify()}). Appropriate in
this context means, that its starting point on the X2Go server matches the class's
- property C{server_port}.
+ property ``server_port``.
Once a new incoming channel gets announced by the L{notify()} method, a new
L{X2GoRevFwSFTPChannelThread} instance will be initialized. As a data stream handler,
@@ -552,7 +552,7 @@ class X2GoRevFwTunnelToSFTP(rforward.X2GoRevFwTunnel):
The channel will last till the connection gets dropped on the X2Go server side or
until the tunnel gets paused by an L{X2GoRevFwTunnelToSFTP.pause()} call or
- stopped via the C{X2GoRevFwTunnelToSFTP.stop_thread()} method.
+ stopped via the ``X2GoRevFwTunnelToSFTP.stop_thread()`` method.
"""
@@ -604,9 +604,9 @@ def x2go_rev_forward_sftpchannel_handler(chan=None, auth_key=None, logger=None):
:type chan: paramiko.Channel instance
:param auth_key: Paramiko/SSH RSAkey object that has to be authenticated against by
the remote sFTP client (Default value = None)
- :type auth_key: C{paramiko.RSAKey} instance
+ :type auth_key: ``paramiko.RSAKey`` instance
:param logger: you must pass an L{X2GoLogger} object to this handler method (Default value = None)
- :type logger: C{X2GoLogger} instance
+ :type logger: ``X2GoLogger`` instance
"""
if logger is None:
diff --git a/x2go/sshproxy.py b/x2go/sshproxy.py
index 23162ed..c36ca0a 100644
--- a/x2go/sshproxy.py
+++ b/x2go/sshproxy.py
@@ -78,67 +78,67 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
are NATted behind routers).
@param username: login user name to be used on the SSH proxy host
- @type username: C{str}
+ @type username: ``str``
@param password: user's password on the SSH proxy host, with private key authentication it will be
used to unlock the key (if needed)
- @type password: C{str}
+ @type password: ``str``
@param passphrase: a passphrase to use for unlocking
a private key in case the password is already needed for two-factor
authentication
@type passphrase: {str}
@param key_filename: name of a SSH private key file
- @type key_filename: C{str}
+ @type key_filename: ``str``
@param pkey: a private DSA/RSA key object (as provided by Paramiko/SSH)
- @type pkey: C{RSA/DSA key instance}
+ @type pkey: ``RSA/DSA key instance``
@param force_password_auth: enforce password authentication even if a key(file) is present
- @type force_password_auth: C{bool}
+ @type force_password_auth: ``bool``
@param look_for_keys: look for key files with standard names and try those if any can be found
- @type look_for_keys: C{bool}
+ @type look_for_keys: ``bool``
@param allow_agent: try authentication via a locally available SSH agent
- @type allow_agent: C{bool}
- @param local_host: bind SSH tunnel to the C{local_host} IP socket address (default: localhost)
- @type local_host: C{str}
+ @type allow_agent: ``bool``
+ @param local_host: bind SSH tunnel to the ``local_host`` IP socket address (default: localhost)
+ @type local_host: ``str``
@param local_port: IP socket port to bind the SSH tunnel to (default; 22022)
- @type local_port: C{int}
+ @type local_port: ``int``
@param remote_host: remote endpoint of the SSH proxying/forwarding tunnel (default: localhost)
- @type remote_host: C{str}
+ @type remote_host: ``str``
@param remote_port: remote endpoint's IP socket port for listening SSH daemon (default: 22)
- @type remote_port: C{int}
- @param known_hosts: full path to a custom C{known_hosts} file
- @type known_hosts: C{str}
- @param add_to_known_hosts: automatically add host keys of unknown SSH hosts to the C{known_hosts} file
- @type add_to_known_hosts: C{bool}
- @param hostname: alias for C{local_host}
- @type hostname: C{str}
- @param port: alias for C{local_port}
- @type port: C{int}
- @param sshproxy_host: alias for C{hostname}
- @type sshproxy_host: C{str}
- @param sshproxy_port: alias for C{post}
- @type sshproxy_port: C{int}
- @param sshproxy_user: alias for C{username}
- @type sshproxy_user: C{str}
- @param sshproxy_password: alias for C{password}
- @type sshproxy_password: C{str}
- @param sshproxy_passphrase: alias for C{passphrase}
- @type sshproxy_passphrase: C{str}
- @param sshproxy_key_filename: alias for C{key_filename}
- @type sshproxy_key_filename: C{str}
- @param sshproxy_pkey: alias for C{pkey}
- @type sshproxy_pkey: C{RSA/DSA key instance} (Paramiko)
- @param sshproxy_force_password_auth: alias for C{force_password_auth}
- @type sshproxy_force_password_auth: C{bool}
- @param sshproxy_look_for_keys: alias for C{look_for_keys}
- @type sshproxy_look_for_keys: C{bool}
- @param sshproxy_allow_agent: alias for C{allow_agent}
- @type sshproxy_allow_agent: C{bool}
+ @type remote_port: ``int``
+ @param known_hosts: full path to a custom ``known_hosts`` file
+ @type known_hosts: ``str``
+ @param add_to_known_hosts: automatically add host keys of unknown SSH hosts to the ``known_hosts`` file
+ @type add_to_known_hosts: ``bool``
+ @param hostname: alias for ``local_host``
+ @type hostname: ``str``
+ @param port: alias for ``local_port``
+ @type port: ``int``
+ @param sshproxy_host: alias for ``hostname``
+ @type sshproxy_host: ``str``
+ @param sshproxy_port: alias for ``post``
+ @type sshproxy_port: ``int``
+ @param sshproxy_user: alias for ``username``
+ @type sshproxy_user: ``str``
+ @param sshproxy_password: alias for ``password``
+ @type sshproxy_password: ``str``
+ @param sshproxy_passphrase: alias for ``passphrase``
+ @type sshproxy_passphrase: ``str``
+ @param sshproxy_key_filename: alias for ``key_filename``
+ @type sshproxy_key_filename: ``str``
+ @param sshproxy_pkey: alias for ``pkey``
+ @type sshproxy_pkey: ``RSA/DSA key instance`` (Paramiko)
+ @param sshproxy_force_password_auth: alias for ``force_password_auth``
+ @type sshproxy_force_password_auth: ``bool``
+ @param sshproxy_look_for_keys: alias for ``look_for_keys``
+ @type sshproxy_look_for_keys: ``bool``
+ @param sshproxy_allow_agent: alias for ``allow_agent``
+ @type sshproxy_allow_agent: ``bool``
@param sshproxy_tunnel: a string of the format <local_host>:<local_port>:<remote_host>:<remote_port>
- which will override---if used---the options: C{local_host}, C{local_port}, C{remote_host} and C{remote_port}
- @type sshproxy_tunnel: C{str}
+ which will override---if used---the options: ``local_host``, ``local_port``, ``remote_host`` and ``remote_port``
+ @type sshproxy_tunnel: ``str``
@param ssh_rootdir: local user's SSH base directory (default: ~/.ssh)
- @type ssh_rootdir: C{str}
+ @type ssh_rootdir: ``str``
@param session_instance: the L{X2GoSession} instance that builds up this SSH proxying tunnel
@type session_instance: L{X2GoSession} instance
@param logger: you can pass an L{X2GoLogger} object to the
@@ -148,8 +148,8 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
constructed with the given loglevel
@type loglevel: int
- @raise X2GoSSHProxyAuthenticationException: if the SSH proxy caused a C{paramiko.AuthenticationException}
- @raise X2GoSSHProxyException: if the SSH proxy caused a C{paramiko.SSHException}
+ @raise X2GoSSHProxyAuthenticationException: if the SSH proxy caused a ``paramiko.AuthenticationException``
+ @raise X2GoSSHProxyException: if the SSH proxy caused a ``paramiko.SSHException``
"""
if logger is None:
self.logger = log.X2GoLogger(loglevel=loglevel)
@@ -439,7 +439,7 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
:returns: local IP socket address
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.local_host
@@ -451,7 +451,7 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
:returns: local IP socket port
- :rtype: C{int}
+ :rtype: ``int``
"""
return self.local_port
@@ -463,7 +463,7 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
:returns: remote IP socket address
- :rtype: C{str}
+ :rtype: ``str``
"""
return self.remote_host
@@ -475,7 +475,7 @@ class X2GoSSHProxy(paramiko.SSHClient, threading.Thread):
:returns: remote SSH port
- :rtype: C{int}
+ :rtype: ``int``
"""
return self.remote_port
diff --git a/x2go/telekinesis.py b/x2go/telekinesis.py
index 268a67e..70aaca4 100644
--- a/x2go/telekinesis.py
+++ b/x2go/telekinesis.py
@@ -73,16 +73,16 @@ class X2GoTelekinesisClient(threading.Thread):
session_instance=None,
logger=None, loglevel=log.loglevel_DEFAULT, ):
"""\
- @param session_info: session information provided as an C{X2GoServerSessionInfo*} backend
+ @param session_info: session information provided as an ``X2GoServerSessionInfo*`` backend
instance
- @type session_info: C{X2GoServerSessionInfo*} instance
- @param ssh_transport: SSH transport object from C{paramiko.SSHClient}
- @type ssh_transport: C{paramiko.Transport} instance
+ @type session_info: ``X2GoServerSessionInfo*`` instance
+ @param ssh_transport: SSH transport object from ``paramiko.SSHClient``
+ @type ssh_transport: ``paramiko.Transport`` instance
@param sessions_rootdir: base dir where X2Go session files are stored (by default: ~/.x2go)
- @type sessions_rootdir: C{str}
+ @type sessions_rootdir: ``str``
@param logger: you can pass an L{X2GoLogger} object to the
L{X2GoTelekinesisClient} constructor
- @param session_instance: the L{X2GoSession} instance this C{X2GoProxy*} instance belongs to
+ @param session_instance: the L{X2GoSession} instance this ``X2GoProxy*`` instance belongs to
@type session_instance: L{X2GoSession} instance
@type logger: L{X2GoLogger} instance
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
@@ -143,9 +143,9 @@ class X2GoTelekinesisClient(threading.Thread):
Test if the Telekinesis client command is installed on this machine.
- :returns: C{True} if the Telekinesis client command is available
+ :returns: ``True`` if the Telekinesis client command is available
- :rtype: C{bool}
+ :rtype: ``bool``
"""
###
@@ -303,7 +303,7 @@ class X2GoTelekinesisClient(threading.Thread):
:returns: a subprocess instance that knows about the externally started Telekinesis client command.
- :rtype: C{obj}
+ :rtype: ``obj``
"""
self.logger('starting local Telekinesis client...', loglevel=log.loglevel_INFO)
@@ -414,9 +414,9 @@ class X2GoTelekinesisClient(threading.Thread):
Check if a proxy instance is up and running.
- :returns: Proxy state, C{True} for proxy being up-and-running, C{False} otherwise
+ :returns: Proxy state, ``True`` for proxy being up-and-running, ``False`` otherwise
- :rtype: C{bool}
+ :rtype: ``bool``
"""
return bool(self.tekiclient and self.tekiclient.poll() is None) and self.fw_ctrl_tunnel.is_active and self.fw_data_tunnel.is_active
diff --git a/x2go/utils.py b/x2go/utils.py
index 5d17f43..29f43fc 100644
--- a/x2go/utils.py
+++ b/x2go/utils.py
@@ -67,9 +67,9 @@ def is_in_nx3packmethods(method):
Test if a given compression method is valid for NX3 Proxy.
:param method: name of an NXv3 pack method
- :type method: C{str}
- :returns: C{True} if C{method} is in the hard-coded list of NX3 compression methods.
- :rtype: C{bool}
+ :type method: ``str``
+ :returns: ``True`` if ``method`` is in the hard-coded list of NX3 compression methods.
+ :rtype: ``bool``
"""
return method in pack_methods_nx3
@@ -78,14 +78,14 @@ def is_in_nx3packmethods(method):
def find_session_line_in_x2golistsessions(session_name, stdout):
"""\
Return the X2Go session meta information as returned by the
- C{x2golistsessions} server command for session C{session_name}.
+ ``x2golistsessions`` server command for session ``session_name``.
:param session_name: name of a session
- :type session_name: C{str}
+ :type session_name: ``str``
:param stdout: raw output from the ,,x2golistsessions'' command, as list of strings
- :type stdout: C{list}
- :returns: the output line that contains C{<session_name>}
- :rtype: C{str} or C{None}
+ :type stdout: ``list``
+ :returns: the output line that contains ``<session_name>``
+ :rtype: ``str`` or ``None``
"""
sessions = stdout.read().split("\n")
@@ -104,9 +104,9 @@ def slugify(value):
converts spaces to hyphens and replaces round brackets by pointed brackets.
:param value: a string that shall be sluggified
- :type value: C{str}
+ :type value: ``str``
:returns: the sluggified string
- :rtype: C{str}
+ :rtype: ``str``
"""
import unicodedata
@@ -123,7 +123,7 @@ def _genSessionProfileId():
:returns: profile ID
- :rtype: C{str}
+ :rtype: ``str``
"""
import datetime
@@ -135,9 +135,9 @@ def _checkIniFileDefaults(data_structure):
Check an ini file data structure passed on by a user app or class.
:param data_structure: an ini file date structure
- :type data_structure: C{dict} of C{dict}s
- :returns: C{True} if C{data_structure} matches that of an ini file data structure
- :rtype: C{bool}
+ :type data_structure: ``dict`` of ``dict``s
+ :returns: ``True`` if ``data_structure`` matches that of an ini file data structure
+ :rtype: ``bool``
"""
if data_structure is None:
@@ -155,9 +155,9 @@ def _checkSessionProfileDefaults(data_structure):
Check the data structure of a default session profile passed by a user app.
:param data_structure: an ini file date structure
- :type data_structure: C{dict} of C{dict}s
- :returns: C{True} if C{data_structure} matches that of an ini file data structure
- :rtype: C{bool}
+ :type data_structure: ``dict`` of ``dict``s
+ :returns: ``True`` if ``data_structure`` matches that of an ini file data structure
+ :rtype: ``bool``
"""
if data_structure is None:
@@ -173,9 +173,9 @@ def _convert_SessionProfileOptions_2_SessionParams(options):
Python X2Go session parameters.
:param options: a dictionary of options, parameter names as in the X2Go ,,sessions'' file
- :type options: C{dict}
- :returns: session options as used in C{X2GoSession} instances
- :rtype: C{dict}
+ :type options: ``dict``
+ :returns: session options as used in ``X2GoSession`` instances
+ :rtype: ``dict``
"""
_params = copy.deepcopy(options)
@@ -386,9 +386,9 @@ def session_names_by_timestamp(session_infos):
Sorts session profile names by their timestamp (as used in the file format's section name).
:param session_infos: a dictionary of session infos as reported by L{X2GoClient.list_sessions()}
- :type session_infos: C{dict}
- :returns: a timestamp-sorted list of session names found in C{session_infos}
- :rtype: C{list}
+ :type session_infos: ``dict``
+ :returns: a timestamp-sorted list of session names found in ``session_infos``
+ :rtype: ``list``
"""
session_names = list(session_infos.keys())
@@ -402,9 +402,9 @@ def touch_file(filename, mode='a'):
Imitates the behaviour of the GNU/touch command.
:param filename: name of the file to touch
- :type filename: C{str}
+ :type filename: ``str``
:param mode: the file mode (as used for Python file objects) (Default value = 'a')
- :type mode: C{str}
+ :type mode: ``str``
"""
if not os.path.isdir(os.path.dirname(filename)):
@@ -418,9 +418,9 @@ def unique(seq):
Imitates the behaviour of the GNU/uniq command.
:param seq: a list/sequence containing consecutive duplicates.
- :type seq: C{list}
+ :type seq: ``list``
:returns: list that has been clean up from the consecutive duplicates
- :rtype: C{list}
+ :rtype: ``list``
"""
# order preserving
@@ -456,9 +456,9 @@ def patiently_remove_file(dirname, filename):
Try to remove a file, wait for unlocking, remove it once removing is possible...
:param dirname: directory name the file is in
- :type dirname: C{str}
+ :type dirname: ``str``
:param filename: name of the file to be removed
- :type filename: C{str}
+ :type filename: ``str``
"""
_not_removed = True
@@ -476,11 +476,11 @@ def detect_unused_port(bind_address='127.0.0.1', preferred_port=None):
Detect an unused IP socket.
:param bind_address: IP address to bind to (Default value = '127.0.0.1')
- :type bind_address: C{str}
+ :type bind_address: ``str``
:param preferred_port: IP socket port that shall be tried first for availability (Default value = None)
- :type preferred_port: C{str}
+ :type preferred_port: ``str``
:returns: free local IP socket port that can be used for binding
- :rtype: C{str}
+ :rtype: ``str``
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
@@ -503,7 +503,7 @@ def get_encoding():
:returns: The system's local character encoding.
- :rtype: C{str}
+ :rtype: ``str``
"""
try:
@@ -523,9 +523,9 @@ def is_abs_path(path):
Test if a given path is an absolute path name.
:param path: test this path for absolutism...
- :type path: C{str}
- :returns: Returns C{True} if path is an absolute path name
- :rtype: C{bool}
+ :type path: ``str``
+ :returns: Returns ``True`` if path is an absolute path name
+ :rtype: ``bool``
"""
return bool((path.startswith('/') or re.match('^[%s]\:\\\\' % string.ascii_letters, path)))
@@ -538,7 +538,7 @@ def xkb_rules_names():
:returns: A Python dictionary that contains the current X11 keyboard rules.
- :rtype: C{dict}
+ :rtype: ``dict``
"""
p = subprocess.Popen(['xprop', '-root', '_XKB_RULES_NAMES',], stdout=subprocess.PIPE, )
@@ -559,7 +559,7 @@ def local_color_depth():
:returns: the local color depth in bits
- :rtype: C{int}
+ :rtype: ``int``
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -588,11 +588,11 @@ def is_color_depth_ok(depth_session, depth_local):
local screen's color depth.
:param depth_session: color depth of the session
- :type depth_session: C{int}
+ :type depth_session: ``int``
:param depth_local: color depth of local screen
- :type depth_local: C{int}
+ :type depth_local: ``int``
:returns: Does the session color depth work with the local display?
- :rtype: C{bool}
+ :rtype: ``bool``
"""
if depth_session == 0:
@@ -611,9 +611,9 @@ def find_session_window(session_name):
Find a session window by its X2GO session ID.
:param session_name: session name/ID of an X2Go session window
- :type session_name: C{str}
+ :type session_name: ``str``
:returns: the window object (or ID) of the searched for session window
- :rtype: C{obj} on Unix, C{int} on Windows
+ :rtype: ``obj`` on Unix, ``int`` on Windows
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -667,7 +667,7 @@ def get_desktop_geometry():
:returns: a (<width>, <height>) tuple will be returned
- :rtype: C{tuple}
+ :rtype: ``tuple``
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -688,7 +688,7 @@ def get_workarea_geometry():
:returns: a (<width>, <height>) tuple will be returned
- :rtype: C{tuple}
+ :rtype: ``tuple``
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -708,9 +708,9 @@ def set_session_window_title(session_window, session_title):
Set title of session window.
:param session_window: session window instance
- :type session_window: C{obj}
- :param session_title: session title to be set for C{session_window}
- :type session_title: C{str}
+ :type session_window: ``obj``
+ :param session_title: session title to be set for ``session_window``
+ :type session_title: ``str``
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -730,7 +730,7 @@ def raise_session_window(session_window):
Raise session window. Not functional for Unix-like operating systems.
:param session_window: session window instance
- :type session_window: C{obj}
+ :type session_window: ``obj``
"""
if _X2GOCLIENT_OS != 'Windows':
@@ -745,11 +745,11 @@ def merge_ordered_lists(l1, l2):
Merge sort two sorted lists
:param l1: first sorted list
- :type l1: C{list}
+ :type l1: ``list``
:param l2: second sorted list
- :type l2: C{list}
+ :type l2: ``list``
:returns: the merge result of both sorted lists
- :rtype: C{list}
+ :rtype: ``list``
"""
ordered_list = []
@@ -778,15 +778,15 @@ def merge_ordered_lists(l1, l2):
def compare_versions(version_a, op, version_b):
"""\
Compare <version_a> with <version_b> using operator <op>.
- In the background C{distutils.version.LooseVersion} is
+ In the background ``distutils.version.LooseVersion`` is
used for the comparison operation.
:param version_a: a version string
- :type version_a: C{str}
+ :type version_a: ``str``
:param op: an operator provide as string (e.g. '<', '>', '==', '>=' etc.)
- :type op: C{str}
+ :type op: ``str``
:param version_b: another version string that is to be compared with <version_a>
- :type version_b: C{str}
+ :type version_b: ``str``
"""
@@ -806,9 +806,9 @@ class ProgressStatus(object):
def __init__(self, progress_event, progress_func=list(range(0, 100, 10))):
"""\
@param progress_event: a threading.Event() object that gets notified on progress
- @type progress_event: C{obj}
+ @type progress_event: ``obj``
@param progress_func: a function that delivers a value between 0 and 100 (progress percentage value)
- @type progress_func: C{func}
+ @type progress_func: ``func``
"""
self.ev = progress_event
@@ -860,11 +860,11 @@ def genkeypair(local_username, client_address, key_type='RSA'):
Generate an SSH pub/priv key pair without writing the private key to file.
:param local_username: the key is for this user
- :type local_username: C{unicode}
+ :type local_username: ``unicode``
:param client_address: the key is only valid for this client
- :type client_address: C{unicode}
+ :type client_address: ``unicode``
:param key_type: either of: RSA, DSA (Default value = 'RSA')
- :type key_type: C{unicode}
+ :type key_type: ``unicode``
"""
key = None
@@ -896,9 +896,9 @@ def which(basename):
Python equivalent to the shell command "which".
:param basename: the basename of an application to be search for in $PATH
- :type basename: C{str}
+ :type basename: ``str``
:returns: full path to the application
- :rtype: C{str}
+ :rtype: ``str``
"""
if _X2GOCLIENT_OS == 'Windows':
diff --git a/x2go/xserver.py b/x2go/xserver.py
index 33e3970..9d79582 100644
--- a/x2go/xserver.py
+++ b/x2go/xserver.py
@@ -59,7 +59,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
def __init__(self, config_files=_X2GO_XCONFIG_CONFIGFILES, defaults=_X2GO_CLIENTXCONFIG_DEFAULTS, logger=None, loglevel=log.loglevel_DEFAULT):
"""\
Constructs an L{X2GoClientXConfig} instance. This is normally done by an L{X2GoClient} instance.
- You can retrieve this L{X2GoClientXConfig} instance with the C{X2GoClient.get_client_xconfig()}
+ You can retrieve this L{X2GoClientXConfig} instance with the ``X2GoClient.get_client_xconfig()``
method.
On construction the L{X2GoClientXConfig} instance is filled with values from the configuration files::
@@ -68,18 +68,18 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
~/.x2goclient/xconfig
The files are read in the specified order and config options of both files are merged. Options
- set in the user configuration file (C{~/.x2goclient/xconfig}) override global options set in
- C{/etc/x2goclient/xconfig}.
+ set in the user configuration file (``~/.x2goclient/xconfig``) override global options set in
+ ``/etc/x2goclient/xconfig``.
@param config_files: a list of configuration file names
- @type config_files: C{list}
+ @type config_files: ``list``
@param defaults: a Python dictionary with configuration file defaults (use on your own risk)
- @type defaults: C{dict}
+ @type defaults: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if _X2GOCLIENT_OS not in ("Windows"):
@@ -100,13 +100,13 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
"""\
Store the Xserver configuration to the storage backend (i.e. on disk).
- For writing the first of the C{config_files} specified on instance construction
+ For writing the first of the ``config_files`` specified on instance construction
that is writable will be used.
- :returns: C{True} if the user config file has been successfully written, C{False} otherwise.
+ :returns: ``True`` if the user config file has been successfully written, ``False`` otherwise.
- :rtype: C{bool}
+ :rtype: ``bool``
"""
self._write_user_config = self.write_user_config
@@ -117,9 +117,9 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
Retrieve the XServer configuration (from the xconfig file) for the given XServer application.
:param xserver_name: name of the XServer application
- :type xserver_name: C{str}
+ :type xserver_name: ``str``
:returns: A Python dictionary containing the XServer's configuration settings
- :rtype: C{list}
+ :rtype: ``list``
"""
_xserver_config = {}
@@ -177,7 +177,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
def xserver_launch_possible(self):
"""\
Detect if there is an XServer (that is known to Python X2Go) installed on the system.
- Equals C{True} if we have found an installed XServer that we can launch.
+ Equals ``True`` if we have found an installed XServer that we can launch.
"""
@@ -187,7 +187,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
def xserver_launch_needed(self):
"""\
Detect if an XServer launch is really needed (or if we use an already running XServer instance).
- Equals C{True} if we have to launch an XServer before we can start/resume
+ Equals ``True`` if we have to launch an XServer before we can start/resume
X2Go sessions.
@@ -202,7 +202,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
:returns: xserver_name>, <xserver_config>)
- :rtype: C{tuple}
+ :rtype: ``tuple``
"""
if self.xserver_launch_possible:
@@ -225,7 +225,7 @@ class X2GoClientXConfig(inifiles.X2GoIniFile):
to the user's X configuration file.
:param xserver_name: name of the XServer application
- :type xserver_name: C{str}
+ :type xserver_name: ``str``
"""
_default_display = self.get_xserver_config(xserver_name)['display']
@@ -285,14 +285,14 @@ class X2GoXServer(threading.Thread):
Initialize an XServer thread.
@param xserver_name: name of the XServer to start (refer to the xconfig file for available names)
- @type xserver_name: C{str}
+ @type xserver_name: ``str``
@param xserver_config: XServer configuration node (as derived from L{X2GoClientXConfig.get_xserver_config()}
- @type xserver_config: C{dict}
+ @type xserver_config: ``dict``
@param logger: you can pass an L{X2GoLogger} object to the L{X2GoClientXConfig} constructor
- @type logger: C{obj}
+ @type logger: ``obj``
@param loglevel: if no L{X2GoLogger} object has been supplied a new one will be
constructed with the given loglevel
- @type loglevel: C{int}
+ @type loglevel: ``int``
"""
if _X2GOCLIENT_OS not in ("Windows"):
--
Alioth's /home/x2go-admin/maintenancescripts/git/hooks/post-receive-email on /srv/git/code.x2go.org/python-x2go.git
More information about the x2go-commits
mailing list