home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1464 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  20.3 KB  |  621 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import datetime
  5. import os
  6.  
  7. try:
  8.     import cPickle as pickle
  9. except ImportError:
  10.     import pickle
  11.  
  12. import random
  13.  
  14. try:
  15.     from hashlib import sha1 as sha
  16. except ImportError:
  17.     from sha import new as sha
  18.  
  19. import time
  20. import threading
  21. import types
  22. from warnings import warn
  23. import cherrypy
  24. from cherrypy.lib import http
  25. missing = object()
  26.  
  27. class Session(object):
  28.     __metaclass__ = cherrypy._AttributeDocstrings
  29.     _id = None
  30.     id_observers = None
  31.     id_observers__doc = "A list of callbacks to which to pass new id's."
  32.     id__doc = 'The current session ID.'
  33.     
  34.     def _get_id(self):
  35.         return self._id
  36.  
  37.     
  38.     def _set_id(self, value):
  39.         self._id = value
  40.         for o in self.id_observers:
  41.             o(value)
  42.         
  43.  
  44.     id = property(_get_id, _set_id, doc = id__doc)
  45.     timeout = 60
  46.     timeout__doc = 'Number of minutes after which to delete session data.'
  47.     locked = False
  48.     locked__doc = '\n    If True, this session instance has exclusive read/write access\n    to session data.'
  49.     loaded = False
  50.     loaded__doc = '\n    If True, data has been retrieved from storage. This should happen\n    automatically on the first attempt to access session data.'
  51.     clean_thread = None
  52.     clean_thread__doc = 'Class-level Monitor which calls self.clean_up.'
  53.     clean_freq = 5
  54.     clean_freq__doc = 'The poll rate for expired session cleanup in minutes.'
  55.     
  56.     def __init__(self, id = None, **kwargs):
  57.         self.id_observers = []
  58.         self._data = { }
  59.         for k, v in kwargs.iteritems():
  60.             setattr(self, k, v)
  61.         
  62.         if id is None:
  63.             self.regenerate()
  64.         else:
  65.             self.id = id
  66.             if not self._exists():
  67.                 self.id = None
  68.                 self.regenerate()
  69.             
  70.  
  71.     
  72.     def regenerate(self):
  73.         if self.id is not None:
  74.             self.delete()
  75.         
  76.         old_session_was_locked = self.locked
  77.         if old_session_was_locked:
  78.             self.release_lock()
  79.         
  80.         self.id = None
  81.         while self.id is None:
  82.             self.id = self.generate_id()
  83.             if self._exists():
  84.                 self.id = None
  85.                 continue
  86.         if old_session_was_locked:
  87.             self.acquire_lock()
  88.         
  89.  
  90.     
  91.     def clean_up(self):
  92.         pass
  93.  
  94.     
  95.     try:
  96.         os.urandom(20)
  97.     except (AttributeError, NotImplementedError):
  98.         
  99.         def generate_id(self):
  100.             return sha('%s' % random.random()).hexdigest()
  101.  
  102.  
  103.     
  104.     def generate_id(self):
  105.         return os.urandom(20).encode('hex')
  106.  
  107.     
  108.     def save(self):
  109.         
  110.         try:
  111.             if self.loaded:
  112.                 t = datetime.timedelta(seconds = self.timeout * 60)
  113.                 expiration_time = datetime.datetime.now() + t
  114.                 self._save(expiration_time)
  115.         finally:
  116.             if self.locked:
  117.                 self.release_lock()
  118.             
  119.  
  120.  
  121.     
  122.     def load(self):
  123.         data = self._load()
  124.         if data is None or data[1] < datetime.datetime.now():
  125.             self._data = { }
  126.         else:
  127.             self._data = data[0]
  128.         self.loaded = True
  129.         cls = self.__class__
  130.         if self.clean_freq and not (cls.clean_thread):
  131.             t = cherrypy.process.plugins.Monitor(cherrypy.engine, self.clean_up, self.clean_freq * 60)
  132.             t.subscribe()
  133.             cls.clean_thread = t
  134.             t.start()
  135.         
  136.  
  137.     
  138.     def delete(self):
  139.         self._delete()
  140.  
  141.     
  142.     def __getitem__(self, key):
  143.         if not self.loaded:
  144.             self.load()
  145.         
  146.         return self._data[key]
  147.  
  148.     
  149.     def __setitem__(self, key, value):
  150.         if not self.loaded:
  151.             self.load()
  152.         
  153.         self._data[key] = value
  154.  
  155.     
  156.     def __delitem__(self, key):
  157.         if not self.loaded:
  158.             self.load()
  159.         
  160.         del self._data[key]
  161.  
  162.     
  163.     def pop(self, key, default = missing):
  164.         if not self.loaded:
  165.             self.load()
  166.         
  167.         if default is missing:
  168.             return self._data.pop(key)
  169.         return self._data.pop(key, default)
  170.  
  171.     
  172.     def __contains__(self, key):
  173.         if not self.loaded:
  174.             self.load()
  175.         
  176.         return key in self._data
  177.  
  178.     
  179.     def has_key(self, key):
  180.         if not self.loaded:
  181.             self.load()
  182.         
  183.         return self._data.has_key(key)
  184.  
  185.     
  186.     def get(self, key, default = None):
  187.         if not self.loaded:
  188.             self.load()
  189.         
  190.         return self._data.get(key, default)
  191.  
  192.     
  193.     def update(self, d):
  194.         if not self.loaded:
  195.             self.load()
  196.         
  197.         self._data.update(d)
  198.  
  199.     
  200.     def setdefault(self, key, default = None):
  201.         if not self.loaded:
  202.             self.load()
  203.         
  204.         return self._data.setdefault(key, default)
  205.  
  206.     
  207.     def clear(self):
  208.         if not self.loaded:
  209.             self.load()
  210.         
  211.         self._data.clear()
  212.  
  213.     
  214.     def keys(self):
  215.         if not self.loaded:
  216.             self.load()
  217.         
  218.         return self._data.keys()
  219.  
  220.     
  221.     def items(self):
  222.         if not self.loaded:
  223.             self.load()
  224.         
  225.         return self._data.items()
  226.  
  227.     
  228.     def values(self):
  229.         if not self.loaded:
  230.             self.load()
  231.         
  232.         return self._data.values()
  233.  
  234.  
  235.  
  236. class RamSession(Session):
  237.     cache = { }
  238.     locks = { }
  239.     
  240.     def clean_up(self):
  241.         now = datetime.datetime.now()
  242.         for data, expiration_time in self.cache.items():
  243.             if expiration_time < now:
  244.                 
  245.                 try:
  246.                     del self.cache[id]
  247.                 except KeyError:
  248.                     pass
  249.  
  250.                 
  251.                 try:
  252.                     del self.locks[id]
  253.                 except KeyError:
  254.                     pass
  255.                 except:
  256.                     None<EXCEPTION MATCH>KeyError
  257.                 
  258.  
  259.             None<EXCEPTION MATCH>KeyError
  260.         
  261.  
  262.     
  263.     def _exists(self):
  264.         return self.id in self.cache
  265.  
  266.     
  267.     def _load(self):
  268.         return self.cache.get(self.id)
  269.  
  270.     
  271.     def _save(self, expiration_time):
  272.         self.cache[self.id] = (self._data, expiration_time)
  273.  
  274.     
  275.     def _delete(self):
  276.         del self.cache[self.id]
  277.  
  278.     
  279.     def acquire_lock(self):
  280.         self.locked = True
  281.         self.locks.setdefault(self.id, threading.RLock()).acquire()
  282.  
  283.     
  284.     def release_lock(self):
  285.         self.locks[self.id].release()
  286.         self.locked = False
  287.  
  288.     
  289.     def __len__(self):
  290.         return len(self.cache)
  291.  
  292.  
  293.  
  294. class FileSession(Session):
  295.     SESSION_PREFIX = 'session-'
  296.     LOCK_SUFFIX = '.lock'
  297.     
  298.     def __init__(self, id = None, **kwargs):
  299.         kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
  300.         Session.__init__(self, id = id, **kwargs)
  301.  
  302.     
  303.     def setup(cls, **kwargs):
  304.         kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
  305.         for k, v in kwargs.iteritems():
  306.             setattr(cls, k, v)
  307.         
  308.         lockfiles = _[1]
  309.  
  310.     setup = classmethod(setup)
  311.     
  312.     def _get_file_path(self):
  313.         f = os.path.join(self.storage_path, self.SESSION_PREFIX + self.id)
  314.         if not os.path.abspath(f).startswith(self.storage_path):
  315.             raise cherrypy.HTTPError(400, 'Invalid session id in cookie.')
  316.         os.path.abspath(f).startswith(self.storage_path)
  317.         return f
  318.  
  319.     
  320.     def _exists(self):
  321.         path = self._get_file_path()
  322.         return os.path.exists(path)
  323.  
  324.     
  325.     def _load(self, path = None):
  326.         if path is None:
  327.             path = self._get_file_path()
  328.         
  329.         
  330.         try:
  331.             f = open(path, 'rb')
  332.             
  333.             try:
  334.                 return pickle.load(f)
  335.             finally:
  336.                 f.close()
  337.  
  338.         except (IOError, EOFError):
  339.             return None
  340.  
  341.  
  342.     
  343.     def _save(self, expiration_time):
  344.         f = open(self._get_file_path(), 'wb')
  345.         
  346.         try:
  347.             pickle.dump((self._data, expiration_time), f)
  348.         finally:
  349.             f.close()
  350.  
  351.  
  352.     
  353.     def _delete(self):
  354.         
  355.         try:
  356.             os.unlink(self._get_file_path())
  357.         except OSError:
  358.             pass
  359.  
  360.  
  361.     
  362.     def acquire_lock(self, path = None):
  363.         if path is None:
  364.             path = self._get_file_path()
  365.         
  366.         path += self.LOCK_SUFFIX
  367.         while True:
  368.             
  369.             try:
  370.                 lockfd = os.open(path, os.O_CREAT | os.O_WRONLY | os.O_EXCL)
  371.             except OSError:
  372.                 time.sleep(0.1)
  373.                 continue
  374.  
  375.             os.close(lockfd)
  376.             break
  377.         self.locked = True
  378.  
  379.     
  380.     def release_lock(self, path = None):
  381.         if path is None:
  382.             path = self._get_file_path()
  383.         
  384.         os.unlink(path + self.LOCK_SUFFIX)
  385.         self.locked = False
  386.  
  387.     
  388.     def clean_up(self):
  389.         now = datetime.datetime.now()
  390.         for fname in os.listdir(self.storage_path):
  391.             if fname.startswith(self.SESSION_PREFIX) and not fname.endswith(self.LOCK_SUFFIX):
  392.                 path = os.path.join(self.storage_path, fname)
  393.                 self.acquire_lock(path)
  394.                 
  395.                 try:
  396.                     contents = self._load(path)
  397.                     if contents is not None:
  398.                         (data, expiration_time) = contents
  399.                         if expiration_time < now:
  400.                             os.unlink(path)
  401.                         
  402.                 finally:
  403.                     self.release_lock(path)
  404.  
  405.                 continue
  406.         
  407.  
  408.     
  409.     def __len__(self):
  410.         return [](_[1])
  411.  
  412.  
  413.  
  414. class PostgresqlSession(Session):
  415.     
  416.     def __init__(self, id = None, **kwargs):
  417.         Session.__init__(self, id, **kwargs)
  418.         self.cursor = self.db.cursor()
  419.  
  420.     
  421.     def setup(cls, **kwargs):
  422.         for k, v in kwargs.iteritems():
  423.             setattr(cls, k, v)
  424.         
  425.         self.db = self.get_db()
  426.  
  427.     setup = classmethod(setup)
  428.     
  429.     def __del__(self):
  430.         if self.cursor:
  431.             self.cursor.close()
  432.         
  433.         self.db.commit()
  434.  
  435.     
  436.     def _exists(self):
  437.         self.cursor.execute('select data, expiration_time from session where id=%s', (self.id,))
  438.         rows = self.cursor.fetchall()
  439.         return bool(rows)
  440.  
  441.     
  442.     def _load(self):
  443.         self.cursor.execute('select data, expiration_time from session where id=%s', (self.id,))
  444.         rows = self.cursor.fetchall()
  445.         if not rows:
  446.             return None
  447.         (pickled_data, expiration_time) = rows[0]
  448.         data = pickle.loads(pickled_data)
  449.         return (data, expiration_time)
  450.  
  451.     
  452.     def _save(self, expiration_time):
  453.         pickled_data = pickle.dumps(self._data)
  454.         self.cursor.execute('update session set data = %s, expiration_time = %s where id = %s', (pickled_data, expiration_time, self.id))
  455.  
  456.     
  457.     def _delete(self):
  458.         self.cursor.execute('delete from session where id=%s', (self.id,))
  459.  
  460.     
  461.     def acquire_lock(self):
  462.         self.locked = True
  463.         self.cursor.execute('select id from session where id=%s for update', (self.id,))
  464.  
  465.     
  466.     def release_lock(self):
  467.         self.cursor.close()
  468.         self.locked = False
  469.  
  470.     
  471.     def clean_up(self):
  472.         self.cursor.execute('delete from session where expiration_time < %s', (datetime.datetime.now(),))
  473.  
  474.  
  475.  
  476. class MemcachedSession(Session):
  477.     mc_lock = threading.RLock()
  478.     locks = { }
  479.     servers = [
  480.         '127.0.0.1:11211']
  481.     
  482.     def setup(cls, **kwargs):
  483.         for k, v in kwargs.iteritems():
  484.             setattr(cls, k, v)
  485.         
  486.         import memcache
  487.         cls.cache = memcache.Client(cls.servers)
  488.  
  489.     setup = classmethod(setup)
  490.     
  491.     def _exists(self):
  492.         self.mc_lock.acquire()
  493.         
  494.         try:
  495.             return bool(self.cache.get(self.id))
  496.         finally:
  497.             self.mc_lock.release()
  498.  
  499.  
  500.     
  501.     def _load(self):
  502.         self.mc_lock.acquire()
  503.         
  504.         try:
  505.             return self.cache.get(self.id)
  506.         finally:
  507.             self.mc_lock.release()
  508.  
  509.  
  510.     
  511.     def _save(self, expiration_time):
  512.         td = int(time.mktime(expiration_time.timetuple()))
  513.         self.mc_lock.acquire()
  514.         
  515.         try:
  516.             if not self.cache.set(self.id, (self._data, expiration_time), td):
  517.                 raise AssertionError('Session data for id %r not set.' % self.id)
  518.             self.cache.set(self.id, (self._data, expiration_time), td)
  519.         finally:
  520.             self.mc_lock.release()
  521.  
  522.  
  523.     
  524.     def _delete(self):
  525.         self.cache.delete(self.id)
  526.  
  527.     
  528.     def acquire_lock(self):
  529.         self.locked = True
  530.         self.locks.setdefault(self.id, threading.RLock()).acquire()
  531.  
  532.     
  533.     def release_lock(self):
  534.         self.locks[self.id].release()
  535.         self.locked = False
  536.  
  537.     
  538.     def __len__(self):
  539.         raise NotImplementedError
  540.  
  541.  
  542.  
  543. def save():
  544.     if not hasattr(cherrypy.serving, 'session'):
  545.         return None
  546.     if hasattr(cherrypy.request, '_sessionsaved'):
  547.         return None
  548.     cherrypy.request._sessionsaved = True
  549.     if cherrypy.response.stream:
  550.         cherrypy.request.hooks.attach('on_end_request', cherrypy.session.save)
  551.     elif isinstance(cherrypy.response.body, types.GeneratorType):
  552.         cherrypy.response.collapse_body()
  553.     
  554.     cherrypy.session.save()
  555.  
  556. save.failsafe = True
  557.  
  558. def close():
  559.     sess = getattr(cherrypy.serving, 'session', None)
  560.     if getattr(sess, 'locked', False):
  561.         sess.release_lock()
  562.     
  563.  
  564. close.failsafe = True
  565. close.priority = 90
  566.  
  567. def init(storage_type = 'ram', path = None, path_header = None, name = 'session_id', timeout = 60, domain = None, secure = False, clean_freq = 5, **kwargs):
  568.     request = cherrypy.request
  569.     if hasattr(request, '_session_init_flag'):
  570.         return None
  571.     request._session_init_flag = True
  572.     id = None
  573.     if name in request.cookie:
  574.         id = request.cookie[name].value
  575.     
  576.     storage_class = storage_type.title() + 'Session'
  577.     storage_class = globals()[storage_class]
  578.     if not hasattr(cherrypy, 'session'):
  579.         if hasattr(storage_class, 'setup'):
  580.             storage_class.setup(**kwargs)
  581.         
  582.     
  583.     kwargs['timeout'] = timeout
  584.     kwargs['clean_freq'] = clean_freq
  585.     cherrypy.serving.session = sess = storage_class(id, **kwargs)
  586.     
  587.     def update_cookie(id):
  588.         cherrypy.response.cookie[name] = id
  589.  
  590.     sess.id_observers.append(update_cookie)
  591.     if not hasattr(cherrypy, 'session'):
  592.         cherrypy.session = cherrypy._ThreadLocalProxy('session')
  593.     
  594.     set_response_cookie(path = path, path_header = path_header, name = name, timeout = timeout, domain = domain, secure = secure)
  595.  
  596.  
  597. def set_response_cookie(path = None, path_header = None, name = 'session_id', timeout = 60, domain = None, secure = False):
  598.     cookie = cherrypy.response.cookie
  599.     cookie[name] = cherrypy.serving.session.id
  600.     if not path and cherrypy.request.headers.get(path_header):
  601.         pass
  602.     cookie[name]['path'] = '/'
  603.     if timeout:
  604.         cookie[name]['expires'] = http.HTTPDate(time.time() + timeout * 60)
  605.     
  606.     if domain is not None:
  607.         cookie[name]['domain'] = domain
  608.     
  609.     if secure:
  610.         cookie[name]['secure'] = 1
  611.     
  612.  
  613.  
  614. def expire():
  615.     name = cherrypy.request.config.get('tools.sessions.name', 'session_id')
  616.     one_year = 31536000
  617.     exp = time.gmtime(time.time() - one_year)
  618.     t = time.strftime('%a, %d-%b-%Y %H:%M:%S GMT', exp)
  619.     cherrypy.response.cookie[name]['expires'] = t
  620.  
  621.