1 from sfa.util.faults import *
2 from sfa.util.namespace import *
3 from sfa.util.rspec import RSpec
4 from sfa.server.registry import Registries
5 from sfa.plc.nodes import *
6 from sfa.plc.api import *
7 from sfa.rspecs.aggregates.vini.utils import *
8 from sfa.rspecs.aggregates.vini.rspec import *
12 Copied from create_slice_aggregate() in sfa.plc.slices
14 def create_slice_vini_aggregate(api, hrn, nodes):
15 # Get the slice record
17 registries = Registries(api)
18 registry = registries[api.hrn]
19 credential = api.getCredential()
20 records = registry.resolve(credential, hrn)
21 for record in records:
22 if record['type'] in ['slice']:
25 raise RecordNotFound(hrn)
27 # Make sure slice exists at plc, if it doesnt add it
28 slicename = hrn_to_pl_slicename(hrn)
29 slices = api.plshell.GetSlices(api.plauth, [slicename], ['node_ids'])
31 parts = slicename.split("_")
33 # if site doesnt exist add it
34 sites = api.plshell.GetSites(api.plauth, [login_base])
36 authority = get_authority(hrn)
37 site_records = registry.resolve(credential, authority)
40 raise RecordNotFound(authority)
41 site = site_records[0]
45 site_id = api.plshell.AddSite(api.plauth, site)
50 slice_keys = ['name', 'url', 'description']
51 for key in slice_keys:
52 if key in slice and slice[key]:
53 slice_fields[key] = slice[key]
54 api.plshell.AddSlice(api.plauth, slice_fields)
60 # get the list of valid slice users from the registry and make
61 # they are added to the slice
62 researchers = record.get('researcher', [])
63 for researcher in researchers:
65 person_records = registry.resolve(credential, researcher)
66 for record in person_records:
67 if record['type'] in ['user']:
68 person_record = record
71 person_dict = person_record
72 persons = api.plshell.GetPersons(api.plauth, [person_dict['email']],
73 ['person_id', 'key_ids'])
75 # Create the person record
77 person_id=api.plshell.AddPerson(api.plauth, person_dict)
79 # The line below enables the user account on the remote aggregate
80 # soon after it is created.
81 # without this the user key is not transfered to the slice
82 # (as GetSlivers returns key of only enabled users),
83 # which prevents the user from login to the slice.
84 # We may do additional checks before enabling the user.
86 api.plshell.UpdatePerson(api.plauth, person_id, {'enabled' : True})
89 key_ids = persons[0]['key_ids']
91 api.plshell.AddPersonToSlice(api.plauth, person_dict['email'],
94 # Get this users local keys
95 keylist = api.plshell.GetKeys(api.plauth, key_ids, ['key'])
96 keys = [key['key'] for key in keylist]
98 # add keys that arent already there
99 for personkey in person_dict['keys']:
100 if personkey not in keys:
101 key = {'key_type': 'ssh', 'key': personkey}
102 api.plshell.AddPersonKey(api.plauth, person_dict['email'], key)
104 # find out where this slice is currently running
105 nodelist = api.plshell.GetNodes(api.plauth, slice['node_ids'],
107 hostnames = [node['hostname'] for node in nodelist]
109 # remove nodes not in rspec
110 deleted_nodes = list(set(hostnames).difference(nodes))
111 # add nodes from rspec
112 added_nodes = list(set(nodes).difference(hostnames))
115 print >> sys.stderr, "Slice on nodes:"
117 print >> sys.stderr, n
118 print >> sys.stderr, "Wants nodes:"
120 print >> sys.stderr, n
121 print >> sys.stderr, "Deleting nodes:"
122 for n in deleted_nodes:
123 print >> sys.stderr, n
124 print >> sys.stderr, "Adding nodes:"
125 for n in added_nodes:
126 print >> sys.stderr, n
129 api.plshell.AddSliceToNodes(api.plauth, slicename, added_nodes)
130 api.plshell.DeleteSliceFromNodes(api.plauth, slicename, deleted_nodes)
134 def get_rspec(api, xrn, origin_hrn):
135 hrn = urn_to_hrn(xrn)[0]
138 slicename = hrn_to_pl_slicename(hrn)
139 slice = get_slice(api, slicename)
142 topo.nodeTopoFromSliceTags(slice)
144 # call the default sfa.plc.nodes.get_rspec() method
145 return Nodes(api).get_rspec(hrn)
147 return topo.toxml(hrn)
152 Hook called via 'sfi.py create'
154 def create_slice(api, xrn, xml):
155 hrn = urn_to_hrn(xrn)[0]
159 topo.nodeTopoFromRSpec(rspec)
161 # Check request against current allocations
162 topo.verifyNodeTopo(hrn, topo)
164 nodes = topo.nodesInTopo()
167 hostnames.append(node.hostname)
168 create_slice_vini_aggregate(api, hrn, hostnames)
170 slicename = hrn_to_pl_slicename(hrn)
171 slice = get_slice(api, slicename)
173 topo.updateSliceTags(slice)
175 # print topo.toxml(hrn)
180 Returns the request context required by sfatables. At some point, this mechanism should be changed
181 to refer to "contexts", which is the information that sfatables is requesting. But for now, we just
182 return the basic information needed in a dict.
184 def fetch_context(slice_hrn, user_hrn, contexts):
185 base_context = {'sfa':{'user':{'hrn':user_hrn},
186 'slice':{'hrn':slice_hrn}}}
191 #rspec = get_rspec(api, "plc.princeton.iias", None)
193 f = open(sys.argv[1])
196 create_slice(api, "plc.princeton.iias", xml)
198 if __name__ == "__main__":