Changeset 418:1c54f87016fb in raven-j

Timestamp:

10/11/2011 05:35:34 PM (7 months ago)

Author:

Dan Connolly <dconnolly@…>

Branch:

recap

Message:

toward right-side-out capabilities: medcenter.py tests pass

• use TypeError? for unsealing failure

Location:

heron_wsgi/admin_lib

Files:

• medcenter.py (modified) (8 diffs)
• sealing.py (modified) (3 diffs)

heron_wsgi/admin_lib/medcenter.py

@@ -1 +1 @@
 '''medcenter.py -- academic medical center directory/policy
 
-  >>> depgraph = injector.Injector([Mock()])
-  >>> m = depgraph.get(MedCenter)
-
-Look someone up in the enterprise directory::
-
-  >>> a1 = m.affiliate('john.smith')
-  >>> a1
-  John Smith <john.smith@js.example>
-  >>> a1.title
+  # logging.basicConfig(level=logging.DEBUG)
+  >>> m, mock, mods, depgraph = Mock.make_stuff()
+  >>> app_secret = depgraph.get(KAppSecret)
+
+Assuming CAS login asked us to issue a login capability::
+
+  >>> box, req = mock.login_info('john.smith')
+  >>> login_caps = m.issue(box, req)
+
+We can exercise an enterprise directory capability::
+
+  >>> a1 = req.idvault_entry
+  >>> m.withId(a1, lambda a: '%s %s <%s>' % (
+  ...                         a['givenname'], a['sn'], a['mail']))
+  'John Smith <john.smith@js.example>'
+  >>> m.withId(a1, lambda a: a['title'])
   'Chair of Department of Neurology'
+
+Note: KUMC uses ou for department. @@test
 
 We use an outboard service to check human subjects "chalk" training::
@@ -19 +28 @@
   url=http://localhost:8080/chalk-checker
 
-  >>> m.trainedThru(a1)
+  >>> m.training(a1)
   '2012-01-01'
 
 '''
 
+import logging
 import os
 import sys
@@ -30 +40 @@
 
 import injector
-from injector import inject, provides
+from injector import inject, provides, singleton
 
 import config
 import ldaplib
+import sealing
+
+log = logging.getLogger(__name__)
 
 KTrainingFunction = injector.Key('TrainingFunction')
+KAppSecret = injector.Key('AppSecret')
 
 CHALK_CONFIG_SECTION='chalk'
-
+PERM_ID=__file__ + '.idvault'
+
+@singleton
 class MedCenter(object):
     excluded_jobcode = "24600"
+    permissions=(PERM_ID,)
 
     @inject(searchsvc=ldaplib.LDAPService,
-            trainingfn=KTrainingFunction)
-    def __init__(self, searchsvc, trainingfn):
+            trainingfn=KTrainingFunction,
+            app_secret=KAppSecret)
+    def __init__(self, searchsvc, trainingfn, app_secret):
+        log.debug('MedCenter.__init__ again?')
         self._svc = searchsvc
         self._training = trainingfn
+        self._app_secret = app_secret
+        self.sealer, self._unsealer = sealing.makeBrandPair('MedCenter')
 
     def __repr__(self):
         return "MedCenter(s, t)"
 
-    def affiliate(self, name):
+    def _lookup(self, name):
         matches = self._svc.search('(cn=%s)' % name, AccountHolder.attributes)
         if len(matches) != 1:
@@ -59 +80 @@
                 raise ValueError, name  # ambiguous
 
