Added special Timeslot element files.
Timeslot supports specification of different timezones
when creating a new experiment using senslab Rspec, computed
in AddSliceToNodes.
Timeslot format used :
<timeslot time="2012-04-26 10:00:00 Canada/Central" duration = "00:18:45" />
Timeslot does not belong to Node element, nor Sliver element.
Specific xml header should be used in order to trigger Slabv1 rspec
parsing functions.
<?xml version="1.0"?>
<rspec type="request" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://senslab.info/resources/rspec/1" xmlns:flack="http://senslab.info/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://senslab.info/resources/rspec/1 http://senslab.info/resources/rspec/1/request.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd" expires="2012-04-20T09:43:07Z" generated="2012-04-20T08:43:07Z">
--- /dev/null
+###########################################################################
+# Copyright (C) 2012 by
+# <savakian@sfa2.grenoble.senslab.info>
+#
+# Copyright: See COPYING file that comes with this distribution
+#
+###########################################################################
+from sfa.rspecs.elements.element import Element
+
+class Timeslot(Element):
+
+ fields = [
+ 'time',
+ 'duration'
+ ]
node_elem.add_instance('hardware_type', hardware_type, HardwareType.fields)
# set location
if node.get('location'):
- node_elem.add_instance('location', node['location'], Location.fields)
+ node_elem.add_instance('location', node['location'], Location.fields)
+
# set interfaces
#if node.get('interfaces'):
#for interface in node.get('interfaces', []):
if node.get('pl_initscripts'):
for initscript in node.get('pl_initscripts', []):
slivers['tags'].append({'name': 'initscript', 'value': initscript['name']})
- Slabv1Sliver.add_slivers(node_elem, slivers)
- print>>sys.stderr, "\r\n \r\n SLABV1NODE.PY \t\t addnodes node_elems[0] %s" %(node_elems[0])
+
+ Slabv1Sliver.add_slivers(node_elem, slivers)
return node_elems
@staticmethod
def get_nodes(xml, filter={}):
xpath = '//node%s | //default:node%s' % (XpathFilter.xpath(filter), XpathFilter.xpath(filter))
- node_elems = xml.xpath(xpath)
+ node_elems = xml.xpath(xpath)
+ print>>sys.stderr, "\r\n \r\n \t\t \t SLABV1NODE.pY get_nodes!!!!!!!!! node_elems %s"%(node_elems)
return Slabv1Node.get_node_objs(node_elems)
- @staticmethod
+ @staticmethod
def get_nodes_with_slivers(xml, filter={}):
- xpath = '//node[count(sliver_type)>0] | //default:node[count(default:sliver_type) > 0]'
- node_elems = xml.xpath(xpath)
+ #xpath = '//node[count(sliver_type)>0] | //default:node[count(default:sliver_type) > 0]'
+ xpath = '//node[count(sliver)>0] | //default:node[count(default:sliver) > 0]'
+ node_elems = xml.xpath(xpath)
+ print>>sys.stderr, "\r\n \r\n \t\t \t SLABV1NODE.pY get_nodes_with_slivers node_elems %s"%(node_elems)
return Slabv1Node.get_node_objs(node_elems)
@staticmethod
# get services
#node['services'] = PGv2Services.get_services(node_elem)
-
+
# get slivers
node['slivers'] = Slabv1Sliver.get_slivers(node_elem)
available_elems = node_elem.xpath('./default:available | ./available')
@staticmethod
def add_slivers(xml, slivers):
+ print>>sys.stderr, "\r\n \r\n \t\t SLABv1NODE.PY add_slivers "
component_ids = []
for sliver in slivers:
filter = {}
from sfa.rspecs.elements.element import Element
from sfa.rspecs.elements.sliver import Sliver
-#from sfa.rspecs.elements.versions.pgv2DiskImage import PGv2DiskImage
+#from sfa.rspecs.elements.versions.pgv2DiskImage import PGv2DiskImage
+import sys
class Slabv1Sliver:
@staticmethod
if not isinstance(slivers, list):
slivers = [slivers]
for sliver in slivers:
- sliver_elem = xml.add_element('sliver_type')
+ #sliver_elem = xml.add_element('sliver_type')
+ sliver_elem = xml.add_element('sliver')
if sliver.get('type'):
sliver_elem.set('name', sliver['type'])
if sliver.get('client_id'):
attrib_elem.set(key, value)
@staticmethod
def get_slivers(xml, filter={}):
- xpath = './default:sliver_type | ./sliver_type'
+ xpath = './default:sliver | ./sliver'
+
sliver_elems = xml.xpath(xpath)
slivers = []
- for sliver_elem in sliver_elems:
+ for sliver_elem in sliver_elems:
sliver = Sliver(sliver_elem.attrib,sliver_elem)
+
if 'component_id' in xml.attrib:
sliver['component_id'] = xml.attrib['component_id']
if 'name' in sliver_elem.attrib:
sliver['type'] = sliver_elem.attrib['name']
#sliver['images'] = Slabv1DiskImage.get_images(sliver_elem)
+
+ print>>sys.stderr, "\r\n \r\n SLABV1SLIVER.PY \t\t\t get_slivers sliver %s " %( sliver)
slivers.append(sliver)
return slivers
--- /dev/null
+from sfa.rspecs.elements.element import Element
+from sfa.rspecs.elements.timeslot import Timeslot
+import sys
+
+class Slabv1Timeslot :
+ @staticmethod
+ def get_slice_timeslot(xml, filter={}):
+ print>>sys.stderr, "\r\n \r\n \t\t \t SLABV1TIMESLOT.pY >>>>>>>>>>>>>>>>>>>>>>>>>>>>> \t get_slice_timeslot "
+ xpath = '//default:timeslot | //timeslot'
+ timeslot_elems = xml.xpath(xpath)
+ print>>sys.stderr, "\r\n \r\n \t\t \t SLABV1TIMESLOT.pY >>>>>>>>>>>>>>>>>>>>>>>>>>>>> \t get_slice_timeslot timeslot_elems %s"%(timeslot_elems)
+ for timeslot_elem in timeslot_elems:
+ timeslot = Timeslot(timeslot_elem.attrib, timeslot_elem)
+ print>>sys.stderr, "\r\n \r\n \t\t \t SLABV1TIMESLOT.pY >>>>>>>>>>>>>>>>>>>>>>>>>>>>> \t get_slice_timeslot timeslot %s"%(timeslot)
+
+ return timeslot
\ No newline at end of file
from sfa.util.xrn import Xrn, urn_to_sliver_id
from sfa.util.plxrn import hostname_to_urn, xrn_to_hostname
from sfa.rspecs.baseversion import BaseVersion
-
+import sys
from sfa.rspecs.elements.versions.slabv1Node import Slabv1Node
from sfa.rspecs.elements.versions.slabv1Sliver import Slabv1Sliver
+from sfa.rspecs.elements.versions.slabv1Timeslot import Slabv1Timeslot
class Slabv1(BaseVersion):
#enabled = True
def get_nodes_with_slivers(self):
return Slabv1Node.get_nodes_with_slivers(self.xml)
+
+ def get_slice_timeslot(self ):
+ return Slabv1Timeslot.get_slice_timeslot(self.xml)
def add_nodes(self, nodes, check_for_dupes=False):
return Slabv1Node.add_nodes(self.xml, nodes)
# Slivers
- def get_sliver_attributes(self, hostname, network=None):
+ def get_sliver_attributes(self, hostname, node, network=None):
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t SLABV1.PY get_sliver_attributes hostname %s " %(hostname)
nodes = self.get_nodes({'component_id': '*%s*' %hostname})
- attribs = []
+ attribs = []
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t SLABV1.PY get_sliver_attributes-----------------nodes %s " %(nodes)
if nodes is not None and isinstance(nodes, list) and len(nodes) > 0:
node = nodes[0]
- sliver = node.xpath('./default:sliver_type', namespaces=self.namespaces)
+ #if node :
+ #sliver = node.xpath('./default:sliver | ./sliver')
+ #sliver = node.xpath('./default:sliver', namespaces=self.namespaces)
+ sliver = node['slivers']
+
if sliver is not None and isinstance(sliver, list) and len(sliver) > 0:
sliver = sliver[0]
+ attribs = sliver
#attribs = self.attributes_list(sliver)
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t SLABV1.PY get_sliver_attributes----------NN------- sliver %s self.namespaces %s attribs %s " %(sliver, self.namespaces,attribs)
return attribs
def get_slice_attributes(self, network=None):
+
slice_attributes = []
+ slot = self.get_slice_timeslot()
nodes_with_slivers = self.get_nodes_with_slivers()
+ slice_attributes.append({'timeslot':slot})
+ #slice_attributes.append({'name': 'timeslot', 'value' : slot})
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t SLABV1.PY get_slice_attributes -----------------nodes_with_slivers %s "%(nodes_with_slivers)
# TODO: default sliver attributes in the PG rspec?
default_ns_prefix = self.namespaces['default']
for node in nodes_with_slivers:
- sliver_attributes = self.get_sliver_attributes(node, network)
+ sliver_attributes = self.get_sliver_attributes(node['component_id'],node, network)
for sliver_attribute in sliver_attributes:
name=str(sliver_attribute[0])
text =str(sliver_attribute[1])
attribs = sliver_attribute[2]
# we currently only suppor the <initscript> and <flack> attributes
- if 'info' in name:
- attribute = {'name': 'flack_info', 'value': str(attribs), 'node_id': node}
- slice_attributes.append(attribute)
- elif 'initscript' in name:
+ #if 'info' in name:
+ #attribute = {'name': 'flack_info', 'value': str(attribs), 'node_id': node}
+ #slice_attributes.append(attribute)
+ #elif 'initscript' in name:
+ if 'initscript' in name:
if attribs is not None and 'name' in attribs:
value = attribs['name']
else:
value = text
attribute = {'name': 'initscript', 'value': value, 'node_id': node}
slice_attributes.append(attribute)
-
+
+
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t SLABV1.PY get_slice_attributes ----------------- slice_attributes %s "%(slice_attributes)
return slice_attributes
def attributes_list(self, elem):
def add_slivers(self, hostnames, attributes=[], sliver_urn=None, append=False):
# all nodes hould already be present in the rspec. Remove all
# nodes that done have slivers
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t\t SLABv1.PY add_slivers ----->get_node "
for hostname in hostnames:
node_elems = self.get_nodes({'component_id': '*%s*' % hostname})
if not node_elems:
continue
sliver = {'type': requested_sliver_type,
'pl_tags': attributes}
-
+ print>>sys.stderr, "\r\n \r\n \r\n \t\t\t SLABv1.PY add_slivers node_elem %s sliver_type %s \r\n \r\n " %(node_elem, sliver_type)
# remove available element
for available_elem in node_elem.xpath('./default:available | ./available'):
node_elem.remove(available_elem)
content_type = 'request'
schema = 'http://senslab.info/resources/rspec/1/request.xsd'
#http://www.geni.net/resources/rspec/3/request.xsd
- template = '<rspec type="advertisement" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://senslab.info/resources/rspec/1" xmlns:flack="http://senslab.info/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://senslab.info/resources/rspec/1 http://senslab.info/resources/rspec/1/ad.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
+ template = '<rspec type="request" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://senslab.info/resources/rspec/1" xmlns:flack="http://senslab.info/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://senslab.info/resources/rspec/1 http://senslab.info/resources/rspec/1/request.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
class Slabv1Manifest(Slabv1):
enabled = True
content_type = 'manifest'
schema = 'http://senslab.info/resources/rspec/1/manifest.xsd'
#http://www.geni.net/resources/rspec/3/manifest.xsd
- template = '<rspec type="advertisement" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://senslab.info/resources/rspec/1" xmlns:flack="http://senslab.info/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://senslab.info/resources/rspec/1 http://senslab.info/resources/rspec/1/ad.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
-#class Slabv1Ad(Slabv1):
- #enabled = True
- #content_type = 'ad'
- #schema = 'http://senslab.info/resources/rspec/1/ad.xsd'
- ##http://www.geni.net/resources/rspec/3/ad.xsd'
- #template = '<rspec type="advertisement" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.geni.net/resources/rspec/3" xmlns:flack="http://www.protogeni.net/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://www.geni.net/resources/rspec/3 http://www.geni.net/resources/rspec/3/ad.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
-
-#class Slabv1Request(Slabv1):
- #enabled = True
- #content_type = 'request'
- #schema = 'http://senslab.info/resources/rspec/1/request.xsd'
- ##http://www.geni.net/resources/rspec/3/request.xsd
- #template = '<rspec type="request" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.geni.net/resources/rspec/3" xmlns:flack="http://www.protogeni.net/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://www.geni.net/resources/rspec/3 http://www.geni.net/resources/rspec/3/request.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
-
-#class Slabv1Manifest(Slabv1):
- #enabled = True
- #content_type = 'manifest'
- #schema = 'http://senslab.info/resources/rspec/1/manifest.xsd'
- ##http://www.geni.net/resources/rspec/3/manifest.xsd
- #template = '<rspec type="manifest" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.geni.net/resources/rspec/3" xmlns:flack="http://www.protogeni.net/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://www.geni.net/resources/rspec/3 http://www.geni.net/resources/rspec/3/manifest.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
-
-
+ template = '<rspec type="manifest" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://senslab.info/resources/rspec/1" xmlns:flack="http://senslab.info/resources/rspec/ext/flack/1" xmlns:planetlab="http://www.planet-lab.org/resources/sfa/ext/planetlab/1" xsi:schemaLocation="http://senslab.info/resources/rspec/1 http://senslab.info/resources/rspec/1/manifest.xsd http://www.planet-lab.org/resources/sfa/ext/planetlab/1 http://www.planet-lab.org/resources/sfa/ext/planetlab/1/planetlab.xsd"/>'
if __name__ == '__main__':
print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI username",username
try:
self.oarserver['uri'] = OARrequest_post_uri_dict[request]['uri']
- print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI rq %s datadict %s " % ( self.oarserver['uri'] ,datadict)
+ #print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI rq %s datadict %s " % ( self.oarserver['uri'] ,datadict)
except:
print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI request not in OARrequest_post_uri_dict"
return
try:
- print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI %s " %( 'strval' in datadict)
+ #print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI %s " %( 'strval' in datadict)
if datadict and 'strval' in datadict:
self.oarserver['uri'] = self.oarserver['uri'].replace("id",str(datadict['strval']))
- print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI REPLACE OK %s"%(self.oarserver['uri'])
+ #print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI REPLACE OK %s"%(self.oarserver['uri'])
del datadict['strval']
- print>>sys.stderr, " \r\n \r\n \t POSTRequestToOARRestAPI datadict %s rq %s" %(datadict, self.oarserver['uri'] )
+ #print>>sys.stderr, " \r\n \r\n \t POSTRequestToOARRestAPI datadict %s rq %s" %(datadict, self.oarserver['uri'] )
except:
print>>sys.stderr, " \r\n \r\n POSTRequestToOARRestAPI ERRRRRORRRRRR "
return
try :
#self.oarserver['postformat'] = POSTformat[format]
- print>>sys.stderr, "\r\n POSTRequestToOARRestAPI headers %s uri %s" %(headers,self.oarserver['uri'])
+ #print>>sys.stderr, "\r\n POSTRequestToOARRestAPI headers %s uri %s" %(headers,self.oarserver['uri'])
conn = httplib.HTTPConnection(self.oarserver['ip'],self.oarserver['port'])
conn.request("POST",self.oarserver['uri'],data,headers )
resp = ( conn.getresponse()).read()
def filter_return_fields( dict_to_filter, return_fields):
filtered_dict = {}
- print>>sys.stderr, " \r\n \t \tfilter_return_fields return fields %s " %(return_fields)
+ #print>>sys.stderr, " \r\n \t \tfilter_return_fields return fields %s " %(return_fields)
for field in return_fields:
#print>>sys.stderr, " \r\n \t \tfield %s " %(field)
if field in dict_to_filter:
filtered_dict[field] = dict_to_filter[field]
- print>>sys.stderr, " \r\n \t\t filter_return_fields filtered_dict %s " %(filtered_dict)
+ #print>>sys.stderr, " \r\n \t\t filter_return_fields filtered_dict %s " %(filtered_dict)
return filtered_dict
'slice':{'str':'slice_hrn','int':'record_id_slice'},\
'peers':{'str':'hrn'}}
- print>>sys.stderr, " \r\n ___ parse_filter param_filter %s type %s return fields %s " %(param_filter,type_of_list, return_fields)
+ #print>>sys.stderr, " \r\n ___ parse_filter param_filter %s type %s return fields %s " %(param_filter,type_of_list, return_fields)
if param_filter is None and return_fields is None:
return list_to_filter
if type_of_list not in list_type:
- print>>sys.stderr, " \r\n type_of_list Error parse_filter %s " %(type_of_list)
+ #print>>sys.stderr, " \r\n type_of_list Error parse_filter %s " %(type_of_list)
return []
return_filtered_list= []
if type(p_filter) is str:
if item[list_type[type_of_list]['str']] == str(p_filter) :
- print>>sys.stderr, " \r\n p_filter %s \t item %s "%(p_filter,item[list_type[type_of_list]['str']])
+ #print>>sys.stderr, " \r\n p_filter %s \t item %s "%(p_filter,item[list_type[type_of_list]['str']])
if return_fields:
tmp_item = filter_return_fields(item,return_fields)
else:
if founditem:
if return_fields:
- print>>sys.stderr, " \r\n \r\n parsing.py param_filter dflt %s founditem %s " %(dflt, founditem)
+ #print>>sys.stderr, " \r\n \r\n parsing.py param_filter dflt %s founditem %s " %(dflt, founditem)
tmp_item = filter_return_fields(founditem[0],return_fields)
else:
tmp_item = founditem[0]
-
-#!/usr/bin/python
-
# import modules used here -- sys is a very standard one
import sys
import httplib
-from sfa.senslab.OARrestapi import *
-#from sfa.senslab.slabdriver import SlabDriver
+#from sfa.senslab.OARrestapi import *
+
from sfa.util.config import Config
from sfa.util.xrn import hrn_to_urn, urn_to_hrn, urn_to_sliver_id
from sfa.util.plxrn import PlXrn, hostname_to_urn, hrn_to_pl_slicename
from sfa.rspecs.elements.location import Location
from sfa.rspecs.elements.hardware_type import HardwareType
from sfa.rspecs.elements.node import Node
-#from sfa.rspecs.elements.link import Link
-from sfa.rspecs.elements.sliver import Sliver
#from sfa.rspecs.elements.login import Login
-#from sfa.rspecs.elements.location import Location
-#from sfa.rspecs.elements.interface import Interface
#from sfa.rspecs.elements.services import Services
-#from sfa.rspecs.elements.pltag import PLTag
+from sfa.rspecs.elements.sliver import Sliver
from sfa.rspecs.version_manager import VersionManager
-#from sfa.plc.vlink import get_tc_rate
+
from sfa.util.sfatime import datetime_to_epoch
def hostname_to_hrn(root_auth,login_base,hostname):
class SlabAggregate:
-
sites = {}
nodes = {}
api = None
user_options = {}
def __init__(self ,driver):
- #self.OARImporter = OARapi()
self.driver = driver
- #self.api = api
- print >>sys.stderr,"\r\n \r\n \t\t_____________INIT Slabaggregate api : %s" %(driver)
-
def get_slice_and_slivers(self, slice_xrn):
"""
#node_id = self.driver.root_auth + '.' + node_id
sliver = Sliver({'sliver_id': urn_to_sliver_id(slice_urn, slice['record_id_slice'], node_id),
'name': slice['slice_hrn'],
- 'type': 'slab-vm',
+ 'type': 'slab-node',
'tags': []})
slivers[node_id]= sliver
except KeyError:
print >>sys.stderr,"\r\n \r\n \t\t_____________ Slabaggregate api get_slice_and_slivers slivers %s " %(slivers)
return (slice, slivers)
-
-
- def get_nodes(self,slice=None,slivers=[], options={}):
- filtre = {}
-
- nodes = self.driver.GetNodes(filtre)
-
-
- interface_ids = []
- tag_ids = []
- nodes_dict = {}
- for node in nodes:
- nodes_dict[node['node_id']] = node
-
- rspec_nodes = []
- for node in nodes:
-
- node['hostname'] = hostname_to_hrn( self.driver.root_auth,node['site_login_base'], node['hostname'])
- rspec_node = Node()
-
- rspec_node['component_id'] = hostname_to_urn(self.driver.root_auth, node['site_login_base'], node['hostname'])
- rspec_node['component_name'] = node['hostname']
- rspec_node['component_manager_id'] = hrn_to_urn(self.driver.root_auth, 'authority+sa')
- rspec_node['authority_id'] = hrn_to_urn(PlXrn.site_hrn(self.driver.root_auth, node['site_login_base']), 'authority+sa')
- rspec_node['boot_state'] = node['boot_state']
- if node['posx'] and node['posy']:
- location = Location({'longitude':node['posx'], 'latitude': node['posy']})
- rspec_node['location'] = location
-
- rspec_node['exclusive'] = 'True'
- rspec_node['hardware_types']= [HardwareType({'name': 'senslab sensor node'})]
- rspec_node['interfaces'] = []
-
-
- rspec_node['tags'] = []
-
- rspec_nodes.append(rspec_node)
- return (rspec_nodes)
- def get_nodes_and_links(self, slice=None,slivers=[], options={}):
+ def get_nodes(self, slice=None,slivers=[], options={}):
# NT: the semantic of this function is not clear to me :
# if slice is not defined, then all the nodes should be returned
# if slice is defined, we should return only the nodes that are part of this slice
#filter.update({'peer_id': None})
#nodes = self.driver.GetNodes(filter['hostname'])
- #print>>sys.stderr, "\r\n \r\n \t get_nodes_and_links nodes %s" %(nodes)
+ #print>>sys.stderr, "\r\n \r\n \t get_nodes nodes %s" %(nodes)
#site_ids = []
#interface_ids = []
# get tags
#node_tags = self.get_node_tags(tags_filter)
- #links = self.get_links(sites_dict, nodes_dict, interfaces)
+
reserved_nodes=self.driver.GetReservedNodes()
rspec_nodes = []
for node in nodes:
#if slice and 'expires' in slice:
#rspec.xml.set('expires', datetime_to_epoch(slice['expires']))
# add sliver defaults
- #nodes, links = self.get_nodes_and_links(slice, slivers)
- nodes = self.get_nodes_and_links(slice,slivers)
+ #nodes, links = self.get_nodes(slice, slivers)
+ nodes = self.get_nodes(slice,slivers)
print>>sys.stderr, " \r\n SlabAggregate \t\t get_rspec ************** options %s rspec_version %s version_manager %s rspec.version %s \r\n" %(options, rspec_version,version_manager, rspec.version)
rspec.version.add_nodes(nodes)
- #rspec.version.add_links(links)
+
default_sliver = slivers.get(None, [])
if default_sliver:
default_sliver_attribs = default_sliver.get('tags', [])
convert a list of dictionaries into a dictionary keyed on the
specified dictionary key
"""
- # print>>sys.stderr, " \r\n \t\t 1list_to_dict : rec %s \r\n \t\t list_to_dict key %s" %(recs,key)
+
keys = [rec[key] for rec in recs]
- #print>>sys.stderr, " \r\n \t\t list_to_dict : rec %s \r\n \t\t list_to_dict keys %s" %(recs,keys)
return dict(zip(keys, recs))
# thierry : note
print >>sys.stderr, "\r\n_____________ SFA SENSLAB DRIVER \r\n"
- # thierry - just to not break the rest of this code
-
- #self.oar = OARapi()
self.oar = OARrestapi()
self.ldap = LDAPapi()
- #self.users = SenslabImportUsers()
self.time_format = "%Y-%m-%d %H:%M:%S"
self.db = SlabDB(config)
- #self.logger=sfa_logger()
self.cache=None
if len(nodes) is 0:
raise SliverDoesNotExist("No slivers allocated ")
-
-
-
+
result = {}
top_level_status = 'unknown'
if nodes:
sliver_id = urn_to_sliver_id(slice_urn, sl['record_id_slice'],nodeall_byhostname[node]['node_id'] )
res['geni_urn'] = sliver_id
if nodeall_byhostname[node]['boot_state'] == 'Alive':
- #if node['boot_state'] == 'Alive':
+
res['geni_status'] = 'ready'
else:
res['geni_status'] = 'failed'
def create_sliver (self, slice_urn, slice_hrn, creds, rspec_string, users, options):
+ print>>sys.stderr, "\r\n \r\n \t=============================== SLABDRIVER.PY create_sliver "
aggregate = SlabAggregate(self)
-
+
slices = SlabSlices(self)
peer = slices.get_peer(slice_hrn)
sfa_peer = slices.get_sfa_peer(slice_hrn)
slice_record=None
-
-
+
if not isinstance(creds, list):
creds = [creds]
-
-
+
if users:
slice_record = users[0].get('slice_record', {})
# parse rspec
rspec = RSpec(rspec_string)
- requested_attributes = rspec.version.get_slice_attributes()
+ print>>sys.stderr, "\r\n \r\n \t=============================== SLABDRIVER.PY create_sliver ============================rspec.version %s " %(rspec.version)
- # ensure site record exists
- #site = slices.verify_site(slice_hrn, slice_record, peer, sfa_peer, options=options)
+
+ # ensure site record exists?
# ensure slice record exists
slice = slices.verify_slice(slice_hrn, slice_record, peer, sfa_peer, options=options)
+ requested_attributes = rspec.version.get_slice_attributes()
+
+ if requested_attributes:
+ for attrib_dict in requested_attributes:
+ if 'timeslot' in attrib_dict:
+ slice.update({'timeslot':attrib_dict['timeslot']})
+ print >>sys.stderr, "\r\n \r\n \t=============================== SLABDRIVER.PY create_sliver ..... slice %s " %(slice)
# ensure person records exists
persons = slices.verify_persons(slice_hrn, slice, users, peer, sfa_peer, options=options)
- # ensure slice attributes exists
- #slices.verify_slice_attributes(slice, requested_attributes, options=options)
+ # ensure slice attributes exists?
+
- # add/remove slice from nodes
+ # add/remove slice from nodes
+ print >>sys.stderr, "\r\n \r\n \t=============================== SLABDRIVER.PY create_sliver ..... "
+
requested_slivers = [node.get('component_name') for node in rspec.version.get_nodes_with_slivers()]
+ print >>sys.stderr, "\r\n \r\n \t=============================== ........... requested_slivers ============================requested_slivers %s " %(requested_slivers)
nodes = slices.verify_slice_nodes(slice, requested_slivers, peer)
-
-
- # handle MyPLC peer association.
- # only used by plc and ple.
- #slices.handle_peer(site, slice, persons, peer)
return aggregate.get_rspec(slice_xrn=slice_urn, version=rspec.version)
self.BindObjectToPeer('slice', slice['slice_id'], peer, slice['peer_slice_id'])
return 1
-
-
-
+
# first 2 args are None in case of resource discovery
def list_resources (self, slice_urn, slice_hrn, creds, options):
#cached_requested = options.get('cached', True)
#return rspec
#panos: passing user-defined options
- #print "manager options = ",options
+
aggregate = SlabAggregate(self)
origin_hrn = Credential(string=creds[0]).get_gid_caller().get_hrn()
- print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources origin_hrn %s" %(origin_hrn)
+ #print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources origin_hrn %s" %(origin_hrn)
options.update({'origin_hrn':origin_hrn})
- print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources options %s" %(options)
+ #print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources options %s" %(options)
rspec = aggregate.get_rspec(slice_xrn=slice_urn, version=rspec_version,
options=options)
print>>sys.stderr, " \r\n \r\n \t SLABDRIVER list_resources rspec "
type = sfa_record['type']
slab_record = self.sfa_fields_to_slab_fields(type, hrn, sfa_record)
- #if type == 'authority':
- #sites = self.shell.GetSites([slab_record['login_base']])
- #if not sites:
- #pointer = self.shell.AddSite(slab_record)
- #else:
- #pointer = sites[0]['site_id']
-
+
if type == 'slice':
acceptable_fields=['url', 'instantiation', 'name', 'description']
for key in slab_record.keys():
self.AddPersonKey(pointer, {'key_type' : 'ssh', 'key' : pub_key})
#No node adding outside OAR
- #elif type == 'node':
- #login_base = hrn_to_slab_login_base(sfa_record['authority'])
- #nodes = self.GetNodes([slab_record['hostname']])
- #if not nodes:
- #pointer = self.AddNode(login_base, slab_record)
- #else:
- #pointer = nodes[0]['node_id']
-
+
return pointer
#No site or node record update allowed
key_exists = True
if not key_exists:
self.AddPersonKey(pointer, {'key_type': 'ssh', 'key': new_key})
-
- #elif type == "node":
- #self.UpdateNode(pointer, new_sfa_record)
+
return True
node_dict = dict(zip(node_hostname_list,node_list))
try :
liste =job_info[node_list_k]
- print>>sys.stderr, "\r\n \r\n \t\t GetJobs resources job_info liste%s" %(liste)
+ #print>>sys.stderr, "\r\n \r\n \t\t GetJobs resources job_info liste%s" %(liste)
for k in range(len(liste)):
job_info[node_list_k][k] = node_dict[job_info[node_list_k][k]]['hostname']
- print>>sys.stderr, "\r\n \r\n \t\t YYYYYYYYYYYYGetJobs resources job_info %s" %(job_info)
+ #print>>sys.stderr, "\r\n \r\n \t\t YYYYYYYYYYYYGetJobs resources job_info %s" %(job_info)
#Replaces the previous entry "assigned_network_address" / "reserved_resources"
#with "node_ids"
job_info.update({'node_ids':job_info[node_list_k]})
return nodes
def GetNodes(self,node_filter= None, return_fields=None):
-
node_dict =self.oar.parser.SendRequest("GET_resources_full")
- print>>sys.stderr, "\r\n \r\n \t\t SLABDRIVER.PY GetNodes "
+
return_node_list = []
if not (node_filter or return_fields):
return_node_list = node_dict.values()
def GetSites(self, site_filter = None, return_fields=None):
site_dict =self.oar.parser.SendRequest("GET_sites")
- print>>sys.stderr, "\r\n \r\n \t\t SLABDRIVER.PY GetSites "
return_site_list = []
if not ( site_filter or return_fields):
return_site_list = site_dict.values()
if slicerec:
rec = slicerec.dumpquerytodict()
login = slicerec.slice_hrn.split(".")[1].split("_")[0]
- print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY slicerec GetSlices %s " %(slicerec)
+ #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY slicerec GetSlices %s " %(slicerec)
if slicerec.oar_job_id is not -1:
rslt = self.GetJobs( slicerec.oar_job_id, resources=False, username = login )
- print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices GetJobs %s " %(rslt)
+ #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices GetJobs %s " %(rslt)
if rslt :
rec.update(rslt)
rec.update({'hrn':str(rec['slice_hrn'])})
rec['oar_job_id'] = -1
rec.update({'hrn':str(rec['slice_hrn'])})
- print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices rec %s" %(rec)
+ try:
+ rec['node_ids'] = rec['node_list']
+ except KeyError:
+ pass
+
+ #print >>sys.stderr, " \r\n \r\n \tSLABDRIVER.PY GetSlices rec %s" %(rec)
return rec
return slab_record
-
-
-
- def AddSliceToNodes(self, slice_name, added_nodes, slice_user=None):
+
+ def AddSliceToNodes(self, slice_dict, added_nodes, slice_user=None):
site_list = []
nodeid_list =[]
resource = ""
reqdict = {}
+ slice_name = slice_dict['name']
+ try:
+ slot = slice_dict['timeslot']
+ except KeyError:
+ slot = { 'time':None, 'duration':'00:10:00' }#10 min
+ reqdict['resource']+= ",walltime=" + str(00) + ":" + str(12) + ":" + str(20) #+2 min 20
+ reqdict['script_path'] = "/bin/sleep 620" #+20 sec
+
reqdict['property'] ="network_address in ("
for node in added_nodes:
#Get the ID of the node : remove the root auth and put the site in a separate list
reqdict['property'] += "'"+ nodeid +"', "
nodeid_list.append(nodeid)
#site_list.append( l[0] )
+
+
reqdict['property'] = reqdict['property'][0: len( reqdict['property'])-2] +")"
reqdict['resource'] ="network_address="+ str(len(nodeid_list))
- reqdict['resource']+= ",walltime=" + str(00) + ":" + str(12) + ":" + str(20) #+2 min 20
- reqdict['script_path'] = "/bin/sleep 620" #+20 sec
+
+
+ #In case of a scheduled experiment
+ if slot['time']:
+
+ walltime = slot['duration'].split(":")
+ # Fixing the walltime by adding a few delays. First put the walltime in seconds
+ # oarAdditionalDelay = 20; additional delay for /bin/sleep command to
+ # take in account prologue and epilogue scripts execution
+ # int walltimeAdditionalDelay = 120; additional delay
+ desired_walltime = int(walltime[0])*3600 + int(walltime[1]) * 60 + int(walltime[2])
+ total_walltime = desired_walltime + 140 #+2 min 20
+ sleep_walltime = desired_walltime + 20 #+20 sec
+ print>>sys.stderr, "\r\n \r\n \t\tAddSliceToNodes desired_walltime %s total_walltime %s sleep_walltime %s " %(desired_walltime,total_walltime,sleep_walltime)
+ #Put the walltime back in str form
+ #First get the hours
+ walltime[0] = str(total_walltime / 3600)
+ total_walltime = total_walltime - 3600 * int(walltime[0])
+ #Get the remaining minutes
+ walltime[1] = str(total_walltime / 60)
+ total_walltime = total_walltime - 60 * int(walltime[1])
+ #Get the seconds
+ walltime[2] = str(total_walltime)
+ print>>sys.stderr, "\r\n \r\n \t\tAddSliceToNodes walltime %s " %(walltime)
+
+ reqdict['resource']+= ",walltime=" + str(walltime[0]) + ":" + str(walltime[1]) + ":" + str(walltime[2])
+ reqdict['script_path'] = "/bin/sleep " + str(sleep_walltime)
+
+ #Get the reservation time
+ parse_time = slot['time'].split(" ")
+ date = ' '.join(parse_time[:-1])
+ #Get zone of the user from the reservation time given in the rspec
+ from_zone = tz.gettz(parse_time[2])
+ user_datetime = datetime.datetime.strptime(date, self.time_format)
+ user_datetime = user_datetime.replace(tzinfo = from_zone)
+
+ #Convert to UTC zone
+ to_zone = tz.tzutc()
+ utc_date = user_datetime.astimezone(to_zone)
+ #Readable time accpeted by OAR
+ reqdict['reservation']= utc_date.strftime(self.time_format)
+
+ print>>sys.stderr, "\r\n \r\n \t\tAddSliceToNodes reqdict['reservation'] %s " %(reqdict['reservation'])
+
+ else:
+ # Immediate XP
+ # reservations are performed in the oar server timebase, so :
+ # 1- we get the server time(in UTC tz )/server timezone
+ # 2- convert the server UTC time in its timezone
+ # 3- add a custom delay to this time
+ # 4- convert this time to a readable form and it for the reservation request.
+ server_timestamp,server_tz = self.GetTimezone()
+ s_tz=tz.gettz(server_tz)
+ UTC_zone = tz.gettz("UTC")
+ #weird... datetime.fromtimestamp should work since we do from datetime import datetime
+ utc_server= datetime.datetime.fromtimestamp(float(server_timestamp)+20,UTC_zone)
+ server_localtime=utc_server.astimezone(s_tz)
+
+ print>>sys.stderr, "\r\n \r\n \t\tAddSliceToNodes server_timestamp %s server_tz %s slice_name %s added_nodes %s username %s reqdict %s " %(server_timestamp,server_tz,slice_name,added_nodes,slice_user, reqdict )
+ readable_time = server_localtime.strftime(self.time_format)
+
+ print >>sys.stderr," \r\n \r\n \t\t\t\tAPRES ParseTimezone readable_time %s timestanp %s " %(readable_time ,server_timestamp)
+ reqdict['reservation'] = readable_time
+
+
reqdict['type'] = "deploy"
reqdict['directory']= ""
reqdict['name']= "TestSandrine"
- # reservations are performed in the oar server timebase, so :
- # 1- we get the server time(in UTC tz )/server timezone
- # 2- convert the server UTC time in its timezone
- # 3- add a custom delay to this time
- # 4- convert this time to a readable form and it for the reservation request.
- server_timestamp,server_tz = self.GetTimezone()
- s_tz=tz.gettz(server_tz)
- UTC_zone = tz.gettz("UTC")
- #weird... datetime.fromtimestamp should work since we do from datetime import datetime
- utc_server= datetime.datetime.fromtimestamp(float(server_timestamp)+20,UTC_zone)
- server_localtime=utc_server.astimezone(s_tz)
-
- print>>sys.stderr, "\r\n \r\n AddSliceToNodes slice_name %s added_nodes %s username %s reqdict %s " %(slice_name,added_nodes,slice_user, reqdict)
- readable_time = server_localtime.strftime(self.time_format)
-
- print >>sys.stderr," \r\n \r\n \t\t\t\tAPRES ParseTimezone readable_time %s timestanp %s " %(readable_time ,server_timestamp)
- reqdict['reservation'] = readable_time
+
- # first step : start the OAR job
+ # first step : start the OAR job and update the job
print>>sys.stderr, "\r\n \r\n AddSliceToNodes reqdict %s \r\n site_list %s" %(reqdict,site_list)
- #OAR = OARrestapi()
+
answer = self.oar.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s " %(answer)
- #self.db.update('slice',['oar_job_id'], [answer['id']], 'slice_hrn', slice_name)
-
-
- self.db.update_job( slice_name, job_id = answer['id'] )
- jobid=answer['id']
- print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s added_nodes %s slice_user %s" %(jobid,added_nodes,slice_user)
+ try:
+ jobid = answer['id']
+ except KeyError:
+ print>>sys.stderr, "\r\n AddSliceTonode Impossible to create job %s " %( answer)
+ return
+
+ print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s added_nodes %s slice_user %s" %(jobid,added_nodes,slice_user)
+ self.db.update_job( slice_name, jobid ,added_nodes)
+
+
# second step : configure the experiment
# we need to store the nodes in a yaml (well...) file like this :
# [1,56,23,14,45,75] with name /tmp/sfa<jobid>.json
print>>sys.stderr, "\r\n \r\n AddSliceToNodes wrapper returns %s " %(output)
return
+
+
+ #def AddSliceToNodes(self, slice_name, added_nodes, slice_user=None):
+
+ #site_list = []
+ #nodeid_list =[]
+ #resource = ""
+ #reqdict = {}
+ #reqdict['property'] ="network_address in ("
+ #for node in added_nodes:
+ ##Get the ID of the node : remove the root auth and put the site in a separate list
+ #s=node.split(".")
+ ## NT: it's not clear for me if the nodenames will have the senslab prefix
+ ## so lets take the last part only, for now.
+ #lastpart=s[-1]
+ ##if s[0] == self.root_auth :
+ ## Again here it's not clear if nodes will be prefixed with <site>_, lets split and tanke the last part for now.
+ #s=lastpart.split("_")
+ #nodeid=s[-1]
+ #reqdict['property'] += "'"+ nodeid +"', "
+ #nodeid_list.append(nodeid)
+ ##site_list.append( l[0] )
+ #reqdict['property'] = reqdict['property'][0: len( reqdict['property'])-2] +")"
+ #reqdict['resource'] ="network_address="+ str(len(nodeid_list))
+ #reqdict['resource']+= ",walltime=" + str(00) + ":" + str(12) + ":" + str(20) #+2 min 20
+ #reqdict['script_path'] = "/bin/sleep 620" #+20 sec
+ #reqdict['type'] = "deploy"
+ #reqdict['directory']= ""
+ #reqdict['name']= "TestSandrine"
+ ## reservations are performed in the oar server timebase, so :
+ ## 1- we get the server time(in UTC tz )/server timezone
+ ## 2- convert the server UTC time in its timezone
+ ## 3- add a custom delay to this time
+ ## 4- convert this time to a readable form and it for the reservation request.
+ #server_timestamp,server_tz = self.GetTimezone()
+ #s_tz=tz.gettz(server_tz)
+ #UTC_zone = tz.gettz("UTC")
+ ##weird... datetime.fromtimestamp should work since we do from datetime import datetime
+ #utc_server= datetime.datetime.fromtimestamp(float(server_timestamp)+20,UTC_zone)
+ #server_localtime=utc_server.astimezone(s_tz)
+
+ #print>>sys.stderr, "\r\n \r\n \t\tAddSliceToNodes server_timestamp %s server_tz %s slice_name %s added_nodes %s username %s reqdict %s " %(server_timestamp,server_tz,slice_name,added_nodes,slice_user, reqdict )
+ #readable_time = server_localtime.strftime(self.time_format)
+
+ #print >>sys.stderr," \r\n \r\n \t\t\t\tAPRES ParseTimezone readable_time %s timestanp %s " %(readable_time ,server_timestamp)
+ #reqdict['reservation'] = readable_time
+
+ ## first step : start the OAR job and update the job
+ #print>>sys.stderr, "\r\n \r\n AddSliceToNodes reqdict %s \r\n site_list %s" %(reqdict,site_list)
+
+ #answer = self.oar.POSTRequestToOARRestAPI('POST_job',reqdict,slice_user)
+ #print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s " %(answer)
+ #try:
+ #jobid = answer['id']
+ #except KeyError:
+ #print>>sys.stderr, "\r\n AddSliceTonode Impossible to create job %s " %( answer)
+ #return
+
+ #print>>sys.stderr, "\r\n \r\n AddSliceToNodes jobid %s added_nodes %s slice_user %s" %(jobid,added_nodes,slice_user)
+ #self.db.update_job( slice_name, jobid ,added_nodes)
+
+
+ ## second step : configure the experiment
+ ## we need to store the nodes in a yaml (well...) file like this :
+ ## [1,56,23,14,45,75] with name /tmp/sfa<jobid>.json
+ #f=open('/tmp/sfa/'+str(jobid)+'.json','w')
+ #f.write('[')
+ #f.write(str(added_nodes[0].strip('node')))
+ #for node in added_nodes[1:len(added_nodes)] :
+ #f.write(','+node.strip('node'))
+ #f.write(']')
+ #f.close()
+
+ ## third step : call the senslab-experiment wrapper
+ ##command= "java -jar target/sfa-1.0-jar-with-dependencies.jar "+str(jobid)+" "+slice_user
+ #javacmdline="/usr/bin/java"
+ #jarname="/opt/senslabexperimentwrapper/sfa-1.0-jar-with-dependencies.jar"
+ ##ret=subprocess.check_output(["/usr/bin/java", "-jar", ", str(jobid), slice_user])
+ #output = subprocess.Popen([javacmdline, "-jar", jarname, str(jobid), slice_user],stdout=subprocess.PIPE).communicate()[0]
+
+ #print>>sys.stderr, "\r\n \r\n AddSliceToNodes wrapper returns %s " %(output)
+ #return
for record in parkour:
if str(record['type']) == 'slice':
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t \t record %s" %(record)
+ #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t \t record %s" %(record)
#sfatable = SfaTable()
#existing_records_by_id = {}
#recslice = self.db.find('slice',{'slice_hrn':str(record['hrn'])})
#recslice = slab_dbsession.query(SliceSenslab).filter_by(slice_hrn = str(record['hrn'])).first()
recslice = self.GetSlices(slice_filter = str(record['hrn']), filter_type = 'slice_hrn')
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t HOY HOY reclise %s" %(recslice)
+ #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t HOY HOY reclise %s" %(recslice)
#if isinstance(recslice,list) and len(recslice) == 1:
#recslice = recslice[0]
recuser = dbsession.query(RegRecord).filter_by(record_id = recslice['record_id_user']).first()
#existing_records_by_id[recslice['record_id_user']]
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t recuser %s" %(recuser)
+ #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info \t\t recuser %s" %(recuser)
record.update({'PI':[recuser.hrn],
'person_ids':[recslice['record_id_user']]})
elif str(record['type']) == 'user':
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info USEEEEEEEEEERDESU!"
+ #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info USEEEEEEEEEERDESU!"
rec = self.GetSlices(slice_filter = record['record_id'], filter_type = 'record_id_user')
#Append record in records list, therfore fetches user and slice info again(one more loop)
rec.update({'type':'slice','hrn':rec['slice_hrn']})
records.append(rec)
- print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info ADDING SLIC EINFO rec %s" %(rec)
+ #print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info ADDING SLIC EINFO rec %s" %(rec)
print >>sys.stderr, "\r\n \t\t SLABDRIVER.PY fill_record_info OKrecords %s" %(records)
except TypeError:
print>>sys.stderr, " \r\n \r\n \t slices.py get_peer slice_authority %s site_authority %s " %(slice_authority, site_authority)
# check if we are already peered with this site_authority, if so
peers = self.driver.GetPeers({})
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peers %s " %(peers)
+ #print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peers %s " %(peers)
for peer_record in peers:
if site_authority == peer_record.hrn:
peer = peer_record
- print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peer %s " %(peer)
+ #print>>sys.stderr, " \r\n \r\n \t slices.py get_peer peer %s " %(peer)
return peer
def get_sfa_peer(self, xrn):
def verify_slice_nodes(self, slice, requested_slivers, peer):
current_slivers = []
deleted_nodes = []
+
if slice['node_ids']:
nodes = self.driver.GetNodes(slice['node_ids'], ['hostname'])
current_slivers = [node['hostname'] for node in nodes]
# add nodes from rspec
added_nodes = list(set(requested_slivers).difference(current_slivers))
- print>>sys.stderr , "\r\n \r\n \t slices.py verify_slice_nodes added_nodes %s slice %s" %( added_nodes,slice)
+ #print>>sys.stderr , "\r\n \r\n \t slices.py verify_slice_nodes added_nodes %s slice %s" %( added_nodes,slice)
try:
#if peer:
#self.driver.UnBindObjectFromPeer('slice', slice['slice_id'], peer['shortname'])
#so that the OAR/LDAP knows the user: remove the authority from the name
tmp= slice['PI'][0].split(".")
username = tmp[(len(tmp)-1)]
- self.driver.AddSliceToNodes(slice['name'], added_nodes, username)
+ self.driver.AddSliceToNodes(slice, added_nodes, username)
+ #self.driver.AddSliceToNodes(slice['name'], added_nodes, username)
if deleted_nodes:
self.driver.DeleteSliceFromNodes(slice['name'], deleted_nodes)
# update_existing users
updated_users_list = [user for user in existing_slice_users if user['hrn'] in \
updated_user_hrns]
- print>>sys.stderr, " \r\n \r\n slices.py verify_persons removed_user_hrns %s updated_users_list %s " %(removed_user_hrns,updated_users_list)
+ #print>>sys.stderr, " \r\n \r\n slices.py verify_persons removed_user_hrns %s updated_users_list %s " %(removed_user_hrns,updated_users_list)
#self.verify_keys(existing_slice_users, updated_users_list, peer, append)
added_persons = []
git://git.onelab.eu / sfa.git / commitdiff