accounts.py

   1 import Queue
   2 import os
   3 import pwd
   4 import threading
   5
   6 import logger
   7 import tools
   8
   9
  10 _name_worker_lock = threading.Lock()
  11 _name_worker = {}
  12
  13 def all():
  14     pw_ents = pwd.getpwall()
  15     for pw_ent in pw_ents:
  16         if pw_ent[6] in acct_class_by_shell:
  17             yield acct_class_by_shell[pw_ent[6]].TYPE, pw_ent[0]
  18
  19 def get(name):
  20     _name_worker_lock.acquire()
  21     try:
  22         if name not in _name_worker: _name_worker[name] = Worker(name)
  23         return _name_worker[name]
  24     finally: _name_worker_lock.release()
  25
  26
  27 def install_ssh_keys(rec):
  28     """Write <rec['ssh_keys']> to <rec['name']>'s authorized_keys file."""
  29     dot_ssh = '/home/%s/.ssh' % rec['name']
  30     def do_installation():
  31         if not os.access(dot_ssh, os.F_OK): os.mkdir(dot_ssh)
  32         tools.write_file(dot_ssh + '/authorized_keys',
  33                          lambda thefile: thefile.write(rec['ssh_keys']))
  34     logger.log('%s: installing ssh keys' % rec['name'])
  35     tools.fork_as(rec['name'], do_installation)
  36
  37
  38 TYPES = []
  39 acct_class_by_shell = {}
  40 acct_class_by_type = {}
  41
  42 def register_account_type(acct_class):
  43     TYPES.append(acct_class.TYPE)
  44     acct_class_by_shell[acct_class.SHELL] = acct_class
  45     acct_class_by_type[acct_class.TYPE] = acct_class
  46
  47
  48 class Worker:
  49     # these semaphores are acquired before creating/destroying an account
  50     _create_sem = threading.Semaphore(1)
  51     _destroy_sem = threading.Semaphore(1)
  52
  53     def __init__(self, name):
  54         self.name = name
  55         self._acct = None
  56         self._q = Queue.Queue()
  57         tools.as_daemon_thread(self._run)
  58
  59     def ensure_created(self, rec):
  60         self._q.put((self._ensure_created, tools.deepcopy(rec)))
  61
  62     def _ensure_created(self, rec):
  63         curr_class = self._get_class()
  64         next_class = acct_class_by_type[rec['account_type']]
  65         if next_class != curr_class:
  66             self._destroy(curr_class)
  67             self._create_sem.acquire()
  68             try: next_class.create(self.name)
  69             finally: self._create_sem.release()
  70         self._make_acct_obj()
  71         self._acct.configure(rec)
  72         if next_class != curr_class: self._acct.start()
  73
  74     def ensure_destroyed(self): self._q.put((self._ensure_destroyed,))
  75     def _ensure_destroyed(self): self._destroy(self._get_class())
  76
  77     def start(self): self._q.put((self._start,))
  78     def _start(self):
  79         self._make_acct_obj()
  80         self._acct.start()
  81
  82     def stop(self): self._q.put((self._stop,))
  83     def _stop(self):
  84         self._make_acct_obj()
  85         self._acct.stop()
  86
  87     def _destroy(self, curr_class):
  88         self._acct = None
  89         if curr_class:
  90             self._destroy_sem.acquire()
  91             try: curr_class.destroy(self.name)
  92             finally: self._destroy_sem.release()
  93
  94     def _get_class(self):
  95         try: shell = pwd.getpwnam(self.name)[6]
  96         except KeyError: return None
  97         return acct_class_by_shell[shell]
  98
  99     def _make_acct_obj(self):
 100         curr_class = self._get_class()
 101         if not isinstance(self._acct, curr_class):
 102             self._acct = curr_class(self.name)
 103
 104     def _run(self):
 105         while True:
 106             try:
 107                 cmd = self._q.get()
 108                 cmd[0](*cmd[1:])
 109             except: logger.log_exc()