Changeset 1439

Timestamp:

03/08/07 18:04:18 (6 years ago)

Author:

mglb1

Message:

Add an 'Ethernet Customer' service to assist with configuring the required
components to provide service to a customer via an Ethernet interface.

Files:

• ccsd/trunk/crcnetd/modules/ccs_billing.py (modified) (3 diffs)
• ccsweb/trunk/ccs_mods/service/ethernet_customer-ilist.tpl (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer-propdetails.tpl (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer-props.js (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer-props.tpl (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer.js (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer.php (added)
• ccsweb/trunk/ccs_mods/service/ethernet_customer.tpl (added)

ccsd/trunk/crcnetd/modules/ccs_billing.py

@@ -33 +33 @@
 from crcnetd._utils.ccsd_config import config_get, config_getboolean
 from crcnetd.modules.ccs_contact import addContact, editContact
+from crcnetd._utils.ccsd_service import ccsd_service, ccs_service_error, \
+        registerService, getServiceInstance
+
+from crcnetd.modules.ccs_interface import INTERFACE_TYPE_ALIAS, addInterface
+from crcnetd.modules.ccs_link import ccs_link
 
 import calendar
@@ -56 +61 @@
 CONNECTION_METHOD_ETHERNET = "Ethernet"
 CONNECTION_METHODS = [ CONNECTION_METHOD_WIRELESS, CONNECTION_METHOD_ETHERNET ]
+
+# The property name for the link to allocate ethernet customer IPs from
+ETHERNET_CUSTOMER_LINK_PROPERTY = "ethernet_customer_link"
+
+# The property name for the firewall class to give to ethernet customers
+ETHERNET_CUSTOMER_FIREWALL_PROPERTY = "ethernet_customer_firewall"
 
 class ccs_billing_error(ccsd_error):
@@ -1074 +1085 @@
 
 #####################################################################
+# Ethernet Customer Service
+#####################################################################
+class ethernet_customer_service(ccsd_service):
+    """Configures customers onto ethernet interfaces"""
+    
+    serviceName = "ethernet_customer"
+    allowNewProperties = True
+    networkService = False
+
+    def __init__(self, session_id, service_id):
+        # Call base class setup
+        ccsd_service.__init__(self, session_id, service_id)
+
+    @exportViaXMLRPC(SESSION_RO, AUTH_ADMINISTRATOR, True, \
+            "getEthernetCustomers")
+    def getCustomers(self):
+        """Returns a list of customers who receive ethernet services"""
+        session = getSessionE(self._session_id)
+
+        # Get the interface details
+        res = session.query("SELECT * FROM customers WHERE " \
+                "connection_method=%s", (CONNECTION_METHOD_ETHERNET))
+        return map(filter_keys, res)
+
+    @exportViaXMLRPC(SESSION_RO, AUTH_ADMINISTRATOR, True, \
+            "getCustomerInterfaces")
+    def getInterfaces(self, host_id):
+        """Returns customer details for the interfaces for the host"""
+        session = getSessionE(self._session_id)
+
+        # Get the interface details
+        res = session.query("SELECT i.*, ci.contact_id FROM " \
+                "interface i LEFT JOIN customer_interface ci ON " \
+                "i.interface_id=ci.interface_id WHERE i.host_id=%s", 
+                (host_id))
+        
+        # Loop through and collapse alias interfaces into the raw interface
+        ifaces = {}
+        tmp = []
+        for iface in res:
+            if iface["contact_id"] == "":
+                iface["contact_id"] = -1
+            if iface["interface_type"] == INTERFACE_TYPE_ALIAS:
+                tmp.append(filter_keys(iface))
+                continue
+            ifaces[iface["name"]] = filter_keys(iface)
+            ifaces[iface["name"]]["customer"] = None
+        for iface in tmp:
+            # Aliases with no associated customer are discarded
+            if iface["contact_id"] == -1: continue
+            if ifaces[iface["name"]]["customer"] is not None:
+                log_warn("Multiple customers assigned to interface %s. " \
+                        "Ignoring all but the first!" % iface["name"])
+                continue
+            ifaces[iface["name"]]["customer"] = iface
+
+        return ifaces
+
+    @exportViaXMLRPC(SESSION_RW, AUTH_ADMINISTRATOR, True)
+    def updateCustomerInterface(self, host_id, interface_id, contact_id):
+        """Updates the customer that is assigned to the interface
+        
+        interface_id should be the id for the raw_interface the customer is
+        assigned to. The actual link record will be created against an alias
+        interface linked to this raw_interface.
+        """
+        session = getSessionE(self._session_id)
+        iface = None
+        host_id = int(host_id)
+        interface_id = int(interface_id)
+        contact_id = int(contact_id)
+        for ifname, temp in self.getInterfaces(host_id).items():
+            if temp["interface_id"] == interface_id:
+                iface = temp
+                break
+        if iface is None:
+            raise ccs_billing_error("Unknown interface")
+
+        # Handle removal now
+        if int(contact_id)==-1:
+            session.begin("Removing customer from interface '%s'" % \
+                    (iface["name"]))
+            try:
+                # Remove the link
+                session.execute("DELETE FROM customer_interface WHERE " \
+                        "interface_id=%s", (iface["customer"]["interface_id"]))
+                # Remove the alias interface
+                session.execute("DELETE FROM interface WHERE interface_id=%s",
+                        (iface["customer"]["interface_id"]))
+                session.commit()
+            except:
+                session.rollback()
+                (etype, value, tb) = sys.exc_info()
+                log_error("Failed to remove customer: %s" % value, 
+                        (etype, value, tb))
+                raise ccs_billing_error("Failed to remove customer: %s" % \
+                        value)
+            return True
+
+        # Get the link to allocate IP address from
+        values = self.getPropertyValues()
+        link_id = values[ETHERNET_CUSTOMER_LINK_PROPERTY]
+        if link_id == -1:
+            raise ccs_billing_error("No IP link specified. " \
+                    "Please configure the customer ethernet service!")
+
+        # Get the firewall class to use
+        firewall_class_id = values[ETHERNET_CUSTOMER_FIREWALL_PROPERTY]
+        if firewall_class_id == -1:
+            raise ccs_billing_error("No firewall class specified. " \
+                    "Please configure the customer ethernet service!")
+                    
+        # Validate that the specified customer is allowed to go onto
+        # an ethernet interface
+        custc = ccs_customer(self._session_id)
+        cust = custc.getCustomer(contact_id)[0]
+        if cust["connection_method"] != CONNECTION_METHOD_ETHERNET:
+            raise ccs_billing_error("%s is a Wireless customer and " \
+                    "cannot be assigned to an Ethernet interface!" % \
+                    cust["username"])
+            
+        session.begin("Configured customer '%s' on interface '%s'" % \
+                (cust["username"], iface["name"]))
+        try:
+            # Create / Find an Alias interface on the specified interface
+            # for this customers real IP address
+            alias_id = -1
+            res = session.query("SELECT i.interface_id, i.ip_address " \
+                    "FROM interface i LEFT JOIN " \
+                    "customer_interface ci ON i.interface_id=" \
+                    "ci.interface_id WHERE i.host_id=%s " \
+                    "AND i.interface_type=%s AND i.raw_interface=%s",
+                    (host_id, INTERFACE_TYPE_ALIAS, interface_id))
+            if len(res) > 0:
+                link = ccs_link(self._session_id, link_id)
+                for temp in res:
+                    # Find an existing interface in the right range
+                    if not link.isValidIP(temp["ip_address"]):
+                        continue
+                    alias_id = temp["interface_id"]
+                    break
+            if alias_id == -1:
+                # Create a new alias interface
+                iface={}
+                iface["interface_type"] = INTERFACE_TYPE_ALIAS
+                iface["raw_interface"] = interface_id
+                iface["host_id"] = host_id
+                iface["link_id"] = link_id
+                iface["interface_active"] = "t"
+                iface["bridge_interface"] = ""
+                iface["alias_netmask"] = "32"
+                iface["ip_address"] = ""
+                alias_id = addInterface(self._session_id, iface)
+            
+            done = False
+            # Link to the interface
+            try:
+                session.execute("INSERT INTO customer_interface (" \
+                        "contact_id, interface_id) VALUES " \
+                        "(%s, %s)", (contact_id, alias_id))
+                # Success
+                session.commit()
+                done = True
+            except:
+                (etype, value, tb) = sys.exc_info()
+                # Assume this is because the record already exists
+                pass
+
+            # Insert failed, try update
+            if not done:
+                try:
+                    session.execute("UPDATE customer_interface SET " \
+                            "contact_id=%s WHERE interface_id=%s", 
+                            (contact_id, interface_id))
+                except:
+                    # Log the previous error
+                    log_error("Failed to insert customer interface record!", \
+                            (etype, value, tb))
+                    # Now log this error
+                    log_error("Failed to update customer interface record!", \
+                            sys.exc_info())
+
+            # Setup firewall
+            firewall = getServiceInstance(self._session_id, "firewall")
+            try:
+                firewall.addService(host_id)
+            except:
+                # Assume due to already existing...
+                pass
+            firewall.updateFirewallInterface(host_id, interface_id, \
+                    firewall_class_id)
+
+            # Make permanent and return
+            session.commit()
+            return True
+        except:
+            session.rollback()
+            (etype, value, tb) = sys.exc_info()
+            log_error("Failed to setup customer interface record!", \
+                        (etype, value, tb))
+            raise ccs_billing_error("Exception updating customer interface!")
+
+        # Somethign bad happened
+        return False
+
+    def getHostTemplateVariables(self, host_id):
+        """Returns a dictionary containing template variables for a host
+
+        See the getTemplateVariables function for more details.
+        """
+
+        # Call base class to get the basics
+        variables = ccsd_service.getHostTemplateVariables(self, host_id)
+        return variables
+
+    @staticmethod
+    def initialiseService():
+        """Called by the system the very first time the service is loaded.
+
+        This should setup an entry in the service table and load any default
+        service properties into the service_prop table.
+        """
+        session = getSessionE(ADMIN_SESSION_ID)
+        session.begin("Initialising ethernet customer service")        
+        try:
+
+            session.execute("INSERT INTO service (service_id, service_name, " \
+                    "enabled) VALUES (DEFAULT, %s, DEFAULT)", \
+                    (ethernet_customer_service.serviceName))
+            service_id = session.getCountOf("SELECT currval('" \
+                    "service_service_id_seq') AS service_id", ())
+
+            # Setup the link and firewall properties
+            session.execute("INSERT INTO service_prop (service_prop_id, " \
+                "service_id, prop_name, prop_type, default_value, required) " \
+                "VALUES (DEFAULT, %s, %s, 'integer', -1, 't')", \
+                (service_id, ETHERNET_CUSTOMER_LINK_PROPERTY))
+            session.execute("INSERT INTO service_prop (service_prop_id, " \
+                "service_id, prop_name, prop_type, default_value, required) " \
+                "VALUES (DEFAULT, %s, %s, 'integer', -1, 't')", \
+                (service_id, ETHERNET_CUSTOMER_FIREWALL_PROPERTY))
+                
+            # Commit the changese
+            session.commit()
+            
+            log_info("Created ethernet customer service entries")
+        except:
+            session.rollback()
+            log_error("Unable to initialise ethernet customer service " \
+                    "database entries!", sys.exc_info())
+            raise ccs_billing_error("Failed to setup database tables!")
+
+        return service_id
+
+#####################################################################
 # Module initialisation
 #####################################################################
 def ccs_init():
     global invoice_store, billing_template_dir, trml_path, invoice_days_to_pay
+
+    # Register the service
+    registerService(ethernet_customer_service)
 
     # Load the path where we store generated invoices