示例#1
0
    def verify_slice(self,
                     slice_hrn,
                     slice_record,
                     sfa_peer,
                     expiration,
                     options={}):
        #top_auth_hrn = top_auth(slice_hrn)
        #site_hrn = '.'.join(slice_hrn.split('.')[:-1])
        #slice_part = slice_hrn.split('.')[-1]
        #if top_auth_hrn == self.driver.hrn:
        #    login_base = slice_hrn.split('.')[-2][:12]
        #else:
        #    login_base = hash_loginbase(site_hrn)
        #slice_name = '_'.join([login_base, slice_part])
        plxrn = PlXrn(xrn=slice_hrn)
        slice_hrn = plxrn.get_hrn()
        type = plxrn.get_type()
        site_hrn = plxrn.get_authority_hrn()
        authority_name = plxrn.pl_authname()
        slicename = plxrn.pl_slicename()
        login_base = plxrn.pl_login_base()

        slices = self.driver.shell.GetSlices({'peer_id': None},
                                             ['slice_id', 'name', 'hrn'])
        # Filter slices by HRN
        slice_exists = [slice for slice in slices if slice['hrn'] == slice_hrn]
        expires = int(datetime_to_epoch(utcparse(expiration)))
        if not slice_exists:
            if slice_record:
                url = slice_record.get('url', slice_hrn)
                description = slice_record.get('description', slice_hrn)
            else:
                url = slice_hrn
                description = slice_hrn
            slice = {
                'name': slice_name,
                'url': url,
                'description': description
            }
            # add the slice
            slice['slice_id'] = self.driver.shell.AddSlice(slice)
            # set the slice HRN
            self.driver.shell.SetSliceHrn(int(slice['slice_id']), slice_hrn)
            # Tag this as created through SFA
            self.driver.shell.SetSliceSfaCreated(int(slice['slice_id']),
                                                 'True')
            # set the expiration
            self.driver.shell.UpdateSlice(int(slice['slice_id']),
                                          {'expires': expires})

        else:
            slice = slice_exists[0]
            #Update expiration if necessary
            if slice.get('expires', None) != expires:
                self.driver.shell.UpdateSlice(int(slice['slice_id']),
                                              {'expires': expires})

        return self.driver.shell.GetSlices(int(slice['slice_id']))[0]
示例#2
0
    def verify_site(self,
                    slice_xrn,
                    slice_record={},
                    sfa_peer=None,
                    options={}):
        #(slice_hrn, type) = urn_to_hrn(slice_xrn)
        #top_auth_hrn = top_auth(slice_hrn)
        #site_hrn = '.'.join(slice_hrn.split('.')[:-1])
        #if top_auth_hrn == self.driver.hrn:
        #    login_base = slice_hrn.split('.')[-2][:12]
        #else:
        #    login_base = hash_loginbase(site_hrn)
        plxrn = PlXrn(xrn=slice_xrn)
        slice_hrn = plxrn.get_hrn()
        type = plxrn.get_type()
        site_hrn = plxrn.get_authority_hrn()
        authority_name = plxrn.pl_authname()
        slicename = plxrn.pl_slicename()
        login_base = plxrn.pl_login_base()

        sites = self.driver.shell.GetSites(
            {'peer_id': None},
            ['site_id', 'name', 'abbreviated_name', 'login_base', 'hrn'])

        # filter sites by hrn
        site_exists = [site for site in sites if site['hrn'] == site_hrn]

        if not site_exists:
            # create new site record
            site = {
                'name': 'sfa:%s' % site_hrn,
                'abbreviated_name': site_hrn,
                'login_base': login_base,
                'max_slices': 100,
                'max_slivers': 1000,
                'enabled': True,
                'peer_site_id': None
            }

            site['site_id'] = self.driver.shell.AddSite(site)
            # Set site HRN
            self.driver.shell.SetSiteHrn(int(site['site_id']), site_hrn)
            # Tag this as created through SFA
            self.driver.shell.SetSiteSfaCreated(int(site['site_id']), 'True')
            # exempt federated sites from monitor policies
            self.driver.shell.AddSiteTag(int(site['site_id']),
                                         'exempt_site_until', "20200101")

        else:
            site = site_exists[0]

        return site
示例#3
0
def redeem_ticket(api, ticket_string):
    ticket = SfaTicket(string=ticket_string)
    ticket.decode()
    hrn = ticket.attributes['slivers'][0]['hrn']
    slicename = PlXrn (hrn).pl_slicename()
    if not api.sliver_exists(slicename):
        raise SliverDoesNotExist(slicename)

    # convert ticket to format nm is used to
    nm_ticket = xmlrpclib.dumps((ticket.attributes,), methodresponse=True)
    api.driver.nodemanager.AdminTicket(nm_ticket)
示例#4
0
    def node_to_rspec_node(self, node, sites, interfaces, node_tags, pl_initscripts=None, grain=None, options=None):
        if pl_initscripts is None: pl_initscripts=[]
        if options is None: options={}
        rspec_node = NodeElement()
        # xxx how to retrieve site['login_base']
        site=sites[node['site_id']]
        rspec_node['component_id'] = hostname_to_urn(self.driver.hrn, site['login_base'], node['hostname'])
        rspec_node['component_name'] = node['hostname']
        rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn()
        rspec_node['authority_id'] = hrn_to_urn(PlXrn.site_hrn(self.driver.hrn, site['login_base']), 'authority+sa')
        # do not include boot state (<available> element) in the manifest rspec
        rspec_node['boot_state'] = node['boot_state']
        if node['boot_state'] == 'boot': 
            rspec_node['available'] = 'true'
        else:
            rspec_node['available'] = 'false'

        #distinguish between Shared and Reservable nodes
        if node['node_type'] == 'reservable':
            rspec_node['exclusive'] = 'true'
        else:
            rspec_node['exclusive'] = 'false'

        rspec_node['hardware_types'] = [HardwareType({'name': 'plab-pc'}),
                                        HardwareType({'name': 'pc'})]
        # only doing this because protogeni rspec needs
        # to advertise available initscripts
        rspec_node['pl_initscripts'] = pl_initscripts.values()
        # add site/interface info to nodes.
        # assumes that sites, interfaces and tags have already been prepared.
        if site['longitude'] and site['latitude']:
            location = Location({'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown'})
            rspec_node['location'] = location
        # Granularity
        granularity = Granularity({'grain': grain})
        rspec_node['granularity'] = granularity
        rspec_node['interfaces'] = []
        if_count=0
        for if_id in node['interface_ids']:
            interface = Interface(interfaces[if_id])
            interface['ipv4'] = interface['ip']
            interface['component_id'] = PlXrn(auth=self.driver.hrn,
                                              interface='node%s:eth%s' % (node['node_id'], if_count)).get_urn()
            # interfaces in the manifest need a client id
            if slice:
                interface['client_id'] = "%s:%s" % (node['node_id'], if_id)
            rspec_node['interfaces'].append(interface)
            if_count+=1
        tags = [PLTag(node_tags[tag_id]) for tag_id in node['node_tag_ids'] if tag_id in node_tags]
        rspec_node['tags'] = tags
        return rspec_node
 def add_slivers(xml, slivers):
     if not slivers:
         return
     if not isinstance(slivers, list):
         slivers = [slivers]
     for sliver in slivers:
         sliver_elem = xml.add_instance('sliver', sliver, ['name'])
         tags = sliver.get('tags', [])
         if tags:
             for tag in tags:
                 NITOSv1Sliver.add_sliver_attribute(sliver_elem, tag['tagname'], tag['value'])
         if sliver.get('sliver_id'):
             name = PlXrn(xrn=sliver.get('sliver_id')).pl_slicename()
             sliver_elem.set('name', name)
