Registries/Aggregates now inherit sfa.server.interface.Interfaces base class

diff --git a/sfa/server/aggregate.py b/sfa/server/aggregate.py
index bc07b76..eb4652e 100644 (file)
--- a/sfa/server/aggregate.py
+++ b/sfa/server/aggregate.py
@@ -1,25 +1,13 @@
 ### $Id$
 ### $URL$
 
-import os
-import sys
-import datetime
-import time
 
 from sfa.util.server import SfaServer
-from sfa.util.storage import *
 from sfa.util.faults import *
-from sfa.trust.gid import GID
-from sfa.util.table import SfaTable
+from sfa.server.interface import Interfaces
 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
 import sfa.util.soapprotocol as soapprotocol
 
-# GeniLight client support is optional
-try:
-    from egeni.geniLight_client import *
-except ImportError:
-    GeniClientLight = None
-
 
 class Aggregate(SfaServer):
 
@@ -39,70 +27,17 @@ class Aggregate(SfaServer):
 
 class Aggregates(dict):
 
-    default_fields = {
-        'hrn': '',
-        'addr': '',
-        'port': '',
-    }    
+    default_dict = {'registries': {'registry': [default_fields]}}
  
     def __init__(self, api, file = "/etc/sfa/aggregates.xml"):
-        dict.__init__(self, {})
-        self.api = api
-        
-        # create default connection dict
-        aggregates_dict = {'aggregates': {'aggregate': [default_fields]}}
-        
-        # load config file
-        self.aggregate_info = XmlStorage(file, aggregates_dict)
-        self.aggregate_info.load()
-        self.interfaces = self.registry_info['aggregates']['aggregate']
-        if not isinstance(self.interfaces, list):
-            self.interfaces = [self.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 aggregates.xml config file. If there
-        # are any missing gids, request a new one from the peer registry.
-        gids_current = self.api.auth.trusted_cert_list.get_list()
-        hrns_current = [gid.get_hrn() for gid in gids_found]
-        hrns_expected = [interface['hrn'] for interfaces in self.interfaces]
-        new_hrns = set(hrns_current).difference(hrns_expected)
-
-        self.get_peer_gids(new_hrns)
-        self.connectAggregates()
+        Interfaces.__init__(self, conf_file, 'sa')
 
-    def connectAggregates(self):
+    def connectAggregates(self, interfaces):
         """
         Get connection details for the trusted peer aggregates from file and 
         create an connection to each. 
         """
-        aggregates = self.aggregate_info['aggregates']['aggregate']
-        if isinstance(aggregates, dict):
-            aggregates = [aggregates]
-        if isinstance(aggregates, list):
-            for aggregate in aggregates:
-                # make sure the required fields are present
-                if not set(self.required_fields).issubset(aggregate.keys()):
-                    continue
-                hrn, address, port = aggregate['hrn'], aggregate['addr'], aggregate['port']
-                if not hrn or not address or not port:
-                    continue
-                self.interfaces.append(aggregate)
-                # check which client we should use
-                # sfa.util.xmlrpcprotocol is default
-                client_type = 'xmlrpcprotocol'
-                if aggregate.has_key('client') and aggregate['client'] in ['geniclientlight']:
-                    client_type = 'geniclientlight'
-                
-                # create url
-                url = 'http://%(address)s:%(port)s' % locals()
-
-                # create the client connection
-                # make sure module exists before trying to instantiate it
-                if client_type in ['geniclientlight'] and GeniClientLight:
-                    self[hrn] = GeniClientLight(url, self.api.key_file, self.api.cert_file)
-                else:
-                    self[hrn] = xmlrpcprotocol.get_server(url, self.api.key_file, self.api.cert_file)
+        connections = Interfaces.get_connections(self, interfaces)
 
         # set up a connection to the local registry
         address = self.api.config.SFA_AGGREGATE_HOST
@@ -110,6 +45,6 @@ class Aggregates(dict):
         url = 'http://%(address)s:%(port)s' % locals()
         local_aggregate = {'hrn': self.api.hrn, 'addr': address, 'port': port}
         self.interfaces.append(local_aggregate) 
-        self[self.api.hrn] = xmlrpcprotocol.get_server(url, self.api.key_file, self.api.cert_file)
-
+        connections[self.api.hrn] = xmlrpcprotocol.get_server(url, self.api.key_file, self.api.cert_file)
+        return connetions
 

diff --git a/sfa/server/registry.py b/sfa/server/registry.py
index 6a219f2..fe845a3 100644 (file)
--- a/sfa/server/registry.py
+++ b/sfa/server/registry.py
@@ -5,24 +5,12 @@
 ### $URL$
 #
 
-import tempfile
-import os
-import time
-import sys
-
 from sfa.util.server import SfaServer
 from sfa.util.faults import *
-from sfa.util.storage import *
-from sfa.trust.gid import GID
-from sfa.util.table import SfaTable
+from sfa.server.interface import Interfaces
 import sfa.util.xmlrpcprotocol as xmlrpcprotocol
 import sfa.util.soapprotocol as soapprotocol
  
-# GeniLight client support is optional
-try:
-    from egeni.geniLight_client import *
-except ImportError:
-    GeniClientLight = None            
 
 ##
 # Registry is a SfaServer that serves registry and slice operations at PLC.
@@ -44,134 +32,19 @@ class Registry(SfaServer):
 # Registries is a dictionary of registry connections keyed on the registry
 # hrn
 
-class Registries(dict):
-
-    default_fields = {
-        'hrn': '',
-        'addr': '', 
-        'port': '', 
-    }
-
-    def __init__(self, api, file = "/etc/sfa/registries.xml"):
-        dict.__init__(self, {})
-        self.api = api
-        
-        # create default connection dict
-        registries_dict = {'registries': {'registry': [default_fields]}}
-
-        # load config file
-        self.registry_info = XmlStorage(file, registries_dict)
-        self.registry_info.load()
-        self.interfaces = self.registry_info['registries']['registry']
-        if not isinstance(self.interfaces, list):
-            self.interfaces = [self.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.
-        gids_current = self.api.auth.trusted_cert_list.get_list()
-        hrns_current = [gid.get_hrn() for gid in gids_found] 
-        hrns_expected = [interface['hrn'] for interfaces in self.interfaces] 
-        new_hrns = set(hrns_current).difference(hrns_expected)
-        
-        self.get_peer_gids(new_hrns)
-
-        # update the local db records for these registries
-        self.update_db_records('sa')
-        
-        # create connections to the registries
-        self.update(self.get_connections(interfaces))
-
-    def get_peer_gids(self, new_hrns):
-        """
-        Install trusted gids from the specified interfaces.  
-        """
-        if not new_hrns:
-            return
-
-        trusted_certs_dir = self.api.config.get_trustedroots_dir()
-        for new_hrn in new_hrns:
-            try:
-                # get gid from the registry
-                registry = self.get_connections(self.interfaces[new_hrn])[new_hrn]
-                trusted_gids = registry.get_trusted_certs()
-                # default message
-                message = "interface: registry\tunable to retrieve and install trusted gid for %s" % new_hrn 
-                if trusted_gids:
-                    # the gid we want shoudl be the first one in the list, but lets 
-                    # make sure
-                    for trusted_gid in trusted_gids:
-                        gid = GID(string=trusted_gids[0])
-                        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 = "interface: registry\tinstalled trusted gid for %s" % \
-                                (new_hrn)
-                # log the message
-                self.api.logger.info(message)
-            except:
-                message = "interface: registry\tunable to retrieve and install trusted gid for %s" % new_hrn 
-                self.api.logger.info(message)
-        
-        # reload the trusted certs list
-        self.api.auth.load_trusted_certs()
-
-    def update_db_records(self, type):
-        """
-        Make sure there is a record in the local db for allowed registries
-        defined in the config file (registries.xml). Removes old records from
-        the db.         
-        """
-        # get hrns we expect to find
-        hrns_expected = self.interfaces.keys()
+class Registries(Interfaces):
+    
+    default_dict = {'registries': {'registry': [default_fields]}}
 
-        # get hrns that actually exist in the db
-        table = SfaTable()
-        records = table.find({'type': 'sa'})
-        hrns_found = [record['hrn'] for record in records]
-        
-        # remove old records
-        for record in records:
-            if record['hrn'] not in hrns_expected:
-                table.remove(record)
+    def __init__(self, api, conf_file = "/etc/sfa/registries.xml"):
+        Interfaces.__init__(self, conf_file, 'sa') 
 
-        # add new records
-        for hrn in hrns_expected:
-            if hrn not in hrns_found:
-                record = {
-                    'hrn': hrn,
-                    'type': 'sa',
-                }
-            table.insert(record)
-                        
- 
-    def get_connections(self, registries):
+    def get_connections(self, interfaces):
         """
         read connection details for the trusted peer registries from file return 
         a dictionary of connections keyed on interface hrn. 
         """
-        connections = {}
-        required_fields = self.default_fields.keys()
-        if not isinstance(registries, []):
-            registries = [registries]
-        for registry in registries:
-            # make sure the required fields are present and not null
-            for key in required_fields
-                if not registry.get(key):
-                    continue 
-            hrn, address, port = registry['hrn'], registry['addr'], registry['port']
-            url = 'http://%(address)s:%(port)s' % locals()
-            # check which client we should use
-            # sfa.util.xmlrpcprotocol is default
-            client_type = 'xmlrpcprotocol'
-            if registry.has_key('client') and \
-               registry['client'] in ['geniclientlight'] and \
-               GeniClientLight:
-                client_type = 'geniclientlight'
-                connections[hrn] = GeniClientLight(url, self.api.key_file, self.api.cert_file) 
-            else:
-                connections[hrn] = xmlrpcprotocol.get_server(url, self.api.key_file, self.api.cert_file)
+        connections = Interfaces.get_connections(self, interfaces)
 
         # set up a connection to the local registry
         address = self.api.config.SFA_REGISTRY_HOST