#
# 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) :
"""
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_hostname_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()
- sql =""
- sql += "SELECT %s FROM foreign_nodes " % ", ".join(ForeignNode.fields)
- sql += "WHERE 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_hostname_list:
- foreign_node_id_list = [ str(x) for x in foreign_node_id_or_hostname_list
- if isinstance(x, (int,long))]
- hostname_list = [ x for x in foreign_node_id_or_hostname_list
- if isinstance(x, StringTypes)]
- sql += " AND (False"
- if foreign_node_id_list:
- sql += " OR foreign_node_id in (%s)" % ", ".join(foreign_node_id_list)
- if hostname_list:
- ## figure how to retrieve peer_id from the hostname(s)
- sql += " OR hostname IN (%s)" % ", ".join(api.db.quote(hostname_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]
+