-        dn, attrs = matches[0]
-
-        return AccountHolder(extract_values(attrs))
-
-    def trainedThru(self, who):
-        return self._training(who.userid())
-
-
-    def checkFaculty(self, who):
-        if (who.kumcPersonJobcode != self.excluded_jobcode
-            and who.kumcPersonFaculty == 'Y'):
-            return
-        raise NotFaculty()
-
-    def affiliateSearch(self, max_qty, cn, sn, givenname):
+        dn, ldapattrs = matches[0]
+        return AccountHolder.rezip(ldapattrs)
+
+    def issue(self, loginbox, req):
+        u, s = self._unsealer.unseal(loginbox)
+        if s != self._app_secret:
+            log.warn('expected app_secret [%s] got [%s]',
+                     self._app_secret, s)
+            return []
+        cap = self.sealer.seal(self._lookup(u))
+        req.idvault_entry = cap
+        return [cap]
+
+    def audit(self, cap, p):
+        log.info('MedCenter.audit(%s, %s)' % (cap, p))
+        if not isinstance(cap, object):
+            raise TypeError
+        self._unsealer.unseal(cap)
+
+    def lookup(self, namebox):
+        name = self._unsealer.unseal(namebox)
+        return self.sealer.seal(self._lookup(name))
+
+    def withId(self, attrsbox, thunk):
+        '''Exercise thunk(attrs) provided attrsbox unseals.
+        '''
+        attrs = self._unsealer.unseal(attrsbox)
+        return thunk(attrs)
+
+    def withFaculty(self, attrsbox, thunk):
+        '''Exercise thunk(attrs) provided attrsbox unseals as faculty.
+        @raises: TypeError on unsealing failure
+        @raises: NotFaculty
+        '''
+        attrs = self._unsealer.unseal(attrsbox)
+        log.debug('withFaculty: %s', attrs)
+        if (attrs['kumcPersonJobcode'] == self.excluded_jobcode
+            or attrs['kumcPersonFaculty'] != 'Y'):
+            raise NotFaculty
+
+        return thunk(attrs)
+
+    def training(self, attrbox):
+        return self._training(self._unsealer.unseal(attrbox)['cn'])
+
+    def search(self, max_qty, cn, sn, givenname):
         clauses = ['(%s=%s*)' % (n, v)
-                   for (n, v) in (('cn', cn), ('sn', sn), ('givenname', givenname))
+                   for (n, v) in (('cn', cn),
+                                  ('sn', sn),
+                                  ('givenname', givenname))
                    if v]
         if len(clauses) == 0:
@@ -86 +140 @@
 
         results = self._svc.search(q, AccountHolder.attributes)[:max_qty]
-        return [AccountHolder(extract_values(attrs))
-                for dn, attrs in results]
-
-
-def extract_values(attrs):
+        return [AccountHolder.rezip(ldapattrs)
+                for dn, ldapattrs in results]
+
+
+def _extract_values(attrs):
     return [attrs.get(n, [None])[0]
             for n in AccountHolder.attributes]
@@ -106 +160 @@
                   "kumcPersonFaculty", "kumcPersonJobcode"]
 
-    def __init__(self, values):
-        self._attrs = dict(zip(self.attributes, values))
+    @classmethod
+    def rezip(cls, ldapattrs):
+        return dict(zip(cls.attributes, _extract_values(ldapattrs)))
+
+    def __init__(self, cap, attrs):
+        self.cap = cap
+        self._attrs = attrs
 
     def __str__(self):
@@ -120 +179 @@
 
     def __getattr__(self, n):
-        if n not in self.attributes:
+        if n.startswith('_') or n not in self.attributes:
             raise AttributeError
         return self._attrs[n]
@@ -154 +213 @@
         binder.bind(KTrainingFunction,
                     injector.InstanceProvider(d.trainedThru))
-
-    @classmethod
-    def make(cls):
-        depgraph = injector.Injector(Mock())
-        return depgraph.get(MedCenter)
+        self._app_secret = 'sekrit'
+        binder.bind(KAppSecret, 
+                    injector.InstanceProvider(self._app_secret))
+
+    def set_medcenter(self, mc):
+        self._mc = mc
+
+    def login_info(self, cn):
+        box = self._mc.sealer.seal((cn, self._app_secret))
+        req = MockRequest()
+        return box, req
+
+    @classmethod
+    def mods(cls):
+        return [Mock()]
+
+    @classmethod
+    def make_stuff(cls):
+        mods = cls.mods()
+        mod = mods[-1]
+        depgraph = injector.Injector(mods)
+        mc = depgraph.get(MedCenter)
+        mod.set_medcenter(mc)
+        return mc, mod, mods, depgraph
+
+
+class MockRequest(dict):
+    def __init__(self, *args, **kwargs):
+        dict.__init__(self, *args, **kwargs)
+        self.__dict__ = self
 
 class IntegrationTest(injector.Module):

heron_wsgi/admin_lib/sealing.py

@@ -50 +50 @@
       Traceback (most recent call last):
       ...
-      UnsealingException
+      TypeError
 
     '''
@@ -76 +76 @@
         shared[0] = noObject
         box.shareContent()
-        if (shared[0] is noObject): raise UnsealingException
+        if (shared[0] is noObject): raise TypeError
         contents = shared[0]
         shared[0] = noObject
@@ -87 +87 @@
     return (sealer, unsealer)
 
-
-class UnsealingException(Exception):
-    pass
 
 class EDef: