%define name sfa
%define version 1.1
-%define taglevel 3
+%define taglevel 4
%define release %{taglevel}%{?pldistro:.%{pldistro}}%{?date:.%{date}}
%global python_sitearch %( python -c "from distutils.sysconfig import get_python_lib; print get_python_lib(1)" )
[ "$1" -ge "1" ] && service sfa-cm restart || :
%changelog
+* Fri Nov 18 2011 Thierry Parmentelat <thierry.parmentelat@sophia.inria.fr> - sfa-1.1-4
+- fixed links and attributes in rspecs
+- minor cleanup in the API methods, and more consistent names in manager methods
+
* Thu Nov 17 2011 Thierry Parmentelat <thierry.parmentelat@sophia.inria.fr> - sfa-1.1-3
- ongoing refoactoring towards more genericity
- passes tests again although known issues remain with attributes/tags
return rspec
- def get_ticket(self, api, xrn, creds, rspec, users):
+ def GetTicket(self, api, xrn, creds, rspec, users):
(slice_hrn, _) = urn_to_hrn(xrn)
slices = Slices(api)
for tmp_record in records:
if tmp_record['type'] == 'slice' and \
not tmp_record['peer_authority']:
- #Error (E0602, get_ticket): Undefined variable 'SliceRecord'
+ #Error (E0602, GetTicket): Undefined variable 'SliceRecord'
record = SliceRecord(dict=tmp_record)
if not record:
raise RecordNotFound(slice_hrn)
except:
# our keypair may be old, try refreshing
sfa_component_setup.get_node_key()
- sfa_component_setup.get_credential(force=True)
+ sfa_component_setup.GetCredential(force=True)
sfa_component_setup.get_trusted_certs()
def SliverStatus(api, slice_xrn, creds):
def __getattr__(self, method):
if not hasattr(self.manager, method):
- raise SfaNotImplemented(method, self.interface)
+ raise SfaNotImplemented(self.interface, method)
return getattr(self.manager, method)
'urn':xrn.get_urn(),
'peers':peers})
- def get_credential(self, api, xrn, type, is_self=False):
+ def GetCredential(self, api, xrn, type, is_self=False):
# convert xrn to hrn
if type:
hrn = urn_to_hrn(xrn)[0]
return new_cred.save_to_string(save_parents=True)
- def resolve(self, api, xrns, type=None, full=True):
+ def Resolve(self, api, xrns, type=None, full=True):
# load all known registry names into a prefix tree and attempt to find
# the longest matching prefix
return records
- def list(self, api, xrn, origin_hrn=None):
+ def List(self, api, xrn, origin_hrn=None):
hrn, type = urn_to_hrn(xrn)
# load all know registry names into a prefix tree and attempt to find
# the longest matching prefix
return records
- def create_gid(self, api, xrn, cert):
+ def CreateGid(self, api, xrn, cert):
# get the authority
authority = Xrn(xrn=xrn).get_authority_hrn()
auth_info = api.auth.get_auth_info(authority)
gid = api.auth.hierarchy.create_gid(xrn, create_uuid(), pkey)
return gid.save_to_string(save_parents=True)
- def register(self, api, record):
+ def Register(self, api, record):
hrn, type = record['hrn'], record['type']
urn = hrn_to_urn(hrn,type)
return record.get_gid_object().save_to_string(save_parents=True)
- def update(self, api, record_dict):
+ def Update(self, api, record_dict):
new_record = SfaRecord(dict = record_dict)
type = new_record['type']
hrn = new_record['hrn']
return 1
# expecting an Xrn instance
- def remove(self, api, xrn, origin_hrn=None):
+ def Remove(self, api, xrn, origin_hrn=None):
table = SfaTable()
filter = {'hrn': xrn.get_hrn()}
table.remove(record)
return 1
-
- def remove_peer_object(self, api, record, origin_hrn=None):
- pass
-
- def register_peer_object(self, api, record, origin_hrn=None):
- pass
return slices
- def get_ticket(self, api, xrn, creds, rspec, users):
+ def GetTicket(self, api, xrn, creds, rspec, users):
slice_hrn, type = urn_to_hrn(xrn)
# get the netspecs contained within the clients rspec
aggregate_rspecs = {}
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, xrn, self.name))
- return self.api.manager.create_gid(self.api, xrn, cert)
+ return self.api.manager.CreateGid(self.api, xrn, cert)
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
- return self.api.manager.get_credential(self.api, xrn, type)
+ return self.api.manager.GetCredential(self.api, xrn, type)
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
# resolve the record
- records = self.api.manager.resolve(self.api, xrns, full = False)
+ records = self.api.manager.Resolve(self.api, xrns, full = False)
if not records:
raise RecordNotFound(xrns)
# authenticate the gid
- records = self.api.manager.resolve(self.api, xrn, type)
+ records = self.api.manager.Resolve(self.api, xrn, type)
if not records:
raise RecordNotFound(hrn)
record = SfaRecord(dict=records[0])
self.api.logger.debug("ConnectionKeyGIDMismatch, %s filename: %s"%(name,obj.filename))
raise ConnectionKeyGIDMismatch(gid.get_subject())
- return self.api.manager.get_credential(self.api, xrn, type, is_self=True)
+ return self.api.manager.GetCredential(self.api, xrn, type, is_self=True)
rspec = run_sfatables(chain_name, hrn, origin_hrn, rspec)
# remove nodes that are not available at this interface from the rspec
- return self.api.manager.get_ticket(self.api, xrn, creds, rspec, users)
+ return self.api.manager.GetTicket(self.api, xrn, creds, rspec, users)
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
- return self.api.manager.list(self.api, xrn)
+ return self.api.manager.List(self.api, xrn)
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
- return self.api.manager.register(self.api, record)
+ return self.api.manager.Register(self.api, record)
+++ /dev/null
-from sfa.util.faults import SfaInvalidArgument
-from sfa.util.xrn import get_authority
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.util.record import SfaRecord
-from sfa.util.table import SfaTable
-from sfa.trust.credential import Credential
-
-class RegisterPeerObject(Method):
- """
- Register a peer object with the registry. In addition to being stored in the
- SFA database, the appropriate records will also be created in the
- PLC databases
-
- @param cred credential string
- @param record_dict dictionary containing record fields
- @return gid string representation
- """
-
- interfaces = ['registry']
-
- accepts = [
- Parameter(str, "Credential string"),
- Parameter(dict, "Record dictionary containing record fields"),
- Mixed(Parameter(str, "Human readable name of the original caller"),
- Parameter(None, "Origin hrn not specified"))
- ]
-
- returns = Parameter(int, "1 if successful")
-
- def call(self, cred, record_dict, origin_hrn=None):
- user_cred = Credential(string=cred)
-
- #log the call
- if not origin_hrn:
- origin_hrn = user_cred.get_gid_caller().get_hrn()
- self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, None, self.name))
-
- # validate the cred
- self.api.auth.check(cred, "register")
-
- # make sure this is a peer record
- if 'peer_authority' not in record_dict or \
- not record_dict['peer_authority']:
- raise SfaInvalidArgument, "peer_authority must be specified"
-
- record = SfaRecord(dict = record_dict)
- type, hrn, peer_authority = record['type'], record['hrn'], record['peer_authority']
- record['authority'] = get_authority(record['hrn'])
- # verify permissions
- self.api.auth.verify_cred_is_me(cred)
-
- # check if record already exists
- table = SfaTable()
- existing_records = table.find({'type': type, 'hrn': hrn, 'peer_authority': peer_authority})
- if existing_records:
- for existing_record in existing_records:
- if existing_record['pointer'] != record['pointer']:
- record['record_id'] = existing_record['record_id']
- table.update(record)
- else:
- record_id = table.insert(record)
-
- return 1
self.api.logger.info("interface: %s\tmethod-name: %s\tcaller-hrn: %s\ttarget-urn: %s"%(
self.api.interface, self.name, origin_hrn, xrn.get_urn()))
- return self.api.manager.remove(self.api, xrn)
+ return self.api.manager.Remove(self.api, xrn)
+++ /dev/null
-from sfa.util.faults import UnknownSfaType, SfaInvalidArgument
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.util.table import SfaTable
-from sfa.trust.credential import Credential
-
-class RemovePeerObject(Method):
- """
- Remove an peer object from the PLC records of a local aggregate.
- This method will be called by registry.remove() while removing
- a record from the local aggreage's PLCDB and sfa table. This
- method need not be directly called by end-user.
-
- @param cred credential string
- @param record record as stored in the local registry
-
- @return 1 if successful, faults otherwise
- """
-
- interfaces = ['registry']
-
- accepts = [
- Parameter(str, "Credential string"),
- Parameter(dict, "Record dictionary"),
- Mixed(Parameter(str, "Human readable name of the original caller"),
- Parameter(None, "Origin hrn not specified"))
- ]
-
- returns = Parameter(int, "1 if successful")
-
- def call(self, cred, record, origin_hrn=None):
- user_cred = Credential(string=cred)
-
- #log the call
- if not origin_hrn:
- origin_hrn = user_cred.get_gid_caller().get_hrn()
- self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, record['hrn'], self.name))
-
- self.api.auth.check(cred, "remove")
-
- # Only allow the local interface or record owner to delete peer_records
- try: self.api.auth.verify_object_permission(record['hrn'])
- except: self.api.auth.verify_cred_is_me(cred)
-
- table = SfaTable()
- hrn, type = record['hrn'], record['type']
- records = table.find({'hrn': hrn, 'type': type })
- for record in records:
- if record['peer_authority']:
- self.remove_plc_record(record)
- table.remove(record)
-
- return 1
-
- def remove_plc_record(self, record):
- type = record['type']
- if type == "user":
- persons = self.api.driver.GetPersons({'person_id' : record['pointer']})
- if not persons:
- return 1
- person = persons[0]
- if person['peer_id']:
- peer = self.get_peer_name(person['peer_id'])
- self.api.driver.UnBindObjectFromPeer('person', person['person_id'], peer)
- self.api.driver.DeletePerson(person['person_id'])
-
- elif type == "slice":
- slices=self.api.driver.GetSlices({'slice_id' : record['pointer']})
- if not slices:
- return 1
- slice=slices[0]
- if slice['peer_id']:
- peer = self.get_peer_name(slice['peer_id'])
- self.api.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
- self.api.driver.DeleteSlice(slice['slice_id'])
- elif type == "authority":
- sites=self.api.driver.GetSites({'site_id' : record['pointer']})
- if not sites:
- return 1
- site=sites[0]
- if site['peer_id']:
- peer = self.get_peer_name(site['peer_id'])
- self.api.driver.UnBindObjectFromPeer('site', site['site_id'], peer)
- self.api.driver.DeleteSite(site['site_id'])
-
- else:
- raise UnknownSfaType(type)
-
- return 1
-
- def get_peer_name(self, peer_id):
- peers = self.api.driver.GetPeers([peer_id], ['peername', 'shortname', 'hrn_root'])
- if not peers:
- raise SfaInvalidArgument, "No such peer"
- peer = peers[0]
- return peer['shortname']
-
-
-
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrns, self.name))
# send the call to the right manager
- return self.api.manager.resolve(self.api, xrns, type)
+ return self.api.manager.Resolve(self.api, xrns, type)
origin_hrn = Credential(string=valid_creds[0]).get_gid_caller().get_hrn()
self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, hrn, self.name))
- return self.api.manager.update(self.api, record_dict)
+ return self.api.manager.Update(self.api, record_dict)
ListSlices
RedeemTicket
Register
-RegisterPeerObject
Remove
-RemovePeerObject
RenewSliver
Resolve
ResolveGENI
Stop
Update
UpdateSliver
-get_aggregates
get_key
-get_registries
get_trusted_certs
-register_peer_object
-remove_peer_object
reset_slice
""".split()
+++ /dev/null
-from sfa.util.xrn import urn_to_hrn
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.server.aggregate import Aggregates
-
-class get_aggregates(Method):
- """
- Get a list of connection information for all known aggregates.
-
- @param cred credential string specifying the rights of the caller
- @param a Human readable name (hrn or urn), or list of hrns or None
- @return list of dictionaries with aggregate information.
- """
-
- interfaces = ['registry', 'aggregate', 'slicemgr']
-
- accepts = [
- Parameter(str, "Credential string"),
- Mixed(Parameter(str, "Human readable name (hrn or urn)"),
- Parameter(None, "hrn not specified"))
- ]
-
- returns = [Parameter(dict, "Aggregate interface information")]
-
- def call(self, cred, xrn = None):
- hrn, type = urn_to_hrn(xrn)
- self.api.auth.check(cred, 'list')
- aggregates = Aggregates(self.api).interfaces.values()
- if hrn:
- aggregates = [agg for agg in aggregates if agg['hrn'] == hrn]
- return aggregates
returns = Parameter(int, "1 if successful, faults otherwise")
def call(self):
- # verify that the callers's ip address exist in the db and is an inteface
+ # verify that the callers's ip address exist in the db and is an interface
# for a node in the db
(ip, port) = self.api.remote_addr
interfaces = self.api.driver.GetInterfaces({'ip': ip}, ['node_id'])
+++ /dev/null
-from sfa.util.xrn import urn_to_hrn
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.server.registry import Registries
-
-class get_registries(Method):
- """
- Get a list of connection information for all known registries.
-
- @param cred credential string specifying the rights of the caller
- @param a Human readable name (hrn or urn), or list of names or None
- @return list of dictionaries with aggregate information.
- """
-
- interfaces = ['registry', 'aggregate', 'slicemgr']
-
- accepts = [
- Parameter(str, "Credential string"),
- Mixed(Parameter(str, "Human readable name (hrn or urn)"),
- Parameter(None, "hrn not specified"))
- ]
-
- returns = [Parameter(dict, "Registry interface information")]
-
- def call(self, cred, xrn = None):
- hrn, type = urn_to_hrn(xrn)
- self.api.auth.check(cred, 'list')
- registries = Registries(self.api).values()
- if hrn:
- registries = [reg for reg in registries if reg['hrn'] == hrn]
- return registries
+++ /dev/null
-
-from sfa.util.faults import SfaInvalidArgument
-from sfa.util.xrn import get_authority
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.util.record import SfaRecord
-from sfa.util.table import SfaTable
-from sfa.trust.credential import Credential
-
-class register_peer_object(Method):
- """
- Register a peer object with the registry. In addition to being stored in the
- SFA database, the appropriate records will also be created in the
- PLC databases
-
- @param cred credential string
- @param record_dict dictionary containing record fields
- @return gid string representation
- """
-
- interfaces = ['registry']
-
- accepts = [
- Parameter(str, "Credential string"),
- Parameter(dict, "Record dictionary containing record fields"),
- Mixed(Parameter(str, "Human readable name of the original caller"),
- Parameter(None, "Origin hrn not specified"))
- ]
-
- returns = Parameter(int, "1 if successful")
-
- def call(self, cred, record_dict, origin_hrn=None):
- user_cred = Credential(string=cred)
-
- #log the call
- if not origin_hrn:
- origin_hrn = user_cred.get_gid_caller().get_hrn()
- self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, None, self.name))
-
- # validate the cred
- self.api.auth.check(cred, "register")
-
- # make sure this is a peer record
- if 'peer_authority' not in record_dict or \
- not record_dict['peer_authority']:
- raise SfaInvalidArgument, "peer_authority must be specified"
-
- record = SfaRecord(dict = record_dict)
- type, hrn, peer_authority = record['type'], record['hrn'], record['peer_authority']
- record['authority'] = get_authority(record['hrn'])
- # verify permissions
- self.api.auth.verify_cred_is_me(cred)
-
- # check if record already exists
- table = SfaTable()
- existing_records = table.find({'type': type, 'hrn': hrn, 'peer_authority': peer_authority})
- if existing_records:
- for existing_record in existing_records:
- if existing_record['pointer'] != record['pointer']:
- record['record_id'] = existing_record['record_id']
- table.update(record)
- else:
- record_id = table.insert(record)
-
- return 1
+++ /dev/null
-from sfa.util.faults import UnknownSfaType, SfaInvalidArgument
-from sfa.util.method import Method
-from sfa.util.parameter import Parameter, Mixed
-from sfa.util.table import SfaTable
-from sfa.trust.credential import Credential
-
-class remove_peer_object(Method):
- """
- Remove a peer object from the PLC records of a local aggregate.
- This method will be called by registry.remove() while removing
- a record from the local aggreage's PLCDB and sfa table. This
- method need not be directly called by end-user.
-
- @param cred credential string
- @param record record as stored in the local registry
-
- @return 1 if successful, faults otherwise
- """
-
- interfaces = ['registry']
-
- accepts = [
- Parameter(str, "Credential string"),
- Parameter(dict, "Record dictionary"),
- Mixed(Parameter(str, "Human readable name of the original caller"),
- Parameter(None, "Origin hrn not specified"))
- ]
-
- returns = Parameter(int, "1 if successful")
-
- def call(self, cred, record, origin_hrn=None):
- user_cred = Credential(string=cred)
-
- #log the call
- if not origin_hrn:
- origin_hrn = user_cred.get_gid_caller().get_hrn()
- self.api.logger.info("interface: %s\tcaller-hrn: %s\ttarget-hrn: %s\tmethod-name: %s"%(self.api.interface, origin_hrn, record['hrn'], self.name))
-
- self.api.auth.check(cred, "remove")
-
- # Only allow the local interface or record owner to delete peer_records
- try: self.api.auth.verify_object_permission(record['hrn'])
- except: self.api.auth.verify_cred_is_me(cred)
-
- table = SfaTable()
- hrn, type = record['hrn'], record['type']
- records = table.find({'hrn': hrn, 'type': type })
- for record in records:
- if record['peer_authority']:
- self.remove_plc_record(record)
- table.remove(record)
-
- return 1
-
- def remove_plc_record(self, record):
- type = record['type']
- if type == "user":
- persons = self.api.driver.GetPersons({'person_id' : record['pointer']})
- if not persons:
- return 1
- person = persons[0]
- if person['peer_id']:
- peer = self.get_peer_name(person['peer_id'])
- self.api.driver.UnBindObjectFromPeer('person', person['person_id'], peer)
- self.api.driver.DeletePerson(person['person_id'])
-
- elif type == "slice":
- slices=self.api.driver.GetSlices({'slice_id' : record['pointer']})
- if not slices:
- return 1
- slice=slices[0]
- if slice['peer_id']:
- peer = self.get_peer_name(slice['peer_id'])
- self.api.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer)
- self.api.driver.DeleteSlice(slice['slice_id'])
- elif type == "authority":
- sites=self.api.driver.GetSites({'site_id' : record['pointer']})
- if not sites:
- return 1
- site=sites[0]
- if site['peer_id']:
- peer = self.get_peer_name(site['peer_id'])
- self.api.driver.UnBindObjectFromPeer('site', site['site_id'], peer)
- self.api.driver.DeleteSite(site['site_id'])
-
- else:
- raise UnknownSfaType(type)
-
- return 1
-
- def get_peer_name(self, peer_id):
- peers = self.api.driver.GetPeers([peer_id], ['peername', 'shortname', 'hrn_root'])
- if not peers:
- raise SfaInvalidArgument, "No such peer"
- peer = peers[0]
- return peer['shortname']
-
-
-
interfaces = {}
for interface in self.api.driver.GetInterfaces(filter):
iface = Interface()
- iface['interface_id'] = interface['interface_id']
- iface['node_id'] = interface['node_id']
- iface['ipv4'] = interface['ip']
if interface['bwlimit']:
- iface['bwlimit'] = str(int(interface['bwlimit'])/1000)
- interfaces[iface['interface_id']] = iface
+ interface['bwlimit'] = str(int(interface['bwlimit'])/1000)
+ interfaces[interface['interface_id']] = interface
return interfaces
- def get_links(self, filter={}):
+ def get_links(self, sites, nodes, interfaces):
- if not self.api.config.SFA_AGGREGATE_TYPE.lower() == 'vini':
- return []
-
topology = Topology()
- links = {}
+ 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 self.sites or site_id2 not in self.sites:
+ if not site_id1 in sites or site_id2 not in sites:
continue
- site1 = self.sites[site_id1]
- site2 = self.sites[site_id2]
+ site1 = sites[site_id1]
+ site2 = sites[site_id2]
# get hrns
site1_hrn = self.api.hrn + '.' + site1['login_base']
site2_hrn = self.api.hrn + '.' + site2['login_base']
- for s1_node in self.nodes[site1['node_ids']]:
- for s2_node in self.nodes[site2['node_ids']]:
+ for s1_node_id in site1['node_ids']:
+ for s2_node_id in site2['node_ids']:
+ 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.api.hrn, interface='node%s:eth0' % (s1_node['node_id']))
- if1_ipv4 = self.interfaces[node1['interface_ids'][0]]['ip']
- if2_xrn = PlXrn(auth=self.api.hrn, interface='node%s:eth0' % (s2_node['node_id']))
- if2_ipv4 = self.interfaces[node2['interface_ids'][0]]['ip']
+ if1_xrn = PlXrn(auth=self.api.hrn, interface='node%s:eth0' % (node1['node_id']))
+ if1_ipv4 = interfaces[node1['interface_ids'][0]]['ip']
+ if2_xrn = PlXrn(auth=self.api.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} )
link['component_name'] = "%s:%s" % (site1['login_base'], site2['login_base'])
link['component_id'] = PlXrn(auth=self.api.hrn, interface=link['component_name']).get_urn()
link['component_manager_id'] = hrn_to_urn(self.api.hrn, 'authority+am')
- links[link['component_name']] = link
+ links.append(link)
return links
return (slice, slivers)
- def get_nodes (self, slice=None,slivers=[]):
+ def get_nodes_and_links(self, slice=None,slivers=[]):
filter = {}
tags_filter = {}
if slice and 'node_ids' in slice and slice['node_ids']:
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})
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:
if_count=0
for if_id in node['interface_ids']:
interface = Interface(interfaces[if_id])
- interface['ipv4'] = interface['ipv4']
+ interface['ipv4'] = interface['ip']
interface['component_id'] = PlXrn(auth=self.api.hrn, interface='node%s:eth%s' % (node['node_id'], if_count)).get_urn()
rspec_node['interfaces'].append(interface)
if_count+=1
service = Services({'login': login})
rspec_node['services'] = [service]
rspec_nodes.append(rspec_node)
- return rspec_nodes
+ return (rspec_nodes, links)
def get_rspec(self, slice_xrn=None, version = None):
slice, slivers = self.get_slice_and_slivers(slice_xrn)
rspec = RSpec(version=rspec_version, user_options=self.user_options)
if slice and 'expires' in slice:
- rspec.xml.set('expires', epochparse(slice['expires']))
- rspec.version.add_nodes(self.get_nodes(slice, slivers))
- rspec.version.add_links(self.get_links(slice))
+ rspec.xml.set('expires', epochparse(slice['expires']))
+
+ nodes, links = self.get_nodes_and_links(slice, slivers)
+ rspec.version.add_nodes(nodes)
+ rspec.version.add_links(links)
# add sliver defaults
default_sliver_attribs = slivers.get(None, [])
+++ /dev/null
-from __future__ import with_statement
-import sys
-import re
-import socket
-from StringIO import StringIO
-from lxml import etree
-from xmlbuilder import XMLBuilder
-
-from sfa.util.faults import InvalidRSpec
-from sfa.util.xrn import get_authority
-from sfa.util.plxrn import hrn_to_pl_slicename, hostname_to_urn
-
-class Sliver:
- def __init__(self, node):
- self.node = node
- self.network = node.network
- self.slice = node.network.slice
-
- def toxml(self, xml):
- with xml.sliver:
- self.slice.tags_to_xml(xml, self.node)
-
-
-class Iface:
- def __init__(self, network, iface):
- self.network = network
- self.id = iface['interface_id']
- self.idtag = "i%s" % self.id
- self.ipv4 = iface['ip']
- self.bwlimit = iface['bwlimit']
- self.hostname = iface['hostname']
- self.primary = iface['is_primary']
-
- def toxml(self, xml):
- """
- Just print out bwlimit right now
- """
- if self.bwlimit:
- with xml.bw_limit(units="kbps"):
- xml << str(self.bwlimit / 1000)
-
-
-class Node:
- def __init__(self, network, node):
- self.network = network
- self.id = node['node_id']
- self.idtag = "n%s" % self.id
- self.hostname = node['hostname']
- self.site_id = node['site_id']
- self.iface_ids = node['interface_ids']
- self.sliver = None
- self.whitelist = node['slice_ids_whitelist']
- auth = self.network.api.hrn
- login_base = self.get_site().idtag
- self.urn = hostname_to_urn(auth, login_base, self.hostname)
-
- def get_primary_iface(self):
- for id in self.iface_ids:
- iface = self.network.lookupIface(id)
- if iface.primary:
- return iface
- return None
-
- def get_site(self):
- return self.network.lookupSite(self.site_id)
-
- def add_sliver(self):
- self.sliver = Sliver(self)
-
- def toxml(self, xml):
- slice = self.network.slice
- if self.whitelist and not self.sliver:
- if not slice or slice.id not in self.whitelist:
- return
-
- with xml.node(id = self.idtag):
- with xml.hostname:
- xml << self.hostname
- with xml.urn:
- xml << self.urn
- iface = self.get_primary_iface()
- if iface:
- iface.toxml(xml)
- if self.sliver:
- self.sliver.toxml(xml)
-
-
-class Site:
- def __init__(self, network, site):
- self.network = network
- self.id = site['site_id']
- self.node_ids = site['node_ids']
- self.node_ids.sort()
- self.name = site['abbreviated_name']
- self.tag = site['login_base']
- self.idtag = site['login_base']
- self.public = site['is_public']
- self.enabled = site['enabled']
- self.links = set()
- self.whitelist = False
-
- def get_sitenodes(self):
- n = []
- for i in self.node_ids:
- n.append(self.network.lookupNode(i))
- return n
-
- def toxml(self, xml):
- if not (self.public and self.enabled and self.node_ids):
- return
- with xml.site(id = self.idtag):
- with xml.name:
- xml << self.name
- for node in self.get_sitenodes():
- node.toxml(xml)
-
-
-class Slice:
- def __init__(self, network, hrn, slice):
- self.hrn = hrn
- self.network = network
- self.id = slice['slice_id']
- self.name = slice['name']
- self.peer_id = slice['peer_id']
- self.node_ids = set(slice['node_ids'])
- self.slice_tag_ids = slice['slice_tag_ids']
-
- """
- Use with tags that can have more than one instance
- """
- def get_multi_tag(self, tagname, node = None):
- tags = []
- for i in self.slice_tag_ids:
- try:
- tag = self.network.lookupSliceTag(i)
- if tag.tagname == tagname:
- if node:
- if node.id == tag.node_id:
- tags.append(tag)
- elif not tag.node_id:
- tags.append(tag)
- except InvalidRSpec, e:
- # As they're not needed, we ignore some tag types from
- # GetSliceTags call. See Slicetag.ignore_tags
- pass
- return tags
-
- """
- Use with tags that have only one instance
- """
- def get_tag(self, tagname, node = None):
- for i in self.slice_tag_ids:
- try:
- tag = self.network.lookupSliceTag(i)
- if tag.tagname == tagname:
- if node:
- if node.id == tag.node_id:
- return tag
- elif not tag.node_id:
- return tag
- except InvalidRSpec, e:
- # As they're not needed, we ignore some tag types from
- # GetSliceTags call. See Slicetag.ignore_tags
- pass
- return None
-
- def get_nodes(self):
- n = []
- for id in self.node_ids:
- if id in self.network.nodes:
- n.append(self.network.nodes[id])
- return n
-
- # Add a new slice tag
- def add_tag(self, tagname, value, node = None, role = "user"):
- tt = self.network.lookupTagType(tagname)
- if not tt.permit_update(role):
- raise InvalidRSpec("permission denied to modify '%s' tag" % tagname)
- tag = Slicetag()
- tag.initialize(tagname, value, node, self.network)
- self.network.tags[tag.id] = tag
- self.slice_tag_ids.append(tag.id)
- return tag
-
- # Update a slice tag if it exists, else add it
- def update_tag(self, tagname, value, node = None, role = "user"):
- tag = self.get_tag(tagname, node)
- if tag and tag.value == value:
- return tag
-
- tt = self.network.lookupTagType(tagname)
- if not tt.permit_update(role):
- raise InvalidRSpec("permission denied to modify '%s' tag" % tagname)
-
- if tag:
- tag.change(value)
- else:
- tag = self.add_tag(tagname, value, node, role)
- return tag
-
- def update_multi_tag(self, tagname, value, node = None, role = "user"):
- tags = self.get_multi_tag(tagname, node)
- for tag in tags:
- if tag and tag.value == value:
- break
- else:
- tag = self.add_tag(tagname, value, node, role)
- return tag
-
- def tags_to_xml(self, xml, node = None):
- tagtypes = self.network.getTagTypes()
- for tt in tagtypes:
- if tt.in_rspec:
- if tt.multi:
- tags = self.get_multi_tag(tt.tagname, node)
- for tag in tags:
- if not tag.was_deleted(): ### Debugging
- xml << (tag.tagname, tag.value)
- else:
- tag = self.get_tag(tt.tagname, node)
- if tag:
- if not tag.was_deleted(): ### Debugging
- xml << (tag.tagname, tag.value)
-
- def toxml(self, xml):
- with xml.sliver_defaults:
- self.tags_to_xml(xml)
-
-
-class Slicetag:
- newid = -1
- filter_fields = ['slice_tag_id','slice_id','tagname','value','node_id','category']
- ignore_tags = ['hmac','ssh_key']
- def __init__(self, tag = None):
- if not tag:
- return
- self.id = tag['slice_tag_id']
- self.slice_id = tag['slice_id']
- self.tagname = tag['tagname']
- self.value = tag['value']
- self.node_id = tag['node_id']
- self.category = tag['category']
- self.status = None
-
- # Create a new slicetag that will be written to the DB later
- def initialize(self, tagname, value, node, network):
- tt = network.lookupTagType(tagname)
- self.id = Slicetag.newid
- Slicetag.newid -=1
- self.slice_id = network.slice.id
- self.tagname = tagname
- self.value = value
- if node:
- self.node_id = node.id
- else:
- self.node_id = None
- self.category = tt.category
- self.status = "new"
-
- def change(self, value):
- if self.value != value:
- self.value = value
- self.status = "change"
- else:
- self.status = "updated"
-
- # Mark a tag as deleted
- def delete(self):
- self.status = "delete"
-
- def was_added(self):
- return (self.id < 0)
-
- def was_changed(self):
- return (self.status == "change")
-
- def was_deleted(self):
- return (self.status == "delete")
-
- def was_updated(self):
- return (self.status != None)
-
- def write(self, api):
- if self.was_added():
- api.driver.AddSliceTag(self.slice_id, self.tagname, self.value, self.node_id)
- elif self.was_changed():
- api.driver.UpdateSliceTag(self.id, self.value)
- elif self.was_deleted():
- api.driver.DeleteSliceTag(self.id)
-
-
-class TagType:
- ignore_tags = ['hmac','ssh_key']
- def __init__(self, tagtype):
- self.id = tagtype['tag_type_id']
- self.category = tagtype['category']
- self.tagname = tagtype['tagname']
- self.roles = tagtype['roles']
- self.multi = False
- self.in_rspec = False
- if self.category == 'slice/rspec':
- self.in_rspec = True
- if self.tagname in ['codemux', 'ip_addresses', 'vsys']:
- self.multi = True
-
- def permit_update(self, role):
- if role in self.roles:
- return True
- return False
-
-
-class Network:
- """
- A Network is a compound object consisting of:
- * a dictionary mapping site IDs to Site objects
- * a dictionary mapping node IDs to Node objects
- * a dictionary mapping interface IDs to Iface objects
- """
- def __init__(self, api, type = "SFA"):
- self.api = api
- self.type = type
- self.sites = self.get_sites(api)
- self.nodes = self.get_nodes(api)
- self.ifaces = self.get_ifaces(api)
- self.tags = self.get_slice_tags(api)
- self.tagtypes = self.get_tag_types(api)
- self.slice = None
- self.sitemap = {}
- for s in self.sites:
- site = self.sites[s]
- self.sitemap[site.idtag] = site.id
-
- def lookupSiteIdtag(self, name):
- """ Lookup site id from name """
- val = None
- try:
- val = self.sitemap[name]
- except:
- raise InvalidRSpec("site name '%s' not found" % name)
- return val
-
- def lookupSite(self, id):
- """ Lookup site based on id or idtag value """
- val = None
- if isinstance(id, basestring):
- id = self.lookupSiteIdtag(id)
- try:
- val = self.sites[id]
- except:
- self.api.logger.error("Invalid RSpec: site ID %s not found" % id )
- raise InvalidRSpec("site ID %s not found" % id)
- return val
-
- def getSites(self):
- sites = []
- for s in self.sites:
- sites.append(self.sites[s])
- return sites
-
- def lookupNode(self, id):
- """ Lookup node based on id or idtag value """
- val = None
- if isinstance(id, basestring):
- id = int(id.lstrip('n'))
- try:
- val = self.nodes[id]
- except:
- raise InvalidRSpec("node ID %s not found" % id)
- return val
-
- def getNodes(self):
- nodes = []
- for n in self.nodes:
- nodes.append(self.nodes[n])
- return nodes
-
- def lookupIface(self, id):
- """ Lookup iface based on id or idtag value """
- val = None
- if isinstance(id, basestring):
- id = int(id.lstrip('i'))
- try:
- val = self.ifaces[id]
- except:
- raise InvalidRSpec("interface ID %s not found" % id)
- return val
-
- def getIfaces(self):
- ifaces = []
- for i in self.ifaces:
- ifaces.append(self.ifaces[i])
- return ifaces
-
- def nodesWithSlivers(self):
- nodes = []
- for n in self.nodes:
- node = self.nodes[n]
- if node.sliver:
- nodes.append(node)
- return nodes
-
- def lookupSliceTag(self, id):
- val = None
- try:
- val = self.tags[id]
- except:
- raise InvalidRSpec("slicetag ID %s not found" % id)
- return val
-
- def getSliceTags(self):
- tags = []
- for t in self.tags:
- tags.append(self.tags[t])
- return tags
-
- def lookupTagType(self, name):
- val = None
- try:
- val = self.tagtypes[name]
- except:
- raise InvalidRSpec("tag %s not found" % name)
- return val
-
- def getTagTypes(self):
- tags = []
- for t in self.tagtypes:
- tags.append(self.tagtypes[t])
- return tags
-
- def __process_attributes(self, element, node=None):
- """
- Process the elements under <sliver_defaults> or <sliver>
- """
- if element is None:
- return
-
- tagtypes = self.getTagTypes()
- for tt in tagtypes:
- if tt.in_rspec:
- if tt.multi:
- for e in element.iterfind("./" + tt.tagname):
- self.slice.update_multi_tag(tt.tagname, e.text, node)
- else:
- e = element.find("./" + tt.tagname)
- if e is not None:
- self.slice.update_tag(tt.tagname, e.text, node)
-
- def addRSpec(self, xml, schema=None):
- """
- Annotate the objects in the Network with information from the RSpec
- """
- try:
- tree = etree.parse(StringIO(xml))
- except etree.XMLSyntaxError:
- message = str(sys.exc_info()[1])
- raise InvalidRSpec(message)
-
- # Filter out stuff that's not for us
- rspec = tree.getroot()
- for network in rspec.iterfind("./network"):
- if network.get("name") != self.api.hrn:
- rspec.remove(network)
- for request in rspec.iterfind("./request"):
- if request.get("name") != self.api.hrn:
- rspec.remove(request)
-
- if schema:
- # Validate the incoming request against the RelaxNG schema
- relaxng_doc = etree.parse(schema)
- relaxng = etree.RelaxNG(relaxng_doc)
-
- if not relaxng(tree):
- error = relaxng.error_log.last_error
- message = "%s (line %s)" % (error.message, error.line)
- self.api.logger.error("failed to validate rspec %r"%message)
- self.api.logger.debug("---------- XML input BEG")
- self.api.logger.debug(xml)
- self.api.logger.debug("---------- XML input END")
- raise InvalidRSpec(message)
-
- self.rspec = rspec
-
- defaults = rspec.find(".//sliver_defaults")
- self.__process_attributes(defaults)
-
- # Find slivers under node elements
- for sliver in rspec.iterfind("./network/site/node/sliver"):
- elem = sliver.getparent()
- try:
- node = self.lookupNode(elem.get("id"))
- except:
- # Don't worry about nodes from other aggregates
- pass
- else:
- node.add_sliver()
- self.__process_attributes(sliver, node)
-
- # Find slivers that specify nodeid
- for sliver in rspec.iterfind("./request/sliver[@nodeid]"):
- try:
- node = self.lookupNode(sliver.get("nodeid"))
- except:
- # Don't worry about nodes from other aggregates
- pass
- else:
- node.add_sliver()
- self.__process_attributes(sliver, node)
-
- return
-
- def addSlice(self):
- """
- Annotate the objects in the Network with information from the slice
- """
- slice = self.slice
- if not slice:
- raise InvalidRSpec("no slice associated with network")
-
- for node in slice.get_nodes():
- node.add_sliver()
-
- def updateSliceTags(self):
- """
- Write any slice tags that have been added or modified back to the DB
- """
- for tag in self.getSliceTags():
- if tag.category == 'slice/rspec' and not tag.was_updated():
- tt = self.lookupTagType(tag.tagname)
- if tt.permit_update("user"):
- tag.delete()
-
- # Update slice tags in database
- for tag in self.getSliceTags():
- if tag.slice_id == self.slice.id:
- tag.write(self.api)
-
- def toxml(self):
- """
- Produce XML directly from the topology specification.
- """
- xml = XMLBuilder(format = True, tab_step = " ")
- with xml.RSpec(type=self.type):
- if self.slice:
- element = xml.network(name=self.api.hrn, slice=self.slice.hrn)
- else:
- element = xml.network(name=self.api.hrn)
-
- with element:
- if self.slice:
- self.slice.toxml(xml)
- for site in self.getSites():
- site.toxml(xml)
-
- header = '<?xml version="1.0"?>\n'
- return header + str(xml)
-
- def get_sites(self, api):
- """
- Create a dictionary of site objects keyed by site ID
- """
- tmp = []
- for site in api.driver.GetSites({'peer_id': None}):
- t = site['site_id'], Site(self, site)
- tmp.append(t)
- return dict(tmp)
-
-
- def get_nodes(self, api):
- """
- Create a dictionary of node objects keyed by node ID
- """
- tmp = []
- for node in api.driver.GetNodes({'peer_id': None}):
- try:
- t = node['node_id'], Node(self, node)
- tmp.append(t)
- except:
- self.api.logger.error("Failed to add node %s (%s) to RSpec" % (node['hostname'], node['node_id']))
-
- return dict(tmp)
-
- def get_ifaces(self, api):
- """
- Create a dictionary of node objects keyed by node ID
- """
- tmp = []
- for iface in api.driver.GetInterfaces():
- t = iface['interface_id'], Iface(self, iface)
- tmp.append(t)
- return dict(tmp)
-
- def get_slice_tags(self, api):
- """
- Create a dictionary of slicetag objects keyed by slice tag ID
- """
- tmp = []
- for tag in api.driver.GetSliceTags({'~tagname':Slicetag.ignore_tags}, Slicetag.filter_fields):
- t = tag['slice_tag_id'], Slicetag(tag)
- tmp.append(t)
- return dict(tmp)
-
- def get_tag_types(self, api):
- """
- Create a list of tagtype obects keyed by tag name
- """
- tmp = []
- for tag in api.driver.GetTagTypes({'~tagname':TagType.ignore_tags}):
- t = tag['tagname'], TagType(tag)
- tmp.append(t)
- return dict(tmp)
-
- def get_slice(self, api, hrn):
- """
- Return a Slice object for a single slice
- """
- slicename = hrn_to_pl_slicename(hrn)
- slice = api.driver.GetSlices([slicename])
- if len(slice):
- self.slice = Slice(self, slicename, slice[0])
- return self.slice
- else:
- return None
-
-
if key in fields:
self[key] = fields[key]
- def __getattr__(self, attr):
- if hasattr(self, attr):
- return getattr(self, attr)
- elif self.element is not None and hasattr(self.element, attr):
- return getattr(self.element, attr)
- raise AttributeError, "Element class has no attribute %s" % attr
+
+ def __getattr__(self, name):
+ if hasattr(self, name):
+ return getattr(self, name)
+ elif hasattr(self.element, name):
+ return getattr(self.element, name)
+ else:
+ raise AttributeError, "class Element has not attribute %s" % name
'execute': Execute.fields,
'login': Login.fields}
for (name, fields) in child_elements.items():
- objects = service.get(name)
- if not objects:
+ child = service.get(name)
+ if not child:
continue
- if isinstance(objects, basestring):
- service_elem.add_instance(name, objects, fields)
- elif isinstance(objects, list):
- for obj in objects:
+ if isinstance(child, dict):
+ service_elem.add_instance(name, child, fields)
+ elif isinstance(child, list):
+ for obj in child:
service_elem.add_instance(name, obj, fields)
@staticmethod
if elem.tag not in Sliver.fields:
xml_element = XmlElement(elem, xml.namespaces)
instance = Element(xml_element)
- instance['tagname'] = elem.tag
+ instance['name'] = elem.tag
instance['value'] = elem.text
attribs.append(instance)
return attribs
SFAv1Node.remove_slivers(self.xml, slivers)
def get_slice_attributes(self, network=None):
- slice_attributes = []
- """
+ attributes = []
nodes_with_slivers = self.get_nodes_with_slivers()
for default_attribute in self.get_default_sliver_attributes(network):
- attribute = {'name': str(default_attribute[0]),
- 'value': str(default_attribute[1]),
- 'node_id': None}
- slice_attributes.append(attribute)
+ attribute['node_id'] = None
+ attributes.append(attribute)
for node in nodes_with_slivers:
- nodename=node.get('component_name')
+ nodename=node['component_name']
sliver_attributes = self.get_sliver_attributes(nodename, network)
for sliver_attribute in sliver_attributes:
- attribute = {'name': str(sliver_attribute[0]), 'value': str(sliver_attribute[1]), 'node_id': node}
- slice_attributes.append(attribute)
- """
- return slice_attributes
+ sliver_attribute['node_id'] = nodename
+ attributes.append(attribute)
+ return attributes
def add_sliver_attribute(self, hostname, name, value, network=None):
attribs = []
if nodes is not None and isinstance(nodes, list) and len(nodes) > 0:
node = nodes[0]
- slivers = node.xpath('./default:sliver', namespaces=self.namespaces)
+ slivers = SFAv1Sliver.get_slivers(node.element)
if slivers is not None and isinstance(slivers, list) and len(slivers) > 0:
sliver = slivers[0]
- attribs = SFAv1Sliver.get_sliver_attributes(sliver)
+ attribs = SFAv1Sliver.get_sliver_attributes(sliver.element)
return attribs
def remove_sliver_attribute(self, hostname, name, value, network=None):
attribs = self.get_sliver_attributes(hostname)
for attrib in attribs:
- if attrib['tagname'] == name and attrib['value'] == value:
+ if attrib['name'] == name and attrib['value'] == value:
attrib.element.delete()
def add_default_sliver_attribute(self, name, value, network=None):
network_tag = self.xml.xpath("//network[@name='%s']" % network)
if isinstance(network_tag, list):
network_tag = network_tag[0]
- defaults = self.xml.add_element('sliver_defaults', attrs={}, parent=network_tag)
+ defaults = network_tag.add_element('sliver_defaults')
elif isinstance(defaults, list):
defaults = defaults[0]
- self.xml.add_attribute(defaults, name, value)
+ Sfav1Sliver.add_sliver_attribute(defaults, name, value)
def get_default_sliver_attributes(self, network=None):
if network:
else:
defaults = self.xml.xpath("//sliver_defaults")
if not defaults: return []
- return self.attributes_list_thierry(defaults)
+ return Sfav1Sliver.get_sliver_attributes(defaults)
def remove_default_sliver_attribute(self, name, value, network=None):
if network:
defaults = self.xml.xpath("//network[@name='%s']/sliver_defaults" % network)
else:
defaults = self.xml.xpath("//sliver_defaults" % network)
- self.xml.remove_attribute(defaults, name, value)
+ attribs = Sfav1Sliver.get_sliver_attributes(defaults)
+ for attrib in attribs:
+ if attrib['name'] == name and attrib['value'] == value:
+ attrib.element.delete()
# Links
def add_links(self, links):
networks = self.get_networks()
if len(networks) > 0:
- xml = networks[0]
+ xml = networks[0].element
else:
xml = self.xml
PGv2Link.add_links(xml, links)
os.unlink(f)
# install the new key pair
- # get_credential will take care of generating the new keypair
+ # GetCredential will take care of generating the new keypair
# and credential
- get_credential()
+ GetCredential()
def get_node_key(registry=None, verbose=False):
cert.save_to_file(certfile, save_parents=True)
@handle_gid_mismatch_exception
-def get_credential(registry=None, force=False, verbose=False):
+def GetCredential(registry=None, force=False, verbose=False):
config = Config()
hierarchy = Hierarchy()
key_dir= hierarchy.basedir
node_gid = GID(filename=node_gid_file)
hrn = node_gid.get_hrn()
# get credential
- cred = get_credential(registry=registry, verbose=verbose)
+ cred = GetCredential(registry=registry, verbose=verbose)
# make sure server key cert pair exists
create_server_keypair(keyfile=keyfile, certfile=certfile, hrn=hrn, verbose=verbose)
registry = server_proxy(url=registry, keyfile=keyfile, certfile=certfile)
hrn = node_gid.get_hrn()
interface_hrn = config.SFA_INTERFACE_HRN
# get credential
- cred = get_credential(registry=registry, verbose=verbose)
+ cred = GetCredential(registry=registry, verbose=verbose)
# make sure server key cert pair exists
create_server_keypair(keyfile=keyfile, certfile=certfile, hrn=hrn, verbose=verbose)
registry = server_proxy(url=registry, keyfile=keyfile, certfile=certfile)
try:
result = self.call(source, method, *args)
except SfaFault, fault:
- result = fault
+ result = fault
+ self.logger.log_exc("XmlrpcApi.handle has caught Exception")
except Exception, fault:
self.logger.log_exc("XmlrpcApi.handle has caught Exception")
result = SfaAPIError(fault)
Parse the topology configuration file.
"""
- #def __init__(self, config_file = "/etc/sfa/topology"):
- def __init__(self, config_file = "/tmp/topology"):
+ def __init__(self, config_file = "/etc/sfa/topology"):
set.__init__(self)
self.config_file = None
self.config_path = None
from sfa.util.faults import InvalidXML
from sfa.rspecs.elements.element import Element
+# helper functions to help build xpaths
class XpathFilter:
@staticmethod
xpath = '[' + xpath + ']'
return xpath
+# a wrapper class around lxml.etree._Element
+# the reason why we need this one is because of the limitations
+# we've found in xpath to address documents with multiple namespaces defined
+# in a nutshell, we deal with xml documents that have
+# a default namespace defined (xmlns="http://default.com/") and specific prefixes defined
+# (xmlns:foo="http://foo.com")
+# according to the documentation instead of writing
+# element.xpath ( "//node/foo:subnode" )
+# we'd then need to write xpaths like
+# element.xpath ( "//{http://default.com/}node/{http://foo.com}subnode" )
+# which is a real pain..
+# So just so we can keep some reasonable programming style we need to manage the
+# namespace map that goes with the _Element (its internal .nsmap being unmutable)
+
class XmlElement:
def __init__(self, element, namespaces):
self.element = element
- self.tag = element.tag
- self.text = element.text
- self.attrib = element.attrib
self.namespaces = namespaces
-
+ # redefine as few methods as possible
def xpath(self, xpath, namespaces=None):
if not namespaces:
namespaces = self.namespaces
def get_instance(self, instance_class=None, fields=[]):
"""
Returns an instance (dict) of this xml element. The instance
- holds a reference this xml element.
+ holds a reference to this xml element.
"""
if not instance_class:
instance_class = Element
else:
self.element.remove(element)
- def get(self, key, *args):
- return self.element.get(key, *args)
-
- def items(self): return self.element.items()
-
- def set(self, key, value):
- self.element.set(key, value)
-
def set_text(self, text):
self.element.text = text
+ # Element does not have unset ?!?
def unset(self, key):
del self.element.attrib[key]
- def iterchildren(self):
- return self.element.iterchildren()
-
def toxml(self):
return etree.tostring(self.element, encoding='UTF-8', pretty_print=True)
def __str__(self):
return self.toxml()
+ ### other method calls or attribute access like .text or .tag or .get
+ # are redirected on self.element
+ def __getattr__ (self, name):
+ if not hasattr(self.element, name):
+ raise AttributeError, name
+ return getattr(self.element, name)
+
class XML:
def __init__(self, xml=None, namespaces=None):
namespaces = self.namespaces
return self.root.xpath(xpath, namespaces=namespaces)
- def set(self, key, value, element=None):
- if not element:
- element = self.root
- return element.set(key, value)
+ def set(self, key, value):
+ return self.root.set(key, value)
def remove_attribute(self, name, element=None):
if not element:
# XX defaulting to user, but this should be configurable so we can
# test from components persepctive
self.type = 'user'
- self.credential = self.get_credential(self.hrn)
+ self.credential = self.GetCredential(self.hrn)
- def get_credential(self, hrn = None, type = 'user'):
+ def GetCredential(self, hrn = None, type = 'user'):
if not hrn: hrn = self.hrn
if hrn == self.hrn:
cert = self.cert.save_to_string(save_parents=True)
return credential
else:
if not self.credential:
- self.credential = self.get_credential(self.hrn, 'user')
- return self.registry.get_credential(self.credential, type, hrn)
+ self.credential = self.GetCredential(self.hrn, 'user')
+ return self.registry.GetCredential(self.credential, type, hrn)
class BasicTestCase(unittest.TestCase):
def __init__(self, testname, client, test_slice=None):
BasicTestCase.setUp(self)
def testGetSelfCredential(self):
- cred = self.client.get_credential()
+ cred = self.client.GetCredential()
# this will raise an openssl error if the credential string isnt valid
Credential(string=cred)
def testRegister(self):
authority = get_authority(self.hrn)
- auth_cred = self.client.get_credential(authority, 'authority')
+ auth_cred = self.client.GetCredential(authority, 'authority')
auth_record = {'hrn': '.'.join([authority, random_string(10).lower()]),
'type': 'authority'}
node_record = {'hrn': '.'.join([authority, random_string(10)]),
all_records = [auth_record, node_record, slice_record, user_record]
for record in all_records:
try:
- self.registry.register(auth_cred, record)
- self.registry.resolve(self.credential, record['hrn'])
+ self.registry.Register(auth_cred, record)
+ self.registry.Resolve(self.credential, record['hrn'])
except:
raise
finally:
- try: self.registry.remove(auth_cred, record['type'], record['hrn'])
+ try: self.registry.Remove(auth_cred, record['type'], record['hrn'])
except: pass
def testUpdate(self):
authority = get_authority(self.hrn)
- auth_cred = self.client.get_credential(authority, 'authority')
- records = self.registry.resolve(self.credential, self.hrn)
+ auth_cred = self.client.GetCredential(authority, 'authority')
+ records = self.registry.Resolve(self.credential, self.hrn)
if not records: assert False
record = records[0]
self.registry.update(auth_cred, record)
def testResolve(self):
authority = get_authority(self.hrn)
- self.registry.resolve(self.credential, self.hrn)
+ self.registry.Resolve(self.credential, self.hrn)
def testRemove(self):
authority = get_authority(self.hrn)
- auth_cred = self.client.get_credential(authority, 'authority')
+ auth_cred = self.client.GetCredential(authority, 'authority')
record = {'hrn': ".".join([authority, random_string(10)]),
'type': 'slice'}
- self.registry.register(auth_cred, record)
- self.registry.remove(auth_cred, record['type'], record['hrn'])
+ self.registry.Register(auth_cred, record)
+ self.registry.Remove(auth_cred, record['type'], record['hrn'])
# should generate an exception
try:
- self.registry.resolve(self.credential, record['hrn'])
+ self.registry.Resolve(self.credential, record['hrn'])
assert False
except:
assert True
def testList(self):
authority = get_authority(self.client.hrn)
- self.registry.list(self.credential, authority)
+ self.registry.List(self.credential, authority)
def testGetRegistries(self):
self.registry.get_registries(self.credential)
def testCreateSlice(self):
# get availabel resources
rspec = self.aggregate.get_resources(self.credential)
- slice_credential = self.client.get_credential(self.slice['hrn'], 'slice')
+ slice_credential = self.client.GetCredential(self.slice['hrn'], 'slice')
self.aggregate.CreateSliver(slice_credential, self.slice['hrn'], rspec)
def testDeleteSlice(self):
- slice_credential = self.client.get_credential(self.slice['hrn'], 'slice')
+ slice_credential = self.client.GetCredential(self.slice['hrn'], 'slice')
self.aggregate.DeleteSliver(slice_credential, self.slice['hrn'],"call-id-delete-slice")
def testGetTicket(self):
- slice_credential = self.client.get_credential(self.slice['hrn'], 'slice')
+ slice_credential = self.client.GetCredential(self.slice['hrn'], 'slice')
rspec = self.aggregate.get_resources(self.credential)
- ticket = self.aggregate.get_ticket(slice_credential, self.slice['hrn'], rspec)
+ ticket = self.aggregate.GetTicket(slice_credential, self.slice['hrn'], rspec)
# will raise an exception if the ticket inst valid
SfaTicket(string=ticket)
class ComponentTest(BasicTestCase):
def setUp(self):
BasicTestCase.setUp(self)
- self.slice_cred = self.client.get_credential(self.slice['hrn'], 'slice')
+ self.slice_cred = self.client.GetCredential(self.slice['hrn'], 'slice')
def testStartSlice(self):
self.cm.start_slice(self.slice_cred, self.slice['hrn'])
def testRedeemTicket(self):
rspec = self.aggregate.get_resources(self.credential)
- ticket = self.aggregate.get_ticket(slice_cred, self.slice['hrn'], rspec)
+ ticket = self.aggregate.GetTicket(slice_cred, self.slice['hrn'], rspec)
self.cm.redeem_ticket(slice_cred, ticket)
def CreateSliver(client):
# register a slice that will be used for some test
authority = get_authority(client.hrn)
- auth_cred = client.get_credential(authority, 'authority')
+ auth_cred = client.GetCredential(authority, 'authority')
slice_record = {'hrn': ".".join([authority, random_string(10)]),
'type': 'slice', 'researcher': [client.hrn]}
- client.registry.register(auth_cred, slice_record)
+ client.registry.Register(auth_cred, slice_record)
return slice_record
def DeleteSliver(client, slice):
authority = get_authority(client.hrn)
- auth_cred = client.get_credential(authority, 'authority')
+ auth_cred = client.GetCredential(authority, 'authority')
if slice:
- client.registry.remove(auth_cred, 'slice', slice['hrn'])
+ client.registry.Remove(auth_cred, 'slice', slice['hrn'])
if __name__ == '__main__':