DiameterPeer.java

Go to the documentation of this file.

/*
 * $Id: DiameterPeer.java 585 2008-10-02 19:11:46Z vingarzan $
 * 
 * Copyright (C) 2004-2006 FhG Fokus
 *
 * This file is part of Open IMS Core - an open source IMS CSCFs & HSS
 * implementation
 *
 * Open IMS Core is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * For a license to use the Open IMS Core software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact Fraunhofer FOKUS by e-mail at the following
 * addresses:
 *     info@open-ims.org
 *
 * Open IMS Core is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

package de.fhg.fokus.diameter.DiameterPeer;


import java.io.IOException;
import java.io.StringReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.Vector;
import java.util.concurrent.ArrayBlockingQueue;


import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import de.fhg.fokus.diameter.DiameterPeer.data.AVP;
import de.fhg.fokus.diameter.DiameterPeer.data.DiameterMessage;
import de.fhg.fokus.diameter.DiameterPeer.data.DiameterTask;
import de.fhg.fokus.diameter.DiameterPeer.peer.Application;
import de.fhg.fokus.diameter.DiameterPeer.peer.Peer;
import de.fhg.fokus.diameter.DiameterPeer.peer.PeerManager;
import de.fhg.fokus.diameter.DiameterPeer.peer.StateMachine;
import de.fhg.fokus.diameter.DiameterPeer.routing.RoutingEngine;
import de.fhg.fokus.diameter.DiameterPeer.transaction.TransactionListener;
import de.fhg.fokus.diameter.DiameterPeer.transaction.TransactionWorker;
import de.fhg.fokus.diameter.DiameterPeer.transport.Acceptor;
public class DiameterPeer {
    
    private static final Logger LOGGER = Logger.getLogger(DiameterPeer.class);
    
    public String FQDN;
    
    public String Realm;
    
    public int Vendor_Id;
    
    public String Product_Name;
    
    public int Tc;
    
    public Vector<Acceptor> acceptors;
    
    public boolean AcceptUnknownPeers;

    public boolean DropUnknownOnDisconnect;

    public Vector<Application> AuthApp,AcctApp;
    
    public RoutingEngine routingTable=null;
    
    public PeerManager peerManager;
        
    public Vector<EventListener> eventListeners;
    
    public int queueLength;
    
    public ArrayBlockingQueue<DiameterTask> queueTasks;
    
    private DiameterWorker workers[]; 
    
    public int workerCount=1;

    private TransactionWorker transactionWorker=null;
    
    Document config;    
    
    public int hopbyhop_id=0;

    public int endtoend_id=0;
    
    public synchronized int getNextHopByHopId()
    {
        return ++hopbyhop_id;
    }
    public synchronized int getNextEndToEndId()
    {
        return ++endtoend_id;
    }
    
    public DiameterPeer()
    {
        LOGGER.info("Bean style constructor called, don't forget to configure!");
    }
    
    public DiameterPeer(String xml)
    {
        configure(xml,false);
    }
    
    public void configure(String xml, boolean isFile)
    {
        Acceptor acc;
        NodeList nl;
        Node n,nv;
        int port,app_id,vendor_id;
        InetAddress addr;
        String fqdn,realm;
        Application app;
        
        eventListeners = new Vector<EventListener>();
        
        java.util.Random rand = new java.util.Random();
        hopbyhop_id = rand.nextInt();
        endtoend_id = ((int) (System.currentTimeMillis()&0xFFF))<<20;
        endtoend_id |= rand.nextInt() & 0xFFFFF;
    
        if (isFile){
            /* parse the config */
            if (!readConfigFile(xml)) {
                LOGGER.error("DiameterPeer: Error parsing config file");
                return;
            }
        }
        else {
            /* parse the config */
            if (!readConfigString(xml)) {
                LOGGER.error("DiameterPeer: Error parsing config String");
                return;
            }
        }
        
        FQDN = config.getDocumentElement().getAttribute("FQDN");
        LOGGER.info("FQDN: " + config.getDocumentElement().getAttribute("FQDN"));
        Realm = config.getDocumentElement().getAttribute("Realm");
        LOGGER.info("Realm: " + config.getDocumentElement().getAttribute("Realm"));
        Vendor_Id = Integer.parseInt(config.getDocumentElement().getAttribute("Vendor_Id"));
        LOGGER.info("Vendor_ID : " + Integer.parseInt(config.getDocumentElement().getAttribute("Vendor_Id")));
        Product_Name = config.getDocumentElement().getAttribute("Product_Name");
        LOGGER.info("Product Name: " + config.getDocumentElement().getAttribute("Product_Name"));
        AcceptUnknownPeers = Integer.parseInt(config.getDocumentElement().getAttribute("AcceptUnknownPeers"))!=0;
        LOGGER.info("AcceptUnknwonPeers: " + AcceptUnknownPeers);
        DropUnknownOnDisconnect = Integer.parseInt(config.getDocumentElement().getAttribute("DropUnknownOnDisconnect"))!=0;
        LOGGER.info("DropUnknownOnDisconnect: " + DropUnknownOnDisconnect);
        
        Tc = Integer.parseInt(config.getDocumentElement().getAttribute("Tc"));
        workerCount = Integer.parseInt(config.getDocumentElement().getAttribute("Workers"));
        queueLength = Integer.parseInt(config.getDocumentElement().getAttribute("QueueLength"));
        
        queueTasks = new ArrayBlockingQueue<DiameterTask>(queueLength,true);
        
        startWorkers();
        
        /* Read Supported Application ids */
        this.AuthApp = new Vector<Application>();
        this.AcctApp = new Vector<Application>();
        nl = config.getDocumentElement().getElementsByTagName("Auth");
        for(int i=0;i<nl.getLength();i++){
            n = nl.item(i);
            app_id = 0;
            app_id = Integer.parseInt(n.getAttributes().getNamedItem("id").getNodeValue());
            vendor_id=0;
            if (n.getAttributes().getNamedItem("vendor")!=null)
                vendor_id = Integer.parseInt(n.getAttributes().getNamedItem("vendor").getNodeValue());
            
            app = new Application(app_id,vendor_id,Application.Auth);
            this.AuthApp.add(app);
        }
        nl = config.getDocumentElement().getElementsByTagName("Acct");
        for(int i=0;i<nl.getLength();i++){
            n = nl.item(i);
            app_id = 0;
            app_id = Integer.parseInt(n.getAttributes().getNamedItem("id").getNodeValue());
            vendor_id=0;
            if (n.getAttributes().getNamedItem("vendor")!=null)
                vendor_id = Integer.parseInt(n.getAttributes().getNamedItem("vendor").getNodeValue());
            
            app = new Application(app_id,vendor_id,Application.Acct);
            this.AcctApp.add(app);
        }
        /* Initialize the Peer Manager */
        peerManager = new PeerManager(this);
        
        /* Read the peers from the configuration file */
        nl = config.getDocumentElement().getElementsByTagName("Peer");
        for(int i=0;i<nl.getLength();i++){
            n = nl.item(i);
 
            fqdn = n.getAttributes().getNamedItem("FQDN").getNodeValue();
            
            realm = n.getAttributes().getNamedItem("Realm").getNodeValue(); 
            
            port = 3868;
            nv = n.getAttributes().getNamedItem("port");
            if (nv==null) port = 3868;
            else port = Integer.parseInt(nv.getNodeValue());
                
            peerManager.configurePeer(fqdn,realm,port);
        }
        
        /* Create & start connection acceptors */
        acceptors = new Vector<Acceptor>();
        nl = config.getDocumentElement().getElementsByTagName("Acceptor");
        for(int i=0;i<nl.getLength();i++){
            n = nl.item(i);
            
            port = 3868;
            nv = n.getAttributes().getNamedItem("port");
            if (nv==null) port = 3868;
            else port = Integer.parseInt(nv.getNodeValue());
            
            addr = null;
            nv = n.getAttributes().getNamedItem("bind");
            if (nv !=null && nv.getNodeValue().length()!=0  )               
                try {
                    addr = InetAddress.getByName(nv.getNodeValue());
                } catch (UnknownHostException e) {
                    LOGGER.error("DiameterPeer: Can not resolve "+nv.getNodeValue());
                    e.printStackTrace();
                    continue;
                } 
            acc = new Acceptor(port,addr,this);
            acc.startAccepting();
            acceptors.add(acc);
        }
        
        initRoutingTable(config);

        peerManager.start();
        
    }
    
    private boolean readConfigFile(String cfgFile)
    {
        DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();
        //factory.setValidating(true);   
        //factory.setNamespaceAware(true);
        try {
           DocumentBuilder builder = factory.newDocumentBuilder();
           config = builder.parse( cfgFile );
        } catch (SAXException sxe) {
           // Error generated during parsing)
           Exception  x = sxe;
           if (sxe.getException() != null)
               x = sxe.getException();
           x.printStackTrace();
           return false;
        } catch (ParserConfigurationException pce) {
            // Parser with specified options can't be built
            pce.printStackTrace();
            return false;
        } catch (IOException ioe) {
           // I/O error
           ioe.printStackTrace();
           return false;
        }
        return true;
    }
    
    private boolean readConfigString(String cfgString)
    {
        DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();
        //factory.setValidating(true);   
        //factory.setNamespaceAware(true);
        try {
           DocumentBuilder builder = factory.newDocumentBuilder();
           config = builder.parse( new InputSource(new StringReader(cfgString)) );
        } catch (SAXException sxe) {
           // Error generated during parsing)
           Exception  x = sxe;
           if (sxe.getException() != null)
               x = sxe.getException();
           x.printStackTrace();
           return false;
        } catch (ParserConfigurationException pce) {
            // Parser with specified options can't be built
            pce.printStackTrace();
            return false;
        } catch (IOException ioe) {
           // I/O error
           ioe.printStackTrace();
           return false;
        }
        return true;
    }
    
    /* configure routing table */
    private void initRoutingTable(Document config) {        
        NodeList nl, nlc;
        String fqdn,realm;
        int metric;
        
        this.routingTable = new RoutingEngine();
        nl = config.getDocumentElement().getElementsByTagName("DefaultRoute");
        for(int i=0;i<nl.getLength();i++){
            fqdn = nl.item(i).getAttributes().getNamedItem("FQDN").getNodeValue();
            metric = Integer.valueOf(nl.item(i).getAttributes().getNamedItem("metric").getNodeValue());
            routingTable.addDefaultRoute(fqdn, metric);
        }
        nl = config.getDocumentElement().getElementsByTagName("Realm");
        for(int i=0;i<nl.getLength();i++){
            realm = nl.item(i).getAttributes().getNamedItem("name").getNodeValue();
            nlc = nl.item(i).getChildNodes();
            for(int j=0;j<nlc.getLength();j++)
                if (nlc.item(j).getNodeName().equalsIgnoreCase("Route")){
                    fqdn = nlc.item(j).getAttributes().getNamedItem("FQDN").getNodeValue();
                    metric = Integer.valueOf(nlc.item(j).getAttributes().getNamedItem("metric").getNodeValue());
                    routingTable.addRealmRoute(realm, fqdn, metric);
                }
        }
         
    }
        
    
    private void startWorkers()
    {
        workers = new DiameterWorker[workerCount];
        for(int i=0;i<workerCount;i++)
            workers[i] = new DiameterWorker(i,this.queueTasks);
    }
    
    public void enableTransactions(long timeout,long checkInterval)
    {
        if (this.transactionWorker == null)
            this.transactionWorker = new TransactionWorker(this,timeout,checkInterval);
    }
    
    
    
    public DiameterMessage newRequest(int command_code, int application_id)
    {
        return newRequest(command_code, true, application_id);
    }
    
    
    
    public DiameterMessage newRequest(int command_code, boolean Proxiable, 
            int application_id)
    {
        DiameterMessage msg = new DiameterMessage(command_code, 
                                                  true, 
                                                  Proxiable, 
                                                  application_id, 
                                                  this.getNextHopByHopId(), 
                                                  this.getNextEndToEndId());
        AVP avp;
        
        avp = new AVP(AVP.Origin_Host,true,0);
        avp.setData(this.FQDN);
        msg.addAVP(avp);
        
        avp = new AVP(AVP.Origin_Realm,true,0);
        avp.setData(this.Realm);
        msg.addAVP(avp);

        return msg;
    }
    
    
    
    public DiameterMessage newResponse(DiameterMessage request)
    {
        DiameterMessage msg = new DiameterMessage(request.commandCode,false,request.applicationID);
        AVP avp;
        
        msg.endToEndID = request.endToEndID;
        msg.hopByHopID = request.hopByHopID;
        
        if (request.getSessionId() != null) {
            avp = request.getSessionId();
            msg.addAVP(avp);
        }
        
        avp = new AVP(AVP.Origin_Host,true,0);
        avp.setData(this.FQDN);
        msg.addAVP(avp);
        
        avp = new AVP(AVP.Origin_Realm,true,0);
        avp.setData(this.Realm);
        msg.addAVP(avp);
        
        
        return msg;
    }
    
    public boolean sendMessage(String peerFQDN,DiameterMessage msg)
    {
        Peer p;
        p = peerManager.getPeerByFQDN(peerFQDN);
        if (p==null){
            LOGGER.error("DiameterPeer: Peer "+peerFQDN+" not found in peer list.");
            return false;
        }
        if (p.state!=StateMachine.I_Open &&
            p.state!=StateMachine.R_Open){
            LOGGER.error("DiameterPeer: Peer "+peerFQDN+" not connected.");
            return false;
        }
        return p.sendMessage(msg);
    }

    public boolean sendMessage(DiameterMessage msg)
    {
        Peer p;
        if (routingTable==null){
            LOGGER.error("DiameterPeer: RoutingTable not initialized!");
            return false;
        }
        p = routingTable.getRoute(msg,peerManager);
        if (p==null){
            LOGGER.error("DiameterPeer: No suitable peer to route to could be found.");
            return false;
        }
        return p.sendMessage(msg);
    }

    public boolean sendRequestTransactional(String peerFQDN,DiameterMessage req,TransactionListener tl)
    {
        if (this.transactionWorker!=null) return transactionWorker.sendRequestTransactional(peerFQDN,req,tl);
        else {
            LOGGER.error("DiameterPeer:sendRequestTransactional(): Transactions are not enabled on this peer!");
            return false;
        }
    }

    public boolean sendRequestTransactional(DiameterMessage req,TransactionListener tl)
    {
        if (this.transactionWorker!=null) return transactionWorker.sendRequestTransactional(req,tl);
        else {
            LOGGER.error("DiameterPeer:sendRequestTransactional(): Transactions are not enabled on this peer!");
            return false;
        }
    }
    
    public DiameterMessage sendRequestBlocking(String peerFQDN,DiameterMessage req)
    {
        if (this.transactionWorker!=null) return transactionWorker.sendRequestBlocking(peerFQDN,req);
        else {
            LOGGER.error("DiameterPeer:sendRequestBlocking(): Transactions are not enabled on this peer!");
            return null;
        }
    }

    public DiameterMessage sendRequestBlocking(DiameterMessage req)
    {
        if (this.transactionWorker!=null) return transactionWorker.sendRequestBlocking(req);
        else {
            LOGGER.error("DiameterPeer:sendRequestBlocking(): Transactions are not enabled on this peer!");
            return null;
        }
    }
    

    public void addEventListener(EventListener l)
    {
        eventListeners.add(l);
    }
    
    
    public void removeEventListener(EventListener l)
    {
        eventListeners.remove(l);
    }
    
    public void shutdown()
    {
        Acceptor acc;
        Iterator<Acceptor> i = acceptors.iterator();
        while(i.hasNext()){
            acc = i.next();
            acc.stopAccepting();
        }
        peerManager.shutdown();
        for(int j=0;j<workerCount;j++)
            workers[j].shutdown();
        if (transactionWorker!=null) transactionWorker.shutdown();
    }
}

---