Revision: 15663
Author: vladimir.ralev
Date: Tue Dec  7 17:43:36 2010
Log: Update Issue 2191
SIP LB performance updates and tests
http://code.google.com/p/mobicents/source/detail?r=15663

Added:
/trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/SIPBalancerValveProcessor.java /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/BlackholeAppServer.java /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/performance /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/performance/Shootist.java /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/performance/UdpForwardingPerformanceTest.java
Modified:
/trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/BalancerContext.java /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/SIPBalancerForwarder.java /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/WorstCaseUdpTestAffinityAlgorithm.java /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/AppServer.java

=======================================
--- /dev/null
+++ /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/SIPBalancerValveProcessor.java Tue Dec 7 17:43:36 2010
@@ -0,0 +1,55 @@
+package org.mobicents.tools.sip.balancer;
+
+import gov.nist.javax.sip.message.SIPRequest;
+import gov.nist.javax.sip.stack.MessageChannel;
+import gov.nist.javax.sip.stack.SIPMessageValve;
+
+import javax.sip.RequestEvent;
+import javax.sip.ResponseEvent;
+import javax.sip.SipProvider;
+import javax.sip.SipStack;
+import javax.sip.message.Response;
+
+public class SIPBalancerValveProcessor implements SIPMessageValve {
+
+
+       @Override
+       public boolean processRequest(SIPRequest request,
+                       MessageChannel messageChannel) {
+               SipProvider p;
+ if(messageChannel.getPort() == BalancerContext.balancerContext.externalPort) {
+                       p = BalancerContext.balancerContext.externalSipProvider;
+               } else {
+                       p = BalancerContext.balancerContext.internalSipProvider;
+               }
+               RequestEvent event = new RequestEvent(p, null, null, request);
+               BalancerContext.balancerContext.forwarder.processRequest(event);
+               return false;
+       }
+
+       @Override
+       public boolean processResponse(Response response,
+                       MessageChannel messageChannel) {
+               SipProvider p;
+ if(messageChannel.getPort() == BalancerContext.balancerContext.externalPort) {
+                       p = BalancerContext.balancerContext.externalSipProvider;
+               } else {
+                       p = BalancerContext.balancerContext.internalSipProvider;
+               }
+               ResponseEvent event = new ResponseEvent(p, null, null, 
response);
+               
BalancerContext.balancerContext.forwarder.processResponse(event);
+               return false;
+       }
+
+       @Override
+       public void destroy() {
+               // TODO Auto-generated method stub
+
+       }
+
+       @Override
+       public void init(SipStack stack) {
+               // TODO Auto-generated method stub
+
+       }
+}
=======================================
--- /dev/null
+++ /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/BlackholeAppServer.java Tue Dec 7 17:43:36 2010
@@ -0,0 +1,143 @@
+package org.mobicents.tools.sip.balancer;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.rmi.registry.LocateRegistry;
+import java.rmi.registry.Registry;
+import java.util.ArrayList;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import javax.sip.SipProvider;
+
+public class BlackholeAppServer {
+       public ProtocolObjects protocolObjects;
+       public TestSipListener sipListener;
+       Timer timer;
+       int port;
+       String name;
+       SIPNode appServerNode;
+       public boolean sendHeartbeat = true;
+       String lbAddress;
+       int lbRMIport;
+       int lbSIPext;
+       int lbSIPint;
+       public SipProvider sipProvider;
+
+ public BlackholeAppServer(String appServer, int port, String lbAddress, int lbRMI, int lbSIPext, int lbSIPint) {
+               this.port = port;
+               this.name = appServer;
+               this.lbAddress = lbAddress;
+               this.lbRMIport = lbRMI;
+               this.lbSIPext = lbSIPext;
+               this.lbSIPint = lbSIPint;
+       }
+
+       public BlackholeAppServer(String appServer, int port) {
+               this(appServer, port, "127.0.0.1");
+
+       }
+
+       public BlackholeAppServer(String appServer, int port, String address) {
+               this(appServer, port, address, 2000, 5060, 5065);
+
+       }
+
+       public void setEventListener(EventListener listener) {
+               sipListener.eventListener = listener;
+       }
+       DatagramSocket socket;
+       public long numPacketsReceived;
+       DatagramPacket packet = new DatagramPacket(new byte[1000], 1000);
+       Thread thread;
+       public void start() {
+               timer = new Timer();
+               try {
+                       socket = new DatagramSocket(port, 
InetAddress.getByName(lbAddress));
+                       thread = new Thread() {
+                               public void run() {
+                                       try {
+                                               while(true) {
+                                                       socket.receive(packet);
+                                                       numPacketsReceived++;
+                                               }
+                                       } catch (IOException e) {
+                                               // TODO Auto-generated catch 
block
+                                               e.printStackTrace();
+                                       }
+                               }
+                       };
+                       thread.start();
+               } catch (SocketException e) {
+                       // TODO Auto-generated catch block
+                       e.printStackTrace();
+               } catch (UnknownHostException e) {
+                       // TODO Auto-generated catch block
+                       e.printStackTrace();
+               }
+               appServerNode = new SIPNode(name, "127.0.0.1");
+               appServerNode.getProperties().put("udpPort", port);
+               timer.schedule(new TimerTask() {
+
+                       @Override
+                       public void run() {
+                               ArrayList<SIPNode> nodes = new 
ArrayList<SIPNode>();
+                               nodes.add(appServerNode);
+                               sendKeepAliveToBalancers(nodes);
+                       }
+               }, 1000, 1000);
+       }
+
+       public void stop() {
+               try {
+                       thread.interrupt();
+                       thread.stop();
+               } catch (Exception e) {}
+               timer.cancel();
+               if(protocolObjects != null)
+               protocolObjects.sipStack.stop();
+               protocolObjects=null;
+               //sendCleanShutdownToBalancers();
+       }
+
+       private void sendKeepAliveToBalancers(ArrayList<SIPNode> info) {
+               if(sendHeartbeat) {
+ Thread.currentThread().setContextClassLoader(NodeRegisterRMIStub.class.getClassLoader());
+                       try {
+                               Registry registry = 
LocateRegistry.getRegistry(lbAddress, lbRMIport);
+ NodeRegisterRMIStub reg=(NodeRegisterRMIStub) registry.lookup("SIPBalancer");
+                               reg.handlePing(info);
+                       } catch (Exception e) {
+                               e.printStackTrace();
+                       }
+               }
+
+       }
+       public void sendCleanShutdownToBalancers() {
+               ArrayList<SIPNode> nodes = new ArrayList<SIPNode>();
+               nodes.add(appServerNode);
+               sendCleanShutdownToBalancers(nodes);
+       }
+
+       public void sendCleanShutdownToBalancers(ArrayList<SIPNode> info) {
+ Thread.currentThread().setContextClassLoader(NodeRegisterRMIStub.class.getClassLoader());
+               try {
+                       Registry registry = 
LocateRegistry.getRegistry(lbAddress, lbRMIport);
+ NodeRegisterRMIStub reg=(NodeRegisterRMIStub) registry.lookup("SIPBalancer");
+                       reg.forceRemoval(info);
+                       stop();
+                       Thread.sleep(2000); // delay the OK for a while
+               } catch (Exception e) {
+                       e.printStackTrace();
+               }
+       }
+
+       public TestSipListener getTestSipListener() {
+               return this.sipListener;
+       }
+
+}
=======================================
--- /dev/null
+++ /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/performance/Shootist.java Tue Dec 7 17:43:36 2010
@@ -0,0 +1,486 @@
+package org.mobicents.tools.sip.balancer.performance;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Properties;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import javax.sip.ClientTransaction;
+import javax.sip.Dialog;
+import javax.sip.DialogState;
+import javax.sip.DialogTerminatedEvent;
+import javax.sip.IOExceptionEvent;
+import javax.sip.InvalidArgumentException;
+import javax.sip.ListeningPoint;
+import javax.sip.PeerUnavailableException;
+import javax.sip.RequestEvent;
+import javax.sip.ResponseEvent;
+import javax.sip.ServerTransaction;
+import javax.sip.SipException;
+import javax.sip.SipFactory;
+import javax.sip.SipListener;
+import javax.sip.SipProvider;
+import javax.sip.SipStack;
+import javax.sip.TransactionAlreadyExistsException;
+import javax.sip.TransactionTerminatedEvent;
+import javax.sip.TransactionUnavailableException;
+import javax.sip.address.Address;
+import javax.sip.address.AddressFactory;
+import javax.sip.address.SipURI;
+import javax.sip.header.CSeqHeader;
+import javax.sip.header.CallIdHeader;
+import javax.sip.header.ContactHeader;
+import javax.sip.header.ContentTypeHeader;
+import javax.sip.header.FromHeader;
+import javax.sip.header.Header;
+import javax.sip.header.HeaderFactory;
+import javax.sip.header.MaxForwardsHeader;
+import javax.sip.header.ToHeader;
+import javax.sip.header.ViaHeader;
+import javax.sip.message.MessageFactory;
+import javax.sip.message.Request;
+import javax.sip.message.Response;
+import junit.framework.TestCase;
+import static junit.framework.TestCase.fail;
+
+public class Shootist implements SipListener {
+    private static AddressFactory addressFactory;
+
+    private static MessageFactory messageFactory;
+
+    private static HeaderFactory headerFactory;
+
+    private  SipProvider sipProvider;
+
+    private SipStack sipStack;
+
+    private ContactHeader contactHeader;
+
+    private ListeningPoint udpListeningPoint;
+
+    private ClientTransaction inviteTid;
+
+    private Dialog dialog;
+
+    private boolean byeTaskRunning;
+
+    public boolean callerSendsBye;
+
+    public Request inviteRequest;
+
+    class ByeTask  extends TimerTask {
+        Dialog dialog;
+        public ByeTask(Dialog dialog)  {
+            this.dialog = dialog;
+        }
+        public void run () {
+            try {
+               Request byeRequest = this.dialog.createRequest(Request.BYE);
+ ClientTransaction ct = sipProvider.getNewClientTransaction(byeRequest);
+               dialog.sendRequest(ct);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+                fail("Unexpected exception ");
+            }
+
+        }
+
+    }
+    public void processInvite(Request request, ServerTransaction stx) {
+       try {
+               inviteRequest = request;
+               Response response = messageFactory.createResponse(180, request);
+ contactHeader = headerFactory.createContactHeader(addressFactory.createAddress("sip:[email protected]:5033"));
+               response.addHeader(contactHeader);
+               dialog = stx.getDialog();
+               stx.sendResponse(response );
+               try {
+                               Thread.sleep(4000);
+                       } catch (InterruptedException e) {
+                               // TODO Auto-generated catch block
+                               e.printStackTrace();
+                       }
+               response = messageFactory.createResponse(200, request);
+ contactHeader = headerFactory.createContactHeader(addressFactory.createAddress("sip:[email protected]:5033"));
+               response.addHeader(contactHeader);
+               dialog = stx.getDialog();
+               stx.sendResponse(response );
+       } catch (SipException e) {
+               // TODO Auto-generated catch block
+               e.printStackTrace();
+       } catch (InvalidArgumentException e) {
+               // TODO Auto-generated catch block
+               e.printStackTrace();
+       } catch (ParseException e) {
+               // TODO Auto-generated catch block
+               e.printStackTrace();
+       }
+    }
+    public void processAck(Request request, ServerTransaction stx) {
+       new Timer().schedule(new ByeTask(dialog), 5000);
+    }
+
+    public void processRequest(RequestEvent requestReceivedEvent) {
+        Request request = requestReceivedEvent.getRequest();
+        ServerTransaction serverTransactionId = requestReceivedEvent
+                .getServerTransaction();
+        if(serverTransactionId == null) {
+               try {
+                               serverTransactionId = 
sipProvider.getNewServerTransaction(request);
+                       } catch (TransactionAlreadyExistsException e) {
+                               // TODO Auto-generated catch block
+                               e.printStackTrace();
+                       } catch (TransactionUnavailableException e) {
+                               // TODO Auto-generated catch block
+                               e.printStackTrace();
+                       }
+        }
+
+        System.out.println("\n\nRequest " + request.getMethod()
+                + " received at " + sipStack.getStackName()
+                + " with server transaction id " + serverTransactionId);
+
+        if (request.getMethod().equals(Request.INVITE)) {
+            processInvite(request, serverTransactionId);
+        } else if (request.getMethod().equals(Request.BYE)) {
+            processBye(request, serverTransactionId);
+        } else if (request.getMethod().equals(Request.ACK)) {
+            processAck(request, serverTransactionId);
+        } else {
+            try {
+ serverTransactionId.sendResponse( messageFactory.createResponse(200,request) );
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail("Unxepcted exception ");
+            }
+        }
+
+    }
+
+    public void processBye(Request request,
+            ServerTransaction serverTransactionId) {
+        try {
+            System.out.println("shootist:  got a bye .");
+            if (serverTransactionId == null) {
+                System.out.println("shootist:  null TID.");
+                return;
+            }
+            Dialog dialog = serverTransactionId.getDialog();
+            System.out.println("Dialog State = " + dialog.getState());
+ Response response = messageFactory.createResponse(200, request);
+            serverTransactionId.sendResponse(response);
+            System.out.println("shootist:  Sending OK.");
+            System.out.println("Dialog State = " + dialog.getState());
+
+        } catch (Exception ex) {
+            fail("Unexpected exception");
+
+        }
+    }
+
+       // Save the created ACK request, to respond to retransmitted 2xx
+       private Request ackRequest;
+
+    public void processResponse(ResponseEvent responseReceivedEvent) {
+        System.out.println("Got a response");
+        Response response = (Response) responseReceivedEvent.getResponse();
+ ClientTransaction tid = responseReceivedEvent.getClientTransaction();
+        CSeqHeader cseq = (CSeqHeader) response.getHeader(CSeqHeader.NAME);
+
+        System.out.println("Response received : Status Code = "
+                + response.getStatusCode() + " " + cseq);
+
+
+        if (tid == null) {
+
+            // RFC3261: MUST respond to every 2xx
+            if (ackRequest!=null && dialog!=null) {
+               System.out.println("re-sending ACK");
+               try {
+                  dialog.sendAck(ackRequest);
+               } catch (SipException se) {
+                  se.printStackTrace();
+                  fail("Unxpected exception ");
+               }
+            }
+            return;
+        }
+        // If the caller is supposed to send the bye
+        if ( callerSendsBye && !byeTaskRunning) {
+            byeTaskRunning = true;
+            new Timer().schedule(new ByeTask(dialog), 4000) ;
+        }
+        System.out.println("transaction state is " + tid.getState());
+        System.out.println("Dialog = " + tid.getDialog());
+ System.out.println("Dialog State is " + tid.getDialog().getState());
+
+ TestCase.assertSame("Checking dialog identity",tid.getDialog(), this.dialog);
+
+        try {
+            if (response.getStatusCode() == Response.OK) {
+                if (cseq.getMethod().equals(Request.INVITE)) {
+                    System.out.println("Dialog after 200 OK  " + dialog);
+ System.out.println("Dialog State after 200 OK " + dialog.getState()); + Request ackRequest = dialog.createAck(cseq.getSeqNumber());
+                    System.out.println("Sending ACK");
+                    dialog.sendAck(ackRequest);
+
+                } else if (cseq.getMethod().equals(Request.CANCEL)) {
+                    if (dialog.getState() == DialogState.CONFIRMED) {
+ // oops cancel went in too late. Need to hang up the
+                        // dialog.
+                        System.out
+ .println("Sending BYE -- cancel went in too late !!"); + Request byeRequest = dialog.createRequest(Request.BYE);
+                        ClientTransaction ct = sipProvider
+                                .getNewClientTransaction(byeRequest);
+                        dialog.sendRequest(ct);
+
+                    }
+
+                }
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+
+        }
+
+    }
+
+    public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
+
+        System.out.println("Transaction Time out");
+    }
+
+    public void sendCancel() {
+        try {
+            System.out.println("Sending cancel");
+            Request cancelRequest = inviteTid.createCancel();
+            ClientTransaction cancelTid = sipProvider
+                    .getNewClientTransaction(cancelRequest);
+            cancelTid.sendRequest();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+    }
+    boolean started = false;
+
+    String peerHostPort ="127.0.0.1:5060";
+    String transport ="udp";
+    synchronized public void start() {
+       started = true;
+        SipFactory sipFactory = null;
+        sipStack = null;
+        sipFactory = SipFactory.getInstance();
+        sipFactory.setPathName("gov.nist");
+        Properties properties = new Properties();
+ properties.setProperty("javax.sip.OUTBOUND_PROXY", peerHostPort + "/"
+                + transport);
+        // If you want to use UDP then uncomment this.
+        properties.setProperty("javax.sip.STACK_NAME", "shootist");
+ properties.setProperty("gov.nist.javax.sip.REENTRANT_LISTENER", "true");
+
+        // The following properties are specific to nist-sip
+        // and are not necessarily part of any other jain-sip
+        // implementation.
+        // You can set a max message size for tcp transport to
+        // guard against denial of service attack.
+        properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
+                "shootistdebug.txt");
+        properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
+                "shootistlog.txt");
+
+ // Drop the client connection after we are done with the transaction. + properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS",
+                "false");
+        // Set to 0 (or NONE) in your production code for max speed.
+ // You need 16 (or TRACE) for logging traces. 32 (or DEBUG) for debug + traces.
+        // Your code will limp at 32 but it is best for debugging.
+        properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "DEBUG");
+
+        try {
+            // Create SipStack object
+            sipStack = sipFactory.createSipStack(properties);
+            headerFactory = sipFactory.createHeaderFactory();
+            addressFactory = sipFactory.createAddressFactory();
+            messageFactory = sipFactory.createMessageFactory();
+            System.out.println("createSipStack " + sipStack);
+        } catch (PeerUnavailableException e) {
+            // could not find
+            // gov.nist.jain.protocol.ip.sip.SipStackImpl
+            // in the classpath
+            e.printStackTrace();
+            System.err.println(e.getMessage());
+            System.exit(0);
+        }
+
+        try {
+            headerFactory = sipFactory.createHeaderFactory();
+            addressFactory = sipFactory.createAddressFactory();
+            messageFactory = sipFactory.createMessageFactory();
+ udpListeningPoint = sipStack.createListeningPoint("127.0.0.1", 5033, transport);
+            sipProvider = sipStack.createSipProvider(udpListeningPoint);
+            Shootist listener = this;
+            sipProvider.addSipListener(listener);
+            sipStack.start();
+        } catch(Exception e) {
+               e.printStackTrace();
+        }
+
+    }
+
+    public void sendInitialInvite() {
+       try{
+               if(!started) start();
+               String fromName = "BigGuy";
+               String fromSipAddress = "here.com";
+               String fromDisplayName = "The Master Blaster";
+
+               String toSipAddress = "there.com";
+               String toUser = "LittleGuy";
+            String toDisplayName = "The Little Blister";
+
+            // create >From Header
+            SipURI fromAddress = addressFactory.createSipURI(fromName,
+                    fromSipAddress);
+
+ Address fromNameAddress = addressFactory.createAddress(fromAddress);
+            fromNameAddress.setDisplayName(fromDisplayName);
+            FromHeader fromHeader = headerFactory.createFromHeader(
+                    fromNameAddress, "12345");
+
+            // create To Header
+            SipURI toAddress = addressFactory
+                    .createSipURI(toUser, toSipAddress);
+ Address toNameAddress = addressFactory.createAddress(toAddress);
+            toNameAddress.setDisplayName(toDisplayName);
+            ToHeader toHeader = headerFactory.createToHeader(toNameAddress,
+                    null);
+
+            // create Request URI
+            SipURI requestURI = addressFactory.createSipURI(toUser,
+                    peerHostPort);
+
+            // Create ViaHeaders
+
+            ArrayList viaHeaders = new ArrayList();
+            String ipAddress = udpListeningPoint.getIPAddress();
+            ViaHeader viaHeader = headerFactory.createViaHeader(ipAddress,
+                    sipProvider.getListeningPoint(transport).getPort(),
+                    transport, null);
+
+            // add via headers
+            viaHeaders.add(viaHeader);
+
+            // Create ContentTypeHeader
+            ContentTypeHeader contentTypeHeader = headerFactory
+                    .createContentTypeHeader("application", "sdp");
+
+            // Create a new CallId header
+            CallIdHeader callIdHeader = sipProvider.getNewCallId();
+
+            // Create a new Cseq header
+            CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L,
+                    Request.INVITE);
+
+            // Create a new MaxForwardsHeader
+            MaxForwardsHeader maxForwards = headerFactory
+                    .createMaxForwardsHeader(70);
+
+            // Create the request.
+            Request request = messageFactory.createRequest(requestURI,
+                    Request.INVITE, callIdHeader, cSeqHeader, fromHeader,
+                    toHeader, viaHeaders, maxForwards);
+            // Create contact headers
+            String host = "127.0.0.1";
+
+ SipURI contactUrl = addressFactory.createSipURI(fromName, host);
+            contactUrl.setPort(udpListeningPoint.getPort());
+            contactUrl.setLrParam();
+
+            // Create the contact name address.
+ SipURI contactURI = addressFactory.createSipURI(fromName, host);
+            contactURI.setPort(sipProvider.getListeningPoint(transport)
+                    .getPort());
+
+ Address contactAddress = addressFactory.createAddress(contactURI);
+
+            // Add the contact address.
+            contactAddress.setDisplayName(fromName);
+
+ contactHeader = headerFactory.createContactHeader(contactAddress);
+            request.addHeader(contactHeader);
+
+            // You can add extension headers of your own making
+            // to the outgoing SIP request.
+            // Add the extension header.
+ Header extensionHeader = headerFactory.createHeader("My-Header",
+                    "my header value");
+            request.addHeader(extensionHeader);
+
+            String sdpData = "v=0\r\n"
+                    + "o=4855 13760799956958020 13760799956958020"
+ + " IN IP4 129.6.55.78\r\n" + "s=mysession session\r\n"
+                    + "p=+46 8 52018010\r\n" + "c=IN IP4  129.6.55.78\r\n"
+                    + "t=0 0\r\n" + "m=audio 6022 RTP/AVP 0 4 18\r\n"
+ + "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:4 G723/8000\r\n"
+                    + "a=rtpmap:18 G729A/8000\r\n" + "a=ptime:20\r\n";
+            byte[] contents = sdpData.getBytes();
+
+            request.setContent(contents, contentTypeHeader);
+            // You can add as many extension headers as you
+            // want.
+
+            extensionHeader = headerFactory.createHeader("My-Other-Header",
+                    "my new header value ");
+            request.addHeader(extensionHeader);
+
+            Header callInfoHeader = headerFactory.createHeader("Call-Info",
+                    "<http://www.antd.nist.gov>");
+            request.addHeader(callInfoHeader);
+
+            // Create the client transaction.
+            inviteTid = sipProvider.getNewClientTransaction(request);
+
+            // send the request out.
+            inviteTid.sendRequest();
+
+            dialog = inviteTid.getDialog();
+
+        } catch (Exception ex) {
+            System.out.println(ex.getMessage());
+            ex.printStackTrace();
+            fail("Unxpected exception ");
+        }
+    }
+
+
+
+    public void processIOException(IOExceptionEvent exceptionEvent) {
+        System.out.println("IOException happened for "
+                + exceptionEvent.getHost() + " port = "
+                + exceptionEvent.getPort());
+
+    }
+
+    public void processTransactionTerminated(
+            TransactionTerminatedEvent transactionTerminatedEvent) {
+
+ System.out.println("Transaction terminated event recieved " + transactionTerminatedEvent.getClientTransaction().getRequest());
+        throw new RuntimeException();
+    }
+
+    public void processDialogTerminated(
+            DialogTerminatedEvent dialogTerminatedEvent) {
+        System.out.println("dialogTerminatedEvent");
+
+    }
+
+    public void stop() {
+
+       if(sipStack != null)
+        this.sipStack.stop();
+       started = false;
+    }
+}
=======================================
--- /dev/null
+++ /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/performance/UdpForwardingPerformanceTest.java Tue Dec 7 17:43:36 2010
@@ -0,0 +1,180 @@
+package org.mobicents.tools.sip.balancer.performance;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Properties;
+
+import junit.framework.TestCase;
+
+import org.mobicents.tools.sip.balancer.AppServer;
+import org.mobicents.tools.sip.balancer.BalancerRunner;
+import org.mobicents.tools.sip.balancer.BlackholeAppServer;
+import org.mobicents.tools.sip.balancer.operation.Shootist;
+
+public class UdpForwardingPerformanceTest extends TestCase {
+ static final String inviteRequest = "INVITE sip:[email protected] SIP/2.0\r\n"+
+       "To: sip:[email protected]\r\n"+
+       "From: sip:[email protected] ;tag=1234\r\n"+
+       "Call-ID: [email protected]\r\n"+
+       "CSeq: 9 INVITE\r\n"+
+       "Via: SIP/2.0/UDP 135.180.130.133\r\n"+
+       "Content-Type: application/sdp\r\n"+
+       "\r\n"+
+       "v=0\r\n"+
+       "o=mhandley 29739 7272939 IN IP4 126.5.4.3\r\n" +
+       "c=IN IP4 135.180.130.88\r\n" +
+       "m=video 3227 RTP/AVP 31\r\n" +
+       "m=audio 4921 RTP/AVP 12\r\n" +
+       "a=rtpmap:31 LPC\r\n";
+
+       static byte[] inviteRequestBytes = inviteRequest.getBytes();
+
+ static final String ringing = "SIP/2.0 180 Ringing\n" + "To: <sip:[email protected]>;tag=5432\n" + + "Via: SIP/2.0/UDP 127.0.0.1:5065;branch=z9hG4bK-3530-488ff2840f609639903eff914df9870f202e2zsd,SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-3530-488ff2840f609639903eff914df9870f202e2,SIP/2.0/UDP 127.0.0.1:5033;branch=z9hG4bK-3530-488ff2840f609639903eff914df9870f\n"+ + "Record-Route: <sip:127.0.0.1:5065;transport=udp;lr>,<sip:127.0.0.1:5060;transport=udp;lr>\n"+
+       "CSeq: 1 INVITE\n"+
+       "Call-ID: [email protected]\n"+
+       "From: <sip:[email protected]>;tag=12345\n"+
+       "Content-Length: 0\n";
+
+       static byte[] ringingBytes = ringing.getBytes();
+
+       BalancerRunner balancer;
+       int numNodes = 2;
+       BlackholeAppServer server;
+       Shootist shootist;
+
+
+       /* (non-Javadoc)
+        * @see junit.framework.TestCase#setUp()
+        */
+       protected void setUp() throws Exception {
+               super.setUp();
+               shootist = new Shootist();
+
+               balancer = new BalancerRunner();
+               Properties properties = new Properties();
+               properties.setProperty("javax.sip.STACK_NAME", 
"SipBalancerForwarder");
+               properties.setProperty("javax.sip.AUTOMATIC_DIALOG_SUPPORT", 
"off");
+               // You need 16 for logging traces. 32 for debug + traces.
+               // Your code will limp at 32 but it is best for debugging.
+               properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "0");
+               properties.setProperty("gov.nist.javax.sip.DEBUG_LOG",
+                               "logs/sipbalancerforwarderdebug.txt");
+               properties.setProperty("gov.nist.javax.sip.SERVER_LOG",
+                               "logs/sipbalancerforwarder.xml");
+               properties.setProperty("gov.nist.javax.sip.THREAD_POOL_SIZE", 
"100");
+               properties.setProperty("gov.nist.javax.sip.REENTRANT_LISTENER", 
"true");
+ properties.setProperty("gov.nist.javax.sip.CANCEL_CLIENT_TRANSACTION_CHECKED", "false");
+
+               properties.setProperty("host", "127.0.0.1");
+               properties.setProperty("externalHost", "127.0.0.1");
+               properties.setProperty("internalHost", "127.0.0.1");
+               properties.setProperty("internalPort", "5065");
+               properties.setProperty("externalPort", "5060");
+               balancer.start(properties);
+
+
+               server = new BlackholeAppServer("blackhole", 18452, 
"127.0.0.1");
+               server.start();
+               Thread.sleep(5000);
+
+       }
+       static InetAddress localhost;
+       static int callIdByteStart = -1;
+       static {try {
+               localhost = InetAddress.getByName("127.0.0.1");
+               byte[] callid = "0ha0isn".getBytes();
+               for(int q=0;q<1000; q++) {
+                       int found = -1;;
+                       for(int w=0;w<callid.length;w++) {
+                               if(callid[w] != inviteRequestBytes[q+w]) {
+                                       break;
+                               }
+                               found = w;
+                       }
+                       if(found >0) {callIdByteStart = q; break;}
+               }
+       } catch (UnknownHostException e) {
+               // TODO Auto-generated catch block
+               e.printStackTrace();
+       }}
+       private static long n = 0;
+       private static void modCallId() {
+               n++;
+               inviteRequestBytes[callIdByteStart] = (byte) (n&0xff);
+               inviteRequestBytes[callIdByteStart+1] = (byte) ((n>>8)&0xff);
+               inviteRequestBytes[callIdByteStart+2] = (byte) ((n>>16)&0xff);
+       }
+
+       public void testInvitePerformanceLong() {
+               testMessagePerformance(1*60*1000, 10, inviteRequestBytes);
+       }
+
+       public void testInvitePerformance10sec() {
+               testMessagePerformance(10*1000, 100, inviteRequestBytes);
+       }
+
+       public void testInvitePerformanceDiffCallId10sec() {
+               testDiffCallIdPerformance(10*1000, 100);
+       }
+
+       public void testRingingPerformance10sec() {
+               testMessagePerformance(10*1000, 100, ringingBytes);
+       }
+
+ private void testMessagePerformance(int timespan, int maxLostPackets, byte[] bytes) {
+               try {
+                       DatagramSocket socket = new DatagramSocket(33276, 
localhost);
+                       long sentPackets = 0;
+                       long startTime = System.currentTimeMillis();
+                       while(true) {
+ boolean diffNotTooBig = sentPackets - server.numPacketsReceived<maxLostPackets; + boolean thereIsStillTime = System.currentTimeMillis()-startTime<timespan;
+                               if(!thereIsStillTime) {
+                                       break;
+                               }
+                               if(diffNotTooBig) {
+                                       socket.send(new 
DatagramPacket(bytes,bytes.length,localhost, 5060));
+                                       sentPackets++;
+                               } else {
+                                       //Thread.sleep(1);
+                               }
+                       }
+ System.out.println("Packets sent in " + timespan + " ms are " + sentPackets + "(making " + sentPackets/((double)(timespan)/1000.) + " initial requests per second)");
+               } catch (Exception e) {
+                       // TODO Auto-generated catch block
+                       e.printStackTrace();
+               }
+       }
+
+       private void testDiffCallIdPerformance(int timespan, int 
maxLostPackets) {
+               try {
+                       DatagramSocket socket = new DatagramSocket(33276, 
localhost);
+                       long sentPackets = 0;
+                       long startTime = System.currentTimeMillis();
+                       while(true) {
+ boolean diffNotTooBig = sentPackets - server.numPacketsReceived<maxLostPackets; + boolean thereIsStillTime = System.currentTimeMillis()-startTime<timespan;
+                               if(!thereIsStillTime) {
+                                       break;
+                               }
+                               if(diffNotTooBig) {
+ socket.send(new DatagramPacket(inviteRequestBytes,inviteRequestBytes.length,localhost, 5060));
+                                       modCallId();
+                                       sentPackets++;
+                               } else {
+                                       Thread.sleep(1);
+                               }
+                       }
+ System.out.println("Packets sent in " + timespan + " ms are " + sentPackets + "(making " + sentPackets/((double)(timespan)/1000.) + " initial requests per second)");
+               } catch (Exception e) {
+                       // TODO Auto-generated catch block
+                       e.printStackTrace();
+               }
+       }
+}
=======================================
--- /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/BalancerContext.java Sun Mar 14 13:12:13 2010 +++ /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/BalancerContext.java Tue Dec 7 17:43:36 2010
@@ -18,6 +18,8 @@
        public ConcurrentHashMap<String, SIPNode> jvmRouteToSipNode;

        public Object parameters;
+
+       SIPBalancerForwarder forwarder;

        public SipProvider externalSipProvider;
        public SipProvider internalSipProvider;
=======================================
--- /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/SIPBalancerForwarder.java Tue Nov 30 11:39:49 2010 +++ /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/SIPBalancerForwarder.java Tue Dec 7 17:43:36 2010
@@ -100,6 +100,7 @@

public SIPBalancerForwarder(Properties properties, NodeRegister register) throws IllegalStateException{
                super();
+               BalancerContext.balancerContext.forwarder = this;
                BalancerContext.balancerContext.properties = properties;
                this.register = register;
        }
@@ -154,6 +155,8 @@
             // Create SipStack object
                sipFactory = SipFactory.getInstance();
                sipFactory.setPathName("gov.nist");
+ BalancerContext.balancerContext.properties.setProperty("gov.nist.javax.sip.SIP_MESSAGE_VALVE", SIPBalancerValveProcessor.class.getName());
+
BalancerContext.balancerContext.sipStack = sipFactory.createSipStack(BalancerContext.balancerContext.properties);

         } catch (PeerUnavailableException pue) {
=======================================
--- /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/WorstCaseUdpTestAffinityAlgorithm.java Thu Nov 18 23:50:44 2010 +++ /trunk/tools/sip-balancer/jar/src/main/java/org/mobicents/tools/sip/balancer/WorstCaseUdpTestAffinityAlgorithm.java Tue Dec 7 17:43:36 2010
@@ -16,6 +16,7 @@

 import javax.sip.address.SipURI;
 import javax.sip.header.RouteHeader;
+import javax.sip.header.ViaHeader;
 import javax.sip.message.Request;
 import javax.sip.message.Response;

@@ -26,8 +27,20 @@
  *
  */
public class WorstCaseUdpTestAffinityAlgorithm extends DefaultBalancerAlgorithm { + protected ConcurrentHashMap<String, SIPNode> txToNode = new ConcurrentHashMap<String, SIPNode>(); + protected ConcurrentHashMap<String, Long> txTimestamps = new ConcurrentHashMap<String, Long>();
+       public synchronized SIPNode getNode(String tx) {
+               return txToNode.get(tx);
+       }
+       public synchronized void setNode(String tx, SIPNode node) {
+               txToNode.put(tx, node);
+               txTimestamps.put(tx, System.currentTimeMillis());
+       }
        public SIPNode processAssignedExternalRequest(Request request,
                        SIPNode assignedNode) {
+               String tx = 
((ViaHeader)request.getHeader(Via.NAME)).getBranch();
+               SIPNode seenNode = getNode(tx);
+               if(seenNode != null) return seenNode;
                if(request.getMethod().contains("ACK")) return assignedNode;
                RouteHeader route = (RouteHeader) 
request.getHeader(RouteHeader.NAME);
                SipURI uri = null;
@@ -45,8 +58,10 @@
                                        String callId = ((SIPHeader) 
request.getHeader(headerName))
                                        .getValue();
                                        callIdMap.put(callId, node);
+                                       setNode(tx, node);

                                        // For 
http://code.google.com/p/mobicents/issues/detail?id=2132
+
                                        if(request.getRequestURI().isSipURI()) {
                                                SipURI ruri = (SipURI) 
request.getRequestURI();
                                                String rurihostid = 
ruri.getHost() + ruri.getPort();
@@ -235,6 +250,25 @@
                                                }
                                                if(oldCalls.size()>0) {
logger.info("Reaping idle calls... Evicted " + oldCalls.size() + " calls.");
+                                               }
+
+                                               // tx
+
+                                               oldCalls = new 
ArrayList<String>();
+                                               keys = 
txTimestamps.keySet().iterator();
+                                               while(keys.hasNext()) {
+                                                       String key = 
keys.next();
+                                                       long time = 
txTimestamps.get(key);
+                                                       
if(System.currentTimeMillis() - time > 1000*maxCallIdleTime) {
+                                                               
oldCalls.add(key);
+                                                       }
+                                               }
+                                               for(String key : oldCalls) {
+                                                       txToNode.remove(key);
+                                                       
txTimestamps.remove(key);
+                                               }
+                                               if(oldCalls.size()>0) {
+ logger.info("Reaping idle transactions... Evicted " + oldCalls.size() + " calls.");
                                                }}
                                } catch (Exception e) {
logger.log(Level.WARNING, "Failed to clean up old calls. If you continue to se this message frequestly and the memory is growing, report this problem.", e);
=======================================
--- /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/AppServer.java Mon Nov 15 14:36:51 2010 +++ /trunk/tools/sip-balancer/jar/src/test/java/org/mobicents/tools/sip/balancer/AppServer.java Tue Dec 7 17:43:36 2010
@@ -48,7 +48,7 @@
        public void start() {
                timer = new Timer();
                protocolObjects = new ProtocolObjects(name,
-                               "gov.nist", "UDP", true, null);
+                               "gov.nist", "UDP", false, null);
sipListener = new TestSipListener(port, lbSIPint, protocolObjects, false);
                sipListener.appServer = this;
                try {

Reply via email to