1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 """\
21 X2goListSessionCache class - caching X2Go session information.
22
23 """
24 __NAME__ = 'x2gocache-pylib'
25
26
27 import copy
28 import gevent
29
30
31 import log
32 import x2go_exceptions
33
35 """\
36 For non-blocking operations in client applications using Python X2Go, it is
37 recommended to enable the L{X2goListSessionsCache}. This can be done by calling
38 the constructor of the L{X2goClient} class.
39
40 The session list and desktop cache gets updated in regular intervals by a threaded
41 L{X2goSessionGuardian} instance. For the session list and desktop list update, the
42 X2Go server commands C{x2golistsessions} and C{x2godesktopsessions} are called and
43 the command's stdout is cached in the session list cache.
44
45 Whenever your client application needs access to either the server's session list
46 or the server's desktop list the session cache is queried instead. This assures that
47 the server's session/desktop list is available without delay, even on slow internet
48 connections.
49
50 """
51 x2go_listsessions_cache = {}
52
54 """\
55 @param client_instance: the L{X2goClient} instance that uses this L{X2goListSessionsCache}
56 @type client_instance: C{obj}
57 @param logger: you can pass an L{X2goLogger} object to the L{X2goListSessionsCache} constructor
58 @type logger: C{obj}
59 @param loglevel: if no L{X2goLogger} object has been supplied a new one will be
60 constructed with the given loglevel
61 @type loglevel: C{int}
62
63 """
64 self.x2go_listsessions_cache = {}
65 self.last_listsessions_cache = {}
66 self.protected = False
67
68 if logger is None:
69 self.logger = log.X2goLogger(loglevel=loglevel)
70 else:
71 self.logger = copy.deepcopy(logger)
72 self.logger.tag = __NAME__
73
74 self.client_instance = client_instance
75
76 - def delete(self, profile_name):
77 """\
78 Remove session list from cache for a given profile.
79
80 @param profile_name: name of profile to operate on
81 @type profile_name: C{str}
82
83 """
84 while self.protected:
85 gevent.sleep(.1)
86 try: del self.x2go_listsessions_cache[profile_name]
87 except KeyError: pass
88
90 """\
91 Check if session list cache elements are still valid (i.e. if all corresponding
92 session profiles are still connected). If not so, remove invalid cache entries from
93 the session list cache.
94
95 """
96 for profile_name in self.x2go_listsessions_cache.keys():
97 if profile_name not in self.client_instance.client_connected_profiles(return_profile_names=True):
98 del self.x2go_listsessions_cache[profile_name]
99
100 - def update_all(self, update_sessions=True, update_desktops=False):
101 """\
102 Update L{X2goListSessionsCache} for all connected session profiles.
103
104 @param update_sessions: cache recent session lists from all connected servers
105 @type update_sessions: C{bool}
106 @param update_desktops: cache recent desktop lists from all connected servers
107 @type update_desktops: C{bool}
108
109 """
110 for profile_name in self.client_instance.client_connected_profiles(return_profile_names=True):
111 self.update(profile_name, update_sessions=update_sessions, update_desktops=update_desktops)
112
113 self.check_cache()
114
115 - def update(self, profile_name, update_sessions=True, update_desktops=False, update_mounts=False):
116 """\
117 Update L{X2goListSessionsCache} (i.e. session/desktops) for session profile C{profile_name}.
118
119 @param profile_name: name of profile to update
120 @type profile_name: C{str}
121 @param update_sessions: cache recent session list from server
122 @type update_sessions: C{bool}
123 @param update_desktops: cache recent desktop list from server
124 @type update_desktops: C{bool}
125 @param update_mounts: cache list of client-side mounts on server
126 @type update_mounts: C{bool}
127
128 """
129 self.protected = True
130 self.last_listsessions_cache = copy.deepcopy(self.x2go_listsessions_cache)
131 control_session = self.client_instance.client_control_session_of_profile_name(profile_name)
132 if not self.x2go_listsessions_cache.has_key(profile_name):
133 self.x2go_listsessions_cache[profile_name] = {'sessions': None, 'desktops': None, 'mounts': {}, }
134 if update_sessions:
135 self._update_sessions(profile_name, control_session)
136 if update_desktops:
137 self._update_desktops(profile_name, control_session)
138 if update_mounts:
139 self._update_mounts(profile_name, control_session)
140 self.protected = False
141
163
184
202
204 """\
205 Retrieve a session list from the current cache content of L{X2goListSessionsCache}
206 for a given L{X2goSession} instance (specified by its unique session UUID).
207
208 @param session_uuid: unique identifier of session to query cache for
209 @type session_uuid: C{str}
210
211 @return: a data object containing available session information
212 @rtype: C{X2goServerSessionList*} instance (or C{None})
213
214 """
215 profile_name = self.client_instance.get_session_profile_name(session_uuid)
216 if self.is_cached(session_uuid=session_uuid):
217 return self.x2go_listsessions_cache[profile_name]['sessions']
218 else:
219 return None
220
222 """\
223 Retrieve a list of available desktop sessions from the current cache content of
224 L{X2goListSessionsCache} for a given L{X2goSession} instance (specified by its
225 unique session UUID).
226
227 @param session_uuid: unique identifier of session to query cache for
228 @type session_uuid: C{str}
229
230 @return: a list of strings representing X2Go desktop sessions available for sharing
231 @rtype: C{list} (or C{None})
232
233 """
234 profile_name = self.client_instance.get_session_profile_name(session_uuid)
235 if self.is_cached(session_uuid=session_uuid):
236 return self.x2go_listsessions_cache[profile_name]['desktops']
237 else:
238 return None
239
241 """\
242 Retrieve a list of mounted client shares from the current cache content of
243 L{X2goListSessionsCache} for a given L{X2goSession} instance (specified by its
244 unique session UUID).
245
246 @param session_uuid: unique identifier of session to query cache for
247 @type session_uuid: C{str}
248
249 @return: a list of strings representing mounted client shares
250 @rtype: C{list} (or C{None})
251
252 """
253 profile_name = self.client_instance.get_session_profile_name(session_uuid)
254 if self.is_cached(session_uuid=session_uuid):
255 return self.x2go_listsessions_cache[profile_name]['mounts']
256 else:
257 return None
258
259 - def is_cached(self, profile_name=None, session_uuid=None, cache_type=None):
260 """\
261 Check if session information is cached.
262
263 @param profile_name: name of profile to update
264 @type profile_name: C{str}
265 @param session_uuid: unique identifier of session to query cache for
266 @type session_uuid: C{str}
267
268 @return: C{True} if session information is cached
269 @rtype: C{bool}
270
271 """
272 if profile_name is None and session_uuid and self.client_instance:
273 try:
274 profile_name = self.client_instance.get_session_profile_name(session_uuid)
275 except x2go_exceptions.X2goSessionRegistryException:
276 raise x2go_exceptions.X2goSessionCacheException("requested session UUID is not valid anymore")
277 _is_profile_cached = self.x2go_listsessions_cache.has_key(profile_name)
278 _is_cache_type_cached = _is_profile_cached and self.x2go_listsessions_cache[profile_name].has_key(cache_type)
279 if cache_type is None:
280 return _is_profile_cached
281 else:
282 return _is_cache_type_cached
283