Source Code for Module x2go.cache

  1  # -*- coding: utf-8 -*- 
  2   
  3  # Copyright (C) 2010-2013 by Mike Gabriel <mike.gabriel@das-netzwerkteam.de> 
  4  # 
  5  # Python X2Go is free software; you can redistribute it and/or modify 
  6  # it under the terms of the GNU Affero General Public License as published by 
  7  # the Free Software Foundation; either version 3 of the License, or 
  8  # (at your option) any later version. 
  9  # 
 10  # Python X2Go is distributed in the hope that it will be useful, 
 11  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 12  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 13  # GNU Affero General Public License for more details. 
 14  # 
 15  # You should have received a copy of the GNU Affero General Public License 
 16  # along with this program; if not, write to the 
 17  # Free Software Foundation, Inc., 
 18  # 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. 
 19   
 20  """\ 
 21  X2GoListSessionCache class - caching X2Go session information. 
 22   
 23  """ 
 24  __NAME__ = 'x2gocache-pylib' 
 25   
 26  # modules 
 27  import copy 
 28  import gevent 
 29   
 30  # Python X2Go modules 
 31  import log 
 32  import x2go_exceptions 
 33   
 34 -class X2GoListSessionsCache(object): 
 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   
 53 -    def __init__(self, client_instance, logger=None, loglevel=log.loglevel_DEFAULT): 
 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   
 89 -    def check_cache(self): 
 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   
