Changeset 2761484


Ignore:
Timestamp:
Feb 28, 2010 12:31:25 PM (14 years ago)
Author:
Ted Faber <faber@…>
Branches:
axis_example, compt_changes, info-ops, master, version-3.01, version-3.02
Children:
109a32a
Parents:
ef252e9
Message:

Inital parameterization and synchronization. Tested for Emulabs, but not DRAGON.
Add get and set value synchronization.

Files:
4 edited

Legend:

Unmodified
Added
Removed

  • fedd/federation/emulab_access.py

    ref252e9 r2761484  
    152152            }
    153153
     154        self.call_SetValue = service_caller('SetValue')
     155        self.call_GetValue = service_caller('GetValue')
    154156
    155157        if not config.has_option("allocate", "uri"):
    … …  
    11991201                    "Cannot write experiment file %s: %s" % (expfn,e))
    12001202
     1203    def export_store_info(self, cf, proj, ename, connInfo):
     1204        """
     1205        For the export requests in the connection info, install the peer names
     1206        at the experiment controller via SetValue calls.
     1207        """
     1208
     1209        for c in connInfo:
     1210            for p in [ p for p in c.get('parameter', []) \
     1211                    if p.get('type', '') == 'output']:
     1212
     1213                if p.get('name', '') != 'peer':
     1214                    self.log.error("Unknown export parameter: %s" % \
     1215                            p.get('name'))
     1216                    continue
     1217
     1218                k = p.get('key', None)
     1219                surl = p.get('store', None)
     1220                if surl and k and k.index('/') != -1:
     1221                    value = "%s.%s.%s%s" % \
     1222                            (k[k.index('/')+1:], ename, proj, self.domain)
     1223                    req = { 'name': k, 'value': value }
     1224                    self.call_SetValue(surl, req, cf)
     1225                else:
     1226                    self.log.error("Bad export request: %s" % p)
     1227
     1228    def import_store_info(self, cf, connInfo):
     1229        """
     1230        Pull any import parameters in connInfo in.  We translate them either
     1231        into known member names or fedAddrs.
     1232        """
     1233
     1234        for c in connInfo:
     1235            for p in [ p for p in c.get('parameter', []) \
     1236                    if p.get('type', '') == 'input']:
     1237                name = p.get('name', None)
     1238                key = p.get('key', None)
     1239                store = p.get('store', None)
     1240
     1241                if name and key and store :
     1242                    req = { 'name': key, 'wait': True }
     1243                    r = self.call_GetValue(store, req, cf)
     1244                    r = r.get('GetValueResponseBody', None)
     1245                    if r :
     1246                        if r.get('name', '') == key:
     1247                            v = r.get('value', None)
     1248                            if v is not None:
     1249                                if name == 'peer':
     1250                                    c['peer'] = v
     1251                                else:
     1252                                    if c.has_key('fedAttr'):
     1253                                        c['fedAttr'].append({
     1254                                            'attribute': name, 'value': value})
     1255                                    else:
     1256                                        c['fedAttr']= [{
     1257                                            'attribute': name, 'value': value}]
     1258                            else:
     1259                                raise service_error(service_error.internal,
     1260                                        'None value exported for %s'  % key)
     1261                        else:
     1262                            raise service_error(service_error.internal,
     1263                                    'Different name returned for %s: %s' \
     1264                                            % (key, r.get('name','')))
     1265                    else:
     1266                        raise service_error(service_error.internal,
     1267                            'Badly formatted response: no GetValueResponseBody')
     1268                else:
     1269                    raise service_error(service_error.internal,
     1270                        'Bad Services missing info for import %s' % c)
     1271
    12011272    def StartSegment(self, req, fid):
    12021273        def get_url(url, cf, destdir, fn=None):
    … …  
    12511322            raise service_error(service_error.req,
    12521323                    "Request missing segmentdescription'")
    1253 
     1324       
    12541325        master = req.get('master', False)
    12551326
    … …  
    13531424                        "Can't find creation user for %s" %aid)
    13541425
     1426            self.export_store_info(certfile, proj, ename, connInfo)
     1427            self.import_store_info(certfile, connInfo)
     1428
    13551429            expfile = "%s/experiment.tcl" % tmpdir
    13561430

  • fedd/federation/experiment_control.py

    ref252e9 r2761484  
    2828from remote_service import xmlrpc_handler, soap_handler, service_caller
    2929from service_error import service_error
     30from synch_store import synch_store
    3031
    3132import topdl
    … …  
    239240        self.state_filename = config.get("experiment_control",
    240241                "experiment_state")
     242        self.store_filename = config.get("experiment_control",
     243                "synch_store")
     244        self.store_url = config.get("experiment_control", "store_url")
    241245        self.splitter_url = config.get("experiment_control", "splitter_uri")
    242246        self.fedkit = parse_tarfile_list(\
    … …  
    332336            self.read_state()
    333337
     338        if self.store_filename:
     339            self.read_store()
     340        else:
     341            self.log.warning("No saved synch store")
     342            self.synch_store = synch_store
     343
    334344        # Dispatch tables
    335345        self.soap_services = {\
    … …  
    342352                'Terminate': soap_handler('Terminate',
    343353                    self.terminate_experiment),
     354                'GetValue': soap_handler('GetValue', self.GetValue),
     355                'SetValue': soap_handler('SetValue', self.SetValue),
    344356        }
    345357
    … …  
    353365                'Terminate': xmlrpc_handler('Terminate',
    354366                    self.terminate_experiment),
     367                'GetValue': xmlrpc_handler('GetValue', self.GetValue),
     368                'SetValue': xmlrpc_handler('SetValue', self.SetValue),
    355369        }
    356370
    … …  
    377391            self.log.error("Pickling problem (TypeError): %s" % e)
    378392
     393    @staticmethod
     394    def get_alloc_ids(state):
     395        """
     396        Pull the fedids of the identifiers of each allocation from the
     397        state.  Again, a dict dive that's best isolated.
     398
     399        Used by read_store and read state
     400        """
     401
     402        return [ f['allocID']['fedid']
     403                for f in state.get('federant',[]) \
     404                    if f.has_key('allocID') and \
     405                        f['allocID'].has_key('fedid')]
     406
    379407    # Call while holding self.state_lock
    380408    def read_state(self):
    … …  
    399427            else:
    400428                return None
    401 
    402         def get_alloc_ids(state):
    403             """
    404             Pull the fedids of the identifiers of each allocation from the
    405             state.  Again, a dict dive that's best isolated.
    406             """
    407 
    408             return [ f['allocID']['fedid']
    409                     for f in state.get('federant',[]) \
    410                         if f.has_key('allocID') and \
    411                             f['allocID'].has_key('fedid')]
    412 
    413429
    414430        try:
    … …  
    438454                    # Set permissions to allow reading of the software repo, if
    439455                    # any, as well.
    440                     for a in get_alloc_ids(s):
     456                    for a in self.get_alloc_ids(s):
    441457                        self.auth.set_attribute(a, 'repo/%s' % eid)
    442458                else:
    … …  
    529545                    "open %s: %s" % (file, e))
    530546        f.close()
     547
     548    def read_store(self):
     549        try:
     550            self.synch_store = synch_store()
     551            self.synch_store.load(self.store_filename)
     552            self.log.debug("[read_store]: Read store from %s" % \
     553                    self.store_filename)
     554        except IOError, e:
     555            self.log.warning("[read_store]: No saved store: Can't open %s: %s"\
     556                    % (self.state_filename, e))
     557            self.synch_store = synch_store()
     558
     559        # Set the initial permissions on data in the store.  XXX: This ad hoc
     560        # authorization attribute initialization is getting out of hand.
     561        for k in self.synch_store.all_keys():
     562            try:
     563                if k.startswith('fedid:'):
     564                    fid = fedid(hexstr=k[6:46])
     565                    if self.state.has_key(fid):
     566                        for a in self.get_alloc_ids(self.state[fid]):
     567                            self.auth.set_attribute(a, k)
     568            except ValueError, e:
     569                self.log.warn("Cannot deduce permissions for %s" % k)
     570
     571
     572    def write_store(self):
     573        """
     574        Write a new copy of synch_store after writing current state
     575        to a backup.  We use the internal synch_store pickle method to avoid
     576        incinsistent data.
     577
     578        State format is a simple pickling of the store.
     579        """
     580        if os.access(self.store_filename, os.W_OK):
     581            copy_file(self.store_filename, \
     582                    "%s.bak" % self.store_filename)
     583        try:
     584            self.synch_store.save(self.store_filename)
     585        except IOError, e:
     586            self.log.error("Can't write file %s: %s" % \
     587                    (self.store_filename, e))
     588        except TypeError, e:
     589            self.log.error("Pickling problem (TypeError): %s" % e)
     590
    531591       
    532592    def generate_ssh_keys(self, dest, type="rsa" ):
    … …  
    13241384
    13251385    def new_portal_node(self, st, dt, tbparams, master, eid, myname, desthost,
    1326             portal_type, iface_desc=(), conn_type="ssh", conn_attrs=[]):
     1386            portal_type, iface_desc=(), conn_type="ssh", conn_attrs=[],
     1387            expid=None):
    13271388        """
    13281389        Return a new internet portal node and a dict with the connectionInfo to
    … …  
    13551416            ifaces.append(inf)
    13561417        if conn_type == "ssh":
     1418            try:
     1419                aid = tbparams[st]['allocID']['fedid']
     1420            except:
     1421                self.log.debug("Can't get allocation id?")
     1422                aid = None
    13571423            info = {
    13581424                    "type" : conn_type,
    13591425                    "portal": myname,
    1360                     'peer': desthost,
    13611426                    'fedAttr': [
    13621427                            { 'attribute': 'masterdomain', 'value': mdomain},
    … …  
    13681433                            { 'attribute': 'smbshare', 'value': smbshare},
    13691434                        ],
     1435                    'parameter': [
     1436                        {
     1437                            'name': 'peer',
     1438                            'key': 'fedid:%s/%s' % (expid, myname),
     1439                            'store': self.store_url,
     1440                            'type': 'output',
     1441                        },
     1442                        {
     1443                            'name': 'peer',
     1444                            'key': 'fedid:%s/%s' % (expid, desthost),
     1445                            'store': self.store_url,
     1446                            'type': 'input',
     1447                        },
     1448                        ]
    13701449                    }
     1450            # Give this allocation the rights to access the key of the
     1451            # peers
     1452            if aid:
     1453                for h in (myname, desthost):
     1454                    self.auth.set_attribute(aid, 'fedid:%s/%s' % (expid, h))
     1455            else:
     1456                self.log.error("No aid for %s in new_portal_node" % st)
    13711457        else:
    13721458            info = None
    … …  
    13841470                ), info)
    13851471
    1386     def new_portal_substrate(self, st, dt, eid, tbparams):
     1472    def new_portal_substrate(self, st, dt, eid, tbparams, expid):
    13871473        ddomain = tbparams[dt].get('domain', ".example.com")
    13881474        dproject = tbparams[dt].get('project', 'project')
    … …  
    14141500        return (tsubstrate, segment_element)
    14151501
    1416     def new_dragon_topo(self, idx, sub, topo, tbs, tbparams):
     1502    def new_dragon_topo(self, idx, sub, topo, tbs, tbparams, connInfo, expid):
    14171503        if sub.capacity is None:
    14181504            raise service_error(service_error.internal,
    … …  
    14241510                    for n, v, in (\
    14251511                            ('vlan', 'unassigned%d' % idx),)])
     1512        name = "dragon%d" % idx
    14261513        for tb in tbs.keys():
    14271514            seg = topdl.Segment(
    … …  
    14421529            segs.append(seg)
    14431530
    1444         topo["dragon%d" %idx] = \
     1531
     1532        try:
     1533            aid = tbparams[tb]['allocID']['fedid']
     1534        except:
     1535            self.log.debug("Can't get allocation id?")
     1536            aid = None
     1537        connInfo[name] = [ {
     1538            'parameter': [ {
     1539                'name': 'vlan_id',
     1540                'key': "fedid:%s/vlan%d" % (expid, idx),
     1541                'store': self.store_url,
     1542                'type': 'output'
     1543                } ]
     1544            } ]
     1545
     1546        # Give this allocation the rights to access the key of the
     1547        # vlan_id
     1548        if aid:
     1549            self.auth.set_attribute(aid, 'fedid:%s/vlan%d' % (expid, idx))
     1550
     1551        topo[name] = \
    14451552                topdl.Topology(substrates=[substr], elements=segs,
    14461553                        attribute=[
    … …  
    14521559
    14531560    def create_dragon_substrate(self, sub, topo, tbs, tbparams, master, eid,
    1454             connInfo, peer={ }):
     1561            connInfo, peer={ }, expid=None):
    14551562        """
    14561563        Add attribiutes to the various elements indicating that they are to be
    … …  
    14861593                if not connInfo.has_key(tb):
    14871594                    connInfo[tb] = [ ]
     1595
     1596                try:
     1597                    aid = tbparams[tb]['allocID']['fedid']
     1598                except:
     1599                    self.log.debug("Can't get allocation id?")
     1600                    aid = None
    14881601
    14891602                # This may need another look, but only a service gateway will
    … …  
    15061619                            { 'attribute': 'active', 'value': active},
    15071620                            ],
     1621                        'parameter': [ {
     1622                            'name': 'vlan_id',
     1623                            'key': 'fedid:%s/vlan%d' % (expid, dn),
     1624                            'store': self.store_url,
     1625                            'type': 'input',
     1626                            } ]
    15081627                        }
    15091628                if peer.has_key(tb):
    15101629                    info['peer'] = peer[tb]
    15111630                connInfo[tb].append(info)
     1631
     1632                # Give this allocation the rights to access the key of the
     1633                # vlan_id
     1634                if aid:
     1635                    self.auth.set_attribute(aid,
     1636                            'fedid:%s/vlan%d' % (expid, dn))
    15121637            else:
    15131638                raise service_error(service_error.internal,
    … …  
    15171642
    15181643    def insert_internet_portals(self, sub, topo, tbs, tbparams, master, eid,
    1519             segment_substrate, portals, connInfo):
     1644            segment_substrate, portals, connInfo, expid):
    15201645        # More than one testbed is on this substrate.  Insert
    15211646        # some portals into the subtopologies.  st == source testbed,
    … …  
    15461671                    # testbed in there.
    15471672                    tsubstrate, segment_element = \
    1548                             self.new_portal_substrate(st, dt, eid, tbparams)
     1673                            self.new_portal_substrate(st, dt, eid, tbparams,
     1674                                    expid)
    15491675                    segment_substrate[st][dt] = tsubstrate
    15501676                    topo[st].substrates.append(tsubstrate)
    … …  
    15671693                        portal_type = "experiment"
    15681694                        myname = "%stunnel%d" % (dt, len(portals[st][dt]))
    1569                         desthost = "%stunnel%d.%s.%s%s" % (st,
    1570                                 len(portals[st][dt]), eid.lower(),
    1571                                 dproject.lower(), ddomain.lower())
     1695                        desthost = "%stunnel%d" % (st.lower(),
     1696                                len(portals[st][dt]))
    15721697                    else:
    15731698                        new_i = topdl.Interface(
    … …  
    15861711                    portals[st][dt] = [ ]
    15871712                    myname = "%stunnel%d" % (dt, len(portals[st][dt]))
    1588                     desthost = "%stunnel%d.%s.%s%s" % (st.lower(),
    1589                             len(portals[st][dt]), eid.lower(),
    1590                             dproject.lower(), ddomain.lower())
     1713                    desthost = "%stunnel%d" % (st.lower(), len(portals[st][dt]))
    15911714
    15921715                    if dt == master or st == master: portal_type = "both"
    … …  
    16021725                    portal, info  =  self.new_portal_node(st, dt, tbparams,
    16031726                            master, eid, myname, desthost, portal_type,
    1604                             infs)
     1727                            infs, conn_type="ssh", conn_attrs=[], expid=expid)
    16051728                    if self.fedkit:
    16061729                        self.add_kit(portal, self.fedkit)
    … …  
    16121735                    connInfo[st].append(info)
    16131736
    1614     def add_control_portal(self, st, dt, master, eid, topo, tbparams, connInfo):
     1737    def add_control_portal(self, st, dt, master, eid, topo, tbparams, connInfo, expid):
    16151738        # Add to the master testbed
    16161739        tsubstrate, segment_element = \
    1617                 self.new_portal_substrate(st, dt, eid, tbparams)
     1740                self.new_portal_substrate(st, dt, eid, tbparams, expid)
    16181741        myname = "%stunnel" % dt
    16191742        desthost = "%stunnel" % st
    … …  
    16211744        portal, info = self.new_portal_node(st, dt, tbparams, master,
    16221745                eid, myname, desthost, "control",
    1623                 ((tsubstrate.name,(('portal','true'),)),))
     1746                ((tsubstrate.name,(('portal','true'),)),), conn_type="ssh",
     1747                conn_attrs=[], expid=expid)
    16241748        if self.fedkit:
    16251749            self.add_kit(portal, self.fedkit)
    … …  
    16351759
    16361760    def new_dragon_portal(self, st, dt, master, eid, myip, dip, idx,
    1637             substrate, tbparams):
     1761            substrate, tbparams, expid):
    16381762        # Add to the master testbed
    16391763        myname = "%stunnel" % dt
    … …  
    16451769                    ('portal','true'),
    16461770                    ('ip4_address', "%s" % ip_addr(myip)),)),),
    1647                 conn_type="transit")
     1771                conn_type="transit", conn_attrs=[], expid=expid)
    16481772        if self.fedkit:
    16491773            self.add_kit(portal, self.fedkit)
    … …  
    16541778
    16551779    def add_portals(self, top, topo, eid, master, tbparams, ip_allocator,
    1656             connInfo):
     1780            connInfo, expid):
    16571781        """
    16581782        For each substrate in the main topology, find those that
    … …  
    16801804                    all([tbparams[x].has_key('dragon') for x in tbs]):
    16811805                self.create_dragon_substrate(s, topo, tbs, tbparams,
    1682                         master, eid, connInfo)
     1806                        master, eid, connInfo, expid)
    16831807            else:
    16841808                self.insert_internet_portals(s, topo, tbs, tbparams, master,
    1685                         eid, segment_substrate, portals, connInfo)
     1809                        eid, segment_substrate, portals, connInfo, expid)
    16861810
    16871811        # Make sure that all the slaves have a control portal back to the
    … …  
    17331857                            )
    17341858                    portal = self.new_dragon_portal(tb, master,
    1735                             master, eid, dip, mip, idx, csub, tbparams)
     1859                            master, eid, dip, mip, idx, csub, tbparams, expid)
    17361860                    topo[tb].substrates.append(csub)
    17371861                    topo[tb].elements.append(portal)
    … …  
    17601884                            )
    17611885                    portal = self.new_dragon_portal(master, tb, master,
    1762                             eid, mip, dip, idx, mcsub, tbparams)
     1886                            eid, mip, dip, idx, mcsub, tbparams, expid)
    17631887                    topo[master].substrates.append(mcsub)
    17641888                    topo[master].elements.append(portal)
    … …  
    17691893                    self.create_dragon_substrate(csub, topo,
    17701894                            {tb: 1, master:1}, tbparams, master, eid, connInfo,
    1771                             {tb: ip_addr(mip), master: ip_addr(dip)})
     1895                            {tb: ip_addr(mip), master: ip_addr(dip)}, expid)
    17721896                else:
    17731897                    self.add_control_portal(master, tb, master, eid, topo,
    1774                             tbparams, connInfo)
     1898                            tbparams, connInfo, expid)
    17751899                    self.add_control_portal(tb, master, master, eid, topo,
    1776                             tbparams, connInfo)
     1900                            tbparams, connInfo, expid)
    17771901
    17781902        # Connect the portal nodes into the topologies and clear out
    … …  
    21032227
    21042228            self.add_portals(top, topo, eid, master, tbparams, ip_allocator,
    2105                     connInfo)
     2229                    connInfo, expid)
    21062230            # Now get access to the dynamic testbeds
    21072231            for k, t in topo.items():
    … …  
    25852709            self.state_lock.release()
    25862710
     2711            # Delete any synch points associated with this experiment.  All
     2712            # synch points begin with the fedid of the experiment.
     2713            fedid_keys = set(["fedid:%s" % f for f in ids \
     2714                    if isinstance(f, fedid)])
     2715            for k in self.synch_store.all_keys():
     2716                try:
     2717                    if len(k) > 45 and k[0:46] in fedid_keys:
     2718                        self.synch_store.del_value(k)
     2719                except synch_store.BadDeleteionError:
     2720                    pass
     2721            self.write_store()
     2722               
    25872723            return {
    25882724                    'experiment': exp ,
    … …  
    25932729            self.state_lock.release()
    25942730            raise service_error(service_error.req, "No saved state")
     2731
     2732
     2733    def GetValue(self, req, fid):
     2734        """
     2735        Get a value from the synchronized store
     2736        """
     2737        req = req.get('GetValueRequestBody', None)
     2738        if not req:
     2739            raise service_error(service_error.req,
     2740                    "Bad request format (no GetValueRequestBody)")
     2741       
     2742        name = req['name']
     2743        wait = req['wait']
     2744        rv = { 'name': name }
     2745
     2746        if self.auth.check_attribute(fid, name):
     2747            v = self.synch_store.get_value(name, wait)
     2748            if v is not None:
     2749                rv['value'] = v
     2750            return rv
     2751        else:
     2752            raise service_error(service_error.access, "Access Denied")
     2753       
     2754
     2755    def SetValue(self, req, fid):
     2756        """
     2757        Set a value in the synchronized store
     2758        """
     2759        req = req.get('SetValueRequestBody', None)
     2760        if not req:
     2761            raise service_error(service_error.req,
     2762                    "Bad request format (no SetValueRequestBody)")
     2763       
     2764        name = req['name']
     2765        v = req['value']
     2766
     2767        if self.auth.check_attribute(fid, name):
     2768            try:
     2769                self.synch_store.set_value(name, v)
     2770                self.write_store()
     2771            except synch_store.CollisionError:
     2772                # Translate into a service_error
     2773                raise service_error(service_error.req,
     2774                        "Value already set: %s" %name)
     2775            return { 'name': name, 'value': v }
     2776        else:
     2777            raise service_error(service_error.access, "Access Denied")

  • wsdl/fedd.wsdl

    ref252e9 r2761484  
    108108  </message>
    109109
     110  <message name="SetValueRequestMessage">
     111    <part name="SetValueRequestBody" type="xsd1:setValueRequestType"/>
     112  </message>
     113
     114  <message name="SetValueResponseMessage">
     115    <part name="SetValueResponseBody" type="xsd1:setValueResponseType"/>
     116  </message>
     117
     118  <message name="GetValueRequestMessage">
     119    <part name="GetValueRequestBody" type="xsd1:getValueRequestType"/>
     120  </message>
     121
     122  <message name="GetValueResponseMessage">
     123    <part name="GetValueResponseBody" type="xsd1:getValueResponseType"/>
     124  </message>
    110125
    111126  <message name="FaultMessage">
    … …  
    225240      <fault name="TerminateSegmentFeddFault" message="tns:FaultMessage"/>
    226241    </operation>
     242
     243    <operation name="SetValue">
     244      <documentation>
     245        Set a shared value
     246      </documentation>
     247      <input message="tns:SetValueRequestMessage"/>
     248      <output message="tns:SetValueResponseMessage"/>
     249      <fault name="TerminateSegmentFeddFault" message="tns:FaultMessage"/>
     250    </operation>
     251
     252    <operation name="GetValue">
     253      <documentation>
     254        Get a shared value
     255      </documentation>
     256      <input message="tns:GetValueRequestMessage"/>
     257      <output message="tns:GetValueResponseMessage"/>
     258      <fault name="TerminateSegmentFeddFault" message="tns:FaultMessage"/>
     259    </operation>
    227260  </portType>
    228261
    … …  
    462495        </output>
    463496        <fault name="TerminateSegmentFeddFault">
     497          <soap:fault use="literal"  name="tns:FeddFault"
     498            namespace="http://www.isi.edu/faber/fedd.wsdl"
     499            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     500        </fault>
     501      </operation>
     502      <operation name="SetValue">
     503        <documentation>
     504          The bindings of this operation are straightforward SOAP RPC 1.1.
     505        </documentation>
     506        <soap:operation soapAction="TerminateSegment"/>
     507        <input>
     508          <soap:body use="literal" parts="tns:SetValueRequestBody"
     509            namespace="http://www.isi.edu/faber/fedd.wsdl"
     510            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     511        </input>
     512        <output>
     513          <soap:body use="literal" parts="tns:SetValueResponseBody"
     514            namespace="http://www.isi.edu/faber/fedd.wsdl"
     515            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     516        </output>
     517        <fault name="SetValueFeddFault">
     518          <soap:fault use="literal"  name="tns:FeddFault"
     519            namespace="http://www.isi.edu/faber/fedd.wsdl"
     520            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     521        </fault>
     522      </operation>
     523      <operation name="GetValue">
     524        <documentation>
     525          The bindings of this operation are straightforward SOAP RPC 1.1.
     526        </documentation>
     527        <soap:operation soapAction="TerminateSegment"/>
     528        <input>
     529          <soap:body use="literal" parts="tns:GetValueRequestBody"
     530            namespace="http://www.isi.edu/faber/fedd.wsdl"
     531            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     532        </input>
     533        <output>
     534          <soap:body use="literal" parts="tns:GetValueResponseBody"
     535            namespace="http://www.isi.edu/faber/fedd.wsdl"
     536            encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
     537        </output>
     538        <fault name="GetValueFeddFault">
    464539          <soap:fault use="literal"  name="tns:FeddFault"
    465540            namespace="http://www.isi.edu/faber/fedd.wsdl"

  • wsdl/fedd_types.xsd

    ref252e9 r2761484  
    368368  </xsd:complexType>
    369369
     370  <xsd:simpleType name="connectionParameterIOType">
     371    <xsd:annotation>
     372      <xsd:documentation>
     373        Connection parameter types: input or output
     374      </xsd:documentation>
     375    </xsd:annotation>
     376    <xsd:restriction base="xsd:string">
     377      <xsd:enumeration value="input"/>
     378      <xsd:enumeration value="output"/>
     379    </xsd:restriction>
     380  </xsd:simpleType>
     381
     382  <xsd:complexType name="connectionParameterType">
     383    <xsd:annotation>
     384      <xsd:documentation>
     385        This is a parameter on which two or more access controllers have to
     386        agree in order to complete the stitching.  This gives the name of the
     387        parameter, the key under which to store it (or it has been stored)  and
     388        whether it is to be input or output.
     389      </xsd:documentation>
     390    </xsd:annotation>
     391    <xsd:sequence>
     392      <xsd:element name="name" type="xsd:string"/>
     393      <xsd:element name="key" type="xsd:string"/>
     394      <xsd:element name="store" type="xsd:string"/>
     395      <xsd:element name="type" type="tns:connectionParameterIOType"/>
     396    </xsd:sequence>
     397  </xsd:complexType>
     398
     399
    370400  <xsd:complexType name="connectionInfoType">
    371401    <xsd:annotation>
    … …  
    384414      <xsd:element name="fedAttr" type="tns:fedAttrType" minOccurs="0"
    385415        maxOccurs="unbounded"/>
     416      <xsd:element name="parameter" type="tns:connectionParameterType"
     417        minOccurs="0" maxOccurs="unbounded"/>
    386418    </xsd:sequence>
    387419  </xsd:complexType>
    … …  
    820852  </xsd:complexType>
    821853
     854  <xsd:complexType name="setValueRequestType">
     855    <xsd:annotation>
     856      <xsd:documentation>
     857        Request to set a shared value.
     858      </xsd:documentation>
     859    </xsd:annotation>
     860    <xsd:sequence>
     861      <xsd:element name="name" type="xsd:string"/>
     862      <xsd:element name="value" type="xsd:string"/>
     863    </xsd:sequence>
     864  </xsd:complexType>
     865
     866  <xsd:complexType name="setValueResponseType">
     867    <xsd:annotation>
     868      <xsd:documentation>
     869        Request to set a shared value.
     870      </xsd:documentation>
     871    </xsd:annotation>
     872    <xsd:sequence>
     873      <xsd:element name="name" type="xsd:string"/>
     874      <xsd:element name="value" type="xsd:string"/>
     875    </xsd:sequence>
     876  </xsd:complexType>
     877
     878  <xsd:complexType name="getValueRequestType">
     879    <xsd:annotation>
     880      <xsd:documentation>
     881        Request to set a shared value.
     882      </xsd:documentation>
     883    </xsd:annotation>
     884    <xsd:sequence>
     885      <xsd:element name="name" type="xsd:string"/>
     886      <xsd:element name="wait" type="xsd:boolean"/>
     887    </xsd:sequence>
     888  </xsd:complexType>
     889
     890  <xsd:complexType name="getValueResponseType">
     891    <xsd:annotation>
     892      <xsd:documentation>
     893        Request to set a shared value.
     894      </xsd:documentation>
     895    </xsd:annotation>
     896    <xsd:sequence>
     897      <xsd:element name="name" type="xsd:string"/>
     898      <xsd:element name="value" type="xsd:string" minOccurs="0" maxOccurs="1"/>
     899    </xsd:sequence>
     900  </xsd:complexType>
    822901
    823902  <xsd:complexType name="faultType">
Note: See TracChangeset for help on using the changeset viewer.