Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package test.unit.gov.nist.javax.sip.stack;
  
  
  
  import javax.sip.Dialog;
 
 import  junit.framework.TestCase;
 
 public class TransactionAlreadyExistsExceptionTest extends TestCase {
     public class Shootme implements SipListener {
 
         private AddressFactory addressFactory;
 
         private MessageFactory messageFactory;
 
         private HeaderFactory headerFactory;
 
         private SipStack sipStack;
 
         private static final String myAddress = "127.0.0.1";
 
         private static final int myPort = 5070;
 
         private Dialog dialog;
 
         private int sawInvite;
 
         private boolean sawTransactionExistsException;
 
         public static final boolean callerSendsBye = true;
 
         public void processRequest(RequestEvent requestEvent) {
             Request request = requestEvent.getRequest();
             ServerTransaction serverTransactionId = requestEvent.getServerTransaction();
 
             ..println("\n\nRequest " + request.getMethod() + " received at "
                     + .getStackName() + " with server transaction id "
                     + serverTransactionId);
 
             if (request.getMethod().equals(.)) {
                 processInvite(requestEvent);
             }
 
         }
 
         public void processResponse(ResponseEvent responseEvent) {
         }

        
Process the ACK request. Send the bye and complete the call flow.
 
         public void processAck(RequestEvent requestEventServerTransaction serverTransaction) {
             try {
                 ..println("shootme: got an ACK! ");
                 ..println("Dialog State = " + .getState());
                 SipProvider provider = (SipProviderrequestEvent.getSource();
                 if (!) {
                     Request byeRequest = .createRequest(.);
                     ClientTransaction ct = provider.getNewClientTransaction(byeRequest);
                     .sendRequest(ct);
                 }
             } catch (Exception ex) {
                 ex.printStackTrace();
             }
 
         }

        
Process the invite request.
 
         public void processInvite(RequestEvent requestEvent) {
             SipProvider sipProvider = (SipProviderrequestEvent.getSource();
            Request request = requestEvent.getRequest();
            this. ++;
            try {
                Response okResponse = .createResponse(.request);
                Address address = .createAddress("Shootme <sip:" +  + ":"
                        +  + ">");
                ContactHeader contactHeader = .createContactHeader(address);
                ToHeader toHeader = (ToHeaderokResponse.getHeader(.);
                toHeader.setTag("4321"); // Application is supposed to set.
                okResponse.addHeader(contactHeader);
                ServerTransaction stx = requestEvent.getServerTransaction();
                if ( stx == null ) {
                    stx = sipProvider.getNewServerTransaction(request);
                    stx.sendResponse(okResponse);
                }
            } catch (TransactionAlreadyExistsException ex) {
                this. = true;
                ..println("Saw TransactionAlreadyExistsException");
            } catch (Exception ex) {
                ..println("Unexpected exception" + ex);
                fail("Unexpected Exception seen");
            }
        }
        public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
            Transaction transaction;
            if (timeoutEvent.isServerTransaction()) {
                transaction = timeoutEvent.getServerTransaction();
            } else {
                transaction = timeoutEvent.getClientTransaction();
            }
            ..println("state = " + transaction.getState());
            ..println("dialog = " + transaction.getDialog());
            ..println("dialogState = " + transaction.getDialog().getState());
            ..println("Transaction Time out");
        }
        public void init() {
            SipFactory sipFactory = null;
             = null;
            sipFactory = SipFactory.getInstance();
            sipFactory.setPathName("gov.nist");
            Properties properties = new Properties();
            properties.setProperty("javax.sip.STACK_NAME""shootme");
            // 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""32");
            properties.setProperty("gov.nist.javax.sip.DEBUG_LOG""shootmedebug.txt");
            properties.setProperty("gov.nist.javax.sip.SERVER_LOG""shootmelog.txt");
            try {
                // Create SipStack object
                 = sipFactory.createSipStack(properties);
                ..println("sipStack = " + );
            } catch (PeerUnavailableException e) {
                // could not find
                // gov.nist.jain.protocol.ip.sip.SipStackImpl
                // in the classpath
                e.printStackTrace();
                ..println(e.getMessage());
                if (e.getCause() != null)
                    e.getCause().printStackTrace();
                System.exit(0);
            }
            try {
                 = sipFactory.createHeaderFactory();
                 = sipFactory.createAddressFactory();
                 = sipFactory.createMessageFactory();
                ((MessageFactoryImpl).setTest(true);
                ListeningPoint lp = .createListeningPoint("127.0.0.1""udp");
                Shootme listener = this;
                SipProvider sipProvider = .createSipProvider(lp);
                ..println("udp provider " + sipProvider);
                sipProvider.addSipListener(listener);
            } catch (Exception ex) {
                ex.printStackTrace();
                fail("Unexpected exception");
            }
        }
        public void processIOException(IOExceptionEvent exceptionEvent) {
            fail("IOException");
        }
        public void processTransactionTerminated(
                TransactionTerminatedEvent transactionTerminatedEvent) {
            if (transactionTerminatedEvent.isServerTransaction())
                ..println("Transaction terminated event recieved"
                        + transactionTerminatedEvent.getServerTransaction());
            else
                ..println("Transaction terminated "
                        + transactionTerminatedEvent.getClientTransaction());
        }
        public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
            Dialog d = dialogTerminatedEvent.getDialog();
            ..println("Local Party = " + d.getLocalParty());
        }
        public void terminate() {
            this..stop();
        }
    }
    public class Shootist implements SipListener {
        private SipProvider sipProvider;
        private AddressFactory addressFactory;
        private MessageFactory messageFactory;
        private HeaderFactory headerFactory;
        private SipStack sipStack;
        private ContactHeader contactHeader;
        private ListeningPoint udpListeningPoint;
        private Dialog dialog;
        private boolean timeoutRecieved;
        boolean sawOk;
        public void processRequest(RequestEvent requestReceivedEvent) {
        }
        public void processResponse(ResponseEvent responseReceivedEvent) {
            try {
                if (responseReceivedEvent.getResponse().getStatusCode() == .) {
                    this. = true;
                    Dialog dialog = responseReceivedEvent.getDialog();
                    long cseq = ((CSeqHeaderresponseReceivedEvent.getResponse().getHeader(
                            .)).getSeqNumber();
                    Request ack = dialog.createAck(cseq);
                    dialog.sendAck(ack);
                }
            } catch (Exception ex) {
                fail("Unexpected exception");
            }
        }
        public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {
            ..println("Got a timeout " + timeoutEvent.getClientTransaction());
            this. = true;
        }
        public void init() {
            SipFactory sipFactory = null;
             = null;
            sipFactory = SipFactory.getInstance();
            sipFactory.setPathName("gov.nist");
            Properties properties = new Properties();
            // If you want to try TCP transport change the following to
            String transport = "udp";
            String peerHostPort = "127.0.0.1:5070";
            properties.setProperty("javax.sip.OUTBOUND_PROXY"peerHostPort + "/" + transport);
            // If you want to use UDP then uncomment this.
            properties.setProperty("javax.sip.STACK_NAME""shootist");
            // 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
                 = sipFactory.createSipStack(properties);
                ..println("createSipStack " + );
            } catch (PeerUnavailableException e) {
                // could not find
                // gov.nist.jain.protocol.ip.sip.SipStackImpl
                // in the classpath
                e.printStackTrace();
                ..println(e.getMessage());
                fail("Problem with setup");
            }
            try {
                 = sipFactory.createHeaderFactory();
                 = sipFactory.createAddressFactory();
                 = sipFactory.createMessageFactory();
                 = .createListeningPoint("127.0.0.1", 5060, "udp");
                 = .createSipProvider();
                Shootist listener = this;
                .addSipListener(listener);
                String retransmittedRequest = "INVITE sip:LittleGuy@127.0.0.1:5070 SIP/2.0\r\n"
                        + "Call-ID: 7a3cd620346e3fa199cb397fe6b6fc16@127.0.0.1\r\n"
                        + "CSeq: 1 INVITE\r\n"
                        + "From: \"The Master Blaster\" <sip:BigGuy@here.com>;tag=12345\r\n"
                        + "To: \"The Little Blister\" <sip:LittleGuy@there.com>\r\n"
                        + "Via: SIP/2.0/UDP 127.0.0.1:5060 ;branch=z9hG4bKba9abfef1063941840d955a5e3e7dae0393734\r\n" 
                        + "Contact: <127.0.0.1:5060>\r\n"
                        + "Max-Forwards: 70\r\n"
                        + "Content-Length: 0\r\n\r\n";
                ..println("Parsing message \n" + retransmittedRequest);
                Request request = null;
                try {
                    request = .createRequest(retransmittedRequest);
                } catch (ParseException ex) {
                    ..println("Unexpected exception " + ex);
                    fail("Unexpected exception");
                }
               
                // send the request out.
                for ( int i = 0 ; i < 10; i++ ) {
                    .sendRequest(request);
                }
               
            } catch (Exception ex) {
                ex.printStackTrace();
                fail("cannot create or send initial invite");
            }
        }
        public void processIOException(IOExceptionEvent exceptionEvent) {
            ..println("IOException happened for " + exceptionEvent.getHost()
                    + " port = " + exceptionEvent.getPort());
        }
        public void processTransactionTerminated(
                TransactionTerminatedEvent transactionTerminatedEvent) {
            ..println("Transaction terminated event recieved");
        }
        public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
            ..println("dialogTerminatedEvent");
        }
        public void terminate() {
            this..stop();
        }
    }
    private Shootme shootme;
    private Shootist shootist;
    public void setUp() {
        this. = new Shootme();
        this. = new Shootist();
    }
    public void tearDown() {
        .terminate();
        .terminate();
    }
    public void testSendInviteWithBadHeader() {
        this..init();
        this..init();
        try {
            Thread.sleep(5000);
        } catch (Exception ex) {
        }
        
        assertTrue("Should see alreadyExistsException or only one INVITE seen"
                . || . == 1 );
        assertTrue("Should see response at shootist".);
    }
New to GrepCode? Check out our FAQ X