--- /dev/null
+#
+# Functions for interacting with the nodenetworks table in the database
+#
+# Mark Huang <mlhuang@cs.princeton.edu>
+# Copyright (C) 2006 The Trustees of Princeton University
+#
+# $Id$
+#
+
+from types import StringTypes
+import socket
+import struct
+
+from PLC.Faults import *
+from PLC.Parameter import Parameter
+from PLC.Debug import profile
+from PLC.Table import Row, Table
+import PLC.Nodes
+
+def in_same_network(address1, address2, netmask):
+ """
+ Returns True if two IPv4 addresses are in the same network. Faults
+ if an address is invalid.
+ """
+
+ address1 = struct.unpack('>L', socket.inet_aton(address1))[0]
+ address2 = struct.unpack('>L', socket.inet_aton(address2))[0]
+ netmask = struct.unpack('>L', socket.inet_aton(netmask))[0]
+
+ return (address1 & netmask) == (address2 & netmask)
+
+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().
+ """
+
+ 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)"),
+ 'is_primary': Parameter(bool, "Is the primary interface for this node"),
+ }
+
+ 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"
+
+ def validate_type(self, type):
+ if type not in self.types:
+ raise PLCInvalidArgument, "Invalid address type"
+
+ def validate_ip(self, ip):
+ try:
+ ip = socket.inet_ntoa(socket.inet_aton(ip))
+ except socket.error:
+ raise PLCInvalidArgument, "Invalid IP address " + ip
+
+ return ip
+
+ def validate_mac(self, mac):
+ try:
+ bytes = mac.split(":")
+ if len(bytes) < 6:
+ raise Exception
+ for i, byte in enumerate(bytes):
+ byte = int(byte, 16)
+ if byte < 0 or byte > 255:
+ raise Exception
+ bytes[i] = "%02x" % byte
+ mac = ":".join(bytes)
+ except:
+ raise PLCInvalidArgument, "Invalid MAC address"
+
+ return mac
+
+ validate_gateway = validate_ip
+ validate_network = validate_ip
+ validate_broadcast = validate_ip
+ validate_netmask = validate_ip
+ validate_dns1 = validate_ip
+ validate_dns2 = validate_ip
+
+ def validate_bwlimit(self, bwlimit):
+ if bwlimit not in self.bwlimits:
+ raise PLCInvalidArgument, "Invalid bandwidth limit"
+
+ 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)
+
+ def flush(self, commit = True):
+ """
+ Flush changes back to the database.
+ """
+
+ # Validate all specified fields
+ self.validate()
+
+ try:
+ method = self['method']
+ self['type']
+ except KeyError:
+ raise PLCInvalidArgument, "method and type must both be specified"
+
+ if method == "proxy" or method == "tap":
+ if 'mac' in self:
+ raise PLCInvalidArgument, "For %s method, mac should not be specified" % method
+ if 'ip' not in self:
+ raise PLCInvalidArgument, "For %s method, ip is required" % method
+ if method == "tap" and 'gateway' not in self:
+ 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
+ # there's no way to tell if the only primary interface is
+ # DHCP!
+
+ elif method == "static":
+ for key in ['ip', 'gateway', 'network', 'broadcast', 'netmask', 'dns1']:
+ if key not in self:
+ raise PLCInvalidArgument, "For static method, %s is required" % key
+ locals()[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)
+ if not in_same_network(broadcast, network, netmask):
+ raise PLCInvalidArgument, "Broadcast address %s is inconsistent with network %s/%s" % \
+ (broadcast, network, netmask)
+ if not in_same_network(ip, gateway, netmask):
+ raise PLCInvalidArgument, "Gateway %s is not reachable from %s/%s" % \
+ (gateway, ip, netmask)
+
+ elif method == "ipmi":
+ if 'ip' not in self:
+ 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)
+ else:
+ self[row['nodenetwork_id']] = NodeNetwork(api, row)
git://git.onelab.eu / plcapi.git / blobdiff