from sfa.rspecs.elements.pltag import PLTag
from sfa.rspecs.elements.lease import Lease
from sfa.rspecs.elements.granularity import Granularity
+from sfa.rspecs.elements.memory import Memory
from sfa.rspecs.version_manager import VersionManager
-from sfa.planetlab.plxrn import PlXrn, hostname_to_urn, hrn_to_pl_slicename, slicename_to_hrn, xrn_to_ext_slicename, top_auth
+from sfa.planetlab.plxrn import PlXrn, hostname_to_urn, hrn_to_pl_slicename, slicename_to_hrn, top_auth, hash_loginbase
from sfa.planetlab.vlink import get_tc_rate
from sfa.planetlab.topology import Topology
-from sfa.storage.alchemy import dbsession
from sfa.storage.model import SliverAllocation
def __init__(self, driver):
self.driver = driver
- def get_nodes(self, options={}):
+ def get_nodes(self, options=None):
+ if options is None: options={}
filter = {'peer_id': None}
geni_available = options.get('geni_available')
if geni_available == True:
return nodes
- def get_sites(self, filter={}):
+ def get_sites(self, filter=None):
+ if filter is None: filter={}
sites = {}
for site in self.driver.shell.GetSites(filter):
sites[site['site_id']] = site
return sites
- def get_interfaces(self, filter={}):
+ def get_interfaces(self, filter=None):
+ if filter is None: filter={}
interfaces = {}
for interface in self.driver.shell.GetInterfaces(filter):
iface = Interface()
return links
- def get_node_tags(self, filter={}):
+ def get_node_tags(self, filter=None):
+ if filter is None: filter={}
node_tags = {}
for node_tag in self.driver.shell.GetNodeTags(filter):
node_tags[node_tag['node_tag_id']] = node_tag
return node_tags
- def get_pl_initscripts(self, filter={}):
+ def get_pl_initscripts(self, filter=None):
+ if filter is None: filter={}
pl_initscripts = {}
filter.update({'enabled': True})
for initscript in self.driver.shell.GetInitScripts(filter):
pl_initscripts[initscript['initscript_id']] = initscript
return pl_initscripts
- def get_slivers(self, urns, options={}):
+ 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':
pass
else:
slice_hrn = xrn.get_hrn()
- top_auth_hrn = top_auth(slice_hrn)
- if top_auth_hrn == self.driver.hrn:
- slice_name = hrn_to_pl_slicename(slice_hrn)
- else:
- slice_name = xrn_to_ext_slicename(slice_hrn)
- names.add(slice_name)
filter = {}
- if names:
- filter['name'] = list(names)
+ filter['peer_id'] = None
if slice_ids:
filter['slice_id'] = list(slice_ids)
- # get slices
- slices = self.driver.shell.GetSlices(filter)
+ # 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]
slivers.append(node)
return slivers
- def node_to_rspec_node(self, node, sites, interfaces, node_tags, pl_initscripts=[], grain=None, options={}):
+ 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']]
else:
rspec_node['exclusive'] = 'false'
+ # this mostly is a sample code, not designed for production but more for
+ # illustrative purposes, that gives an example of how you can extend the node's
+ # rspec to expose their amount of memory
+ # in this example I chose to always expose a <memory> tag
+ # also by default the exposed amount will be 4 Gb
+ # but this value can be overridden by setting a 'memory' tag on the node
+ memory_in_gb='4'
+ # let's scan the node tags to find for any 'memory' tag
+ for id,node_tag in node_tags.items():
+ if node_tag['tagname']=='memory':
+ memory_in_gb = node_tag['value']
+ # note that in this case it would make sense to delete the node_tag
+ # so that the XML does not contain a duplicate information
+ # always add a 'memory' xml tag
+ # this will be rendered by pgv2node.py
+ rspec_node['memory'] = Memory({'Gb':memory_in_gb})
+
rspec_node['hardware_types'] = [HardwareType({'name': 'plab-pc'}),
HardwareType({'name': 'pc'})]
# only doing this because protogeni rspec needs
tags_dict[tag['node_id']] = tag
return tags_dict
- def get_slice_nodes(self, slice, options={}):
+ def get_slice_nodes(self, slice, options=None):
+ if options is None: options={}
nodes_dict = {}
filter = {'peer_id': None}
tags_filter = {}
nodes_dict[node['node_id']] = node
return nodes_dict
- def rspec_node_to_geni_sliver(self, rspec_node, sliver_allocations = {}):
+ def rspec_node_to_geni_sliver(self, rspec_node, sliver_allocations=None):
+ if sliver_allocations is None: sliver_allocations={}
if rspec_node['sliver_id'] in sliver_allocations:
# set sliver allocation and operational status
sliver_allocation = sliver_allocations[rspec_node['sliver_id']]
}
return geni_sliver
- def get_leases(self, slice=None, options={}):
+ def get_leases(self, slice=None, options=None):
+ if options is None: options={}
now = int(time.time())
filter={}
return rspec_leases
- def list_resources(self, version = None, options={}):
+ def list_resources(self, version = None, options=None):
+ if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
return rspec.toxml()
- def describe(self, urns, version=None, options={}):
+ def describe(self, urns, version=None, options=None):
+ if options is None: options={}
version_manager = VersionManager()
version = version_manager.get_version(version)
rspec_version = version_manager._get_version(version.type, version.version, 'manifest')
geni_urn = urns[0]
sliver_ids = [sliver['sliver_id'] for sliver in slivers]
constraint = SliverAllocation.sliver_id.in_(sliver_ids)
- sliver_allocations = dbsession.query(SliverAllocation).filter(constraint)
+ sliver_allocations = self.driver.api.dbsession().query(SliverAllocation).filter(constraint)
sliver_allocation_dict = {}
for sliver_allocation in sliver_allocations:
geni_urn = sliver_allocation.slice_urn
git://git.onelab.eu / sfa.git / blobdiff