Changeset b709861 for fedd


Ignore:
Timestamp:
Nov 30, 2011 4:45:15 PM (9 years ago)
Author:
Ted Faber <faber@…>
Branches:
compt_changes, info-ops, master
Children:
1ae1aa2
Parents:
22a1a77
Message:

Rebooting works

Location:
fedd/federation
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • fedd/federation/emulab_access.py

    r22a1a77 rb709861  
    102102            self.stop_segment = proxy_emulab_segment.stop_segment
    103103            self.info_segment = proxy_emulab_segment.info_segment
     104            self.operation_segment = proxy_emulab_segment.operation_segment
    104105        elif self.access_type == 'local_emulab':
    105106            self.start_segment = local_emulab_segment.start_segment
    106107            self.stop_segment = local_emulab_segment.stop_segment
    107108            self.info_segment = local_emulab_segment.info_segment
     109            self.operation_segment = local_emulab_segment.operation_segment
    108110        else:
    109111            self.start_segment = None
    110112            self.stop_segment = None
    111113            self.info_segment = None
     114            self.operation_segment = None
    112115
    113116        self.restricted = [ ]
     
    185188                self.TerminateSegment),
    186189            'InfoSegment': soap_handler("InfoSegment", self.InfoSegment),
     190            'OperationSegment': soap_handler("OperationSegment",
     191                self.OperationSegment),
    187192            }
    188193        self.xmlrpc_services =  {\
     
    195200                self.TerminateSegment),
    196201            'InfoSegment': xmlrpc_handler("InfoSegment", self.InfoSegment),
     202            'OperationSegment': xmlrpc_handler("OperationSegment",
     203                self.OperationSegment),
    197204            }
    198205
     
    10601067                'allocationLog': logv,
    10611068                'segmentdescription': {
    1062                     'topdldescription': t.clone().to_dict()
     1069                    'topdldescription': t.to_dict()
    10631070                    },
    10641071                'proof': proof.to_dict(),
    10651072                }
    1066         self.allocation[aid]['topo'] = topo.clone()
     1073        self.allocation[aid]['topo'] = t
    10671074        retval = copy.copy(self.allocation[aid]['started'])
    10681075        self.write_state()
     
    12391246            user = self.allocation[aid].get('user', None)
    12401247            ename = self.allocation[aid].get('experiment', None)
    1241             nonce = self.allocation[aid].get('nonce', False)
    12421248        else:
    12431249            proj = None
    12441250            user = None
    12451251            ename = None
    1246             nonce = False
     1252            topo = None
    12471253        self.state_lock.release()
    12481254
     
    12701276                'proof': proof.to_dict(),
    12711277                }
     1278
     1279    def OperationSegment(self, req, fid):
     1280        def get_pname(e):
     1281            """
     1282            Get the physical name of a node
     1283            """
     1284            if e.localname:
     1285                return re.sub('\..*','', e.localname[0])
     1286            else:
     1287                return None
     1288
     1289        try:
     1290            req = req['OperationSegmentRequestBody']
     1291        except KeyError:
     1292            raise service_error(server_error.req, "Badly formed request")
     1293
     1294        auth_attr = req['allocID']['fedid']
     1295        aid = "%s" % auth_attr
     1296
     1297        access_ok, proof = self.auth.check_attribute(fid, auth_attr,
     1298                with_proof=True)
     1299        if not access_ok:
     1300            raise service_error(service_error.access, "Access denied")
     1301
     1302        op = req.get('operation', None)
     1303        targets = req.get('target', None)
     1304        params = req.get('parameter', None)
     1305
     1306        if op is None :
     1307            raise service_error(service_error.req, "missing operation")
     1308        elif targets is None:
     1309            raise service_error(service_error.req, "no targets")
     1310
     1311        if aid in self.allocation:
     1312            topo = self.allocation[aid].get('topo', None)
     1313            if topo: topo = topo.clone()
     1314        else:
     1315            topo = None
     1316
     1317        targets = copy.copy(targets)
     1318        ptargets = { }
     1319        for e in topo.elements:
     1320            if isinstance(e, topdl.Computer):
     1321                if e.name in targets:
     1322                    targets.remove(e.name)
     1323                    pn = get_pname(e)
     1324                    if pn: ptargets[e.name] = pn
     1325
     1326        status = [ operation_status(t, operation_status.no_target) \
     1327                for t in targets]
     1328
     1329        ops = self.operation_segment(keyfile=self.ssh_privkey_file,
     1330                debug=self.create_debug, boss=self.boss,
     1331                cert=self.xmlrpc_cert)
     1332        ops(self, op, ptargets, params)
     1333       
     1334        status.extend(ops.status)
     1335
     1336        return {
     1337                'allocID': req['allocID'],
     1338                'status': [s.to_dict() for s in status],
     1339                'proof': proof.to_dict(),
     1340                }
  • fedd/federation/emulab_segment.py

    r22a1a77 rb709861  
    1414from federation.util import fedd_ssl_context
    1515from federation import service_error
     16from federation.operation_status import operation_status
    1617
    1718class emulab_segment:
     
    3233        self.debug = getattr(self, 'debug', False)
    3334        self.node = { }
     35        self.status = [ ]
    3436
    3537    def emulab_call(self, method, params):
     
    103105        if self.debug:
    104106            if self.log:
    105                 self.log.debug("[make_null_experiment]: (debug) Creating experiment")
     107                self.log.debug("[make_null_experiment]: " + \
     108                        "(debug) Creating experiment")
    106109            return True
    107110        else:
     
    243246                        "Cannot get node mapping of segment:%s/%s" % (pid, eid))
    244247
     248    def do_operation(self, op, lnode, pnode, params):
     249        """
     250        Carry out operation on node in the given experiment.
     251        """
     252        def get_param(params, name):
     253            if params is None:
     254                return None
     255            for d in params:
     256                if 'attribute' in d and d['attribute'] == name:
     257                    return d.get('value', None)
     258            else:
     259                return None
     260
     261        op = op.lower()
     262
     263        if op == 'restore':
     264            state = get_param(params, 'state')
     265            if state is None:
     266                self.status.append(operation_status(lnode,
     267                        operation_status.bad_param, 'No state to restore'))
     268                return False
     269            elif state == 'initial':
     270                self.status.append(operation_status(lnode,
     271                        operation_status.unsupp, 'Image load unsupported'))
     272                return False
     273            elif state == 'boot':
     274                p = {'nodes': pnode, 'wait': False}
     275                code, result = self.emulab_call('node.reboot', p)
     276                if code == 0:
     277                    self.status.append(operation_status(lnode,
     278                        operation_status.success, 'rebooting'))
     279                    return True
     280                else:
     281                    self.status.append(operation_status(lnode,
     282                            operation_status.federant, 'Error code: %d' % code))
     283                    return False
     284            else:
     285                self.status.append(operation_status(lnode,
     286                        operation_status.bad_param,
     287                        "Unsupported state %s" % state))
     288                return False
     289        else:
     290            self.status.append(operation_status(lnode, operation_status.unsupp))
     291            return False
     292
  • fedd/federation/experiment_control.py

    r22a1a77 rb709861  
    23912391                    results.append(operation_status(t,
    23922392                        operation_status.federant,
    2393                         'Unexpected error ion %s' % tb))
     2393                        'Unexpected error on %s' % tb))
    23942394        # Clean up the tmpdir no matter what
    23952395        finally:
     
    24122412            else: return { }
    24132413
     2414        def element_name(e):
     2415            if isinstance(e, topdl.Computer): return e.name
     2416            elif isinstance(e, topdl.Testbed):
     2417                if e.localname: return e.localname[0]
     2418                else: return None
     2419            else: return None
     2420
    24142421        req = req.get('OperationRequestBody', None)
    24152422        if not req:
     
    24182425        exp = req.get('experiment', None)
    24192426        op = req.get('operation', None)
    2420         target = set(req.get('target', []))
     2427        targets = set(req.get('target', []))
    24212428        params = req.get('parameter', None)
    24222429
     
    24332440            raise service_error(service_error.req, "No request?")
    24342441
    2435         if op is None or not target
     2442        if op is None or not targets:
    24362443            raise service_error(service_error.req, "No request?")
    24372444
     
    24402447        if key in self.state:
    24412448            d1, op_params, cert, d2 = \
    2442                     self.get_segment_info(self.state[key], need_lock=False)
     2449                    self.get_segment_info(self.state[key], need_lock=False,
     2450                            key='tb')
    24432451            top = self.state[key].top
    24442452            if top is not None:
     
    24532461        results = []
    24542462        for e in top.elements:
    2455             if e.name in targets:
     2463            ename = element_name(e)
     2464            if ename in targets:
    24562465                tb = element_to_tb(e)
     2466                targets.remove(ename)
    24572467                if tb is not None:
    2458                     if tb in testbeds: testbeds[tb].append(e.name)
    2459                     else: testbeds[tb] = [ e.name ]
     2468                    if tb in testbeds: testbeds[tb].append(ename)
     2469                    else: testbeds[tb] = [ ename ]
    24602470                else:
    24612471                    results.append(operation_status(e.name,
     
    24632473                        description='Cannot map target to testbed'))
    24642474
     2475        for t in targets:
     2476            results.append(operation_status(t, operation_status.no_target))
     2477
    24652478        self.operate_on_segments(op_params, cert, op, testbeds, params,
    24662479                results)
     
    24682481        return {
    24692482                'experiment': exp,
    2470                 'status': [make_dict(r) for r in results]
     2483                'status': [make_dict(r) for r in results],
    24712484                'proof': proof.to_dict()
    24722485                }
     
    25242537                    "Experiment has no status!?")
    25252538
    2526     def get_segment_info(self, fed_exp, need_lock=True):
     2539    def get_segment_info(self, fed_exp, need_lock=True, key='aid'):
    25272540        ids = []
    25282541        term_params = { }
     
    25372550            uri = fed.uri
    25382551            aid = fed.allocID
    2539             term_params[aid] = (uri, aid)
     2552            if key == 'aid': term_params[aid] = (uri, aid)
     2553            elif key == 'tb': term_params[fed.tb] = (uri, aid)
     2554
    25402555        if need_lock: self.state_lock.release()
    25412556        return ids, term_params, expcert, repo
  • fedd/federation/local_emulab_segment.py

    r22a1a77 rb709861  
    132132        self.get_mapping(pid,eid)
    133133        return True
     134
     135class operation_segment(local_segment, emulab_segment):
     136    def __init__(self, log=None, keyfile=None, debug=False, boss=None,
     137            cert=None):
     138        local_segment.__init__(self, log=log, keyfile=keyfile, debug=debug)
     139        emulab_segment.__init__(self, boss=boss, cert=cert)
     140
     141    def __call__(self, parent, op, targets, param):
     142        for l, p in targets.items():
     143            self.log.info("[operation_segment]: Calling op on %s(%s)" % (l,p))
     144            self.do_operation(op, l, p, param)
     145        return True
Note: See TracChangeset for help on using the changeset viewer.