prepare_ methods accept a filter argument

[sfa.git] / sfa / plc / aggregate.py

diff --git a/sfa/plc/aggregate.py b/sfa/plc/aggregate.py
index 8fa7c80..8b1d221 100644 (file)
--- a/sfa/plc/aggregate.py
+++ b/sfa/plc/aggregate.py
@@ -3,6 +3,7 @@ from sfa.util.xrn import hrn_to_urn, urn_to_hrn
 from sfa.util.plxrn import PlXrn, hostname_to_urn, hrn_to_pl_slicename
 from sfa.rspecs.rspec import RSpec
 from sfa.rspecs.elements.link import Link
+from sfa.rspecs.elements.interface import Interface
 from sfa.managers.vini.topology import PhysicalLinks
 from sfa.rspecs.version_manager import VersionManager
 from sfa.plc.vlink import get_tc_rate
@@ -24,14 +25,15 @@ class Aggregate:
         self.api = api
         self.user_options = user_options
 
-    def prepare_sites(self, force=False):
+    def prepare_sites(self, filter={}, force=False):
         if not self.sites or force:  
-            for site in self.api.plshell.GetSites(self.api.plauth):
+            for site in self.api.plshell.GetSites(self.api.plauth, filter):
                 self.sites[site['site_id']] = site
     
-    def prepare_nodes(self, force=False):
+    def prepare_nodes(self, filter={}, force=False):
         if not self.nodes or force:
-            for node in self.api.plshell.GetNodes(self.api.plauth, {'peer_id': None}):
+            filter.update({'peer_id': None}) 
+            for node in self.api.plshell.GetNodes(self.api.plauth, filter):
                 # add site/interface info to nodes.
                 # assumes that sites, interfaces and tags have already been prepared.
                 site = self.sites[node['site_id']]
@@ -46,12 +48,12 @@ class Aggregate:
                 node['tags'] = tags
                 self.nodes[node['node_id']] = node
 
-    def prepare_interfaces(self, force=False):
+    def prepare_interfaces(self, filter={}, force=False):
         if not self.interfaces or force:
-            for interface in self.api.plshell.GetInterfaces(self.api.plauth):
+            for interface in self.api.plshell.GetInterfaces(self.api.plauth, filter):
                 self.interfaces[interface['interface_id']] = interface
 
-    def prepare_links(self, force=False):
+    def prepare_links(self, filter={}, force=False):
         if not self.links or force:
             if not self.api.config.SFA_AGGREGATE_TYPE.lower() == 'vini':
                 return
@@ -66,8 +68,8 @@ class Aggregate:
                 site1_hrn = self.api.hrn + '.' + site1['login_base']
                 site2_hrn = self.api.hrn + '.' + site2['login_base']
                 # get the first node
-                node1 = self.nodes[site1['node_id'][0]]
-                node2 = self.nodes[site2['node_id'][0]]
+                node1 = self.nodes[site1['node_ids'][0]]
+                node2 = self.nodes[site2['node_ids'][0]]
 
                 # set interfaces
                 # just get first interface of the first node
@@ -82,33 +84,41 @@ class Aggregate:
                 link['interface1'] = if1
                 link['interface2'] = if2
                 link['component_name'] = "%s:%s" % (site1['login_base'], site2['login_base'])
-                link['component_id'] = PlXrn(auth=self.api.hrn, link=link['component_name'])
+                link['component_id'] = PlXrn(auth=self.api.hrn, interface=link['component_name']).get_urn()
                 link['component_manager_id'] =  hrn_to_urn(self.api.hrn, 'authority+am')
                 self.links[link['component_name']] = link
 
 
-    def prepare_node_tags(self, force=False):
+    def prepare_node_tags(self, filter={}, force=False):
         if not self.node_tags or force:
-            for node_tag in self.api.plshell.GetNodeTags(self.api.plauth):
+            for node_tag in self.api.plshell.GetNodeTags(self.api.plauth, filter):
                 self.node_tags[node_tag['node_tag_id']] = node_tag
 
-    def prepare_pl_initscripts(self, force=False):
+    def prepare_pl_initscripts(self, filter={}, force=False):
         if not self.pl_initscripts or force:
-            for initscript in self.api.plshell.GetInitScripts(self.api.plauth, {'enabled': True}):
+            filter.update({'enabled': True})
+            for initscript in self.api.plshell.GetInitScripts(self.api.plauth, filter):
                 self.pl_initscripts[initscript['initscript_id']] = initscript
 
-    def prepare(self, force=False):
-        if not self.prepared or force:
-            self.prepare_sites(force)
-            self.prepare_interfaces(force)
-            self.prepare_node_tags(force)
-            self.prepare_nodes(force)
-            self.prepare_links(force)
-            self.prepare_pl_initscripts()
-        self.prepared = True  
+    def prepare(self, slice = None, force=False):
+        if not self.prepared or force or slice:
+            if not slice:
+                self.prepare_sites(force=force)
+                self.prepare_interfaces(force=force)
+                self.prepare_node_tags(force=force)
+                self.prepare_nodes(force=force)
+                self.prepare_links(force=force)
+                self.prepare_pl_initscripts(force=force)
+            else:
+                self.prepare_sites({'site_id': slice['site_id']})
+                self.prepare_interfaces({'node_id': slice['node_ids']})
+                self.prepare_node_tags({'node_id': slice['node_ids']})
+                self.prepare_nodes({'node_id': slice['node_ids']})
+                self.prepare_links({'slice_id': slice['slice_id']})
+                self.prepare_pl_initscripts({'slice_id': slice['slice_id']})
+            self.prepared = True  
 
     def get_rspec(self, slice_xrn=None, version = None):
-        self.prepare()
         version_manager = VersionManager()
         version = version_manager.get_version(version)
         if not slice_xrn:
@@ -124,8 +134,10 @@ class Aggregate:
             slice_name = hrn_to_pl_slicename(slice_hrn)
             slices = self.api.plshell.GetSlices(self.api.plauth, slice_name)
             if slices:
-                slice = slices[0]            
-
+                slice = slices[0]
+        else:
+            self.prepare()
+            
         # filter out nodes with a whitelist:
         valid_nodes = [] 
         for node in self.nodes.values():