X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=PLC%2FNodeNetworks.py;h=19229e6b2a0c77232b81df1f99b9dd8d3e346d47;hb=refs%2Fheads%2Fplanetlab-4_0-branch;hp=04d6cf5e4aebb8e9f3e4c5bb54f89622f6dc2551;hpb=ba2b6814533bb92c5c5c3d5e4406384a53423428;p=plcapi.git diff --git a/PLC/NodeNetworks.py b/PLC/NodeNetworks.py index 04d6cf5..19229e6 100644 --- a/PLC/NodeNetworks.py +++ b/PLC/NodeNetworks.py @@ -4,7 +4,7 @@ # Mark Huang # Copyright (C) 2006 The Trustees of Princeton University # -# $Id: NodeNetworks.py,v 1.1 2006/09/06 15:36:07 mlhuang Exp $ +# $Id: NodeNetworks.py 5574 2007-10-25 20:33:17Z thierry $ # from types import StringTypes @@ -13,10 +13,20 @@ import struct 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.NetworkTypes import NetworkType, NetworkTypes +from PLC.NetworkMethods import NetworkMethod, NetworkMethods import PLC.Nodes +def valid_ip(ip): + try: + ip = socket.inet_ntoa(socket.inet_aton(ip)) + return True + except socket.error: + return False + def in_same_network(address1, address2, netmask): """ Returns True if two IPv4 addresses are in the same network. Faults @@ -33,68 +43,52 @@ class NodeNetwork(Row): """ Representation of a row in the nodenetworks table. To use, optionally instantiate with a dict of values. Update as you would a - dict. Commit to the database with flush(). + dict. Commit to the database with sync(). """ + table_name = 'nodenetworks' + primary_key = 'nodenetwork_id' + join_tables = ['nodenetwork_setting'] fields = { 'nodenetwork_id': Parameter(int, "Node interface identifier"), 'method': Parameter(str, "Addressing method (e.g., 'static' or 'dhcp')"), 'type': Parameter(str, "Address type (e.g., 'ipv4')"), - 'ip': Parameter(str, "IP address"), - 'mac': Parameter(str, "MAC address"), - 'gateway': Parameter(str, "IP address of primary gateway"), - 'network': Parameter(str, "Subnet address"), - 'broadcast': Parameter(str, "Network broadcast address"), - 'netmask': Parameter(str, "Subnet mask"), - 'dns1': Parameter(str, "IP address of primary DNS server"), - 'dns2': Parameter(str, "IP address of secondary DNS server"), - # XXX Should be an int (bps) - 'bwlimit': Parameter(str, "Bandwidth limit"), - 'hostname': Parameter(str, "(Optional) Hostname"), - } - - # These fields are derived from join tables and are not - # actually in the nodenetworks table. - join_fields = { - 'node_id': Parameter(int, "Node associated with this interface (if any)"), + 'ip': Parameter(str, "IP address", nullok = True), + 'mac': Parameter(str, "MAC address", nullok = True), + 'gateway': Parameter(str, "IP address of primary gateway", nullok = True), + 'network': Parameter(str, "Subnet address", nullok = True), + 'broadcast': Parameter(str, "Network broadcast address", nullok = True), + 'netmask': Parameter(str, "Subnet mask", nullok = True), + 'dns1': Parameter(str, "IP address of primary DNS server", nullok = True), + 'dns2': Parameter(str, "IP address of secondary DNS server", nullok = True), + 'bwlimit': Parameter(int, "Bandwidth limit", min = 0, nullok = True), + 'hostname': Parameter(str, "(Optional) Hostname", nullok = True), + 'node_id': Parameter(int, "Node associated with this interface"), 'is_primary': Parameter(bool, "Is the primary interface for this node"), + 'nodenetwork_setting_ids' : Parameter([int], "List of nodenetwork settings"), } - all_fields = dict(join_fields.items() + fields.items()) - - methods = ['static', 'dhcp', 'proxy', 'tap', 'ipmi', 'unknown'] - - types = ['ipv4'] - - bwlimits = ['-1', - '100kbit', '250kbit', '500kbit', - '1mbit', '2mbit', '5mbit', - '10mbit', '20mbit', '50mbit', - '100mbit'] - - def __init__(self, api, fields): - Row.__init__(self, fields) - self.api = api - def validate_method(self, method): - if method not in self.methods: - raise PLCInvalidArgument, "Invalid addressing method" + network_methods = [row['method'] for row in NetworkMethods(self.api)] + if method not in network_methods: + raise PLCInvalidArgument, "Invalid addressing method %s"%method return method def validate_type(self, type): - if type not in self.types: - raise PLCInvalidArgument, "Invalid address type" + network_types = [row['type'] for row in NetworkTypes(self.api)] + if type not in network_types: + raise PLCInvalidArgument, "Invalid address type %s"%type return type def validate_ip(self, ip): - try: - ip = socket.inet_ntoa(socket.inet_aton(ip)) - except socket.error: - raise PLCInvalidArgument, "Invalid IP address " + ip - + if ip and not valid_ip(ip): + raise PLCInvalidArgument, "Invalid IP address %s"%ip return ip def validate_mac(self, mac): + if not mac: + return mac + try: bytes = mac.split(":") if len(bytes) < 6: @@ -106,7 +100,7 @@ class NodeNetwork(Row): bytes[i] = "%02x" % byte mac = ":".join(bytes) except: - raise PLCInvalidArgument, "Invalid MAC address" + raise PLCInvalidArgument, "Invalid MAC address %s"%mac return mac @@ -118,38 +112,69 @@ class NodeNetwork(Row): validate_dns2 = validate_ip def validate_bwlimit(self, bwlimit): - if bwlimit not in self.bwlimits: - raise PLCInvalidArgument, "Invalid bandwidth limit" - return bwlimit + if not bwlimit: + return bwlimit + + if bwlimit < 500000: + raise PLCInvalidArgument, 'Minimum bw is 500 kbs' + + return bwlimit def validate_hostname(self, hostname): # Optional if not hostname: return hostname - # Validate hostname, and check for conflicts with a node hostname - return PLC.Nodes.Node.validate_hostname(self, hostname) + if not PLC.Nodes.valid_hostname(hostname): + raise PLCInvalidArgument, "Invalid hostname %s"%hostname + + return hostname + + def validate_node_id(self, node_id): + nodes = PLC.Nodes.Nodes(self.api, [node_id]) + if not nodes: + raise PLCInvalidArgument, "No such node %d"%node_id + + return node_id - def flush(self, commit = True): + def validate_is_primary(self, is_primary): + """ + Set this interface to be the primary one. + """ + + if is_primary: + nodes = PLC.Nodes.Nodes(self.api, [self['node_id']]) + if not nodes: + raise PLCInvalidArgument, "No such node %d"%node_id + node = nodes[0] + + if node['nodenetwork_ids']: + conflicts = NodeNetworks(self.api, node['nodenetwork_ids']) + for nodenetwork in conflicts: + if ('nodenetwork_id' not in self or \ + self['nodenetwork_id'] != nodenetwork['nodenetwork_id']) and \ + nodenetwork['is_primary']: + raise PLCInvalidArgument, "Can only set one primary interface per node" + + return is_primary + + def validate(self): """ Flush changes back to the database. """ - # Validate all specified fields - self.validate() + # Basic validation + Row.validate(self) - try: - method = self['method'] - self['type'] - except KeyError: - raise PLCInvalidArgument, "method and type must both be specified" + assert 'method' in self + method = self['method'] if method == "proxy" or method == "tap": - if 'mac' in self: + if 'mac' in self and self['mac']: raise PLCInvalidArgument, "For %s method, mac should not be specified" % method - if 'ip' not in self: + if 'ip' not in self or not self['ip']: raise PLCInvalidArgument, "For %s method, ip is required" % method - if method == "tap" and 'gateway' not in self: + if method == "tap" and ('gateway' not in self or not self['gateway']): raise PLCInvalidArgument, "For tap method, gateway is required and should be " \ "the IP address of the node that proxies for this address" # Should check that the proxy address is reachable, but @@ -158,9 +183,9 @@ class NodeNetwork(Row): elif method == "static": for key in ['ip', 'gateway', 'network', 'broadcast', 'netmask', 'dns1']: - if key not in self: + if key not in self or not self[key]: raise PLCInvalidArgument, "For static method, %s is required" % key - locals()[key] = self[key] + globals()[key] = self[key] if not in_same_network(ip, network, netmask): raise PLCInvalidArgument, "IP address %s is inconsistent with network %s/%s" % \ (ip, network, netmask) @@ -172,92 +197,30 @@ class NodeNetwork(Row): (gateway, ip, netmask) elif method == "ipmi": - if 'ip' not in self: + if 'ip' not in self or not self['ip']: raise PLCInvalidArgument, "For ipmi method, ip is required" - # Fetch a new nodenetwork_id if necessary - if 'nodenetwork_id' not in self: - rows = self.api.db.selectall("SELECT NEXTVAL('nodenetworks_nodenetwork_id_seq') AS nodenetwork_id") - if not rows: - raise PLCDBError("Unable to fetch new nodenetwork_id") - self['nodenetwork_id'] = rows[0]['nodenetwork_id'] - insert = True - else: - insert = False - - # Filter out fields that cannot be set or updated directly - fields = dict(filter(lambda (key, value): key in self.fields, - self.items())) - - # Parameterize for safety - keys = fields.keys() - values = [self.api.db.param(key, value) for (key, value) in fields.items()] - - if insert: - # Insert new row in nodenetworks table - sql = "INSERT INTO nodenetworks (%s) VALUES (%s)" % \ - (", ".join(keys), ", ".join(values)) - else: - # Update existing row in sites table - columns = ["%s = %s" % (key, value) for (key, value) in zip(keys, values)] - sql = "UPDATE nodenetworks SET " + \ - ", ".join(columns) + \ - " WHERE nodenetwork_id = %(nodenetwork_id)d" - - self.api.db.do(sql, fields) - - if commit: - self.api.db.commit() - - def delete(self, commit = True): - """ - Delete existing nodenetwork. - """ - - assert 'nodenetwork_id' in self - - # Delete ourself - for table in ['node_nodenetworks', 'nodenetworks']: - self.api.db.do("DELETE FROM %s" \ - " WHERE nodenetwork_id = %d" % \ - (table, self['nodenetwork_id'])) - - if commit: - self.api.db.commit() - class NodeNetworks(Table): """ Representation of row(s) from the nodenetworks table in the database. """ - def __init__(self, api, nodenetwork_id_or_hostname_list = None): - self.api = api - - # N.B.: Node IDs returned may be deleted. - sql = "SELECT nodenetworks.*" \ - ", node_nodenetworks.node_id" \ - ", node_nodenetworks.is_primary" \ - " FROM nodenetworks" \ - " LEFT JOIN node_nodenetworks USING (nodenetwork_id)" - - if nodenetwork_id_or_hostname_list: - # Separate the list into integers and strings - nodenetwork_ids = filter(lambda nodenetwork_id: isinstance(nodenetwork_id, (int, long)), - nodenetwork_id_or_hostname_list) - hostnames = filter(lambda hostname: isinstance(hostname, StringTypes), - nodenetwork_id_or_hostname_list) - sql += " WHERE (False" - if nodenetwork_ids: - sql += " OR nodenetwork_id IN (%s)" % ", ".join(map(str, nodenetwork_ids)) - if hostnames: - sql += " OR hostname IN (%s)" % ", ".join(api.db.quote(hostnames)).lower() - sql += ")" - - rows = self.api.db.selectall(sql) - for row in rows: - if self.has_key(row['nodenetwork_id']): - nodenetwork = self[row['nodenetwork_id']] - nodenetwork.update(row) + def __init__(self, api, nodenetwork_filter = None, columns = None): + Table.__init__(self, api, NodeNetwork, columns) + + sql = "SELECT %s FROM view_nodenetworks WHERE True" % \ + ", ".join(self.columns) + + if nodenetwork_filter is not None: + if isinstance(nodenetwork_filter, (list, tuple, set)): + nodenetwork_filter = Filter(NodeNetwork.fields, {'nodenetwork_id': nodenetwork_filter}) + elif isinstance(nodenetwork_filter, dict): + nodenetwork_filter = Filter(NodeNetwork.fields, nodenetwork_filter) + elif isinstance(nodenetwork_filter, int): + nodenetwork_filter = Filter(NodeNetwork.fields, {'nodenetwork_id': [nodenetwork_filter]}) else: - self[row['nodenetwork_id']] = NodeNetwork(api, row) + raise PLCInvalidArgument, "Wrong node network filter %r"%nodenetwork_filter + sql += " AND (%s) %s" % nodenetwork_filter.sql(api) + + self.selectall(sql)