示例#6
0
文件: pldriver.py 项目: gnogueras/sfa
    def sfa_fields_to_pl_fields(self, type, hrn, sfa_record):

        pl_record = {}

        if type == "slice":
            pl_record["name"] = hrn_to_pl_slicename(hrn)
            if "instantiation" in sfa_record:
                pl_record['instantiation'] = sfa_record['instantiation']
            else:
                pl_record["instantiation"] = "plc-instantiated"
            if "url" in sfa_record:
                pl_record["url"] = sfa_record["url"]
            if "description" in sfa_record:
                pl_record["description"] = sfa_record["description"]
            if "expires" in sfa_record:
                date = utcparse(sfa_record['expires'])
                expires = datetime_to_epoch(date)
                pl_record["expires"] = expires

        elif type == "node":
            if not "hostname" in pl_record:
                # fetch from sfa_record
                if "hostname" not in sfa_record:
                    raise MissingSfaInfo("hostname")
                pl_record["hostname"] = sfa_record["hostname"]
            if "model" in sfa_record:
                pl_record["model"] = sfa_record["model"]
            else:
                pl_record["model"] = "geni"

        elif type == "authority":
            pl_record["login_base"] = PlXrn(xrn=hrn,
                                            type='authority').pl_login_base()
            if "name" not in sfa_record:
                pl_record["name"] = hrn
            if "abbreviated_name" not in sfa_record:
                pl_record["abbreviated_name"] = hrn
            if "enabled" not in sfa_record:
                pl_record["enabled"] = True
            if "is_public" not in sfa_record:
                pl_record["is_public"] = True

        return pl_record
示例#7
0
def reset_slice(api, xrn):
    slicename = PlXrn(xrn, type='slice').pl_slicename()
    if not api.sliver_exists(slicename):
        raise SliverDoesNotExist(slicename)
    api.driver.nodemanager.ReCreate(slicename)
示例#8
0
def DeleteSliver(api, xrn, creds, call_id):
    slicename = PlXrn(xrn, type='slice').pl_slicename()
    api.driver.nodemanager.Destroy(slicename)
示例#9
0
def stop_slice(api, xrn, creds):
    slicename = PlXrn(xrn, type='slice').pl_slicename()
    api.driver.nodemanager.Stop(slicename)
示例#10
0
文件: testXrn.py 项目: gnogueras/sfa
 def test_person001(self):
     xrn = PlXrn(auth="ple.inria", email="*****@*****.**")
     self.assertEqual(xrn.get_hrn_type(),
                      ("ple.inria.first_last", 'person'))
示例#11
0
文件: testXrn.py 项目: gnogueras/sfa
 def test_slice001(self):
     xrn = PlXrn(auth="ple", slicename="inria_omftest")
     self.assertEqual(xrn.get_hrn_type(), ("ple.inria.omftest", 'slice'))
示例#12
0
文件: testXrn.py 项目: gnogueras/sfa
 def test_host002(self):
     xrn = PlXrn(auth="ple\\.inria", hostname="onelab09.pl.sophia.inria.fr")
     self.assertEqual(
         xrn.get_hrn_type(),
         ("ple\\.inria.onelab09\\.pl\\.sophia\\.inria\\.fr", 'node'))
示例#13
0
文件: testXrn.py 项目: gnogueras/sfa
 def test_authname_001(self):
     xrn = PlXrn(xrn='ple.inria.omftest', type='slice')
     self.assertEqual(xrn.pl_authname(), 'inria')