142 -    def _update_mounts(self, profile_name, control_session): 
143          """\ 
144          Update mounts list of L{X2GoListSessionsCache} for session profile C{profile_name}. 
145   
146          @param profile_name: name of profile to update 
147          @type profile_name: C{str} 
148   
149          @raise X2GoControlSessionException: if the control session's C{list_mounts} method fails 
150          """ 
151          try: 
152              self.x2go_listsessions_cache[profile_name]['mounts'] = {} 
153              if self.x2go_listsessions_cache[profile_name]['sessions']: 
154                  for session_name in self.x2go_listsessions_cache[profile_name]['sessions']: 
155                      if control_session is not None and not control_session.has_session_died(): 
156                          self.x2go_listsessions_cache[profile_name]['mounts'].update(control_session.list_mounts(session_name)) 
157          except (x2go_exceptions.X2GoControlSessionException, AttributeError), e: 
158              if profile_name in self.x2go_listsessions_cache.keys(): 
159                  del self.x2go_listsessions_cache[profile_name] 
160              self.protected = False 
161              raise x2go_exceptions.X2GoControlSessionException 
162          except x2go_exceptions.X2GoTimeOutException: 
163              pass 
164   
165 -    def _update_desktops(self, profile_name, control_session): 
166          """\ 
167          Update session lists of L{X2GoListSessionsCache} for session profile C{profile_name}. 
168   
169          @param profile_name: name of profile to update 
170          @type profile_name: C{str} 
171          @param control_session: X2Go control session instance 
172          @type control_session: C{obj} 
173   
174          @raise X2GoControlSessionException: if the control session's C{list_desktop} method fails 
175          """ 
176          try: 
177              if control_session is not None and not control_session.has_session_died(): 
178                  self.x2go_listsessions_cache[profile_name]['desktops'] = control_session.list_desktops() 
179          except (x2go_exceptions.X2GoControlSessionException, AttributeError), e: 
180              if profile_name in self.x2go_listsessions_cache.keys(): 
181                  del self.x2go_listsessions_cache[profile_name] 
182              self.protected = False 
183              raise x2go_exceptions.X2GoControlSessionException 
184          except x2go_exceptions.X2GoTimeOutException: 
185              pass 
186   
187 -    def _update_sessions(self, profile_name, control_session): 
188          """\ 
189          Update desktop list of L{X2GoListSessionsCache} for session profile C{profile_name}. 
190   
191          @param profile_name: name of profile to update 
192          @type profile_name: C{str} 
193   
194          @raise X2GoControlSessionException: if the control session's C{list_sessions} method fails 
195          """ 
196          try: 
197              if control_session is not None and not control_session.has_session_died(): 
198                  self.x2go_listsessions_cache[profile_name]['sessions'] = control_session.list_sessions() 
199          except (x2go_exceptions.X2GoControlSessionException, AttributeError), e: 
200              if profile_name in self.x2go_listsessions_cache.keys(): 
201                  del self.x2go_listsessions_cache[profile_name] 
202              self.protected = False 
203              raise x2go_exceptions.X2GoControlSessionException 
204   
205 -    def list_sessions(self, session_uuid): 
206          """\ 
207          Retrieve a session list from the current cache content of L{X2GoListSessionsCache} 
208          for a given L{X2GoSession} instance (specified by its unique session UUID). 
209   
210          @param session_uuid: unique identifier of session to query cache for 
211          @type session_uuid: C{str} 
212   
213          @return: a data object containing available session information 
214          @rtype: C{X2GoServerSessionList*} instance (or C{None}) 
215   
216          """ 
217          profile_name = self.client_instance.get_session_profile_name(session_uuid) 
218          if self.is_cached(session_uuid=session_uuid): 
219              return self.x2go_listsessions_cache[profile_name]['sessions'] 
220          else: 
221              return None 
222   
223 -    def list_desktops(self, session_uuid): 
224          """\ 
225          Retrieve a list of available desktop sessions from the current cache content of 
226          L{X2GoListSessionsCache} for a given L{X2GoSession} instance (specified by its  
227          unique session UUID). 
228   
229          @param session_uuid: unique identifier of session to query cache for 
230          @type session_uuid: C{str} 
231   
232          @return: a list of strings representing X2Go desktop sessions available for sharing 
233          @rtype: C{list} (or C{None}) 
234   
235          """ 
236          profile_name = self.client_instance.get_session_profile_name(session_uuid) 
237          if self.is_cached(session_uuid=session_uuid): 
238              return self.x2go_listsessions_cache[profile_name]['desktops'] 
239          else: 
240              return None 
241   
242 -    def list_mounts(self, session_uuid): 
243          """\ 
244          Retrieve a list of mounted client shares from the current cache content of 
245          L{X2GoListSessionsCache} for a given L{X2GoSession} instance (specified by its  
246          unique session UUID). 
247   
248          @param session_uuid: unique identifier of session to query cache for 
249          @type session_uuid: C{str} 
250   
251          @return: a list of strings representing mounted client shares 
252          @rtype: C{list} (or C{None}) 
253   
254          """ 
255          profile_name = self.client_instance.get_session_profile_name(session_uuid) 
256          if self.is_cached(session_uuid=session_uuid): 
257              return self.x2go_listsessions_cache[profile_name]['mounts'] 
258          else: 
259              return None 
260   
261 -    def is_cached(self, profile_name=None, session_uuid=None, cache_type=None): 
262          """\ 
263          Check if session information is cached. 
264   
265          @param profile_name: name of profile to update 
266          @type profile_name: C{str} 
267          @param session_uuid: unique identifier of session to query cache for 
268          @type session_uuid: C{str} 
269   
270          @return: C{True} if session information is cached 
271          @rtype: C{bool} 
272   
273          """ 
274          if profile_name is None and session_uuid and self.client_instance: 
275              try: 
276                  profile_name = self.client_instance.get_session_profile_name(session_uuid) 
277              except x2go_exceptions.X2GoSessionRegistryException: 
278                  raise x2go_exceptions.X2GoSessionCacheException("requested session UUID is not valid anymore") 
279          _is_profile_cached = self.x2go_listsessions_cache.has_key(profile_name) 
280          _is_cache_type_cached = _is_profile_cached and self.x2go_listsessions_cache[profile_name].has_key(cache_type) 
281          if cache_type is None: 
282              return _is_profile_cached 
283          else: 
284              return _is_cache_type_cached 
285