First version. Most definitely a work in progress.

[nodemanager.git] / accounts.py

diff --git a/accounts.py b/accounts.py
new file mode 100644 (file)
index 0000000..b22a4ba
--- /dev/null
+++ b/accounts.py
@@ -0,0 +1,109 @@
+import Queue
+import os
+import pwd
+import threading
+
+import logger
+import tools
+
+
+_name_worker_lock = threading.Lock()
+_name_worker = {}
+
+def all():
+    pw_ents = pwd.getpwall()
+    for pw_ent in pw_ents:
+        if pw_ent[6] in acct_class_by_shell:
+            yield acct_class_by_shell[pw_ent[6]].TYPE, pw_ent[0]
+
+def get(name):
+    _name_worker_lock.acquire()
+    try:
+        if name not in _name_worker: _name_worker[name] = Worker(name)
+        return _name_worker[name]
+    finally: _name_worker_lock.release()
+
+
+def install_ssh_keys(rec):
+    """Write <rec['ssh_keys']> to <rec['name']>'s authorized_keys file."""
+    dot_ssh = '/home/%s/.ssh' % rec['name']
+    def do_installation():
+        if not os.access(dot_ssh, os.F_OK): os.mkdir(dot_ssh)
+        tools.write_file(dot_ssh + '/authorized_keys',
+                         lambda thefile: thefile.write(rec['ssh_keys']))
+    logger.log('%s: installing ssh keys' % rec['name'])
+    tools.fork_as(rec['name'], do_installation)
+
+
+TYPES = []
+acct_class_by_shell = {}
+acct_class_by_type = {}
+
+def register_account_type(acct_class):
+    TYPES.append(acct_class.TYPE)
+    acct_class_by_shell[acct_class.SHELL] = acct_class
+    acct_class_by_type[acct_class.TYPE] = acct_class
+
+
+class Worker:
+    # these semaphores are acquired before creating/destroying an account
+    _create_sem = threading.Semaphore(1)
+    _destroy_sem = threading.Semaphore(1)
+
+    def __init__(self, name):
+        self.name = name
+        self._acct = None
+        self._q = Queue.Queue()
+        tools.as_daemon_thread(self._run)
+
+    def ensure_created(self, rec):
+        self._q.put((self._ensure_created, tools.deepcopy(rec)))
+
+    def _ensure_created(self, rec):
+        curr_class = self._get_class()
+        next_class = acct_class_by_type[rec['account_type']]
+        if next_class != curr_class:
+            self._destroy(curr_class)
+            self._create_sem.acquire()
+            try: next_class.create(self.name)
+            finally: self._create_sem.release()
+        self._make_acct_obj()
+        self._acct.configure(rec)
+        if next_class != curr_class: self._acct.start()
+
+    def ensure_destroyed(self): self._q.put((self._ensure_destroyed,))
+    def _ensure_destroyed(self): self._destroy(self._get_class())
+
+    def start(self): self._q.put((self._start,))
+    def _start(self):
+        self._make_acct_obj()
+        self._acct.start()
+
+    def stop(self): self._q.put((self._stop,))
+    def _stop(self):
+        self._make_acct_obj()
+        self._acct.stop()
+
+    def _destroy(self, curr_class):
+        self._acct = None
+        if curr_class:
+            self._destroy_sem.acquire()
+            try: curr_class.destroy(self.name)
+            finally: self._destroy_sem.release()
+
+    def _get_class(self):
+        try: shell = pwd.getpwnam(self.name)[6]
+        except KeyError: return None
+        return acct_class_by_shell[shell]
+
+    def _make_acct_obj(self):
+        curr_class = self._get_class()
+        if not isinstance(self._acct, curr_class):
+            self._acct = curr_class(self.name)
+
+    def _run(self):
+        while True:
+            try:
+                cmd = self._q.get()
+                cmd[0](*cmd[1:])
+            except: logger.log_exc()