- RefreshPeer & AddSliceToNodes had bugs

[plcapi.git] / PLC / ForeignNodes.py

diff --git a/PLC/ForeignNodes.py b/PLC/ForeignNodes.py
index c58bdf2..b609006 100644 (file)
--- a/PLC/ForeignNodes.py
+++ b/PLC/ForeignNodes.py
@@ -1,13 +1,13 @@
 #
-# the nodes standing on peer plc's
-#
-# Thierry Parmentelat
+# Thierry Parmentelat - INRIA
 # 
+import time
 
 from types import StringTypes
 
 from PLC.Table import Row, Table
 from PLC.Parameter import Parameter
+from PLC.Filter import Filter
 
 class ForeignNode (Row) :
     """
@@ -15,49 +15,78 @@ class ForeignNode (Row) :
     other peering instances of myplc
     """
 
-    table_name = 'foreign_nodes'
-    primary_key = 'foreign_node_id'
+    table_name = 'nodes'
+    primary_key = 'node_id'
 
     fields = {
-       'foreign_node_id': Parameter (int, "Foreign Node Id"),
+       'node_id': Parameter (int, "Node Id"),
        'hostname': Parameter (str, "Node name"),
-       'boot_state' : Parameter (str, "Boot state"),
        'peer_id': Parameter (str, "Peer id"),
+       'boot_state' : Parameter (str, "Boot state, see Node"),
+        'model' : Parameter (str,"Model, see Node"),
+        'version' : Parameter (str,"Version, see Node"),
+        'date_created': Parameter(int, "Creation time, see Node"),
+        'last_updated': Parameter(int, "Update time, see Node"),
+        'slice_ids': Parameter([int], "List of slices on this node"),
        }
 
     def __init__(self,api,fields={},uptodate=True):
        Row.__init__(self,api,fields)
        self.uptodate=uptodate
 
-class ForeignNodes (Table):
+    def validate_date_created(self,timestamp):
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp))
 
-    def __init__ (self, api, foreign_node_id_or_peername_list=None):
+    def validate_last_updated(self,timestamp):
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp))
 
-       self.api=api
+    def purge_peer_node (self,commit=True):
+        sql = "DELETE FROM peer_node WHERE node_id=%d"%self['node_id']
+        self.api.db.do(sql)
+        if commit:
+            self.api.db.commit()
 
-       # must qualify fields because peer_id otherwise gets ambiguous
-       fields = ["foreign_nodes.%s"%x for x in ForeignNode.fields]
-                 
-       sql =""
-       sql += "SELECT %s FROM foreign_nodes, peers " % ", ".join(fields)
-       sql += "WHERE foreign_nodes.peer_id=peers.peer_id "
-       sql += "AND foreign_nodes.deleted IS False " 
+    def delete (self, commit=True):
+        """
+        Delete existing foreign node.
+        """
+        self.purge_peer_node()
+        self['deleted']=True
+        self.sync(commit)
+        
 
-       if foreign_node_id_or_peername_list:
-           foreign_node_id_list = [ x for x in foreign_node_id_or_peername_list if isinstance(x, (int,long))]
-           peername_list = [ x for x in foreign_node_id_or_peername_list if isinstance(x, StringTypes)]
-           sql += " AND (False"
-           if foreign_node_id_list:
-               sql += " OR foreign_node_id in (%s)" % ", ".join([str(i) for i in foreign_node_id_list])
-           if peername_list:
-               ## figure how to retrieve peer_id from the peername(s)
-               sql += " OR peername IN (%s)" % ", ".join(api.db.quote(peername_list))
-           sql += ")"
+class ForeignNodes (Table):
+    def __init__ (self, api, foreign_node_filter = None, columns = None):
+        Table.__init__(self, api, ForeignNode, columns)
 
-       rows = self.api.db.selectall (sql)
+        sql = ""
+       sql += "SELECT %s FROM view_foreign_nodes " % ", ".join(self.columns)
+        sql += "WHERE deleted IS False "
+              
+        if foreign_node_filter is not None:
+            if isinstance(foreign_node_filter, (list, tuple, set)):
+                # Separate the list into integers and strings
+                ints = filter(lambda x: isinstance(x, (int, long)), foreign_node_filter)
+                strs = filter(lambda x: isinstance(x, StringTypes), foreign_node_filter)
+                foreign_node_filter = Filter(ForeignNode.fields, {'node_id': ints, 'hostname': strs})
+                sql += " AND (%s)" % foreign_node_filter.sql(api, "OR")
+            elif isinstance(foreign_node_filter, dict):
+                foreign_node_filter = Filter(ForeignNode.fields, foreign_node_filter)
+                sql += " AND (%s)" % foreign_node_filter.sql(api, "AND")
 
-       for row in rows:
-           self[row['hostname']] = ForeignNode (api,row)
+       self.selectall(sql)
 
+    # managing an index by hostname
+    def hostname_index(self):
+        if 'hostname' not in self.columns:
+            raise PLCFault,"ForeignNodes::index_hostname, hostname not selected"
+        self.index={}
+        for foreign_node in self:
+            self.index[foreign_node['hostname']]=foreign_node
+            
+    def hostname_add_by(self,foreign_node):
+        self.index[foreign_node['hostname']]=foreign_node
 
-       
+    def hostname_locate(self,hostname):
+        return self.index[hostname]
+