# Mark Huang <mlhuang@cs.princeton.edu>
# Copyright (C) 2006 The Trustees of Princeton University
#
-# $Id: ConfFiles.py,v 1.6 2006/11/02 18:32:55 mlhuang Exp $
+# $Id: ConfFiles.py,v 1.7 2006/11/06 20:48:33 mlhuang Exp $
#
from PLC.Faults import *
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
from PLC.Table import Row, Table
from PLC.Nodes import Node, Nodes
from PLC.NodeGroups import NodeGroup, NodeGroups
'error_cmd': Parameter(str, "Shell command to execute if any error occurs", max = 1024, nullok = True),
'ignore_cmd_errors': Parameter(bool, "Install file anyway even if an error occurs"),
'always_update': Parameter(bool, "Always attempt to install file even if unchanged"),
- 'node_ids': Parameter(int, "List of nodes linked to this file", ro = True),
- 'nodegroup_ids': Parameter(int, "List of node groups linked to this file", ro = True),
+ 'node_ids': Parameter(int, "List of nodes linked to this file"),
+ 'nodegroup_ids': Parameter(int, "List of node groups linked to this file"),
}
def add_node(self, node, commit = True):
Representation of the conf_files table in the database.
"""
- def __init__(self, api, conf_file_ids = None, enabled = None):
+ def __init__(self, api, conf_file_filter = None):
+ Table.__init__(self, api, ConfFile)
+
sql = "SELECT %s FROM view_conf_files WHERE True" % \
", ".join(ConfFile.fields)
-
- if conf_file_ids:
- # Separate the list into integers and strings
- sql += " AND conf_file_id IN (%s)" % ", ".join(map(str, api.db.quote(conf_file_ids)))
-
- if enabled is not None:
- sql += " AND enabled = %(enabled)s"
-
- rows = api.db.selectall(sql, locals())
-
- for row in rows:
- self[row['conf_file_id']] = ConfFile(api, row)
+ if conf_file_filter is not None:
+ if isinstance(conf_file_filter, list):
+ conf_file_filter = Filter(ConfFile.fields, {'conf_file_id': conf_file_filter})
+ elif isinstance(conf_file_filter, dict):
+ conf_file_filter = Filter(ConfFile.fields, conf_file_filter)
+ sql += " AND (%s)" % conf_file_filter.sql(api)
- for row in rows:
- self[row['conf_file_id']] = conf_file = ConfFile(api, row)
- for aggregate in ['node_ids', 'nodegroup_ids']:
- if not conf_file.has_key(aggregate) or conf_file[aggregate] is None:
- conf_file[aggregate] = []
- else:
- conf_file[aggregate] = map(int, conf_file[aggregate].split(','))
+ self.selectall(sql)
from PLC.Table import Row, Table
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
class ForeignNode (Row) :
"""
class ForeignNodes (Table):
- def __init__ (self, api, foreign_node_id_or_hostname_list=None):
+ def __init__ (self, api, foreign_node_filter = None):
+ Table.__init__(self, api, ForeignNode)
- self.api=api
+ sql = "SELECT %s FROM view_foreign_nodes WHERE deleted IS False" % \
+ ", ".join(ForeignNode.fields)
- sql =""
- sql += "SELECT %s FROM view_foreign_nodes " % ", ".join(ForeignNode.fields)
- sql += "WHERE view_foreign_nodes.deleted IS False "
+ if foreign_node_filter is not None:
+ if isinstance(foreign_node_filter, list):
+ # 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")
- 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 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 += ")"
-
- rows = self.api.db.selectall (sql)
-
- for row in rows:
- self[row['hostname']] = ForeignNode (api,row)
-
-
-
+ self.selectall(sql)
# Mark Huang <mlhuang@cs.princeton.edu>
# Copyright (C) 2006 The Trustees of Princeton University
#
-# $Id: NodeGroups.py,v 1.15 2006/10/25 14:29:13 mlhuang Exp $
+# $Id: NodeGroups.py,v 1.16 2006/11/02 18:32:55 mlhuang Exp $
#
from types import StringTypes
from PLC.Faults import *
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
from PLC.Debug import profile
from PLC.Table import Row, Table
from PLC.Nodes import Node, Nodes
database.
"""
- def __init__(self, api, nodegroup_id_or_name_list = None):
- self.api = api
+ def __init__(self, api, nodegroup_filter = None):
+ Table.__init__(self, api, NodeGroup)
- sql = "SELECT %s FROM view_nodegroups" % \
+ sql = "SELECT %s FROM view_nodegroups WHERE True" % \
", ".join(NodeGroup.fields)
- if nodegroup_id_or_name_list:
- # Separate the list into integers and strings
- nodegroup_ids = filter(lambda nodegroup_id: isinstance(nodegroup_id, (int, long)),
- nodegroup_id_or_name_list)
- names = filter(lambda name: isinstance(name, StringTypes),
- nodegroup_id_or_name_list)
- sql += " WHERE (False"
- if nodegroup_ids:
- sql += " OR nodegroup_id IN (%s)" % ", ".join(map(str, nodegroup_ids))
- if names:
- sql += " OR name IN (%s)" % ", ".join(api.db.quote(names))
- sql += ")"
-
- rows = self.api.db.selectall(sql)
-
- for row in rows:
- self[row['nodegroup_id']] = nodegroup = NodeGroup(api, row)
- for aggregate in ['node_ids', 'conf_file_ids']:
- if not nodegroup.has_key(aggregate) or nodegroup[aggregate] is None:
- nodegroup[aggregate] = []
- else:
- nodegroup[aggregate] = map(int, nodegroup[aggregate].split(','))
+ if nodegroup_filter is not None:
+ if isinstance(nodegroup_filter, list):
+ # Separate the list into integers and strings
+ ints = filter(lambda x: isinstance(x, (int, long)), nodegroup_filter)
+ strs = filter(lambda x: isinstance(x, StringTypes), nodegroup_filter)
+ nodegroup_filter = Filter(NodeGroup.fields, {'nodegroup_id': ints, 'name': strs})
+ sql += " AND (%s)" % nodegroup_filter.sql(api, "OR")
+ elif isinstance(nodegroup_filter, dict):
+ nodegroup_filter = Filter(NodeGroup.fields, nodegroup_filter)
+ sql += " AND (%s)" % nodegroup_filter.sql(api, "AND")
+
+ self.selectall(sql)
# Mark Huang <mlhuang@cs.princeton.edu>
# Copyright (C) 2006 The Trustees of Princeton University
#
-# $Id: PCUs.py,v 1.6 2006/10/25 14:29:13 mlhuang Exp $
+# $Id: PCUs.py,v 1.7 2006/11/02 18:32:55 mlhuang Exp $
#
from PLC.Faults import *
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
from PLC.Debug import profile
from PLC.Table import Row, Table
from PLC.NodeNetworks import valid_ip, NodeNetwork, NodeNetworks
'password': Parameter(str, "PCU username", max = 254, nullok = True),
'notes': Parameter(str, "Miscellaneous notes", max = 254, nullok = True),
'model': Parameter(str, "PCU model string", max = 32, nullok = True),
- 'node_ids': Parameter([int], "List of nodes that this PCU controls", ro = True),
- 'ports': Parameter([int], "List of the port numbers that each node is connected to", ro = True),
+ 'node_ids': Parameter([int], "List of nodes that this PCU controls"),
+ 'ports': Parameter([int], "List of the port numbers that each node is connected to"),
}
def validate_ip(self, ip):
database.
"""
- def __init__(self, api, pcu_ids = None):
- self.api = api
+ def __init__(self, api, pcu_filter = None):
+ Table.__init__(self, api, PCU)
- # N.B.: Node IDs returned may be deleted.
- sql = "SELECT %s FROM view_pcus" % \
+ sql = "SELECT %s FROM view_pcus WHERE True" % \
", ".join(PCU.fields)
- if pcu_ids:
- sql += " WHERE pcu_id IN (%s)" % ", ".join(map(str, pcu_ids))
+ if pcu_filter is not None:
+ if isinstance(pcu_filter, list):
+ pcu_filter = Filter(PCU.fields, {'pcu_id': pcu_filter})
+ elif isinstance(pcu_filter, dict):
+ pcu_filter = Filter(PCU.fields, pcu_filter)
+ sql += " AND (%s)" % pcu_filter.sql(api)
- rows = self.api.db.selectall(sql)
-
- for row in rows:
- self[row['pcu_id']] = pcu = PCU(api, row)
- for aggregate in ['node_ids', 'ports']:
- if not pcu.has_key(aggregate) or pcu[aggregate] is None:
- pcu[aggregate] = []
- else:
- pcu[aggregate] = map(int, pcu[aggregate].split(','))
+ self.selectall(sql)
from PLC.Faults import *
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
from PLC.Table import Row, Table
class Peer (Row):
Maps to the peers table in the database
"""
- def __init__ (self, api, peer_id_or_peername_list = None):
- self.api = api
+ def __init__ (self, api, peer_filter = None):
+ Table.__init__(self, api, Peer)
- sql="SELECT %s FROM view_peers WHERE deleted IS False" % \
- ", ".join(Peer.fields)
- if peer_id_or_peername_list:
- peer_ids = [x for x in peer_id_or_peername_list if isinstance(x, (int, long))]
- peernames = [x for x in peer_id_or_peername_list if isinstance(x, StringTypes)]
- sql += " AND (False"
- if peer_ids:
- sql += " OR peer_id in (%s)"% ", ".join([str(i) for i in peer_ids])
- if peernames:
- sql += " OR peername in (%s)"% ". ".join(api.db.quote(peernames)).lower()
- sql += ")"
-
- rows = self.api.db.selectall(sql)
-
- for row in rows:
- self[row['peer_id']] = peer = Peer(api,row)
- for aggregate in ['node_ids']:
- if not peer.has_key(aggregate) or peer[aggregate] is None:
- peer[aggregate] = []
- else:
- peer[aggregate] = map(int, peer[aggregate].split(','))
+ sql = "SELECT %s FROM view_peers WHERE deleted IS False" % \
+ ", ".join(Peer.fields)
+ if peer_filter is not None:
+ if isinstance(peer_filter, list):
+ # Separate the list into integers and strings
+ 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")
+ elif isinstance(peer_filter, dict):
+ peer_filter = Filter(Peer.fields, peer_filter)
+ sql += " AND (%s)" % peer_filter.sql(api, "AND")
+ self.selectall(sql)
from PLC.Faults import *
from PLC.Parameter import Parameter
+from PLC.Filter import Filter
from PLC.Debug import profile
from PLC.Table import Row, Table
from PLC.Slices import Slice, Slices
'last_updated': Parameter(int, "Date and time when site entry was last updated, in seconds since UNIX epoch", ro = True),
'max_slices': Parameter(int, "Maximum number of slices that the site is able to create"),
'max_slivers': Parameter(int, "Maximum number of slivers that the site is able to create"),
- 'person_ids': Parameter([int], "List of account identifiers", ro = True),
- 'slice_ids': Parameter([int], "List of slice identifiers", ro = True),
- 'address_ids': Parameter([int], "List of address identifiers", ro = True),
- 'pcu_ids': Parameter([int], "List of PCU identifiers", ro = True),
- 'node_ids': Parameter([int], "List of site node identifiers", ro = True),
+ 'person_ids': Parameter([int], "List of account identifiers"),
+ 'slice_ids': Parameter([int], "List of slice identifiers"),
+ 'address_ids': Parameter([int], "List of address identifiers"),
+ 'pcu_ids': Parameter([int], "List of PCU identifiers"),
+ 'node_ids': Parameter([int], "List of site node identifiers"),
}
def validate_name(self, name):
class Sites(Table):
"""
Representation of row(s) from the sites table in the
- database. Specify fields to limit columns to just the specified
- fields.
+ database.
"""
- def __init__(self, api, site_id_or_login_base_list = None):
- self.api = api
+ def __init__(self, api, site_filter = None):
+ Table.__init__(self, api, Site)
sql = "SELECT %s FROM view_sites WHERE deleted IS False" % \
", ".join(Site.fields)
- if site_id_or_login_base_list:
- # Separate the list into integers and strings
- site_ids = filter(lambda site_id: isinstance(site_id, (int, long)),
- site_id_or_login_base_list)
- login_bases = filter(lambda login_base: isinstance(login_base, StringTypes),
- site_id_or_login_base_list)
- sql += " AND (False"
- if site_ids:
- sql += " OR site_id IN (%s)" % ", ".join(map(str, site_ids))
- if login_bases:
- sql += " OR login_base IN (%s)" % ", ".join(api.db.quote(login_bases))
- sql += ")"
-
- rows = self.api.db.selectall(sql)
-
- for row in rows:
- self[row['site_id']] = site = Site(api, row)
- for aggregate in ['person_ids', 'slice_ids', 'address_ids',
- 'pcu_ids', 'node_ids']:
- if not site.has_key(aggregate) or site[aggregate] is None:
- site[aggregate] = []
- else:
- site[aggregate] = map(int, site[aggregate].split(','))
+ if site_filter is not None:
+ if isinstance(site_filter, list):
+ # Separate the list into integers and strings
+ ints = filter(lambda x: isinstance(x, (int, long)), site_filter)
+ strs = filter(lambda x: isinstance(x, StringTypes), site_filter)
+ site_filter = Filter(Site.fields, {'site_id': ints, 'login_base': strs})
+ sql += " AND (%s)" % site_filter.sql(api, "OR")
+ elif isinstance(site_filter, dict):
+ site_filter = Filter(Site.fields, site_filter)
+ sql += " AND (%s)" % site_filter.sql(api, "AND")
+
+ self.selectall(sql)
git://git.onelab.eu / plcapi.git / commitdiff