Ignore:
Timestamp:
Dec 14, 2010 6:58:28 PM (14 years ago)
Author:
Ted Faber <faber@…>
Branches:
axis_example, compt_changes, info-ops, master
Children:
c092b7f
Parents:
2627eb3
Message:

Move proofs around. Lots of changes, including fault handling.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • fedd/federation/experiment_control.py

    r2627eb3 re83f2f2  
    801801            self.response = None
    802802            self.node = { }
     803            self.proof = None
    803804
    804805        def make_map(self, resp):
    … …  
    850851                            self.log_collector.write(line)
    851852                    self.make_map(r['StartSegmentResponseBody'])
     853                    if 'proof' in r: self.proof = r['proof']
    852854                    self.response = r
    853855                else:
    … …  
    10211023            # mapping.
    10221024            embedding = [ ]
     1025            proofs = { }
    10231026            for s in starters:
    10241027                for k, v in s.node.items():
    … …  
    10281031                        'testbed': s.testbed
    10291032                        })
     1033                if s.proof:
     1034                    proofs[s.testbed] = s.proof
    10301035            log.info("[start_segment]: Experiment %s active" % eid)
    10311036
    … …  
    10441049                top.to_dict()
    10451050        self.state[eid]['embedding'] = embedding
     1051        # Append startup proofs
     1052        for f in self.state[eid]['federant']:
     1053            if 'name' in f and 'localname' in f['name']:
     1054                if f['name']['localname'] in proofs:
     1055                    f['proof'].append(proofs[f['name']['localname']])
     1056
    10461057        if self.state_filename: self.write_state()
    10471058        self.state_lock.release()
    … …  
    13261337            raise service_error(service_error.protocol,
    13271338                        "Bad proxy response")
     1339        if 'proof' not in r:
     1340            raise service_error(service_error.protocol,
     1341                        "Bad access response (no access proof)")
    13281342       
    13291343        tbparam[tb] = {
    13301344                "allocID" : r['allocID'],
    13311345                "uri": uri,
     1346                "proof": [ r['proof'] ],
    13321347                }
    13331348
    … …  
    14981513            self.auth.save()
    14991514
    1500         if not self.auth.check_attribute(fid, 'new'):
    1501             raise service_error(service_error.access, "New access denied")
     1515        access_ok, proof = self.auth.check_attribute(fid, 'new',
     1516                with_proof=True)
     1517
     1518        if not access_ok:
     1519            raise service_error(service_error.access, "New access denied",
     1520                    proof=[proof])
    15021521
    15031522        try:
    … …  
    15431562                ],
    15441563                'experimentStatus': 'empty',
    1545                 'experimentAccess': { 'X509' : expcert }
     1564                'experimentAccess': { 'X509' : expcert },
     1565                'proof': proof.to_dict(),
    15461566            }
    15471567
    … …  
    18141834            raise service_error(service_error.req, "No request?")
    18151835
    1816         self.check_experiment_access(fid, key)
     1836        proof = self.check_experiment_access(fid, key)
    18171837
    18181838        self.state_lock.acquire()
    18191839        if self.state.has_key(key):
    18201840            if self.state[key].has_key('vtopo'):
    1821                 rv = { 'experiment' : {keytype: key },\
    1822                         'vtopo': self.state[key]['vtopo'],\
     1841                rv = { 'experiment' : {keytype: key },
     1842                        'vtopo': self.state[key]['vtopo'],
     1843                        'proof': proof.to_dict(),
    18231844                    }
    18241845            else:
    … …  
    18581879            raise service_error(service_error.req, "No request?")
    18591880
    1860         self.check_experiment_access(fid, key)
     1881        proof = self.check_experiment_access(fid, key)
    18611882
    18621883        self.state_lock.acquire()
    18631884        if self.state.has_key(key):
    18641885            if self.state[key].has_key('vis'):
    1865                 rv =  { 'experiment' : {keytype: key },\
    1866                         'vis': self.state[key]['vis'],\
     1886                rv =  { 'experiment' : {keytype: key },
     1887                        'vis': self.state[key]['vis'],
     1888                        'proof': proof.to_dict(),
    18671889                        }
    18681890            else:
    … …  
    18851907        between when it was started and the beginning of resource allocation.
    18861908        This is basically the information about each local allocation.  This
    1887         fills in the values of the placeholder allocation in the state.
     1909        fills in the values of the placeholder allocation in the state.  It
     1910        also collects the access proofs and returns them as dicts for a
     1911        response message.
    18881912        """
    18891913        # save federant information
    … …  
    18931917                    'allocID' : tbparams[k]['allocID'],
    18941918                    'uri': tbparams[k]['uri'],
     1919                    'proof': tbparams[k]['proof'],
    18951920                }
    18961921
    … …  
    19031928                [ tbparams[tb]['federant'] for tb in tbparams.keys() \
    19041929                    if tbparams[tb].has_key('federant') ]
     1930        # Access proofs for the response message
     1931        proofs = [copy.deepcopy(p) for k in tbparams.keys()\
     1932                    for p in tbparams[k]['federant']['proof']]
    19051933        if self.state_filename:
    19061934            self.write_state()
    19071935        self.state_lock.release()
     1936        return proofs
    19081937
    19091938    def clear_placeholder(self, eid, expid, tmpdir):
    … …  
    19451974
    19461975        # Make sure that the caller can talk to us
    1947         self.check_experiment_access(fid, key)
     1976        proof = self.check_experiment_access(fid, key)
    19481977
    19491978        # Install the testbed map entries supplied with the request into a copy
    … …  
    20302059            vtopo = topdl.topology_to_vtopo(top)
    20312060            vis = self.genviz(vtopo)
    2032             self.save_federant_information(allocated, tbparams, eid, vtopo,
    2033                     vis, top)
     2061            proofs = self.save_federant_information(allocated, tbparams,
     2062                    eid, vtopo, vis, top)
    20342063        except service_error, e:
    20352064            # If something goes wrong in the parse (usually an access error)
    … …  
    20422071        # Start the background swapper and return the starting state.  From
    20432072        # here on out, the state will stick around a while.
    2044 
    2045         # XXX: I think this is redundant
    2046         # Let users touch the state
    2047         # self.auth.set_attribute(fid, expid)
    2048         # self.auth.set_attribute(expid, expid)
    2049         # Override fedids can manipulate state as well
    2050         # for o in self.overrides:
    2051             # self.auth.set_attribute(o, expid)
    2052         # self.auth.save()
    20532073
    20542074        # Create a logger that logs to the experiment's state object as well as
    … …  
    20762096                ],
    20772097                'experimentStatus': 'starting',
     2098                'proof': [ proof.to_dict() ] + proofs,
    20782099            }
    20792100
    … …  
    21212142            key = self.get_experiment_fedid(key)
    21222143
    2123         if self.auth.check_attribute(fid, key):
    2124             return True
     2144        access_ok, proof = self.auth.check_attribute(fid, key, with_proof=True)
     2145
     2146        if access_ok:
     2147            return proof
    21252148        else:
    2126             raise service_error(service_error.access, "Access Denied")
     2149            raise service_error(service_error.access, "Access Denied",
     2150                proof)
    21272151
    21282152
    … …  
    21332157        """
    21342158        self.log.info("Get handler %s %s" % (path, fid))
     2159        # XXX: log proofs?
    21352160        if self.auth.check_attribute(fid, path):
    21362161            return ("%s/%s" % (self.repodir, path), "application/binary")
    … …  
    21382163            return (None, None)
    21392164
    2140     def clean_info_response(self, rv):
     2165    def clean_info_response(self, rv, proof):
    21412166        """
    21422167        Remove the information in the experiment's state object that is not in
    … …  
    21622187                if f.has_key('allocID'): del f['allocID']
    21632188                if f.has_key('uri'): del f['uri']
     2189        rv['proof'] = proof.to_dict()
    21642190
    21652191        return rv
    … …  
    21882214            raise service_error(service_error.req, "No request?")
    21892215
    2190         self.check_experiment_access(fid, key)
     2216        proof = self.check_experiment_access(fid, key)
    21912217
    21922218        # The state may be massaged by the service function that called
    … …  
    21992225
    22002226        if rv:
    2201             return self.clean_info_response(rv)
     2227            return self.clean_info_response(rv, proof)
    22022228        else:
    22032229            raise service_error(service_error.req, "No such experiment")
    … …  
    22072233        Return all the stored info that this fedid can access
    22082234        """
    2209         rv = { 'info': [ ] }
     2235        rv = { 'info': [ ], 'proof': [ ] }
    22102236
    22112237        self.state_lock.acquire()
    22122238        for key in [ k for k in self.state.keys() if isinstance(k, fedid)]:
    22132239            try:
    2214                 self.check_experiment_access(fid, key)
     2240                proof = self.check_experiment_access(fid, key)
    22152241            except service_error, e:
    22162242                if e.code == service_error.access:
    … …  
    22222248            if self.state.has_key(key):
    22232249                e = copy.deepcopy(self.state[key])
    2224                 e = self.clean_info_response(e)
     2250                e = self.clean_info_response(e, proof)
    22252251                rv['info'].append(e)
     2252                rv['proof'].append(proof.to_dict())
    22262253        self.state_lock.release()
    22272254        return rv
    … …  
    23512378            if tmpdir: self.remove_dirs(tmpdir)
    23522379
    2353 
    23542380    def terminate_experiment(self, req, fid):
    23552381        """
    … …  
    23642390
    23652391        key = self.get_experiment_key(req, 'experiment')
    2366         self.check_experiment_access(fid, key)
     2392        proof = self.check_experiment_access(fid, key)
    23672393        exp = req.get('experiment', False)
    23682394        force = req.get('force', False)
    … …  
    24162442            if repo:
    24172443                self.remove_dirs("%s/%s" % (self.repodir, repo))
    2418                
     2444       
    24192445            return {
    24202446                    'experiment': exp ,
    24212447                    'deallocationLog': string.join(dealloc_list, ''),
     2448                    'proof': [proof.to_dict()],
    24222449                    }
    24232450        else:
    … …  
    24382465        rv = { 'name': name }
    24392466
    2440         if name and self.auth.check_attribute(fid, name):
     2467        if not name:
     2468            raise service_error(service_error.req, "No name?")
     2469
     2470        access_ok, proof = self.auth.check_attribute(fid, name, with_proof=True)
     2471
     2472        if access_ok:
    24412473            self.log.debug("[GetValue] asking for %s " % name)
    24422474            try:
    … …  
    24482480            if v is not None:
    24492481                rv['value'] = v
     2482            rv['proof'] = proof.to_dict()
    24502483            self.log.debug("[GetValue] got %s from %s" % (v, name))
    24512484            return rv
    24522485        else:
    2453             raise service_error(service_error.access, "Access Denied")
     2486            raise service_error(service_error.access, "Access Denied",
     2487                    proof=proof)
    24542488       
    24552489
    … …  
    24662500        v = req.get('value', '')
    24672501
    2468         if name and self.auth.check_attribute(fid, name):
     2502        if not name:
     2503            raise service_error(service_error.req, "No name?")
     2504
     2505        access_ok, proof = self.auth.check_attribute(fid, name, with_proof=True)
     2506
     2507        if access_ok:
    24692508            try:
    24702509                self.synch_store.set_value(name, v)
    … …  
    24792518                raise service_error(service_error.federant,
    24802519                        "Synch key %s revoked" % name)
    2481             return { 'name': name, 'value': v }
     2520                return { 'name': name, 'value': v, 'proof': proof.to_dict() }
    24822521        else:
    2483             raise service_error(service_error.access, "Access Denied")
     2522            raise service_error(service_error.access, "Access Denied",
     2523                    proof=proof)
Note: See TracChangeset for help on using the changeset viewer.