setting the sfa-0.9-15 tag
[sfa.git] / sfa / managers / aggregate_manager_eucalyptus.py
1 from __future__ import with_statement 
2 from sfa.util.faults import *
3 from sfa.util.namespace import *
4 from sfa.util.rspec import RSpec
5 from sfa.server.registry import Registries
6
7 import boto
8 from boto.ec2.regioninfo import RegionInfo
9 from boto.exception import EC2ResponseError
10 from ConfigParser import ConfigParser
11 from xmlbuilder import XMLBuilder
12 from lxml import etree as ET
13 from sqlobject import *
14
15 import sys
16 import os
17
18 ##
19 # The data structure used to represent a cloud.
20 # It contains the cloud name, its ip address, image information,
21 # key pairs, and clusters information.
22 #
23 cloud = {}
24
25 ##
26 # The location of the RelaxNG schema.
27 #
28 EUCALYPTUS_RSPEC_SCHEMA='/etc/sfa/eucalyptus.rng'
29
30 ##
31 # A representation of an Eucalyptus instance. This is a support class
32 # for instance <-> slice mapping.
33 #
34 class EucaInstance(SQLObject):
35     instance_id = StringCol(unique=True, default=None)
36     kernel_id   = StringCol()
37     image_id    = StringCol()
38     ramdisk_id  = StringCol()
39     inst_type   = StringCol()
40     key_pair    = StringCol()
41     slice = ForeignKey('Slice')
42
43     ##
44     # Contacts Eucalyptus and tries to reserve this instance.
45     # 
46     # @param botoConn A connection to Eucalyptus.
47     #
48     def reserveInstance(self, botoConn):
49         print >>sys.stderr, 'Reserving an instance: image: %s, kernel: ' \
50                             '%s, ramdisk: %s, type: %s, key: %s' % \
51                             (self.image_id, self.kernel_id, self.ramdisk_id, 
52                              self.inst_type, self.key_pair)
53
54         # XXX The return statement is for testing. REMOVE in production
55         #return
56
57         try:
58             reservation = botoConn.run_instances(self.image_id,
59                                                  kernel_id = self.kernel_id,
60                                                  ramdisk_id = self.ramdisk_id,
61                                                  instance_type = self.inst_type,
62                                                  key_name  = self.key_pair)
63             for instance in reservation.instances:
64                 self.instance_id = instance.id
65
66         # If there is an error, destroy itself.
67         except EC2ResponseError, ec2RespErr:
68             errTree = ET.fromstring(ec2RespErr.body)
69             msg = errTree.find('.//Message')
70             print >>sys.stderr, msg.text
71             self.destroySelf()
72
73 ##
74 # A representation of a PlanetLab slice. This is a support class
75 # for instance <-> slice mapping.
76 #
77 class Slice(SQLObject):
78     slice_hrn = StringCol()
79     #slice_index = DatabaseIndex('slice_hrn')
80     instances = MultipleJoin('EucaInstance')
81
82 ##
83 # Initialize the aggregate manager by reading a configuration file.
84 #
85 def init_server():
86     configParser = ConfigParser()
87     configParser.read(['/etc/sfa/eucalyptus_aggregate.conf', 'eucalyptus_aggregate.conf'])
88     if len(configParser.sections()) < 1:
89         print >>sys.stderr, 'No cloud defined in the config file'
90         raise Exception('Cannot find cloud definition in configuration file.')
91
92     # Only read the first section.
93     cloudSec = configParser.sections()[0]
94     cloud['name'] = cloudSec
95     cloud['access_key'] = configParser.get(cloudSec, 'access_key')
96     cloud['secret_key'] = configParser.get(cloudSec, 'secret_key')
97     cloud['cloud_url']  = configParser.get(cloudSec, 'cloud_url')
98     cloudURL = cloud['cloud_url']
99     if cloudURL.find('https://') >= 0:
100         cloudURL = cloudURL.replace('https://', '')
101     elif cloudURL.find('http://') >= 0:
102         cloudURL = cloudURL.replace('http://', '')
103     (cloud['ip'], parts) = cloudURL.split(':')
104
105     # Initialize sqlite3 database.
106     dbPath = '/etc/sfa/db'
107     dbName = 'euca_aggregate.db'
108
109     if not os.path.isdir(dbPath):
110         print >>sys.stderr, '%s not found. Creating directory ...' % dbPath
111         os.mkdir(dbPath)
112
113     conn = connectionForURI('sqlite://%s/%s' % (dbPath, dbName))
114     sqlhub.processConnection = conn
115     Slice.createTable(ifNotExists=True)
116     EucaInstance.createTable(ifNotExists=True)
117
118     # Make sure the schema exists.
119     if not os.path.exists(EUCALYPTUS_RSPEC_SCHEMA):
120         err = 'Cannot location schema at %s' % EUCALYPTUS_RSPEC_SCHEMA
121         print >>sys.stderr, err
122         raise Exception(err)
123
124 ##
125 # Creates a connection to Eucalytpus. This function is inspired by 
126 # the make_connection() in Euca2ools.
127 #
128 # @return A connection object or None
129 #
130 def getEucaConnection():
131     global cloud
132     accessKey = cloud['access_key']
133     secretKey = cloud['secret_key']
134     eucaURL   = cloud['cloud_url']
135     useSSL    = False
136     srvPath   = '/'
137     eucaPort  = 8773
138
139     if not accessKey or not secretKey or not eucaURL:
140         print >>sys.stderr, 'Please set ALL of the required environment ' \
141                             'variables by sourcing the eucarc file.'
142         return None
143     
144     # Split the url into parts
145     if eucaURL.find('https://') >= 0:
146         useSSL  = True
147         eucaURL = eucaURL.replace('https://', '')
148     elif eucaURL.find('http://') >= 0:
149         useSSL  = False
150         eucaURL = eucaURL.replace('http://', '')
151     (eucaHost, parts) = eucaURL.split(':')
152     if len(parts) > 1:
153         parts = parts.split('/')
154         eucaPort = int(parts[0])
155         parts = parts[1:]
156         srvPath = '/'.join(parts)
157
158     return boto.connect_ec2(aws_access_key_id=accessKey,
159                             aws_secret_access_key=secretKey,
160                             is_secure=useSSL,
161                             region=RegionInfo(None, 'eucalyptus', eucaHost), 
162                             port=eucaPort,
163                             path=srvPath)
164
165 ##
166 # A class that builds the RSpec for Eucalyptus.
167 #
168 class EucaRSpecBuilder(object):
169     ##
170     # Initizes a RSpec builder
171     #
172     # @param cloud A dictionary containing data about a 
173     #              cloud (ex. clusters, ip)
174     def __init__(self, cloud):
175         self.eucaRSpec = XMLBuilder(format = True, tab_step = "  ")
176         self.cloudInfo = cloud
177
178     ##
179     # Creates a request stanza.
180     # 
181     # @param num The number of instances to create.
182     # @param image The disk image id.
183     # @param kernel The kernel image id.
184     # @param keypair Key pair to embed.
185     # @param ramdisk Ramdisk id (optional).
186     #
187     def __requestXML(self, num, image, kernel, keypair, ramdisk = ''):
188         xml = self.eucaRSpec
189         with xml.request:
190             with xml.instances:
191                 xml << str(num)
192             with xml.kernel_image(id=kernel):
193                 xml << ''
194             if ramdisk == '':
195                 with xml.ramdisk:
196                     xml << ''
197             else:
198                 with xml.ramdisk(id=ramdisk):
199                     xml << ''
200             with xml.disk_image(id=image):
201                 xml << ''
202             with xml.keypair:
203                 xml << keypair
204
205     ##
206     # Creates the cluster stanza.
207     #
208     # @param clusters Clusters information.
209     #
210     def __clustersXML(self, clusters):
211         cloud = self.cloudInfo
212         xml = self.eucaRSpec
213
214         for cluster in clusters:
215             instances = cluster['instances']
216             with xml.cluster(id=cluster['name']):
217                 with xml.ipv4:
218                     xml << cluster['ip']
219                 with xml.vm_types:
220                     for inst in instances:
221                         with xml.vm_type(name=inst[0]):
222                             with xml.free_slots:
223                                 xml << str(inst[1])
224                             with xml.max_instances:
225                                 xml << str(inst[2])
226                             with xml.cores:
227                                 xml << str(inst[3])
228                             with xml.memory(unit='MB'):
229                                 xml << str(inst[4])
230                             with xml.disk_space(unit='GB'):
231                                 xml << str(inst[5])
232                             if inst[0] == 'm1.small':
233                                 self.__requestXML(1, 'emi-88760F45', 'eki-F26610C6', 'cortex')
234                             if 'instances' in cloud and inst[0] in cloud['instances']:
235                                 existingEucaInstances = cloud['instances'][inst[0]]
236                                 with xml.euca_instances:
237                                     for eucaInst in existingEucaInstances:
238                                         with xml.euca_instance(id=eucaInst['id']):
239                                             with xml.state:
240                                                 xml << eucaInst['state']
241                                             with xml.public_dns:
242                                                 xml << eucaInst['public_dns']
243                                             with xml.keypair:
244                                                 xml << eucaInst['key']
245
246     ##
247     # Creates the Images stanza.
248     #
249     # @param images A list of images in Eucalyptus.
250     #
251     def __imagesXML(self, images):
252         xml = self.eucaRSpec
253         with xml.images:
254             for image in images:
255                 with xml.image(id=image.id):
256                     with xml.type:
257                         xml << image.type
258                     with xml.arch:
259                         xml << image.architecture
260                     with xml.state:
261                         xml << image.state
262                     with xml.location:
263                         xml << image.location
264
265     ##
266     # Creates the KeyPairs stanza.
267     #
268     # @param keypairs A list of key pairs in Eucalyptus.
269     #
270     def __keyPairsXML(self, keypairs):
271         xml = self.eucaRSpec
272         with xml.keypairs:
273             for key in keypairs:
274                 with xml.keypair:
275                     xml << key.name
276
277     ##
278     # Generates the RSpec.
279     #
280     def toXML(self):
281         if not self.cloudInfo:
282             print >>sys.stderr, 'No cloud information'
283             return ''
284
285         xml = self.eucaRSpec
286         cloud = self.cloudInfo
287         with xml.RSpec(type='eucalyptus'):
288             with xml.cloud(id=cloud['name']):
289                 with xml.ipv4:
290                     xml << cloud['ip']
291                 self.__keyPairsXML(cloud['keypairs'])
292                 self.__imagesXML(cloud['images'])
293                 self.__clustersXML(cloud['clusters'])
294         return str(xml)
295
296 ##
297 # A parser to parse the output of availability-zones.
298 #
299 # Note: Only one cluster is supported. If more than one, this will
300 #       not work.
301 #
302 class ZoneResultParser(object):
303     def __init__(self, zones):
304         self.zones = zones
305
306     def parse(self):
307         if len(self.zones) < 3:
308             return
309         clusterList = []
310         cluster = {} 
311         instList = []
312
313         cluster['name'] = self.zones[0].name
314         cluster['ip']   = self.zones[0].state
315
316         for i in range(2, len(self.zones)):
317             currZone = self.zones[i]
318             instType = currZone.name.split()[1]
319
320             stateString = currZone.state.split('/')
321             rscString   = stateString[1].split()
322
323             instFree      = int(stateString[0])
324             instMax       = int(rscString[0])
325             instNumCpu    = int(rscString[1])
326             instRam       = int(rscString[2])
327             instDiskSpace = int(rscString[3])
328
329             instTuple = (instType, instFree, instMax, instNumCpu, instRam, instDiskSpace)
330             instList.append(instTuple)
331         cluster['instances'] = instList
332         clusterList.append(cluster)
333
334         return clusterList
335
336 def get_rspec(api, creds, options): 
337     global cloud
338     # get slice's hrn from options
339     xrn = options.get('geni_slice_urn', None)
340     hrn, type = urn_to_hrn(xrn)
341
342     # get hrn of the original caller
343     origin_hrn = options.get('origin_hrn', None)
344     if not origin_hrn:
345         origin_hrn = Credential(string=creds[0]).get_gid_caller().get_hrn()
346
347     conn = getEucaConnection()
348
349     if not conn:
350         print >>sys.stderr, 'Error: Cannot create a connection to Eucalyptus'
351         return 'Cannot create a connection to Eucalyptus'
352
353     try:
354         # Zones
355         zones = conn.get_all_zones(['verbose'])
356         p = ZoneResultParser(zones)
357         clusters = p.parse()
358         cloud['clusters'] = clusters
359         
360         # Images
361         images = conn.get_all_images()
362         cloud['images'] = images
363
364         # Key Pairs
365         keyPairs = conn.get_all_key_pairs()
366         cloud['keypairs'] = keyPairs
367
368         if hrn:
369             instanceId = []
370             instances  = []
371
372             # Get the instances that belong to the given slice from sqlite3
373             # XXX use getOne() in production because the slice's hrn is supposed
374             # to be unique. For testing, uniqueness is turned off in the db.
375             # If the slice isn't found in the database, create a record for the 
376             # slice.
377             matchedSlices = list(Slice.select(Slice.q.slice_hrn == hrn))
378             if matchedSlices:
379                 theSlice = matchedSlices[-1]
380             else:
381                 theSlice = Slice(slice_hrn = hrn)
382             for instance in theSlice.instances:
383                 instanceId.append(instance.instance_id)
384
385             # Get the information about those instances using their ids.
386             if len(instanceId) > 0:
387                 reservations = conn.get_all_instances(instanceId)
388             else:
389                 reservations = []
390             for reservation in reservations:
391                 for instance in reservation.instances:
392                     instances.append(instance)
393
394             # Construct a dictory for the EucaRSpecBuilder
395             instancesDict = {}
396             for instance in instances:
397                 instList = instancesDict.setdefault(instance.instance_type, [])
398                 instInfoDict = {} 
399
400                 instInfoDict['id'] = instance.id
401                 instInfoDict['public_dns'] = instance.public_dns_name
402                 instInfoDict['state'] = instance.state
403                 instInfoDict['key'] = instance.key_name
404
405                 instList.append(instInfoDict)
406             cloud['instances'] = instancesDict
407
408     except EC2ResponseError, ec2RespErr:
409         errTree = ET.fromstring(ec2RespErr.body)
410         errMsgE = errTree.find('.//Message')
411         print >>sys.stderr, errMsgE.text
412
413     rspec = EucaRSpecBuilder(cloud).toXML()
414
415     # Remove the instances records so next time they won't 
416     # show up.
417     if 'instances' in cloud:
418         del cloud['instances']
419
420     return rspec
421
422 """
423 Hook called via 'sfi.py create'
424 """
425 def create_slice(api, xrn, creds, xml, users):
426     global cloud
427     hrn = urn_to_hrn(xrn)[0]
428
429     conn = getEucaConnection()
430     if not conn:
431         print >>sys.stderr, 'Error: Cannot create a connection to Eucalyptus'
432         return False
433
434     # Validate RSpec
435     schemaXML = ET.parse(EUCALYPTUS_RSPEC_SCHEMA)
436     rspecValidator = ET.RelaxNG(schemaXML)
437     rspecXML = ET.XML(xml)
438     if not rspecValidator(rspecXML):
439         error = rspecValidator.error_log.last_error
440         message = '%s (line %s)' % (error.message, error.line) 
441         # XXX: InvalidRSpec is new. Currently, I am not working with Trunk code.
442         #raise InvalidRSpec(message)
443         raise Exception(message)
444
445     # Get the slice from db or create one.
446     s = Slice.select(Slice.q.slice_hrn == hrn).getOne(None)
447     if s is None:
448         s = Slice(slice_hrn = hrn)
449
450     # Process any changes in existing instance allocation
451     pendingRmInst = []
452     for sliceInst in s.instances:
453         pendingRmInst.append(sliceInst.instance_id)
454     existingInstGroup = rspecXML.findall('.//euca_instances')
455     for instGroup in existingInstGroup:
456         for existingInst in instGroup:
457             if existingInst.get('id') in pendingRmInst:
458                 pendingRmInst.remove(existingInst.get('id'))
459     for inst in pendingRmInst:
460         print >>sys.stderr, 'Instance %s will be terminated' % inst
461         dbInst = EucaInstance.select(EucaInstance.q.instance_id == inst).getOne(None)
462         dbInst.destroySelf()
463     conn.terminate_instances(pendingRmInst)
464
465     # Process new instance requests
466     requests = rspecXML.findall('.//request')
467     for req in requests:
468         vmTypeElement = req.getparent()
469         instType = vmTypeElement.get('name')
470         numInst  = int(req.find('instances').text)
471         instKernel  = req.find('kernel_image').get('id')
472         instDiskImg = req.find('disk_image').get('id')
473         instKey     = req.find('keypair').text
474         
475         ramDiskElement = req.find('ramdisk')
476         ramDiskAttr    = ramDiskElement.attrib
477         if 'id' in ramDiskAttr:
478             instRamDisk = ramDiskAttr['id']
479         else:
480             instRamDisk = None
481
482         # Create the instances
483         for i in range(0, numInst):
484             eucaInst = EucaInstance(slice = s, 
485                                     kernel_id = instKernel,
486                                     image_id = instDiskImg,
487                                     ramdisk_id = instRamDisk,
488                                     key_pair = instKey,
489                                     inst_type = instType)
490             eucaInst.reserveInstance(conn)
491
492     return True
493
494 def main():
495     init_server()
496
497     theRSpec = None
498     with open(sys.argv[1]) as xml:
499         theRSpec = xml.read()
500     create_slice(None, 'planetcloud.pc.test', theRSpec)
501
502     #rspec = get_rspec('euca', 'planetcloud.pc.test', 'planetcloud.pc.marcoy')
503     #print rspec
504
505 if __name__ == "__main__":
506     main()
507