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 {