示例#14
0
    def get_slivers(self, urns, options=None):
        if options is None: options={}
        names = set()
        slice_ids = set()
        node_ids = []
        slice_hrn = None
        for urn in urns:
            xrn = PlXrn(xrn=urn)
            if xrn.type == 'sliver':
                 # id: slice_id-node_id
                try:
                    sliver_id_parts = xrn.get_sliver_id_parts()
                    slice_id = int(sliver_id_parts[0]) 
                    node_id = int(sliver_id_parts[1])
                    slice_ids.add(slice_id) 
                    node_ids.append(node_id)
                except ValueError:
                    pass 
            else:  
                slice_hrn = xrn.get_hrn()

        filter = {}
        filter['peer_id'] = None
        if slice_ids:
            filter['slice_id'] = list(slice_ids)
        # get all slices
        all_slices = self.driver.shell.GetSlices(filter, ['slice_id', 'name', 'hrn', 'person_ids', 'node_ids', 'slice_tag_ids', 'expires'])
        if slice_hrn:
            slices = [slice for slice in all_slices if slice['hrn'] == slice_hrn]
        else:
            slices = all_slices
      
        if not slices:
            return []
        slice = slices[0]     
        slice['hrn'] = slice_hrn   

        # get sliver users
        persons = []
        person_ids = []
        for slice in slices:
            person_ids.extend(slice['person_ids'])
        if person_ids:
            persons = self.driver.shell.GetPersons(person_ids)
                 
        # get user keys
        keys = {}
        key_ids = []
        for person in persons:
            key_ids.extend(person['key_ids'])
        
        if key_ids:
            key_list = self.driver.shell.GetKeys(key_ids)
            for key in key_list:
                keys[key['key_id']] = key  

        # construct user key info
        users = []
        for person in persons:
            person_urn = hrn_to_urn(self.driver.shell.GetPersonHrn(int(person['person_id'])), 'user')
            user = {
                'login': slice['name'], 
                'user_urn': person_urn,
                'keys': [keys[k_id]['key'] for k_id in person['key_ids'] if k_id in keys]
            }
            users.append(user)

        if node_ids:
            node_ids = [node_id for node_id in node_ids if node_id in slice['node_ids']]
            slice['node_ids'] = node_ids
        tags_dict = self.get_slice_tags(slice)
        nodes_dict = self.get_slice_nodes(slice, options)
        slivers = []
        for node in nodes_dict.values():
            node.update(slice) 
            node['tags'] = tags_dict[node['node_id']]
            sliver_hrn = '%s.%s-%s' % (self.driver.hrn, slice['slice_id'], node['node_id'])
            node['sliver_id'] = Xrn(sliver_hrn, type='sliver').urn
            node['urn'] = node['sliver_id'] 
            node['services_user'] = users
            slivers.append(node)
        return slivers
示例#15
0
文件: pldriver.py 项目: gnogueras/sfa
    def register(self, sfa_record, hrn, pub_key):
        type = sfa_record['type']
        pl_record = self.sfa_fields_to_pl_fields(type, hrn, sfa_record)

        if type == 'authority':
            sites = self.shell.GetSites({
                'peer_id': None,
                'login_base': pl_record['login_base']
            })
            if not sites:
                # xxx when a site gets registered through SFA we need to set its max_slices
                if 'max_slices' not in pl_record:
                    pl_record['max_slices'] = 2
                pointer = self.shell.AddSite(pl_record)
                self.shell.SetSiteHrn(int(pointer), hrn)
            else:
                pointer = sites[0]['site_id']

        elif type == 'slice':
            acceptable_fields = ['url', 'instantiation', 'name', 'description']
            for key in pl_record.keys():
                if key not in acceptable_fields:
                    pl_record.pop(key)
            slices = self.shell.GetSlices({
                'peer_id': None,
                'name': pl_record['name']
            })
            if not slices:
                if not pl_record.get('url', None) or not pl_record.get(
                        'description', None):
                    pl_record['url'] = hrn
                    pl_record['description'] = hrn

                pointer = self.shell.AddSlice(pl_record)
                self.shell.SetSliceHrn(int(pointer), hrn)
            else:
                pointer = slices[0]['slice_id']

        elif type == 'user':
            persons = self.shell.GetPersons({
                'peer_id': None,
                'email': sfa_record['email']
            })
            if not persons:
                for key in ['first_name', 'last_name']:
                    if key not in sfa_record: sfa_record[key] = '*from*sfa*'
                # AddPerson does not allow everything to be set
                can_add = [
                    'first_name', 'last_name', 'title', 'email', 'password',
                    'phone', 'url', 'bio'
                ]
                add_person_dict = dict([(k, sfa_record[k]) for k in sfa_record
                                        if k in can_add])
                pointer = self.shell.AddPerson(add_person_dict)
                self.shell.SetPersonHrn(int(pointer), hrn)
            else:
                pointer = persons[0]['person_id']

            # enable the person's account
            self.shell.UpdatePerson(pointer, {'enabled': True})
            # add this person to the site
            login_base = get_leaf(sfa_record['authority'])
            self.shell.AddPersonToSite(pointer, login_base)

            # What roles should this user have?
            roles = []
            if 'roles' in sfa_record:
                # if specified in xml, but only low-level roles
                roles = [
                    role for role in sfa_record['roles']
                    if role in ['user', 'tech']
                ]
            # at least user if no other cluse could be found
            if not roles:
                roles = ['user']
            for role in roles:
                self.shell.AddRoleToPerson(role, pointer)
            # Add the user's key
            if pub_key:
                self.shell.AddPersonKey(pointer, {
                    'key_type': 'ssh',
                    'key': pub_key
                })

        elif type == 'node':
            login_base = PlXrn(xrn=sfa_record['authority'],
                               type='authority').pl_login_base()
            nodes = self.shell.GetNodes({
                'peer_id': None,
                'hostname': pl_record['hostname']
            })
            if not nodes:
                pointer = self.shell.AddNode(login_base, pl_record)
                self.shell.SetNodeHrn(int(pointer), hrn)
            else:
                pointer = nodes[0]['node_id']

        return pointer
