def actual_caller_hrn (self): """a helper method used by some API calls like e.g. Allocate to try and find out who really is the original caller This admittedly is a bit of a hack, please USE IN LAST RESORT This code uses a heuristic to identify a delegated credential A first known restriction if for traffic that gets through a slice manager in this case the hrn reported is the one from the last SM in the call graph which is not at all what is meant here""" caller_hrn = self.get_gid_caller().get_hrn() issuer_hrn = self.get_signature().get_issuer_gid().get_hrn() subject_hrn = self.get_gid_object().get_hrn() # if we find that the caller_hrn is an immediate descendant of the issuer, then # this seems to be a 'regular' credential if caller_hrn.startswith(issuer_hrn): actual_caller_hrn=caller_hrn # else this looks like a delegated credential, and the real caller is the issuer else: actual_caller_hrn=issuer_hrn logger.info("actual_caller_hrn: caller_hrn=%s, issuer_hrn=%s, returning %s" %(caller_hrn,issuer_hrn,actual_caller_hrn)) return actual_caller_hrn
def init_or_upgrade(self): # check if under version control, and initialize it otherwise if self.current_version() is None: before = "Unknown" # can be either a very old version, or a fresh install # for very old versions: self.handle_old_releases() # in any case, initialize db from current code and reflect in migrate model.init_tables(self.engine) code_version = migrate.version(self.repository) migrate.version_control(self.url, self.repository, code_version) after = "%s" % self.current_version() logger.info("DBSchema : jumped to version %s" % (after)) else: # use migrate in the usual way before = "%s" % self.current_version() migrate.upgrade(self.url, self.repository) after = "%s" % self.current_version() if before != after: logger.info("DBSchema : upgraded version from %s to %s" % (before, after)) else: logger.debug( "DBSchema : no change needed in db schema (%s==%s)" % (before, after))
def update_pis (self, pi_hrns, dbsession): # strip that in case we have <researcher> words </researcher> pi_hrns = [ x.strip() for x in pi_hrns ] request = dbsession.query (RegUser).filter(RegUser.hrn.in_(pi_hrns)) logger.info ("RegAuthority.update_pis: %d incoming pis, %d matches found"%(len(pi_hrns),request.count())) pis = dbsession.query (RegUser).filter(RegUser.hrn.in_(pi_hrns)).all() self.reg_pis = pis
def clean(self): try: retcod = os.unlink(self.filename) logger.info("Cleaned up version cache %s, retcod=%d" % (self.filename, retcod)) except: logger.info("Could not unlink version cache %s" % self.filename)
def update_researchers (self, researcher_hrns, dbsession): # strip that in case we have <researcher> words </researcher> researcher_hrns = [ x.strip() for x in researcher_hrns ] request = dbsession.query (RegUser).filter(RegUser.hrn.in_(researcher_hrns)) logger.info ("RegSlice.update_researchers: %d incoming researchers, %d matches found"%(len(researcher_hrns),request.count())) researchers = dbsession.query (RegUser).filter(RegUser.hrn.in_(researcher_hrns)).all() self.reg_researchers = researchers
def delete_router(self, tenant_id): is_router = False ports = self.driver.shell.network_manager.list_ports() ports = ports['ports'] networks = self.driver.shell.network_manager.list_networks() networks = networks['networks'] # find the subnetwork ID for removing the interface related with private network # TOPOLOGY: Public Network -- Router -- Private Network -- VM Instance(s) for port in ports: if (port.get('tenant_id') == tenant_id) and \ (port.get('device_owner') == 'network:router_interface'): router_id = port.get('device_id') port_net_id = port.get('network_id') for network in networks: if network.get('tenant_id') == tenant_id: net_id = network.get('id') if port_net_id == net_id: sbnet_ids = network.get('subnets') is_router = True if is_router: # remove the router's interface which is related with private network if sbnet_ids: body = {'subnet_id': sbnet_ids[0]} self.driver.shell.network_manager.remove_interface_router( router=router_id, body=body) # remove the router's interface which is related with public network self.driver.shell.network_manager.remove_gateway_router(router=router_id) # delete the router self.driver.shell.network_manager.delete_router(router=router_id) logger.info("Deleted the router: Router ID [%s]" % router_id) return 1
def update_relation(self, subject_type, target_type, relation_name, subject_id, target_ids): # hard-wire the code for slice/user for now, could be smarter if needed if subject_type == 'slice' and target_type == 'user' and relation_name == 'researcher': subject = self.shell.GetSlices({'slice_id': subject_id})[0] if 'user_ids' not in subject.keys(): subject['user_ids'] = [] current_target_ids = subject['user_ids'] add_target_ids = list( set(target_ids).difference(current_target_ids)) del_target_ids = list( set(current_target_ids).difference(target_ids)) logger.debug("subject_id = %s (type=%s)" % (subject_id, type(subject_id))) for target_id in add_target_ids: self.shell.AddUserToSlice({ 'user_id': target_id, 'slice_id': subject_id }) logger.debug("add_target_id = %s (type=%s)" % (target_id, type(target_id))) for target_id in del_target_ids: logger.debug("del_target_id = %s (type=%s)" % (target_id, type(target_id))) self.shell.DeleteUserFromSlice({ 'user_id': target_id, 'slice_id': subject_id }) else: logger.info('unexpected relation %s to maintain, %s -> %s' % (relation_name, subject_type, target_type))
def update_relation(self, subject_type, target_type, relation_name, subject_id, target_ids): # hard-wire the code for slice/user for now, could be smarter if needed if subject_type == 'slice' and target_type == 'user' and relation_name == 'researcher': subject = self.shell.GetSlices(subject_id)[0] current_target_ids = subject['person_ids'] add_target_ids = list( set(target_ids).difference(current_target_ids)) del_target_ids = list( set(current_target_ids).difference(target_ids)) logger.debug("subject_id = %s (type=%s)" % (subject_id, type(subject_id))) for target_id in add_target_ids: self.shell.AddPersonToSlice(target_id, subject_id) logger.debug("add_target_id = %s (type=%s)" % (target_id, type(target_id))) for target_id in del_target_ids: logger.debug("del_target_id = %s (type=%s)" % (target_id, type(target_id))) self.shell.DeletePersonFromSlice(target_id, subject_id) elif subject_type == 'authority' and target_type == 'user' and relation_name == 'pi': # due to the plcapi limitations this means essentially adding pi role to all people in the list # it's tricky to remove any pi role here, although it might be desirable persons = self.shell.GetPersons({ 'peer_id': None, 'person_id': target_ids }) for person in persons: if 'pi' not in person['roles']: self.shell.AddRoleToPerson('pi', person['person_id']) else: logger.info('unexpected relation %s to maintain, %s -> %s' % (relation_name, subject_type, target_type))
def node_to_rspec_node(self, node, options={}): rspec_node = NodeElement() site=self.driver.testbedInfo rspec_node['component_id'] = hostname_to_urn(self.driver.hrn, site['name'], node['hostname']) rspec_node['component_name'] = node['hostname'] rspec_node['ip'] = node['ip'] rspec_node['protocol'] = node['protocol'] rspec_node['port'] = node['port'] rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn() rspec_node['authority_id'] = hrn_to_urn(unigetestbedXrn.site_hrn(self.driver.hrn, site['name']), 'authority+sa') #distinguish between Shared and Reservable nodes rspec_node['exclusive'] = 'false' rspec_node['hardware_types'] = [HardwareType({'name': 'endpoint'}), HardwareType({'name': 'sensor'})] resources = [] for resource in node['resources']: resources.append(Resource({'name':resource.get('name'),'path':resource.get('path'), 'type':resource.get('type'), 'unit':resource.get('unit'), 'data_type':resource.get('datatype')})) rspec_node['resources'] = resources logger.info(rspec_node) if site['longitude'] and site['latitude']: location = Location({'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown'}) rspec_node['location'] = location logger.info(rspec_node); return rspec_node
def update_relation(self, subject_type, target_type, relation_name, subject_id, target_ids): if subject_type == 'slice' and target_type == 'user' and relation_name == 'researcher': subject = self.shell.getSlices({'slice_id': subject_id}, [])[0] current_target_ids = subject['user_ids'] add_target_ids = list( set(target_ids).difference(current_target_ids)) del_target_ids = list( set(current_target_ids).difference(target_ids)) logger.debug("subject_id = %s (type=%s)" % (subject_id, type(subject_id))) for target_id in add_target_ids: self.shell.addUserToSlice({ 'user_id': target_id, 'slice_id': subject_id }) logger.debug("add_target_id = %s (type=%s)" % (target_id, type(target_id))) for target_id in del_target_ids: logger.debug("del_target_id = %s (type=%s)" % (target_id, type(target_id))) self.shell.deleteUserFromSlice({ 'user_id': target_id, 'slice_id': subject_id }) else: logger.info('unexpected relation %s to maintain, %s -> %s' % (relation_name, subject_type, target_type))
def install_peer_certs(server_key_file, server_cert_file): """ Attempt to install missing trusted gids and db records for our federated interfaces """ # Attempt to get any missing peer gids # There should be a gid file in /etc/sfa/trusted_roots for every # peer registry found in in the registries.xml config file. If there # are any missing gids, request a new one from the peer registry. api = SfaAPI(key_file=server_key_file, cert_file=server_cert_file) registries = Registries() aggregates = Aggregates() interfaces = dict(registries.items() + aggregates.items()) gids_current = api.auth.trusted_cert_list hrns_current = [gid.get_hrn() for gid in gids_current] hrns_expected = set([hrn for hrn in interfaces]) new_hrns = set(hrns_expected).difference(hrns_current) # gids = self.get_peer_gids(new_hrns) + gids_current peer_gids = [] if not new_hrns: return trusted_certs_dir = api.config.get_trustedroots_dir() for new_hrn in new_hrns: if not new_hrn: continue # the gid for this interface should already be installed if new_hrn == api.config.SFA_INTERFACE_HRN: continue try: # get gid from the registry url = interfaces[new_hrn].get_url() interface = interfaces[new_hrn].get_server(server_key_file, server_cert_file, timeout=30) # skip non sfa aggregates server_version = api.get_cached_server_version(interface) if "sfa" not in server_version: logger.info("get_trusted_certs: skipping non sfa aggregate: %s" % new_hrn) continue trusted_gids = interface.get_trusted_certs() if trusted_gids: # the gid we want should be the first one in the list, # but lets make sure for trusted_gid in trusted_gids: # default message message = "interface: %s\t" % (api.interface) message += "unable to install trusted gid for %s" % (new_hrn) gid = GID(string=trusted_gids[0]) peer_gids.append(gid) if gid.get_hrn() == new_hrn: gid_filename = os.path.join(trusted_certs_dir, "%s.gid" % new_hrn) gid.save_to_file(gid_filename, save_parents=True) message = "installed trusted cert for %s" % new_hrn # log the message api.logger.info(message) except: message = "interface: %s\tunable to install trusted gid for %s" % (api.interface, new_hrn) api.logger.log_exc(message) # doesnt matter witch one update_cert_records(peer_gids)
def init_server(): logger = logging.getLogger('EucaAggregate') 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() configParser.read(['/etc/sfa/eucalyptus_aggregate.conf', 'eucalyptus_aggregate.conf']) if len(configParser.sections()) < 1: logger.error('No cloud defined in the config file') raise Exception('Cannot find cloud definition in configuration file.') # Only read the first section. cloudSec = configParser.sections()[0] cloud['name'] = cloudSec cloud['access_key'] = configParser.get(cloudSec, 'access_key') cloud['secret_key'] = configParser.get(cloudSec, 'secret_key') cloud['cloud_url'] = configParser.get(cloudSec, 'cloud_url') cloudURL = cloud['cloud_url'] if cloudURL.find('https://') >= 0: cloudURL = cloudURL.replace('https://', '') elif cloudURL.find('http://') >= 0: cloudURL = cloudURL.replace('http://', '') (cloud['ip'], parts) = cloudURL.split(':') # Create image bundles images = getEucaConnection().get_all_images() cloud['images'] = images cloud['imageBundles'] = {} for i in images: if i.type != 'machine' or i.kernel_id is None: continue name = os.path.dirname(i.location) detail = {'imageID' : i.id, 'kernelID' : i.kernel_id, 'ramdiskID' : i.ramdisk_id} cloud['imageBundles'][name] = detail # Initialize sqlite3 database and tables. dbPath = '/etc/sfa/db' dbName = 'euca_aggregate.db' if not os.path.isdir(dbPath): logger.info('%s not found. Creating directory ...' % dbPath) os.mkdir(dbPath) conn = connectionForURI('sqlite://%s/%s' % (dbPath, dbName)) sqlhub.processConnection = conn Slice.createTable(ifNotExists=True) EucaInstance.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): err = 'Cannot location schema at %s' % EUCALYPTUS_RSPEC_SCHEMA logger.error(err) raise Exception(err)
def reserveInstance(self, botoConn, pubKeys): logger = logging.getLogger('EucaAggregate') logger.info('Reserving an instance: image: %s, kernel: ' \ '%s, ramdisk: %s, type: %s, key: %s' % \ (self.image_id, self.kernel_id, self.ramdisk_id, self.inst_type, self.key_pair)) # XXX The return statement is for testing. REMOVE in production #return try: reservation = botoConn.run_instances(self.image_id, kernel_id = self.kernel_id, ramdisk_id = self.ramdisk_id, instance_type = self.inst_type, key_name = self.key_pair, user_data = pubKeys) for instance in reservation.instances: self.instance_id = instance.id # If there is an error, destroy itself. except EC2ResponseError, ec2RespErr: errTree = ET.fromstring(ec2RespErr.body) msg = errTree.find('.//Message') logger.error(msg.text) self.destroySelf()
def get_euca_connection(self, project_name=None): if not has_boto: logger.info('Unable to access EC2 API - boto library not found.') return None if not self.access_key or not self.secret_key: self.init_context(project_name) url = self.config.SFA_NOVA_API_URL host = None port = None path = "/" use_ssl = False # Split the url into parts if url.find('https://') >= 0: use_ssl = True url = url.replace('https://', '') elif url.find('http://') >= 0: use_ssl = False url = url.replace('http://', '') parts = url.split(':') host = parts[0] if len(parts) > 1: parts = parts[1].split('/') port = int(parts[0]) parts = parts[1:] path = '/'+'/'.join(parts) return boto.connect_ec2(aws_access_key_id=self.access_key, aws_secret_access_key=self.secret_key, is_secure=use_ssl, region=RegionInfo(None, 'eucalyptus', host), host=host, port=port, path=path)
def get_rspec(self, slice_xrn=None, version = None, options={}): version_manager = VersionManager() version = version_manager.get_version(version) if not slice_xrn: rspec_version = version_manager._get_version(version.type, version.version, 'ad') else: rspec_version = version_manager._get_version(version.type, version.version, 'manifest') slice, slivers = self.get_slice_and_slivers(slice_xrn) rspec = RSpec(version=rspec_version, user_options=options) if slice and 'expires' in slice: rspec.xml.set('expires', datetime_to_string(utcparse(slice['expires']))) nodes = self.get_nodes(slice_xrn, slice, slivers, options) rspec.version.add_nodes(nodes) # add sliver defaults default_sliver = slivers.get(None, []) if default_sliver: default_sliver_attribs = default_sliver.get('tags', []) for attrib in default_sliver_attribs: logger.info(attrib) rspec.version.add_default_sliver_attribute(attrib['tagname'], attrib['value']) return rspec.toxml()
def init_compute_manager_conn(self): from sfa.util.config import Config import sfa.openstack.client as os_client opts = os_client.parse_accrc(Config().SFA_NOVA_NOVARC) self.shell.compute_manager.connect( username=opts.get('OS_USERNAME'), \ tenant=opts.get('OS_TENANT_NAME'), \ password=opts.get('OS_PASSWORD') ) logger.info( "Initialize Openstack connection from novarc file." )
def update_pis(self, pi_hrns, dbsession): # strip that in case we have <researcher> words </researcher> pi_hrns = [x.strip() for x in pi_hrns] request = dbsession.query(RegUser).filter(RegUser.hrn.in_(pi_hrns)) logger.info( "RegAuthority.update_pis: %d incoming pis, %d matches found" % (len(pi_hrns), request.count())) pis = dbsession.query(RegUser).filter(RegUser.hrn.in_(pi_hrns)).all() self.reg_pis = pis
def createCred(credString=None, credFile=None): if not credString and not credFile: raise Exception("CredentialFactory.createCred called with no argument") if credFile: try: credString = open(credFile).read() except Exception, e: logger.info("Error opening credential file %s: %s" % credFile, e) return None
def func(*args, **kwds): if name not in FdShell.direct_calls: raise Exception, "Illegal method call %s for FEDERICA driver"%(name) logger.info("Issuing %s args=%s kwds=%s to federica"%\ (name,args,kwds)) # result=getattr(self.proxy, "AggregateManager.%s"%name)(credential, *args, **kwds) result=getattr(self.proxy, "AggregateManager.%s"%name)(*args, **kwds) logger.debug('FdShell %s (%s) returned ... '%(name,name)) return result
def scan(self, interfaces, graph): if not isinstance(interfaces, list): interfaces = [interfaces] # remember node to interface mapping node2interface = {} # add entry points right away using the interface uid's as a key to_scan = interfaces for i in interfaces: graph.add_node(i.uid()) node2interface[graph.get_node(i.uid())] = i scanned = [] # keep on looping until we reach a fixed point # don't worry about abels and shapes that will get fixed later on while to_scan: for interface in to_scan: # performing xmlrpc call logger.info("retrieving/fetching version at interface %s" % interface.url()) version = interface.get_version() if not version: logger.info( "<EMPTY GetVersion(); offline or cannot authenticate>") else: for (k, v) in version.iteritems(): if not isinstance(v, dict): logger.debug("\r\t%s:%s" % (k, v)) else: logger.debug(k) for (k1, v1) in v.iteritems(): logger.debug("\r\t\t%s:%s" % (k1, v1)) # proceed with neighbours if 'peers' in version: for (next_name, next_url) in version['peers'].iteritems(): next_interface = Interface( next_url, mentioned_in=interface.url()) # locate or create node in graph try: # if found, we're good with this one next_node = graph.get_node(next_interface.uid()) except: # otherwise, let's move on with it graph.add_node(next_interface.uid()) next_node = graph.get_node(next_interface.uid()) node2interface[next_node] = next_interface to_scan.append(next_interface) graph.add_edge(interface.uid(), next_interface.uid()) scanned.append(interface) to_scan.remove(interface) # we've scanned the whole graph, let's get the labels and shapes right for node in graph.nodes(): interface = node2interface.get(node, None) if interface: for (k, v) in interface.get_layout().iteritems(): node.attr[k] = v else: logger.error("MISSED interface with node %s" % node)
def update_pis (self, pi_hrns): # don't ruin the import of that file in a client world from sfa.storage.alchemy import dbsession # strip that in case we have <researcher> words </researcher> pi_hrns = [ x.strip() for x in pi_hrns ] request = dbsession.query (RegUser).filter(RegUser.hrn.in_(pi_hrns)) logger.info ("RegAuthority.update_pis: %d incoming pis, %d matches found"%(len(pi_hrns),request.count())) pis = dbsession.query (RegUser).filter(RegUser.hrn.in_(pi_hrns)).all() self.reg_pis = pis
def scan(self,interfaces,graph): if not isinstance(interfaces,list): interfaces=[interfaces] # remember node to interface mapping node2interface={} # add entry points right away using the interface uid's as a key to_scan=interfaces for i in interfaces: graph.add_node(i.uid()) node2interface[graph.get_node(i.uid())]=i scanned=[] # keep on looping until we reach a fixed point # don't worry about abels and shapes that will get fixed later on while to_scan: for interface in to_scan: # performing xmlrpc call version=interface.get_version() if self.verbose: logger.info("GetVersion at interface %s"%interface.url()) if not version: logger.info("<EMPTY GetVersion(); offline or cannot authenticate>") else: for (k,v) in version.iteritems(): if not isinstance(v,dict): logger.info("\r\t%s:%s"%(k,v)) else: logger.info(k) for (k1,v1) in v.iteritems(): logger.info("\r\t\t%s:%s"%(k1,v1)) # 'geni_api' is expected if the call succeeded at all # 'peers' is needed as well as AMs typically don't have peers if 'geni_api' in version and 'peers' in version: # proceed with neighbours for (next_name,next_url) in version['peers'].iteritems(): next_interface=Interface(next_url) # locate or create node in graph try: # if found, we're good with this one next_node=graph.get_node(next_interface.uid()) except: # otherwise, let's move on with it graph.add_node(next_interface.uid()) next_node=graph.get_node(next_interface.uid()) node2interface[next_node]=next_interface to_scan.append(next_interface) graph.add_edge(interface.uid(),next_interface.uid()) scanned.append(interface) to_scan.remove(interface) # we've scanned the whole graph, let's get the labels and shapes right for node in graph.nodes(): interface=node2interface.get(node,None) if interface: for (k,v) in interface.get_layout().iteritems(): node.attr[k]=v else: logger.error("MISSED interface with node %s"%node)
def update_researchers (self, researcher_hrns): # don't ruin the import of that file in a client world from sfa.storage.alchemy import dbsession # strip that in case we have <researcher> words </researcher> researcher_hrns = [ x.strip() for x in researcher_hrns ] request = dbsession.query (RegUser).filter(RegUser.hrn.in_(researcher_hrns)) logger.info ("RegSlice.update_researchers: %d incoming researchers, %d matches found"%(len(researcher_hrns),request.count())) researchers = dbsession.query (RegUser).filter(RegUser.hrn.in_(researcher_hrns)).all() self.reg_researchers = researchers
def fill_record_sfa_info(self, records): def startswith(prefix, values): return [value for value in values if value.startswith(prefix)] # get user ids user_ids = [] for record in records: user_ids.extend(record.get("user_ids", [])) # get the registry records user_list, users = [], {} user_list = self.api.dbsession().query(RegRecord).filter( RegRecord.pointer.in_(user_ids)).all() # create a hrns keyed on the sfa record's pointer. # Its possible for multiple records to have the same pointer so # the dict's value will be a list of hrns. users = defaultdict(list) for user in user_list: users[user.pointer].append(user) # get the nitos records nitos_user_list, nitos_users = [], {} nitos_all_users = self.convert_id(self.shell.getUsers()) nitos_user_list = [ user for user in nitos_all_users if user['user_id'] in user_ids ] nitos_users = list_to_dict(nitos_user_list, 'user_id') # fill sfa info for record in records: if record['pointer'] == -1: continue sfa_info = {} type = record['type'] logger.info("fill_record_sfa_info - incoming record typed %s" % type) if (type == "slice"): # all slice users are researchers record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice') record['researcher'] = [] for user_id in record.get('user_ids', []): hrns = [user.hrn for user in users[user_id]] record['researcher'].extend(hrns) elif (type == "node"): sfa_info['dns'] = record.get("hostname", "") # xxx TODO: URI, LatLong, IP, DNS elif (type == "user"): logger.info('setting user.email') sfa_info['email'] = record.get("email", "") sfa_info['geni_urn'] = hrn_to_urn(record['hrn'], 'user') sfa_info['geni_certificate'] = record['gid'] # xxx TODO: PostalAddress, Phone record.update(sfa_info)
def __init__(self, ip, port, key_file, cert_file,interface): threading.Thread.__init__(self) self.key = Keypair(filename = key_file) self.cert = Certificate(filename = cert_file) #self.server = SecureXMLRPCServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file) self.server = ThreadedServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file) self.server.interface=interface self.trusted_cert_list = None self.register_functions() logger.info("Starting SfaServer, interface=%s"%interface)
def log_invalid_cred(cred): if not isinstance (cred, StringTypes): logger.info("cannot validate credential %s - expecting a string"%cred) error="checkCredentials: expected a string, received %s"%(type(cred)) else: cred_obj=Credential(string=cred) logger.info("failed to validate credential - dump=%s"%\ cred_obj.dump_string(dump_parents=True)) error = sys.exc_info()[:2] return error
def __init__(self, ip, port, key_file, cert_file, interface): threading.Thread.__init__(self) self.key = Keypair(filename=key_file) self.cert = Certificate(filename=cert_file) #self.server = SecureXMLRPCServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file) self.server = ThreadedServer( (ip, int(port)), SecureXMLRpcRequestHandler, key_file, cert_file) self.server.interface = interface self.trusted_cert_list = None self.register_functions() logger.info("Starting SfaServer, interface=%s" % interface)
def fill_record_sfa_info(self, records): def startswith(prefix, values): return [value for value in values if value.startswith(prefix)] # get user ids user_ids = [] for record in records: user_ids.extend(record.get("user_ids", [])) # get the registry records user_list, users = [], {} user_list = dbsession.query(RegRecord).filter(RegRecord.pointer.in_(user_ids)).all() # create a hrns keyed on the sfa record's pointer. # Its possible for multiple records to have the same pointer so # the dict's value will be a list of hrns. users = defaultdict(list) for user in user_list: users[user.pointer].append(user) # get the nitos records nitos_user_list, nitos_users = [], {} nitos_all_users = self.convert_id(self.shell.getUsers()) nitos_user_list = [user for user in nitos_all_users if user['user_id'] in user_ids] nitos_users = list_to_dict(nitos_user_list, 'user_id') # fill sfa info for record in records: if record['pointer'] == -1: continue sfa_info = {} type = record['type'] logger.info("fill_record_sfa_info - incoming record typed %s"%type) if (type == "slice"): # all slice users are researchers record['geni_urn'] = hrn_to_urn(record['hrn'], 'slice') record['researcher'] = [] for user_id in record.get('user_ids', []): hrns = [user.hrn for user in users[user_id]] record['researcher'].extend(hrns) elif (type == "node"): sfa_info['dns'] = record.get("hostname", "") # xxx TODO: URI, LatLong, IP, DNS elif (type == "user"): logger.info('setting user.email') sfa_info['email'] = record.get("email", "") sfa_info['geni_urn'] = hrn_to_urn(record['hrn'], 'user') sfa_info['geni_certificate'] = record['gid'] # xxx TODO: PostalAddress, Phone record.update(sfa_info)
def GetSlices(self,filter={}): logger.info("GETSlices") logger.info(filter) result = [] result.extend(self.slices) if 'slice_name' in filter: for slice in self.slices: if slice['slice_name'] not in filter['slice_name']: result.remove(slice) return self.slices
def func(*args, **kwds): if name not in FdShell.direct_calls: raise Exception, "Illegal method call %s for FEDERICA driver" % ( name) logger.info("Issuing %s args=%s kwds=%s to federica"%\ (name,args,kwds)) # result=getattr(self.proxy, "AggregateManager.%s"%name)(credential, *args, **kwds) result = getattr(self.proxy, "AggregateManager.%s" % name)(*args, **kwds) logger.debug('FdShell %s (%s) returned ... ' % (name, name)) return result
def update_researchers(self, researcher_hrns, dbsession): # strip that in case we have <researcher> words </researcher> researcher_hrns = [x.strip() for x in researcher_hrns] request = dbsession.query(RegUser).filter( RegUser.hrn.in_(researcher_hrns)) logger.info( "RegSlice.update_researchers: %d incoming researchers, %d matches found" % (len(researcher_hrns), request.count())) researchers = dbsession.query(RegUser).filter( RegUser.hrn.in_(researcher_hrns)).all() self.reg_researchers = researchers
def LdapAddUser(self, record) : """Add SFA user to LDAP if it is not in LDAP yet. :param record: dictionnary with the user's data. :returns: a dictionary with the status (Fail= False, Success= True) and the uid of the newly added user if successful, or the error message it is not. Dict has keys bool and message in case of failure, and bool uid in case of success. :rtype: dict .. seealso:: make_ldap_filters_from_record """ logger.debug(" \r\n \t LDAP LdapAddUser \r\n\r\n ================\r\n ") user_ldap_attrs = self.make_ldap_attributes_from_record(record) #Check if user already in LDAP wih email, first name and last name filter_by = self.make_ldap_filters_from_record(user_ldap_attrs) user_exist = self.LdapSearch(filter_by) if user_exist: logger.warning(" \r\n \t LDAP LdapAddUser user %s %s \ already exists" % (user_ldap_attrs['sn'], user_ldap_attrs['mail'])) return {'bool': False} #Bind to the server result = self.conn.connect() if(result['bool']): # A dict to help build the "body" of the object logger.debug(" \r\n \t LDAP LdapAddUser attrs %s " % user_ldap_attrs) # The dn of our new entry/object dn = 'uid=' + user_ldap_attrs['uid'] + "," + self.baseDN try: ldif = modlist.addModlist(user_ldap_attrs) logger.debug("LDAPapi.py add attrs %s \r\n ldif %s" % (user_ldap_attrs, ldif)) self.conn.ldapserv.add_s(dn, ldif) logger.info("Adding user %s login %s in LDAP" % (user_ldap_attrs['cn'], user_ldap_attrs['uid'])) except ldap.LDAPError, error: logger.log_exc("LDAP Add Error %s" % error) return {'bool': False, 'message': error} self.conn.close() return {'bool': True, 'uid': user_ldap_attrs['uid']}
def AddUserToSlice(self,param): logger.info("Add user to slice") logger.info(param) if not isinstance(param, dict): return False try: for slice in self.slices: if param['slice_id'] == slice['slice_id']: if not 'user_ids' in slice: slice['user_ids'] = [] slice['user_ids'].append(param['user_id']) return True return False except: return False
def AddSliceToNodes(self,param): logger.info("AddSliceToNode") logger.info(param) if not isinstance(param, dict): return False try: for slice in self.slices: if param['slice_id'] == slice['slice_id']: if not 'node_ids' in slice: slice['node_ids'] = [] slice['node_ids'].extend(param['node_ids']) return True return False except: return False
def create_user(self, user_name, password, tenant_id, email=None, enabled=True): if password is None: logger.warning("If you want to make a user, you should include your password!!") raise ValueError('You should include your password!!') users = self.driver.shell.auth_manager.users.findall() for user in users: if user_name == user.name: user_info = user logger.info("The user name[%s] already exists." % user_name) break else: user_info = self.driver.shell.auth_manager.users.create(user_name, password, \ email, tenant_id, enabled) return user_info
def updateMeta(): 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(30) # Get IDs of the instances that don't have IPs yet. dbResults = Meta.select( AND(Meta.q.pri_addr == None, Meta.q.state != 'deleted') ) dbResults = list(dbResults) logger.debug('[update process] dbResults: %s' % dbResults) instids = [] for r in dbResults: if not r.instance: continue instids.append(r.instance.instance_id) logger.debug('[update process] Instance Id: %s' % ', '.join(instids)) # Get instance information from Eucalyptus conn = getEucaConnection() vmInstances = [] reservations = conn.get_all_instances(instids) for reservation in reservations: vmInstances += reservation.instances # 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 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 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' dumpInstanceInfo()
def update_relation (self, subject_type, target_type, relation_name, subject_id, target_ids): if subject_type =='slice' and target_type == 'user' and relation_name == 'researcher': subject=self.shell.getSlices ({'slice_id': subject_id}, [])[0] current_target_ids = subject['user_ids'] add_target_ids = list ( set (target_ids).difference(current_target_ids)) del_target_ids = list ( set (current_target_ids).difference(target_ids)) logger.debug ("subject_id = %s (type=%s)"%(subject_id,type(subject_id))) for target_id in add_target_ids: self.shell.addUserToSlice ({'user_id': target_id, 'slice_id': subject_id}) logger.debug ("add_target_id = %s (type=%s)"%(target_id,type(target_id))) for target_id in del_target_ids: logger.debug ("del_target_id = %s (type=%s)"%(target_id,type(target_id))) self.shell.deleteUserFromSlice ({'user_id': target_id, 'slice_id': subject_id}) else: logger.info('unexpected relation %s to maintain, %s -> %s'%(relation_name,subject_type,target_type))
def update_relation (self, subject_type, target_type, subject_id, target_ids): # hard-wire the code for slice/user for now, could be smarter if needed if subject_type =='slice' and target_type == 'user': subject=self.shell.project_get(subject_id)[0] current_target_ids = [user.name for user in subject.members] add_target_ids = list ( set (target_ids).difference(current_target_ids)) del_target_ids = list ( set (current_target_ids).difference(target_ids)) logger.debug ("subject_id = %s (type=%s)"%(subject_id,type(subject_id))) for target_id in add_target_ids: self.shell.project_add_member(target_id,subject_id) logger.debug ("add_target_id = %s (type=%s)"%(target_id,type(target_id))) for target_id in del_target_ids: logger.debug ("del_target_id = %s (type=%s)"%(target_id,type(target_id))) self.shell.project_remove_member(target_id, subject_id) else: logger.info('unexpected relation to maintain, %s -> %s'%(subject_type,target_type))
def node_to_rspec_node(self, node, options={}): rspec_node = NodeElement() site = self.driver.testbedInfo rspec_node['component_id'] = hostname_to_urn(self.driver.hrn, site['name'], node['hostname']) rspec_node['component_name'] = node['hostname'] rspec_node['ip'] = node['ip'] rspec_node['protocol'] = node['protocol'] rspec_node['port'] = node['port'] rspec_node['component_manager_id'] = Xrn(self.driver.hrn, 'authority+cm').get_urn() rspec_node['authority_id'] = hrn_to_urn( unigetestbedXrn.site_hrn(self.driver.hrn, site['name']), 'authority+sa') #distinguish between Shared and Reservable nodes rspec_node['exclusive'] = 'false' rspec_node['hardware_types'] = [ HardwareType({'name': 'endpoint'}), HardwareType({'name': 'sensor'}) ] resources = [] for resource in node['resources']: resources.append( Resource({ 'name': resource.get('name'), 'path': resource.get('path'), 'type': resource.get('type'), 'unit': resource.get('unit'), 'data_type': resource.get('datatype') })) rspec_node['resources'] = resources logger.info(rspec_node) if site['longitude'] and site['latitude']: location = Location({ 'longitude': site['longitude'], 'latitude': site['latitude'], 'country': 'unknown' }) rspec_node['location'] = location logger.info(rspec_node) return rspec_node
def get_version(self): ### if we already know the answer: if self.probed: return self._version ### otherwise let's look in the cache file logger.debug("searching in version cache %s" % self.url()) cached_version = VersionCache().get(self.url()) if cached_version is not None: logger.info("Retrieved version info from cache %s" % self.url()) return cached_version ### otherwise let's do the hard work # dummy to meet Sfi's expectations for its 'options' field class DummyOptions: pass options = DummyOptions() options.verbose = self.verbose options.timeout = 10 try: client = Sfi(options) client.read_config() client.bootstrap() key_file = client.private_key cert_file = client.my_gid logger.debug("using key %s & cert %s" % (key_file, cert_file)) url = self.url() logger.info('issuing GetVersion at %s' % url) # setting timeout here seems to get the call to fail - even though the response time is fast #server=SfaServerProxy(url, key_file, cert_file, verbose=self.verbose, timeout=options.timeout) server = SfaServerProxy(url, key_file, cert_file, verbose=self.verbose) self._version = ReturnValue.get_value(server.GetVersion()) except: logger.log_exc("failed to get version") self._version = {} # so that next run from this process will find out self.probed = True # store in version cache so next processes will remember for an hour cache = VersionCache() cache.set(self.url(), self._version) cache.save() logger.debug("Saved version for url=%s in version cache" % self.url()) # that's our result return self._version
def create_router(self, tenant_id): is_router = True # checking whether the created router exist routers = self.driver.shell.network_manager.list_routers() routers = routers['routers'] for router in routers: if router.get('tenant_id') == tenant_id: router_id = router.get('id') router = self.driver.shell.network_manager.show_router(router_id) is_router = False if is_router: config = OSConfig() # Information of public network(external network) from configuration file extnet_name = config.get('network', 'external_network_name') # find the network information related with a new interface networks = self.driver.shell.network_manager.list_networks() networks = networks['networks'] for network in networks: if (network.get('name') == extnet_name) or \ (network.get('name') == 'public') or (network.get('name') == 'ext-net'): pub_net_id = network.get('id') # Information of subnet network name from configuration file subnet_name = config.get('subnet', 'name') subnets = self.driver.shell.network_manager.list_subnets() subnets = subnets['subnets'] for subnet in subnets: if ((subnet.get('name') == subnet_name) or (subnet.get('name') == 'private-subnet')) and \ (subnet.get('tenant_id') == tenant_id): pri_sbnet_id = subnet.get('id') # create a router and connect external gateway related with public network r_body = {'router': {'name': 'router', 'admin_state_up': True, 'external_gateway_info':{'network_id': pub_net_id}}} router = self.driver.shell.network_manager.create_router(body=r_body) # create a internal port of the router router_id = router['router']['id'] int_pt_body = {'subnet_id': pri_sbnet_id} int_port = self.driver.shell.network_manager.add_interface_router( router=router_id, body=int_pt_body) logger.info("Created a router with interfaces") return router
def update_relation(self, subject_type, target_type, relation_name, subject_id, target_ids): # hard-wire the code for slice/user for now, could be smarter if needed if subject_type == "slice" and target_type == "user" and relation_name == "researcher": subject = self.shell.GetSlices({"slice_id": subject_id})[0] if "user_ids" not in subject.keys(): subject["user_ids"] = [] current_target_ids = subject["user_ids"] add_target_ids = list(set(target_ids).difference(current_target_ids)) del_target_ids = list(set(current_target_ids).difference(target_ids)) logger.debug("subject_id = %s (type=%s)" % (subject_id, type(subject_id))) for target_id in add_target_ids: self.shell.AddUserToSlice({"user_id": target_id, "slice_id": subject_id}) logger.debug("add_target_id = %s (type=%s)" % (target_id, type(target_id))) for target_id in del_target_ids: logger.debug("del_target_id = %s (type=%s)" % (target_id, type(target_id))) self.shell.DeleteUserFromSlice({"user_id": target_id, "slice_id": subject_id}) else: logger.info("unexpected relation %s to maintain, %s -> %s" % (relation_name, subject_type, target_type))
def make_record_dict (record_dict): assert ('type' in record_dict) type=record_dict['type'].split('+')[0] if type=='authority': result=RegAuthority (dict=record_dict) elif type=='user': result=RegUser (dict=record_dict) elif type=='slice': result=RegSlice (dict=record_dict) elif type=='node': result=RegNode (dict=record_dict) else: logger.debug("Untyped RegRecord instance") result=RegRecord (dict=record_dict) logger.info ("converting dict into Reg* with type=%s"%type) logger.info ("returning=%s"%result) # xxx todo # register non-db attributes in an extensions field return result
def make_record_dict(record_dict): assert ('type' in record_dict) type = record_dict['type'].split('+')[0] if type == 'authority': result = RegAuthority(dict=record_dict) elif type == 'user': result = RegUser(dict=record_dict) elif type == 'slice': result = RegSlice(dict=record_dict) elif type == 'node': result = RegNode(dict=record_dict) else: logger.debug("Untyped RegRecord instance") result = RegRecord(dict=record_dict) logger.info("converting dict into Reg* with type=%s" % type) logger.info("returning=%s" % result) # xxx todo # register non-db attributes in an extensions field return result
def get_rspec(self, slice_xrn=None, version=None, options={}): version_manager = VersionManager() version = version_manager.get_version(version) if not slice_xrn: rspec_version = version_manager._get_version( version.type, version.version, 'ad') else: rspec_version = version_manager._get_version( version.type, version.version, 'manifest') slice, slivers = self.get_slice_and_slivers(slice_xrn) rspec = RSpec(version=rspec_version, user_options=options) if slice and 'expires' in slice: rspec.xml.set('expires', datetime_to_string(utcparse(slice['expires']))) if not options.get('list_leases') or options.get( 'list_leases') and options['list_leases'] != 'leases': nodes = self.get_nodes(slice_xrn, slice, slivers, options) rspec.version.add_nodes(nodes) # add sliver defaults default_sliver = slivers.get(None, []) if default_sliver: default_sliver_attribs = default_sliver.get('tags', []) for attrib in default_sliver_attribs: logger.info(attrib) rspec.version.add_default_sliver_attribute( attrib['tagname'], attrib['value']) # add wifi channels channels = self.get_channels(slice, options) rspec.version.add_channels(channels) if not options.get('list_leases') or options.get( 'list_leases') and options['list_leases'] != 'resources': leases_channels = self.get_leases_and_channels(slice, slice_xrn) rspec.version.add_leases(leases_channels) return rspec.toxml()
def __init__ ( self, config ) : url = config.SFA_PLC_URL # try to figure if the url is local hostname=urlparse(url).hostname is_local=False if hostname == 'localhost': is_local=True # otherwise compare IP addresses; # this might fail for any number of reasons, so let's harden that try: # xxx todo this seems to result in a DNS request for each incoming request to the AM # should be cached or improved url_ip=socket.gethostbyname(hostname) local_ip=socket.gethostbyname(socket.gethostname()) if url_ip==local_ip: is_local=True except: pass if is_local: try: # too bad this is not installed properly plcapi_path="/usr/share/plc_api" if plcapi_path not in sys.path: sys.path.append(plcapi_path) import PLC.Shell plc_direct_access=True except: plc_direct_access=False if is_local and plc_direct_access: logger.info('plshell access - capability') self.plauth = { 'AuthMethod': 'capability', 'Username': str(config.SFA_PLC_USER), 'AuthString': str(config.SFA_PLC_PASSWORD), } self.proxy = PLC.Shell.Shell () else: logger.info('plshell access - xmlrpc') self.plauth = { 'AuthMethod': 'password', 'Username': str(config.SFA_PLC_USER), 'AuthString': str(config.SFA_PLC_PASSWORD), } self.proxy = xmlrpclib.Server(url, verbose = False, allow_none = True)
def update_relation(self, subject_type, target_type, subject_id, target_ids): # hard-wire the code for slice/user for now, could be smarter if needed if subject_type == 'slice' and target_type == 'user': subject = self.shell.project_get(subject_id)[0] current_target_ids = [user.name for user in subject.members] add_target_ids = list( set(target_ids).difference(current_target_ids)) del_target_ids = list( set(current_target_ids).difference(target_ids)) logger.debug("subject_id = %s (type=%s)" % (subject_id, type(subject_id))) for target_id in add_target_ids: self.shell.project_add_member(target_id, subject_id) logger.debug("add_target_id = %s (type=%s)" % (target_id, type(target_id))) for target_id in del_target_ids: logger.debug("del_target_id = %s (type=%s)" % (target_id, type(target_id))) self.shell.project_remove_member(target_id, subject_id) else: logger.info('unexpected relation to maintain, %s -> %s' % (subject_type, target_type))
def DeleteSlice(self, slice_record): """Deletes the specified slice and kills the jobs associated with the slice if any, using DeleteSliceFromNodes. :param slice_record: record of the slice, must contain oar_job_id, user :type slice_record: dict :returns: True if all the jobs in the slice have been deleted, or the list of jobs that could not be deleted otherwise. :rtype: list or boolean .. seealso:: DeleteSliceFromNodes """ ret = self.DeleteSliceFromNodes(slice_record) delete_failed = None for job_id in ret: if False in ret[job_id]: if delete_failed is None: delete_failed = [] delete_failed.append(job_id) logger.info("IOTLAB_API DeleteSlice %s answer %s"%(slice_record, \ delete_failed)) return delete_failed or True
def AddSlice(self,slice): logger.info("AddSlice") logger.info(slice) if not isinstance(slice, dict): return False for key in slice.keys(): if key not in['slice_name','user_ids','node_ids','enabled','expired']: return False slice['slice_id'] = self.indexes['slices_index'] slice['expires'] = int(time.time())+60*60*24*30 self.indexes['slices_index']+=1 self.slices.append(slice) logger.info(self.slices) return slice['slice_id']
def main(self): usage = "%prog [options] url-entry-point(s)" parser = OptionParser(usage=usage) parser.add_option("-d", "--dir", dest="sfi_dir", help="config & working directory - default is " + Sfi.default_sfi_dir(), metavar="PATH", default=Sfi.default_sfi_dir()) parser.add_option( "-o", "--output", action='append', dest='outfiles', default=[], help="output filenames (cumulative) - defaults are %r" % SfaScan.default_outfiles) parser.add_option("-l", "--left-to-right", action="store_true", dest="left_to_right", default=False, help="instead of top-to-bottom") parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0, help="verbose - can be repeated for more verbosity") parser.add_option("-c", "--clean-cache", action='store_true', dest='clean_cache', default=False, help='clean/trash version cache and exit') parser.add_option("-s", "--show-cache", action='store_true', dest='show_cache', default=False, help='show/display version cache') (options, args) = parser.parse_args() logger.enable_console() # apply current verbosity to logger logger.setLevelFromOptVerbose(options.verbose) # figure if we need to be verbose for these local classes that only have a bool flag bool_verbose = logger.getBoolVerboseFromOpt(options.verbose) if options.show_cache: VersionCache().show() sys.exit(0) if options.clean_cache: VersionCache().clean() sys.exit(0) if not args: parser.print_help() sys.exit(1) if not options.outfiles: options.outfiles = SfaScan.default_outfiles scanner = Scanner(left_to_right=options.left_to_right, verbose=bool_verbose) entries = [ Interface(entry, mentioned_in="command line") for entry in args ] try: g = scanner.graph(entries) logger.info("creating layout") g.layout(prog='dot') for outfile in options.outfiles: logger.info("drawing in %s" % outfile) g.draw(outfile) logger.info("done") # test mode when pygraphviz is not available except: entry = entries[0] print "GetVersion at %s returned %s" % (entry.url(), entry.get_version())
def make_record_xml(xml): xml_record = XML(xml) xml_dict = xml_record.todict() logger.info("load from xml, keys=%s" % xml_dict.keys()) return make_record_dict(xml_dict)
def drop_tables(engine): logger.info("Dropping tables from current/latest model") Base.metadata.drop_all(engine)
def init_tables(engine): logger.info("Initializing db schema from current/latest model") Base.metadata.create_all(engine)
def Resolve(self, api, xrns, type=None, details=False): if not isinstance(xrns, types.ListType): # try to infer type if not set and we get a single input if not type: type = Xrn(xrns).get_type() xrns = [xrns] hrns = [urn_to_hrn(xrn)[0] for xrn in xrns] # load all known registry names into a prefix tree and attempt to find # the longest matching prefix # create a dict where key is a registry hrn and its value is a list # of hrns at that registry (determined by the known prefix tree). xrn_dict = {} registries = api.registries tree = prefixTree() registry_hrns = registries.keys() tree.load(registry_hrns) for xrn in xrns: registry_hrn = tree.best_match(urn_to_hrn(xrn)[0]) if registry_hrn not in xrn_dict: xrn_dict[registry_hrn] = [] xrn_dict[registry_hrn].append(xrn) records = [] for registry_hrn in xrn_dict: # skip the hrn without a registry hrn # XX should we let the user know the authority is unknown? if not registry_hrn: continue # if the best match (longest matching hrn) is not the local registry, # forward the request xrns = xrn_dict[registry_hrn] if registry_hrn != api.hrn: credential = api.getCredential() interface = api.registries[registry_hrn] server_proxy = api.server_proxy(interface, credential) # should propagate the details flag but that's not supported in the xmlrpc interface yet #peer_records = server_proxy.Resolve(xrns, credential,type, details=details) peer_records = server_proxy.Resolve(xrns, credential) # pass foreign records as-is # previous code used to read # records.extend([SfaRecord(dict=record).as_dict() for record in peer_records]) # not sure why the records coming through xmlrpc had to be processed at all records.extend(peer_records) # try resolving the remaining unfound records at the local registry local_hrns = list ( set(hrns).difference([record['hrn'] for record in records]) ) # local_records = dbsession.query(RegRecord).filter(RegRecord.hrn.in_(local_hrns)) if type: local_records = local_records.filter_by(type=type) local_records=local_records.all() for local_record in local_records: augment_with_sfa_builtins (local_record) logger.info("Resolve, (details=%s,type=%s) local_records=%s "%(details,type,local_records)) local_dicts = [ record.__dict__ for record in local_records ] if details: # in details mode we get as much info as we can, which involves contacting the # testbed for getting implementation details about the record self.driver.augment_records_with_testbed_info(local_dicts) # also we fill the 'url' field for known authorities # used to be in the driver code, sounds like a poorman thing though def solve_neighbour_url (record): if not record.type.startswith('authority'): return hrn=record.hrn for neighbour_dict in [ api.aggregates, api.registries ]: if hrn in neighbour_dict: record.url=neighbour_dict[hrn].get_url() return for record in local_records: solve_neighbour_url (record) # convert local record objects to dicts for xmlrpc # xxx somehow here calling dict(record) issues a weird error # however record.todict() seems to work fine # records.extend( [ dict(record) for record in local_records ] ) records.extend( [ record.todict(exclude_types=[InstrumentedList]) for record in local_records ] ) if not records: raise RecordNotFound(str(hrns)) return records
def validate_datetime(self, key, incoming): if isinstance(incoming, datetime): return incoming elif isinstance(incoming, (int, float)): return datetime.fromtimestamp(incoming) else: logger.info("Cannot validate datetime for key %s with input %s"%\ (key,incoming))