X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=PLC%2FPeers.py;h=0973c3d4716905f11e64572f081723ab9b510658;hb=a0e131a2893c75df786c94997370b01cb623dee0;hp=c4ff3df481bc38f34ccf2a7f112f489f8b0b69b0;hpb=ca4a71145de39b3725517aec5801291a6c869c53;p=plcapi.git diff --git a/PLC/Peers.py b/PLC/Peers.py index c4ff3df..0973c3d 100644 --- a/PLC/Peers.py +++ b/PLC/Peers.py @@ -4,17 +4,23 @@ import re from types import StringTypes +from urlparse import urlparse from PLC.Faults import * -from PLC.Parameter import Parameter +from PLC.Parameter import Parameter, Mixed from PLC.Filter import Filter from PLC.Table import Row, Table +import PLC.Auth -from PLC.Nodes import Nodes,Node -from PLC.ForeignNodes import ForeignNodes,ForeignNode -from PLC.ForeignSlices import ForeignSlices,ForeignSlice +from PLC.Sites import Site, Sites +from PLC.Persons import Person, Persons +from PLC.Keys import Key, Keys +from PLC.Nodes import Node, Nodes +from PLC.SliceAttributeTypes import SliceAttributeType, SliceAttributeTypes +from PLC.SliceAttributes import SliceAttribute, SliceAttributes +from PLC.Slices import Slice, Slices -class Peer (Row): +class Peer(Row): """ Stores the list of peering PLCs in the peers table. See the Row class for more details @@ -22,283 +28,187 @@ class Peer (Row): table_name = 'peers' primary_key = 'peer_id' + join_tables = ['peer_site', 'peer_person', 'peer_key', 'peer_node', + 'peer_slice_attribute_type', 'peer_slice_attribute', 'peer_slice'] fields = { - 'peer_id' : Parameter (int, "Peer identifier"), - 'peername' : Parameter (str, "Peer name"), - 'peer_url' : Parameter (str, "Peer API url"), - 'person_id' : Parameter (int, "Person_id of the account storing credentials - temporary"), - 'node_ids' : Parameter ([int], "This peer's nodes ids"), - 'slice_ids' : Parameter ([int], "This peer's slices ids"), + 'peer_id': Parameter (int, "Peer identifier"), + 'peername': Parameter (str, "Peer name"), + 'peer_url': Parameter (str, "Peer API URL"), + 'key': Parameter(str, "Peer GPG public key"), + 'cacert': Parameter(str, "Peer SSL public certificate"), + ### cross refs + 'site_ids': Parameter([int], "List of sites for which this peer is authoritative"), + 'person_ids': Parameter([int], "List of users for which this peer is authoritative"), + 'key_ids': Parameter([int], "List of keys for which this peer is authoritative"), + 'node_ids': Parameter([int], "List of nodes for which this peer is authoritative"), + 'slice_ids': Parameter([int], "List of slices for which this peer is authoritative"), } - def validate_peer_url (self, url): + def validate_peername(self, peername): + if not len(peername): + raise PLCInvalidArgument, "Peer name must be specified" + + conflicts = Peers(self.api, [peername]) + for peer in conflicts: + if 'peer_id' not in self or self['peer_id'] != peer['peer_id']: + raise PLCInvalidArgument, "Peer name already in use" + + return peername + + def validate_peer_url(self, url): """ - Validate URL, checks it looks like https + Validate URL. Must be HTTPS. """ - invalid_url = PLCInvalidArgument("Invalid URL") - if not re.compile ("^https://.*$").match(url) : - raise invalid_url + + (scheme, netloc, path, params, query, fragment) = urlparse(url) + if scheme != "https": + raise PLCInvalidArgument, "Peer URL scheme must be https" + return url - def delete (self, commit=True): + def delete(self, commit = True): """ - Delete peer + Deletes this peer and all related entities. """ - - assert 'peer_id' in self - # remove nodes depending on this peer - for foreign_node_id in self.get_foreign_nodes(): - try: - foreign_node = ForeignNodes(self.api,[foreign_node_id])[0] - foreign_node.delete(commit) - except: - print "Glitch : a foreign node instance was uncleanly deleted" + assert 'peer_id' in self - # remove the peer + # Remove all related entities + for obj in \ + Slices(self.api, self['slice_ids']) + \ + Keys(self.api, self['key_ids']) + \ + Persons(self.api, self['person_ids']) + \ + Nodes(self.api, self['node_ids']) + \ + Sites(self.api, self['site_ids']): + assert obj['peer_id'] == self['peer_id'] + obj.delete(commit = False) + + # Mark as deleted self['deleted'] = True self.sync(commit) - def get_foreign_nodes (self): + def add_site(self, site, peer_site_id, commit = True): """ - returns a list of the foreign nodes in this peer + Associate a local site entry with this peer. """ - sql="SELECT node_ids FROM peer_nodes WHERE peer_id=%d"%self['peer_id'] - node_ids = self.api.db.selectall(sql) - return node_ids[0]['node_ids'] - def manage_node (self, foreign_node, add_if_true, commit=True): + add = Row.add_object(Site, 'peer_site') + add(self, site, + {'peer_id': self['peer_id'], + 'site_id': site['site_id'], + 'peer_site_id': peer_site_id}, + commit = commit) + + def add_person(self, person, peer_person_id, commit = True): """ - associate/dissociate a foreign node to/from a peer - foreign_node is a local object that describes a remote node - convention is: - if add_if_true is None : performs dissociation - otherwise: performs association + Associate a local user entry with this peer. """ - assert 'peer_id' in self - assert 'node_id' in foreign_node - - peer_id = self['peer_id'] - node_id = foreign_node ['node_id'] - - if add_if_true: - ### ADDING - sql = "INSERT INTO peer_node VALUES (%d,%d)" % (peer_id,node_id) - self.api.db.do(sql) - if self['node_ids'] is None: - self['node_ids']=[node_id,] - else: - self['node_ids'].append(node_id) - ### DELETING - else: - sql = "DELETE FROM peer_node WHERE peer_id=%d AND node_id=%d" % (peer_id,node_id) - self.api.db.do(sql) - self['node_ids'].remove(node_id) - - if commit: - self.api.db.commit() + add = Row.add_object(Person, 'peer_person') + add(self, person, + {'peer_id': self['peer_id'], + 'person_id': person['person_id'], + 'peer_person_id': peer_person_id}, + commit = commit) - def manage_slice (self, foreign_slice, add_if_true, commit=True): + def add_key(self, key, peer_key_id, commit = True): """ - associate/dissociate a foreign node to/from a peer - foreign_slice is a local object that describes a remote slice - alien_id is the unique id as provided by the remote peer - convention is: - if add_if_true is None : performs dissociation - otherwise: performs association + Associate a local key entry with this peer. """ - assert 'peer_id' in self - assert 'slice_id' in foreign_slice - - peer_id = self['peer_id'] - slice_id = foreign_slice ['slice_id'] - - if add_if_true: - ### ADDING - sql = "INSERT INTO peer_slice VALUES (%d,%d)" % (peer_id,slice_id) - self.api.db.do(sql) - if self['slice_ids'] is None: - self['slice_ids']=[slice_id,] - else: - self['slice_ids'].append(slice_id) - ### DELETING - else: - sql = "DELETE FROM peer_slice WHERE peer_id=%d AND slice_id=%d" % (peer_id,slice_id) - self.api.db.do(sql) - self['slice_ids'].remove(slice_id) - - if commit: - self.api.db.commit() + add = Row.add_object(Key, 'peer_key') + add(self, key, + {'peer_id': self['peer_id'], + 'key_id': key['key_id'], + 'peer_key_id': peer_key_id}, + commit = commit) - def refresh_nodes (self, peer_get_nodes): + def add_node(self, node, peer_node_id, commit = True): + """ + Associate a local node entry with this peer. """ - refreshes the foreign_nodes and peer_node tables - expected input is the current list of nodes as returned by GetNodes - returns the number of new nodes on this peer (can be negative) + add = Row.add_object(Node, 'peer_node') + add(self, node, + {'peer_id': self['peer_id'], + 'node_id': node['node_id'], + 'peer_node_id': peer_node_id}, + commit = commit) + + def add_slice(self, slice, peer_slice_id, commit = True): + """ + Associate a local slice entry with this peer. """ - peer_id = self['peer_id'] - - # we get the whole table just in case - # a host would have switched from one plc to the other - local_foreign_nodes = ForeignNodes (self.api) - # index it by hostname for searching later - local_foreign_nodes_index = local_foreign_nodes.dict('hostname') - - ### mark entries for this peer outofdate - old_count=0; - for foreign_node in local_foreign_nodes: - if foreign_node['peer_id'] == peer_id: - foreign_node.uptodate=False - old_count += 1 - - ### these fields get copied through - remote_fields = ['boot_state','model','version','date_created','last_updated'] - - ### scan the new entries, and mark them uptodate - for node in peer_get_nodes: - hostname = node['hostname'] - try: - foreign_node = local_foreign_nodes_index[hostname] - if foreign_node['peer_id'] != peer_id: - ### the node has changed its plc, needs to update peer_node - old_peer_id = foreign_node['peer_id'] - old_peers=Peers(self.api,[peer_id]) - assert old_peer[0] - # remove from previous peer - old_peers[0].manage_node(foreign_node,False,False) - # add to new peer - self.manage_node(foreign_node,True,True) - foreign_node['peer_id'] = peer_id - ### update it anyway: copy other relevant fields - for field in remote_fields: - foreign_node[field]=node[field] - # this row is now valid - foreign_node.uptodate=True - foreign_node.sync() - except: - new_foreign_node = ForeignNode(self.api, {'hostname':hostname}) - for field in remote_fields: - new_foreign_node[field]=node[field] - ### need to sync so we get a node_id - new_foreign_node.sync() - new_foreign_node.uptodate = True - self.manage_node(new_foreign_node,True,True) - local_foreign_nodes_index[hostname]=new_foreign_node - - ### delete entries that are not uptodate - for foreign_node in local_foreign_nodes: - if not foreign_node.uptodate: - foreign_node.delete() - - return len(peer_get_nodes)-old_count - - ### transcode node_id - def locate_alien_node_id_in_foreign_nodes (self, peer_foreign_nodes_dict, alien_id): + add = Row.add_object(Slice, 'peer_slice') + add(self, slice, + {'peer_id': self['peer_id'], + 'slice_id': slice['slice_id'], + 'peer_slice_id': peer_slice_id}, + commit = commit) + + def connect(self, **kwds): """ - returns a local node_id as transcoded from an alien node_id - only lookups our local nodes because we dont need to know about other sites - returns a valid local node_id, or throws an exception + Connect to this peer via XML-RPC. """ - peer_foreign_node = peer_foreign_nodes_dict[alien_id] - hostname = peer_foreign_node['hostname'] - return Nodes(self.api,[hostname])[0]['node_id'] - def refresh_slices (self, peer_get_slices, peer_foreign_nodes): + import xmlrpclib + from PLC.PyCurl import PyCurlTransport + self.server = xmlrpclib.ServerProxy(self['peer_url'], + PyCurlTransport(self['peer_url'], self['cacert']), + allow_none = 1, **kwds) + + def add_auth(self, function, methodname, **kwds): + """ + Sign the specified XML-RPC call and add an auth struct as the + first argument of the call. """ - refreshes the foreign_slices and peer_slice tables - expected input is the current list of slices as returned by GetSlices - returns the number of new slices on this peer (can be negative) + def wrapper(*args, **kwds): + from PLC.GPG import gpg_sign + signature = gpg_sign(args, + self.api.config.PLC_ROOT_GPG_KEY, + self.api.config.PLC_ROOT_GPG_KEY_PUB, + methodname) + + auth = {'AuthMethod': "gpg", + 'name': self.api.config.PLC_NAME, + 'signature': signature} + + # Automagically add auth struct to every call + args = (auth,) + args + + return function(*args) + + return wrapper + + def __getattr__(self, attr): + """ + Returns a callable API function if attr is the name of a + PLCAPI function; otherwise, returns the specified attribute. """ - peer_id = self['peer_id'] - - # we get the whole table just in case - # a host would have switched from one plc to the other - local_foreign_slices = ForeignSlices (self.api) - # index it by name for searching later - local_foreign_slices_index = local_foreign_slices.dict('name') - - ### mark entries for this peer outofdate - old_count=0; - for foreign_slice in local_foreign_slices: - if foreign_slice['peer_id'] == peer_id: - foreign_slice.uptodate=False - old_count += 1 - - ### these fields get copied through - remote_fields = ['instantiation', 'url', 'description', - 'max_nodes', 'created', 'expires'] - - ### scan the new entries, and mark them uptodate - new_count=0 - for slice in peer_get_slices: - ### ignore system-wide slices - if slice['creator_person_id'] == 1: - continue - - name = slice['name'] - - # create or update - try: - foreign_slice = local_foreign_slices_index[name] - if foreign_slice['peer_id'] != peer_id: - ### the slice has changed its plc, needs to update peer_slice - old_peer_id = foreign_slice['peer_id'] - old_peers=Peers(self.api,[peer_id]) - assert old_peer[0] - # remove from previous peer - old_peers[0].manage_slice(foreign_slice,False,False) - # add to new peer - self.manage_slice(foreign_slice,True,True) - foreign_slice['peer_id'] = peer_id - except: - foreign_slice = ForeignSlice(self.api, {'name':name}) -# ### xxx temporary -# foreign_slice['site_id']=1 - ### need to sync so we get a slice_id - foreign_slice.sync() - self.manage_slice(foreign_slice,True,True) - # insert in index - local_foreign_slices_index[name]=foreign_slice - - # go on with update - for field in remote_fields: - foreign_slice[field]=slice[field] - # this row is now valid - foreign_slice.uptodate=True - new_count += 1 - foreign_slice.sync() - - ### handle node_ids - # in slice we get a set of node_ids - # but these ids are RELATIVE TO THE PEER - # so we need to figure the local node_id for these nodes - # we do this through peer_foreign_nodes - # dictify once - peer_foreign_nodes_dict = {} - for foreign_node in peer_foreign_nodes: - peer_foreign_nodes_dict[foreign_node['node_id']]=foreign_node - updated_node_ids = [] - for alien_node_id in slice['node_ids']: - try: - local_node_id=self.locate_alien_node_id_in_foreign_nodes(peer_foreign_nodes_dict,alien_node_id) - updated_node_ids.append(local_node_id) - except: - # this node_id is not in our scope - pass - foreign_slice.update_slice_nodes (updated_node_ids) - - ### delete entries that are not uptodate - for foreign_slice in local_foreign_slices: - if not foreign_slice.uptodate: - foreign_slice.delete() - - return new_count-old_count + try: + # Figure out if the specified attribute is the name of a + # PLCAPI function. If so and the function requires an + # authentication structure as its first argument, return a + # callable that automagically adds an auth struct to the + # call. + methodname = attr + api_function = self.api.callable(methodname) + if api_function.accepts and \ + (isinstance(api_function.accepts[0], PLC.Auth.Auth) or \ + (isinstance(api_function.accepts[0], Mixed) and \ + filter(lambda param: isinstance(param, Auth), api_function.accepts[0]))): + function = getattr(self.server, methodname) + return self.add_auth(function, methodname) + except Exception, err: + pass + + if hasattr(self, attr): + return getattr(self, attr) + else: + raise AttributeError, "type object 'Peer' has no attribute '%s'" % attr class Peers (Table): """ @@ -317,9 +227,9 @@ class Peers (Table): ints = filter(lambda x: isinstance(x, (int, long)), peer_filter) strs = filter(lambda x: isinstance(x, StringTypes), peer_filter) peer_filter = Filter(Peer.fields, {'peer_id': ints, 'peername': strs}) - sql += " AND (%s)" % peer_filter.sql(api, "OR") + sql += " AND (%s) %s" % peer_filter.sql(api, "OR") elif isinstance(peer_filter, dict): peer_filter = Filter(Peer.fields, peer_filter) - sql += " AND (%s)" % peer_filter.sql(api, "AND") + sql += " AND (%s) %s" % peer_filter.sql(api, "AND") self.selectall(sql)