示例#16
0
    def get_links(self, sites, nodes, interfaces):

        topology = Topology()
        links = []
        for (site_id1, site_id2) in topology:
            site_id1 = int(site_id1)
            site_id2 = int(site_id2)
            link = Link()
            if not site_id1 in sites or site_id2 not in sites:
                continue
            site1 = sites[site_id1]
            site2 = sites[site_id2]
            # get hrns
            site1_hrn = self.driver.hrn + '.' + site1['login_base']
            site2_hrn = self.driver.hrn + '.' + site2['login_base']

            for s1_node_id in site1['node_ids']:
                for s2_node_id in site2['node_ids']:
                    if s1_node_id not in nodes or s2_node_id not in nodes:
                        continue
                    node1 = nodes[s1_node_id]
                    node2 = nodes[s2_node_id]
                    # set interfaces
                    # just get first interface of the first node
                    if1_xrn = PlXrn(auth=self.driver.hrn,
                                    interface='node%s:eth0' %
                                    (node1['node_id']))
                    if1_ipv4 = interfaces[node1['interface_ids'][0]]['ip']
                    if2_xrn = PlXrn(auth=self.driver.hrn,
                                    interface='node%s:eth0' %
                                    (node2['node_id']))
                    if2_ipv4 = interfaces[node2['interface_ids'][0]]['ip']

                    if1 = Interface({
                        'component_id': if1_xrn.urn,
                        'ipv4': if1_ipv4
                    })
                    if2 = Interface({
                        'component_id': if2_xrn.urn,
                        'ipv4': if2_ipv4
                    })

                    # set link
                    link = Link({
                        'capacity': '1000000',
                        'latency': '0',
                        'packet_loss': '0',
                        'type': 'ipv4'
                    })
                    link['interface1'] = if1
                    link['interface2'] = if2
                    link['component_name'] = "%s:%s" % (site1['login_base'],
                                                        site2['login_base'])
                    link['component_id'] = PlXrn(
                        auth=self.driver.hrn,
                        interface=link['component_name']).get_urn()
                    link['component_manager_id'] = hrn_to_urn(
                        self.driver.hrn, 'authority+am')
                    links.append(link)

        return links
