[X2Go-Commits] python-x2go.git - release/0.4.0.x (branch) updated: 0.0.44.2-40-g8f96ae7
X2Go dev team
git-admin at x2go.org
Tue Jan 7 16:17:06 CET 2014
The branch, release/0.4.0.x has been updated
via 8f96ae78ee15292f4984e384b0f9e9d21b63501e (commit)
from 13a3bb439d1242f1103976a1f86448b405043d47 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
-----------------------------------------------------------------------
Summary of changes:
x2go/client.py | 4 +-
x2go/registry.py | 219 +++++++++++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 201 insertions(+), 22 deletions(-)
The diff of changes is:
diff --git a/x2go/client.py b/x2go/client.py
index 85d3600..2d17915 100644
--- a/x2go/client.py
+++ b/x2go/client.py
@@ -1998,9 +1998,9 @@ class X2goClient(object):
"""
if return_profile_names:
- return [ self.to_profile_name(p_id) for p_id in self.session_registry.connected_profiles ]
+ return [ self.to_profile_name(p_id) for p_id in self.session_registry.connected_profiles() ]
else:
- return self.session_registry.connected_profiles
+ return self.session_registry.connected_profiles()
__client_connected_profiles = client_connected_profiles
def disconnect_profile(self, profile_name):
diff --git a/x2go/registry.py b/x2go/registry.py
index 2af0e97..af5d108 100644
--- a/x2go/registry.py
+++ b/x2go/registry.py
@@ -51,13 +51,20 @@ from defaults import X2GO_SSH_ROOTDIR as _X2GO_SSH_ROOTDIR
class X2goSessionRegistry(object):
"""\
- STILL UNDOCUMENTED
+ This class is utilized by L{X2goClient} instances to maintain a good overview on
+ session status of all associated L{X2goSession} instances.
"""
def __init__(self, client_instance,
logger=None, loglevel=log.loglevel_DEFAULT):
"""\
- STILL UNDOCUMENTED
+ @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{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}
"""
if logger is None:
@@ -72,6 +79,13 @@ class X2goSessionRegistry(object):
self.control_sessions = {}
def keys(self):
+ """\
+ A list of session registry keys.
+
+ @return: session registry key list
+ @rtype: C{list}
+
+ """
return self.registry.keys()
def __repr__(self):
@@ -83,28 +97,48 @@ class X2goSessionRegistry(object):
def __call__(self, session_uuid):
"""\
- STILL UNDOCUMENTED
+ 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}
+ @return: the corresponding L{X2goSession} instance
+ @rtype: L{X2goSession} instance
"""
return self.registry[session_uuid]
def get_profile_id(self, session_uuid):
"""\
- STILL UNDOCUMENTED
+ 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}
+ @return: profile ID
+ @rtype: C{str}
"""
return self(session_uuid).get_profile_id()
def get_profile_name(self, session_uuid):
"""\
- STILL UNDOCUMENTED
+ 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}
+ @return: profile name
+ @rtype: C{str}
"""
return self(session_uuid).get_profile_name()
def session_summary(self, session_uuid, status_only=False):
"""\
- STILL UNDOCUMENTED
+ Compose a session summary (as Python dictionary).
+
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: C{str}
+ @return: session summary dictionary
+ @rtype: C{dict}
"""
_session_summary = {}
@@ -146,7 +180,20 @@ class X2goSessionRegistry(object):
def update_status(self, session_uuid=None, profile_name=None, profile_id=None, session_list=None):
"""\
- STILL UNDOCUMENTED
+ Update the session status for L{X2goSession} that is represented by a given session UUID hash,
+ profile name or profile ID.
+
+ @param session_uuid: the X2go session's UUID registry hash
+ @type session_uuid: C{str}
+ @param profile_name: alternatively, a profile name can be specified (the stati of all registered sessions for this session
+ profile will be updated)
+ @type profile_name: C{str}
+ @param profile_id: alternatively, a profile ID can be given (the stati of all registered sessions for this session
+ profile will be updated)
+ @type profile_id: C{str}
+ @param session_list: an optional C{X2goServerSessionList*} instance (as returned by the L{X2goClient.list_sessions()} command can
+ be passed to this method.
+ @type session_list: C{X2goServerSessionList*} instance
"""
if session_uuid and profile_name or session_uuid and profile_id or profile_name and profile_id:
@@ -215,7 +262,16 @@ class X2goSessionRegistry(object):
del self.registry[_session_uuid]
def register_available_server_sessions(self, profile_name, session_list=None):
+ """\
+ 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
+ be passed to this method.
+ @type session_list: C{X2goServerSessionList*} instance
+ """
_connected_sessions = self.connected_sessions_of_profile_name(profile_name=profile_name, return_objects=False)
_registered_sessions = self.registered_sessions_of_profile_name(profile_name=profile_name, return_objects=False)
_session_names = [ self(s_uuid).session_name for s_uuid in _registered_sessions if self(s_uuid).session_name is not None ]
@@ -286,7 +342,46 @@ class X2goSessionRegistry(object):
known_hosts=None,
**kwargs):
"""\
- STILL UNDOCUMENTED
+ Register a new L{X2goSession} instance with this L{X2goSessionRegistry}.
+
+ @param server: hostname of X2go server
+ @type server: C{str}
+ @param profile_id: profile ID
+ @type profile_id: C{str}
+ @param profile_name: profile name
+ @type profile_name: C{str}
+ @param session_name: session name (if available)
+ @type session_name: C{str}
+ @param control_backend: X2go control session backend to use
+ @type control_backend: C{class}
+ @param terminal_backend: X2go terminal session backend to use
+ @type terminal_backend: C{class}
+ @param info_backend: X2go session info backend to use
+ @type info_backend: C{class}
+ @param list_backend: X2go session list backend to use
+ @type list_backend: C{class}
+ @param proxy_backend: X2go proxy backend to use
+ @type proxy_backend: C{class}
+ @param profiles_backend: X2go session profiles backend to use
+ @type profiles_backend: C{class}
+ @param settings_backend: X2go client settings backend to use
+ @type settings_backend: C{class}
+ @param printing_backend: X2go client printing backend to use
+ @type printing_backend: C{class}
+ @param client_rootdir: client base dir (default: ~/.x2goclient)
+ @type client_rootdir: C{str}
+ @param sessions_rootdir: sessions base dir (default: ~/.x2go)
+ @type sessions_rootdir: C{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}
+ @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}
+ @param kwargs: all other options will be passed on to the constructor of the to-be-instantiated L{X2goSession} instance
+ @type C{dict}
"""
control_session = None
@@ -350,7 +445,12 @@ class X2goSessionRegistry(object):
def has_session_of_session_name(self, session_name):
"""\
- STILL UNDOCUMENTED
+ Detect if we know about an L{X2goSession} of name C{<session_name>}.
+
+ @param session_name: name of session to be searched for
+ @type session_name: C{str}
+ @return: C{True} if a session of C{<session_name>} has been found
+ @rtype: C{bool}
"""
try:
@@ -361,7 +461,14 @@ class X2goSessionRegistry(object):
def get_session_of_session_name(self, session_name, return_object=False):
"""\
- STILL UNDOCUMENTED
+ Retrieve the L{X2goSession} instance with session name C{<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
+ @type return_object: C{bool}
+ @return: L{X2goSession} object or its representing session UUID hash
+ @rtype: L{X2goSession} instance or C{str}
"""
found_sessions = [ s for s in self.registered_sessions() if s.session_name == session_name and s.session_name is not None ]
@@ -481,7 +588,17 @@ class X2goSessionRegistry(object):
def connected_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- STILL UNDOCUMENTED
+ 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 return_* options is specified a list of session UUID hashes will be returned.
+
+ @param profile_name: session profile name
+ @type profile_name: C{str}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
"""
if return_objects:
@@ -493,7 +610,17 @@ class X2goSessionRegistry(object):
def associated_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- STILL UNDOCUMENTED
+ For a given session profile name retrieve a list of sessions that are currently associated 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}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
"""
if return_objects:
@@ -505,7 +632,17 @@ class X2goSessionRegistry(object):
def registered_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- STILL UNDOCUMENTED
+ For a given session profile name retrieve a list of sessions that are currently registered with 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}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
"""
@@ -517,7 +654,21 @@ class X2goSessionRegistry(object):
return self.registered_sessions() and [ s.get_uuid() for s in self.registered_sessions() if s.profile_name == profile_name ]
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 return_* options is specified a list of
+ session UUID hashes will be returned.
+
+ @param profile_name: session profile name
+ @type profile_name: C{str}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
+ """
if return_objects:
return self.virgin_sessions() and [ s for s in self.virgin_sessions() if s.profile_name == profile_name ]
elif return_session_names:
@@ -525,10 +676,19 @@ class X2goSessionRegistry(object):
else:
return self.virgin_sessions() and [ s.get_uuid() for s in self.virgin_sessions() if s.profile_name == profile_name ]
-
def running_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- STILL UNDOCUMENTED
+ For a given session profile name retrieve a list of sessions that are currently running.
+ 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}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
"""
if return_objects:
@@ -540,7 +700,17 @@ class X2goSessionRegistry(object):
def suspended_sessions_of_profile_name(self, profile_name, return_objects=True, return_session_names=False):
"""\
- STILL UNDOCUMENTED
+ For a given session profile name retrieve a list of sessions that are currently in suspended 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}
+ @param return_objects: return as list of L{X2goSession} instances
+ @type return_objects: C{bool}
+ @param return_session_names: return as list of X2go session names
+ @type return_session_names: C{bool}
+ @return: a session list (as UUID hashes, objects or session names)
+ @rtype: C{list}
"""
if return_objects:
@@ -552,7 +722,12 @@ class X2goSessionRegistry(object):
def control_session_of_profile_name(self, profile_name):
"""\
- STILL UNDOCUMENTED
+ For a given session profile name retrieve a the corresponding C{X2goControlSession*} instance.
+
+ @param profile_name: session profile name
+ @type profile_name: C{str}
+ @return: contol session instance
+ @rtype: C{X2goControlSession*} instance
"""
_sessions = self.registered_sessions_of_profile_name(profile_name, return_objects=True)
@@ -564,15 +739,19 @@ class X2goSessionRegistry(object):
@property
def connected_control_sessions(self):
"""\
- STILL UNDOCUMENTED
+ Equals a list of all currently connected control sessions.
"""
return [ c for c in self.control_sessions.values() if c.is_connected() ]
- @property
def connected_profiles(self, use_paramiko=False):
"""\
- STILL UNDOCUMENTED
+ Retrieve a list of all currently connected session profiles.
+
+ @param use_paramiko: send query directly to the Paramiko/SSH layer
+ @type use_paramiko: C{bool}
+ @return: list of connected session profiles
+ @rtype: C{list}
"""
if use_paramiko:
hooks/post-receive
--
python-x2go.git (Python X2Go Client API)
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "python-x2go.git" (Python X2Go Client API).
More information about the x2go-commits
mailing list