from sqlobject import *
from sfa.util.faults import *
-from sfa.util.xrn import urn_to_hrn
+from sfa.util.xrn import urn_to_hrn, Xrn
from sfa.util.rspec import RSpec
from sfa.server.registry import Registries
from sfa.trust.credential import Credential
from sfa.plc.api import SfaAPI
from sfa.util.plxrn import hrn_to_pl_slicename, slicename_to_hrn
from sfa.util.callids import Callids
+from sfa.util.sfalogging import logger
+from sfa.rspecs.sfa_rspec import sfa_rspec_version
+from sfa.util.version import version_core
-from threading import Thread
+from multiprocessing import Process
from time import sleep
##
fileHandler = logging.FileHandler('/var/log/euca.log')
fileHandler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
logger.addHandler(fileHandler)
+ fileHandler.setLevel(logging.DEBUG)
logger.setLevel(logging.DEBUG)
configParser = ConfigParser()
sqlhub.processConnection = conn
Slice.createTable(ifNotExists=True)
EucaInstance.createTable(ifNotExists=True)
- IP.createTable(ifNotExists=True)
+ Meta.createTable(ifNotExists=True)
+
+ # Start the update process to keep track of the meta data
+ # about Eucalyptus instance.
+ Process(target=updateMeta).start()
# Make sure the schema exists.
if not os.path.exists(EUCALYPTUS_RSPEC_SCHEMA):
# @param sliceHRN The hunman readable name of the slice.
# @return sting()
#
-def getKeysForSlice(sliceHRN):
- logger = logging.getLogger('EucaAggregate')
- try:
- # convert hrn to slice name
- plSliceName = hrn_to_pl_slicename(sliceHRN)
- except IndexError, e:
- logger.error('Invalid slice name (%s)' % sliceHRN)
+def getKeysForSlice(api, sliceHRN):
+ logger = logging.getLogger('EucaAggregate')
+ cred = api.getCredential()
+ registry = api.registries[api.hrn]
+ keys = []
+
+ # Get the slice record
+ records = registry.Resolve(sliceHRN, cred)
+ if not records:
+ logging.warn('Cannot find any record for slice %s' % sliceHRN)
return []
- # Get the slice's information
- sliceData = api.plshell.GetSlices(api.plauth, {'name':plSliceName})
- if not sliceData:
- logger.warn('Cannot get any data for slice %s' % plSliceName)
- return []
+ # Find who can log into this slice
+ persons = records[0]['persons']
- # It should only return a list with len = 1
- sliceData = sliceData[0]
+ # Extract the keys from persons records
+ for p in persons:
+ sliceUser = registry.Resolve(p, cred)
+ userKeys = sliceUser[0]['keys']
+ keys += userKeys
- keys = []
- person_ids = sliceData['person_ids']
- if not person_ids:
- logger.warn('No users in slice %s' % sliceHRN)
- return []
-
- persons = api.plshell.GetPersons(api.plauth, person_ids)
- for person in persons:
- pkeys = api.plshell.GetKeys(api.plauth, person['key_ids'])
- for key in pkeys:
- keys.append(key['key'])
-
return ''.join(keys)
##
xml = self.eucaRSpec
cloud = self.cloudInfo
with xml.RSpec(type='eucalyptus'):
- with xml.cloud(id=cloud['name']):
+ with xml.network(name=cloud['name']):
with xml.ipv4:
xml << cloud['ip']
#self.__keyPairsXML(cloud['keypairs'])
schemaXML = ET.parse(EUCALYPTUS_RSPEC_SCHEMA)
rspecValidator = ET.RelaxNG(schemaXML)
rspecXML = ET.XML(xml)
+ for network in rspecXML.iterfind("./network"):
+ if network.get('id') != cloud['name']:
+ # Throw away everything except my own RSpec
+ # sfa_logger().error("CreateSliver: deleting %s from rspec"%network.get('id'))
+ network.getparent().remove(network)
if not rspecValidator(rspecXML):
error = rspecValidator.error_log.last_error
message = '%s (line %s)' % (error.message, error.line)
pendingRmInst = []
for sliceInst in s.instances:
pendingRmInst.append(sliceInst.instance_id)
- existingInstGroup = rspecXML.findall('.//euca_instances')
+ existingInstGroup = rspecXML.findall(".//euca_instances")
for instGroup in existingInstGroup:
for existingInst in instGroup:
if existingInst.get('id') in pendingRmInst:
conn.terminate_instances(pendingRmInst)
# Process new instance requests
- requests = rspecXML.findall('.//request')
+ requests = rspecXML.findall(".//request")
if requests:
# Get all the public keys associate with slice.
- pubKeys = getKeysForSlice(s.slice_hrn)
+ pubKeys = getKeysForSlice(api, s.slice_hrn)
logger.debug('Passing the following keys to the instance:\n%s' % pubKeys)
for req in requests:
vmTypeElement = req.getparent()
return xml
##
-# A thread that will update the meta data.
+# A separate process that will update the meta data.
#
def updateMeta():
- logger = logging.getLogger('EucaAggregate')
+ logger = logging.getLogger('EucaMeta')
+ fileHandler = logging.FileHandler('/var/log/euca_meta.log')
+ fileHandler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+ logger.addHandler(fileHandler)
+ fileHandler.setLevel(logging.DEBUG)
+ logger.setLevel(logging.DEBUG)
+
while True:
- sleep(120)
+ sleep(30)
# Get IDs of the instances that don't have IPs yet.
dbResults = Meta.select(
Meta.q.state != 'deleted')
)
dbResults = list(dbResults)
- logger.debug('[update thread] dbResults: %s' % dbResults)
+ logger.debug('[update process] dbResults: %s' % dbResults)
instids = []
for r in dbResults:
instids.append(r.instance.instance_id)
- logger.debug('[update thread] Instance Id: %s' % ', '.join(instids))
+ logger.debug('[update process] Instance Id: %s' % ', '.join(instids))
# Get instance information from Eucalyptus
conn = getEucaConnection()
# Check the IPs
instIPs = [ {'id':i.id, 'pri_addr':i.private_dns_name, 'pub_addr':i.public_dns_name}
for i in vmInstances if i.private_dns_name != '0.0.0.0' ]
- logger.debug('[update thread] IP dict: %s' % str(instIPs))
+ logger.debug('[update process] IP dict: %s' % str(instIPs))
# Update the local DB
for ipData in instIPs:
dbInst = EucaInstance.select(EucaInstance.q.instance_id == ipData['id']).getOne(None)
if not dbInst:
- logger.info('[update thread] Could not find %s in DB' % ipData['id'])
+ logger.info('[update process] Could not find %s in DB' % ipData['id'])
continue
dbInst.meta.pri_addr = ipData['pri_addr']
dbInst.meta.pub_addr = ipData['pub_addr']
dbInst.meta.state = 'running'
+def GetVersion(api):
+ xrn=Xrn(api.hrn)
+ request_rspec_versions = [dict(sfa_rspec_version)]
+ ad_rspec_versions = [dict(sfa_rspec_version)]
+ version_more = {'interface':'aggregate',
+ 'testbed':'myplc',
+ 'hrn':xrn.get_hrn(),
+ 'request_rspec_versions': request_rspec_versions,
+ 'ad_rspec_versions': ad_rspec_versions,
+ 'default_ad_rspec': dict(sfa_rspec_version)
+ }
+ return version_core(version_more)
+
def main():
init_server()
#rspec = ListResources('euca', 'planetcloud.pc.test', 'planetcloud.pc.marcoy', 'test_euca')
#print rspec
- print getKeysForSlice('gc.gc.test1')
+
+ server_key_file = '/var/lib/sfa/authorities/server.key'
+ server_cert_file = '/var/lib/sfa/authorities/server.cert'
+ api = SfaAPI(key_file = server_key_file, cert_file = server_cert_file, interface='aggregate')
+ print getKeysForSlice(api, 'gc.gc.test1')
if __name__ == "__main__":
main()