示例#17
0
    def node_to_rspec_node(self,
                           node,
                           sites,
                           interfaces,
                           node_tags,
                           pl_initscripts=[],
                           grain=None,
                           options={}):
        rspec_node = NodeElement()
        # xxx how to retrieve site['login_base']
        site = sites[node['site_id']]
        rspec_node['component_id'] = hostname_to_urn(self.driver.hrn,
                                                     site['login_base'],
                                                     node['hostname'])
        rspec_node['component_name'] = node['hostname']
        rspec_node['component_manager_id'] = Xrn(self.driver.hrn,
                                                 'authority+cm').get_urn()
        rspec_node['authority_id'] = hrn_to_urn(
            PlXrn.site_hrn(self.driver.hrn, site['login_base']),
            'authority+sa')
        # do not include boot state (<available> element) in the manifest rspec
        rspec_node['boot_state'] = node['boot_state']
        if node['boot_state'] == 'boot':
            rspec_node['available'] = 'true'
        else:
            rspec_node['available'] = 'false'

        #distinguish between Shared and Reservable nodes
        if node['node_type'] == 'reservable':
            rspec_node['exclusive'] = 'true'
        else:
            rspec_node['exclusive'] = 'false'

        rspec_node['hardware_types'] = [
            HardwareType({'name': 'plab-pc'}),
            HardwareType({'name': 'pc'})
        ]
        # only doing this because protogeni rspec needs
        # to advertise available initscripts
        rspec_node['pl_initscripts'] = pl_initscripts.values()
        # add site/interface info to nodes.
        # assumes that sites, interfaces and tags have already been prepared.
        if site['longitude'] and site['latitude']:
            location = Location({
                'longitude': site['longitude'],
                'latitude': site['latitude'],
                'country': 'unknown'
            })
            rspec_node['location'] = location
        # Granularity
        granularity = Granularity({'grain': grain})
        rspec_node['granularity'] = granularity
        rspec_node['interfaces'] = []
        if_count = 0
        for if_id in node['interface_ids']:
            interface = Interface(interfaces[if_id])
            interface['ipv4'] = interface['ip']
            interface['component_id'] = PlXrn(
                auth=self.driver.hrn,
                interface='node%s:eth%s' %
                (node['node_id'], if_count)).get_urn()
            # interfaces in the manifest need a client id
            if slice:
                interface['client_id'] = "%s:%s" % (node['node_id'], if_id)
            rspec_node['interfaces'].append(interface)
            if_count += 1
        tags = [
            PLTag(node_tags[tag_id]) for tag_id in node['node_tag_ids']
            if tag_id in node_tags
        ]
        rspec_node['tags'] = tags
        return rspec_node
示例#18
0
    def get_slivers(self, urns, options={}):
        names = set()
        slice_ids = set()
        node_ids = []
        slice_hrn = None
        for urn in urns:
            xrn = PlXrn(xrn=urn)
            if xrn.type == 'sliver':
                # id: slice_id-node_id
                try:
                    sliver_id_parts = xrn.get_sliver_id_parts()
                    slice_id = int(sliver_id_parts[0])
                    node_id = int(sliver_id_parts[1])
                    slice_ids.add(slice_id)
                    node_ids.append(node_id)
                except ValueError:
                    pass
            else:
                slice_hrn = xrn.get_hrn()

        filter = {}
        filter['peer_id'] = None
        if slice_ids:
            filter['slice_id'] = list(slice_ids)
        # get all slices
        all_slices = self.driver.shell.GetSlices(filter, [
            'slice_id', 'name', 'hrn', 'person_ids', 'node_ids',
            'slice_tag_ids', 'expires'
        ])
        if slice_hrn:
            slices = [
                slice for slice in all_slices if slice['hrn'] == slice_hrn
            ]
        else:
            slices = all_slices

        if not slices:
            return []
        slice = slices[0]
        slice['hrn'] = slice_hrn

        # get sliver users
        persons = []
        person_ids = []
        for slice in slices:
            person_ids.extend(slice['person_ids'])
        if person_ids:
            persons = self.driver.shell.GetPersons(person_ids)

        # get user keys
        keys = {}
        key_ids = []
        for person in persons:
            key_ids.extend(person['key_ids'])

        if key_ids:
            key_list = self.driver.shell.GetKeys(key_ids)
            for key in key_list:
                keys[key['key_id']] = key

        # construct user key info
        users = []
        for person in persons:
            person_urn = hrn_to_urn(
                self.driver.shell.GetPersonHrn(int(person['person_id'])),
                'user')
            user = {
                'login':
                slice['name'],
                'user_urn':
                person_urn,
                'keys': [
                    keys[k_id]['key'] for k_id in person['key_ids']
                    if k_id in keys
                ]
            }
            users.append(user)

        if node_ids:
            node_ids = [
                node_id for node_id in node_ids if node_id in slice['node_ids']
            ]
            slice['node_ids'] = node_ids
        tags_dict = self.get_slice_tags(slice)
        nodes_dict = self.get_slice_nodes(slice, options)
        slivers = []
        for node in nodes_dict.values():
            node.update(slice)
            node['tags'] = tags_dict[node['node_id']]
            sliver_hrn = '%s.%s-%s' % (self.driver.hrn, slice['slice_id'],
                                       node['node_id'])
            node['sliver_id'] = Xrn(sliver_hrn, type='sliver').urn
            node['urn'] = node['sliver_id']
            node['services_user'] = users
            slivers.append(node)
        return slivers
示例#19
0
    def instance_to_rspec_node(self, instance):
        # determine node urn
        node_xrn = instance.metadata.get('component_id')
        if not node_xrn:
            node_xrn = OSXrn('cloud', type='node')
        else:
            node_xrn = OSXrn(xrn=node_xrn, type='node')

        rspec_node = Node()
        rspec_node['component_id'] = node_xrn.urn
        rspec_node['component_name'] = node_xrn.name
        rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn()
        rspec_node['sliver_id'] = OSXrn(name=instance.name, type='slice', id=instance.id).get_urn() 
        if instance.metadata.get('client_id'):
            rspec_node['client_id'] = instance.metadata.get('client_id')

        # get sliver details
        flavor = self.driver.shell.nova_manager.flavors.find(id=instance.flavor['id'])
        sliver = self.instance_to_sliver(flavor)
        # get firewall rules
        fw_rules = []
        group_name = instance.metadata.get('security_groups')
        if group_name:
            group = self.driver.shell.nova_manager.security_groups.find(name=group_name)
            for rule in group.rules:
                port_range ="%s:%s" % (rule['from_port'], rule['to_port'])
                fw_rule = FWRule({'protocol': rule['ip_protocol'],
                                  'port_range': port_range,
                                  'cidr_ip': rule['ip_range']['cidr']})
                fw_rules.append(fw_rule)
        sliver['fw_rules'] = fw_rules 
        rspec_node['slivers'] = [sliver]

        # get disk image
        image = self.driver.shell.image_manager.get_images(id=instance.image['id'])
        if isinstance(image, list) and len(image) > 0:
            image = image[0]
        disk_image = image_to_rspec_disk_image(image)
        sliver['disk_image'] = [disk_image]

        # get interfaces            
        rspec_node['services'] = []
        rspec_node['interfaces'] = []
        addresses = instance.addresses
        # HACK: public ips are stored in the list of private, but 
        # this seems wrong. Assume pub ip is the last in the list of 
        # private ips until openstack bug is fixed.      
        if addresses.get('private'):
            login = Login({'authentication': 'ssh-keys',
                           'hostname': addresses.get('private')[-1]['addr'],
                           'port':'22', 'username': '******'})
            service = Services({'login': login})
            rspec_node['services'].append(service)    
        
        for private_ip in addresses.get('private', []):
            if_xrn = PlXrn(auth=self.driver.hrn, 
                           interface='node%s' % (instance.hostId)) 
            if_client_id = Xrn(if_xrn.urn, type='interface', id="eth%s" %if_index).urn
            if_sliver_id = Xrn(rspec_node['sliver_id'], type='slice', id="eth%s" %if_index).urn
            interface = Interface({'component_id': if_xrn.urn,
                                   'client_id': if_client_id,
                                   'sliver_id': if_sliver_id})
            interface['ips'] =  [{'address': private_ip['addr'],
                                 #'netmask': private_ip['network'],
                                 'type': private_ip['version']}]
            rspec_node['interfaces'].append(interface) 
        
        # slivers always provide the ssh service
        for public_ip in addresses.get('public', []):
            login = Login({'authentication': 'ssh-keys', 
                           'hostname': public_ip['addr'], 
                           'port':'22', 'username': '******'})
            service = Services({'login': login})
            rspec_node['services'].append(service)
        return rspec_node
示例#20
0
文件: testXrn.py 项目: gnogueras/sfa
 def test_login_base_001(self):
     xrn = PlXrn(xrn='ple.inria.omftest', type='slice')
     self.assertEqual(xrn.pl_login_base(), 'inria')
示例#21
0
文件: plaggregate.py 项目: tubav/sfa
    def get_nodes_and_links(self, slice_xrn, slice=None,slivers=[], options={}):
        # if we are dealing with a slice that has no node just return 
        # and empty list    
        if slice_xrn:
            if not slice or not slice['node_ids']:
                return ([],[])

        filter = {}
        tags_filter = {}
        if slice and 'node_ids' in slice and slice['node_ids']:
            filter['node_id'] = slice['node_ids']
            tags_filter=filter.copy()

        geni_available = options.get('geni_available')    
        if geni_available == True:
            filter['boot_state'] = 'boot'     
        
        filter.update({'peer_id': None})
        nodes = self.driver.shell.GetNodes(filter)
        
        # get the granularity in second for the reservation system
        grain = self.driver.shell.GetLeaseGranularity()
       
        site_ids = []
        interface_ids = []
        tag_ids = []
        nodes_dict = {}
        for node in nodes:
            site_ids.append(node['site_id'])
            interface_ids.extend(node['interface_ids'])
            tag_ids.extend(node['node_tag_ids'])
            nodes_dict[node['node_id']] = node
 
        # get sites
        sites_dict  = self.get_sites({'site_id': site_ids}) 
        # get interfaces
        interfaces = self.get_interfaces({'interface_id':interface_ids}) 
        # get tags
        node_tags = self.get_node_tags(tags_filter)
        # get initscripts
        pl_initscripts = self.get_pl_initscripts()
        
        links = self.get_links(sites_dict, nodes_dict, interfaces)

        rspec_nodes = []
        for node in nodes:
            # skip whitelisted nodes
            if node['slice_ids_whitelist']:
                if not slice or slice['slice_id'] not in node['slice_ids_whitelist']:
                    continue
            rspec_node = Node()
            # xxx how to retrieve site['login_base']
            site_id=node['site_id']
            site=sites_dict[site_id]
            rspec_node['component_id'] = hostname_to_urn(self.driver.hrn, site['login_base'], node['hostname'])
            rspec_node['component_name'] = node['hostname']
            rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn()
            rspec_node['authority_id'] = hrn_to_urn(PlXrn.site_hrn(self.driver.hrn, site['login_base']), 'authority+sa')
            # do not include boot state (<available> element) in the manifest rspec
            if not slice:     
                rspec_node['boot_state'] = node['boot_state']

            #add the exclusive tag to distinguish between Shared and Reservable nodes
            if node['node_type'] == 'reservable':
                rspec_node['exclusive'] = 'true'
            else:
                rspec_node['exclusive'] = 'false'

            rspec_node['hardware_types'] = [HardwareType({'name': 'plab-pc'}),
                                            HardwareType({'name': 'pc'})]
            # only doing this because protogeni rspec needs
            # to advertise available initscripts 
            rspec_node['pl_initscripts'] = pl_initscripts.values()
             # add site/interface info to nodes.
            # assumes that sites, interfaces and tags have already been prepared.
            site = sites_dict[node['site_id']]
            if site['longitude'] and site['latitude']:  
                location = Location({'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown'})
                rspec_node['location'] = location
            # Granularity
            granularity = Granularity({'grain': grain})
            rspec_node['granularity'] = granularity

            rspec_node['interfaces'] = []
            if_count=0
            for if_id in node['interface_ids']:
                interface = Interface(interfaces[if_id]) 
                interface['ipv4'] = interface['ip']
                interface['component_id'] = PlXrn(auth=self.driver.hrn, 
                                                  interface='node%s:eth%s' % (node['node_id'], if_count)).get_urn()
                # interfaces in the manifest need a client id
                if slice:
                    interface['client_id'] = "%s:%s" % (node['node_id'], if_id)            
                rspec_node['interfaces'].append(interface)
                if_count+=1

            tags = [PLTag(node_tags[tag_id]) for tag_id in node['node_tag_ids']\
                    if tag_id in node_tags]
            rspec_node['tags'] = tags
            if node['node_id'] in slivers:
                # add sliver info
                sliver = slivers[node['node_id']]
                rspec_node['sliver_id'] = sliver['sliver_id']
                rspec_node['slivers'] = [sliver]
                for tag in sliver['tags']:
                    if tag['tagname'] == 'client_id':
                         rspec_node['client_id'] = tag['value']
                
                # slivers always provide the ssh service
                login = Login({'authentication': 'ssh-keys', 'hostname': node['hostname'], 'port':'22', 'username': sliver['name']})
                service = Services({'login': login})
                rspec_node['services'] = [service]
            rspec_nodes.append(rspec_node)
        return (rspec_nodes, links)