Revision: e1bdc23a6a68
Author:   Sergey Vetyutnev <[email protected]>
Date:     Thu Aug 16 04:10:09 2012
Log:      anonymous connections 16082012
http://code.google.com/p/sctp/source/detail?r=e1bdc23a6a68

Modified:
 /sctp-api/src/main/java/org/mobicents/protocols/api/Management.java
 /sctp-impl/src/main/java/org/mobicents/protocols/sctp/AssociationImpl.java
 /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ManagementImpl.java
 /sctp-impl/src/main/java/org/mobicents/protocols/sctp/SelectorThread.java
 /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ServerImpl.java
/sctp-impl/src/test/java/org/mobicents/protocols/sctp/AnonymousConnectionTest.java

=======================================
--- /sctp-api/src/main/java/org/mobicents/protocols/api/Management.java Wed Aug 15 06:32:03 2012 +++ /sctp-api/src/main/java/org/mobicents/protocols/api/Management.java Thu Aug 16 04:10:09 2012
@@ -266,6 +266,7 @@
         *
         * @param hostAddress
         * @param hostPort
+        *              If hostPort==0 this mean the local port will be any 
vacant port
         * @param peerAddress
         * @param peerPort
         * @param assocName
=======================================
--- /sctp-impl/src/main/java/org/mobicents/protocols/sctp/AssociationImpl.java Wed Aug 15 09:38:13 2012 +++ /sctp-impl/src/main/java/org/mobicents/protocols/sctp/AssociationImpl.java Thu Aug 16 04:10:09 2012
@@ -77,6 +77,7 @@
        private String name;
        private IpChannelType ipChannelType;
        private String[] extraHostAddresses;
+ private ServerImpl server; // this is filled only for anonymous Associations

        private AssociationType type;

@@ -191,12 +192,13 @@
         * @param assocName
         * @param ipChannelType
         */
- protected AssociationImpl(String peerAddress, int peerPort, String serverName, IpChannelType ipChannelType) { + protected AssociationImpl(String peerAddress, int peerPort, String serverName, IpChannelType ipChannelType, ServerImpl server) {
                this();
                this.peerAddress = peerAddress;
                this.peerPort = peerPort;
                this.serverName = serverName;
                this.ipChannelType = ipChannelType;
+               this.server = server;

                this.type = AssociationType.ANONYMOUS_SERVER;

@@ -214,7 +216,9 @@
                this.started = true;

                if (logger.isInfoEnabled()) {
-                       logger.info(String.format("Started Association=%s", 
this));
+                       if (this.type != AssociationType.ANONYMOUS_SERVER) {
+                               logger.info(String.format("Started 
Association=%s", this));
+                       }
                }
        }

@@ -307,11 +311,22 @@
        }

        protected void markAssociationUp() {
+               if (this.server != null) {
+                       synchronized (this.server.anonymAssociations) {
+                               this.server.anonymAssociations.add(this);
+                       }
+               }
+
                this.up = true;
        }

        protected void markAssociationDown() {
                this.up = false;
+               if (this.server != null) {
+                       synchronized (this.server.anonymAssociations) {
+                               this.server.anonymAssociations.remove(this);
+                       }
+               }
        }

        /**
=======================================
--- /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ManagementImpl.java Wed Aug 15 06:32:03 2012 +++ /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ManagementImpl.java Thu Aug 16 04:10:09 2012
@@ -692,8 +692,8 @@
                        throw new Exception("Host address cannot be null");
                }

-               if (hostPort < 1) {
-                       throw new Exception("Host port cannot be less than 1");
+               if (hostPort < 0) {
+                       throw new Exception("Host port cannot be less than 0");
                }

                if (peerAddress == null) {
=======================================
--- /sctp-impl/src/main/java/org/mobicents/protocols/sctp/SelectorThread.java Wed Aug 15 11:37:12 2012 +++ /sctp-impl/src/main/java/org/mobicents/protocols/sctp/SelectorThread.java Thu Aug 16 04:10:09 2012
@@ -112,9 +112,14 @@
                                                        
key1.attach(change.getAssociation());
                                                        break;
                                                case ChangeRequest.CONNECT:
-                                                       if 
(change.getExecutionTime() <= System.currentTimeMillis()) {
+                                                       if 
(!change.getAssociation().isStarted()) {
+                                                               // if 
Association is stopped - remove pending connection requests
                                                                
pendingChanges.remove(change);
-                                                               
change.getAssociation().initiateConnection();
+                                                       } else {
+                                                               if 
(change.getExecutionTime() <= System.currentTimeMillis()) {
+                                                                       
pendingChanges.remove(change);
+                                                                       
change.getAssociation().initiateConnection();
+                                                               }
                                                        }
                                                        break;
                                                case ChangeRequest.CLOSE:
@@ -282,9 +287,21 @@
if (!provisioned && srv.isAcceptAnonymousConnections() && this.management.getServerListener() != null) {
                                        // the server accepts anonymous 
connections

+                                       // checking for limit of concurrent 
connections
+ if (srvv.getMaxConcurrentConnectionsCount() > 0 && srvv.anonymAssociations.size() >= srvv.getMaxConcurrentConnectionsCount()) { + logger.warn(String.format("Incoming anonymous connection is rejected because of too many active connections to Server=%s", srv));
+                                               try {
+                                                       socketChannel.close();
+                                               } catch (Exception ee) {
+                                               }
+                                               return;
+                                       }
+
                                        provisioned = true;

- AssociationImpl anonymAssociation = new AssociationImpl(firstInetAddress.getHostAddress(), firstPort, srv.getName(), srv.getIpChannelType()); + AssociationImpl anonymAssociation = new AssociationImpl(firstInetAddress.getHostAddress(), firstPort, srv.getName(),
+                                                       srv.getIpChannelType(), 
srvv);
+                                       
anonymAssociation.setManagement(this.management);
                                        
anonymAssociation.setSocketChannel(socketChannel);

                                        // Accept the connection and make it
@@ -319,7 +336,7 @@
                                        key1.attach(anonymAssociation);

                                        if (logger.isInfoEnabled()) {
- logger.info(String.format("Connected anonymous %s", anonymAssociation)); + logger.info(String.format("Accepted anonymous %s", anonymAssociation));
                                        }

                                        if 
(anonymAssociation.getIpChannelType() == IpChannelType.TCP) {
@@ -329,7 +346,10 @@
                                        }
                                }
                        }
-               }
+
+                       if (provisioned)
+                               break;
+               }

                if (!provisioned) {
                        // There is no corresponding Associate provisioned. 
Lets close the
@@ -346,9 +366,6 @@
                        this.finishConnectionSctp(key);
                else
                        this.finishConnectionTcp(key);
-
-               // TODO: may be add anonymAssociation to the 
anonymAssociationList;
-               // ...........................
        }

        private void finishConnectionSctp(SelectionKey key) throws IOException {
@@ -366,7 +383,7 @@
                        }

                        if (logger.isInfoEnabled()) {
- logger.info(String.format("Asscoiation=%s connected to=%s", association.getName(), socketChannel.getRemoteAddresses())); + logger.info(String.format("Association=%s connected to=%s", association.getName(), socketChannel.getRemoteAddresses()));
                        }

                        // Register an interest in writing on this channel
@@ -392,7 +409,7 @@
                        }

                        if (logger.isInfoEnabled()) {
- logger.info(String.format("Asscoiation=%s connected to=%s", association.getName(), socketChannel.getRemoteAddress())); + logger.info(String.format("Association=%s connected to=%s", association.getName(), socketChannel.getRemoteAddress()));
                        }

                        // Register an interest in writing on this channel
=======================================
--- /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ServerImpl.java Wed Aug 15 06:32:03 2012 +++ /sctp-impl/src/main/java/org/mobicents/protocols/sctp/ServerImpl.java Thu Aug 16 04:10:09 2012
@@ -76,7 +76,7 @@
        private ManagementImpl management = null;

        protected FastList<String> associations = new FastList<String>();
-//     protected FastList<String> anonymAssociations = new FastList<String>();
+ protected FastList<Association> anonymAssociations = new FastList<Association>();

        // The channel on which we'll accept connections
        private SctpServerChannel serverChannelSctp;
@@ -127,8 +127,11 @@
                        }
                }

-               // TODO: stop all anonymous associations?
-
+               synchronized (this.anonymAssociations) {
+                       // TODO: stop all anonymous associations?
+                       this.anonymAssociations.clear();
+               }
+
                if (this.getIpChannel() != null) {
                        try {
                                this.getIpChannel().close();
@@ -216,6 +219,11 @@
                maxConcurrentConnectionsCount = val;
        }

+       // TODO: should we share an access to the anonymAssociations list
+//     public FastList<Association> getAnonymAssociations() {
+//             return this.anonymAssociations;
+//     }
+
        protected AbstractSelectableChannel getIpChannel() {
                if (this.ipChannelType == IpChannelType.SCTP)
                        return this.serverChannelSctp;
=======================================
--- /sctp-impl/src/test/java/org/mobicents/protocols/sctp/AnonymousConnectionTest.java Wed Aug 15 11:37:12 2012 +++ /sctp-impl/src/test/java/org/mobicents/protocols/sctp/AnonymousConnectionTest.java Thu Aug 16 04:10:09 2012
@@ -22,11 +22,16 @@

 package org.mobicents.protocols.sctp;

-import static org.junit.Assert.assertTrue;
-
+import static org.junit.Assert.*;
 import java.util.Arrays;
-
+import javolution.util.FastList;
+import org.apache.log4j.Logger;
+import org.mobicents.protocols.api.Association;
+import org.mobicents.protocols.api.AssociationListener;
 import org.mobicents.protocols.api.IpChannelType;
+import org.mobicents.protocols.api.PayloadData;
+import org.mobicents.protocols.api.Server;
+import org.mobicents.protocols.api.ServerListener;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
@@ -36,45 +41,44 @@
  * @author sergey vetyutnev
  *
  */
-public class AnonymousConnectionTest {
+public class AnonymousConnectionTest implements ServerListener {
        private static final String SERVER_NAME = "testserver";
        private static final String SERVER_HOST = "127.0.0.1";
        private static final int SERVER_PORT = 2354;

-// private static final String SERVER_ASSOCIATION_NAME = "serverAssociation"; private static final String CLIENT_ASSOCIATION_NAME1 = "clientAssociation1"; - private static final String CLIENT_ASSOCIATION_NAME2 = "clientAssociation1"; + private static final String CLIENT_ASSOCIATION_NAME2 = "clientAssociation2"; + private static final String CLIENT_ASSOCIATION_NAME3 = "clientAssociation3";

        private static final String CLIENT_HOST = "127.0.0.1";
-       private static final int CLIENT_PORT1 = 2355;
-       private static final int CLIENT_PORT2 = 2356;
+//     private static final int CLIENT_PORT1 = 2355;
+       private static final int CLIENT_PORT1 = 0;
+       private static final int CLIENT_PORT2 = 0;
+       private static final int CLIENT_PORT3 = 0;

        private final byte[] CLIENT_MESSAGE = "Client says Hi".getBytes();
+ private final byte[] CLIENT_MESSAGE2 = "Client says Hi ones moew".getBytes();
        private final byte[] SERVER_MESSAGE = "Server says Hi".getBytes();
+
+       private final int CONNECT_DELAY = 4000;

        private ManagementImpl management = null;
+       private ManagementImpl management2 = null;
+       private ManagementImpl management3 = null;

        // private Management managementClient = null;
        private ServerImpl server = null;

-//     private AssociationImpl serverAssociation = null;
        private AssociationImpl clientAssociation1 = null;
        private AssociationImpl clientAssociation2 = null;
+       private AssociationImpl clientAssociation3 = null;

-//     private volatile boolean clientAssocUp = false;
-//     private volatile boolean serverAssocUp = false;
-//
-//     private volatile boolean clientAssocDown = false;
-//     private volatile boolean serverAssocDown = false;
-
-//     private byte[] clientMessage;
-//     private byte[] serverMessage;
-//
-//     private volatile int clientMaxInboundStreams = 0;
-//     private volatile int clientMaxOutboundStreams = 0;
-//
-//     private volatile int serverMaxInboundStreams = 0;
-//     private volatile int serverMaxOutboundStreams = 0;
+       private boolean rejectConn;
+
+       private AssociationData assDataClt1;
+       private AssociationData assDataClt2;
+       private AssociationData assDataClt3;
+ private FastList<AssociationData> assDataSrv = new FastList<AssociationData>();

        @BeforeClass
        public static void setUpClass() throws Exception {
@@ -85,36 +89,39 @@
        }

        public void setUp(IpChannelType ipChannelType) throws Exception {
-//             this.clientMaxInboundStreams = 0;
-//             this.serverMaxOutboundStreams = 0;
-//
-//             this.clientAssocUp = false;
-//             this.serverAssocUp = false;
-//
-//             this.clientAssocDown = false;
-//             this.serverAssocDown = false;
-//
-//             this.clientMessage = null;
-//             this.serverMessage = null;

                this.management = new ManagementImpl("server-management");
-               this.management.setConnectDelay(10000);// Try connecting every 
10 secs
+ this.management.setConnectDelay(CONNECT_DELAY);// Try connecting every x secs
                this.management.setSingleThread(true);
                this.management.start();
                this.management.removeAllResourses();

+               this.management2 = new ManagementImpl("server-management2");
+ this.management2.setConnectDelay(CONNECT_DELAY);// Try connecting every x secs
+               this.management2.setSingleThread(true);
+               this.management2.start();
+               this.management2.removeAllResourses();
+
+               this.management3 = new ManagementImpl("server-management3");
+ this.management3.setConnectDelay(CONNECT_DELAY);// Try connecting every x secs
+               this.management3.setSingleThread(true);
+               this.management3.start();
+               this.management3.removeAllResourses();
+
this.server = this.management.addServer(SERVER_NAME, SERVER_HOST, SERVER_PORT, ipChannelType, true, 2, null); -// this.serverAssociation = this.management.addServerAssociation(CLIENT_HOST, CLIENT_PORT, SERVER_NAME, SERVER_ASSOCIATION_NAME, ipChannelType); this.clientAssociation1 = this.management.addAssociation(CLIENT_HOST, CLIENT_PORT1, SERVER_HOST, SERVER_PORT, CLIENT_ASSOCIATION_NAME1, ipChannelType,
                                null);
- this.clientAssociation2 = this.management.addAssociation(CLIENT_HOST, CLIENT_PORT2, SERVER_HOST, SERVER_PORT, CLIENT_ASSOCIATION_NAME2, ipChannelType, + this.clientAssociation2 = this.management2.addAssociation(CLIENT_HOST, CLIENT_PORT2, SERVER_HOST, SERVER_PORT, CLIENT_ASSOCIATION_NAME2, ipChannelType,
                                null);
+ this.clientAssociation3 = this.management3.addAssociation(CLIENT_HOST, CLIENT_PORT3, SERVER_HOST, SERVER_PORT, CLIENT_ASSOCIATION_NAME3, ipChannelType,
+                               null);
        }

        public void tearDown() throws Exception {

                this.management.removeAssociation(CLIENT_ASSOCIATION_NAME1);
-               this.management.removeAssociation(CLIENT_ASSOCIATION_NAME2);
+               this.management2.removeAssociation(CLIENT_ASSOCIATION_NAME2);
+               this.management3.removeAssociation(CLIENT_ASSOCIATION_NAME3);
                this.management.removeServer(SERVER_NAME);

                this.management.stop();
@@ -151,65 +158,343 @@

                this.management.startServer(SERVER_NAME);

-// this.clientAssociation1.setAssociationListener(new ClientAssociationListener());
-//             this.management.startAssociation(CLIENT_ASSOCIATION_NAME1);
-//
-// this.clientAssociation2.setAssociationListener(new ClientAssociationListener());
-//             this.management.startAssociation(CLIENT_ASSOCIATION_NAME2);
+               this.assDataClt1 = new AssociationData();
+               this.assDataClt2 = new AssociationData();
+               this.assDataClt3 = new AssociationData();
+               this.assDataSrv.clear();
+ this.clientAssociation1.setAssociationListener(new ClientAssociationListener(this.assDataClt1)); + this.clientAssociation2.setAssociationListener(new ClientAssociationListener(this.assDataClt2)); + this.clientAssociation3.setAssociationListener(new ClientAssociationListener(this.assDataClt3));
+

                // test1 - do not accept because of ServerListener is absent
+               this.management.setServerListener(null);
+               this.management.startAssociation(CLIENT_ASSOCIATION_NAME1);
+               Thread.sleep(CONNECT_DELAY + 2000);
+               assertEquals(this.server.anonymAssociations.size(), 0);
+               assertEquals(this.assDataSrv.size(), 0);
+               assertTrue(this.assDataClt1.assocUp);
+               this.assDataClt1.assocUp = false;
+               assertTrue(this.assDataClt1.assocDown);
+               this.assDataClt1.assocDown = false;
+               this.management.stopAssociation(CLIENT_ASSOCIATION_NAME1);
+               assertFalse(this.clientAssociation1.isConnected());
+               assertFalse(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               Thread.sleep(500);

                // test2 - a server reject the first connection
+               this.management.setServerListener(this);
+               this.rejectConn = true;
+               this.management.startAssociation(CLIENT_ASSOCIATION_NAME1);
+               Thread.sleep(CONNECT_DELAY + 2000);
+               assertEquals(this.server.anonymAssociations.size(), 0);
+               assertEquals(this.assDataSrv.size(), 0);
+               assertTrue(this.assDataClt1.assocUp);
+               this.assDataClt1.assocUp = false;
+               assertTrue(this.assDataClt1.assocDown);
+               this.assDataClt1.assocDown = false;
+               assertNull(this.assDataClt1.rsvdMsg);
+               this.management.stopAssociation(CLIENT_ASSOCIATION_NAME1);
+               assertFalse(this.clientAssociation1.isConnected());
+               assertFalse(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               Thread.sleep(500);

                // test3 - successfully establishing conn1 + transfer data
+               this.rejectConn = false;
+               this.management.startAssociation(CLIENT_ASSOCIATION_NAME1);
+               for (int i1 = 0; i1 < 15; i1++) {
+                       if (this.server.anonymAssociations.size() > 0)
+                               break;
+                       Thread.sleep(1000 * 1);
+               }
+               Thread.sleep(1000 * 1);
+
+               assertEquals(this.server.anonymAssociations.size(), 1);
+               assertEquals(this.assDataSrv.size(), 1);
+               assertTrue(this.assDataClt1.assocUp);
+               assertFalse(this.assDataClt1.assocDown);
+               assertFalse(this.assDataClt2.assocUp);
+               assertFalse(this.assDataClt2.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertFalse(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.clientAssociation1.isConnected());
+               assertFalse(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted());
+               assertTrue(Arrays.equals(SERVER_MESSAGE, 
this.assDataClt1.rsvdMsg));
+ assertTrue(Arrays.equals(CLIENT_MESSAGE, this.assDataSrv.get(0).rsvdMsg));

                // test4 - successfully establishing conn2 + transfer data
+               this.management2.startAssociation(CLIENT_ASSOCIATION_NAME2);
+               for (int i1 = 0; i1 < 15; i1++) {
+                       if (this.server.anonymAssociations.size() > 1)
+                               break;
+                       Thread.sleep(1000 * 1);
+               }
+               Thread.sleep(1000 * 1);

-               // test5 - close conn1 from client side
+               assertEquals(this.server.anonymAssociations.size(), 2);
+               assertEquals(this.assDataSrv.size(), 2);
+               assertTrue(this.assDataClt1.assocUp);
+               assertFalse(this.assDataClt1.assocDown);
+               assertTrue(this.assDataClt2.assocUp);
+               assertFalse(this.assDataClt2.assocDown);
+               assertFalse(this.assDataClt3.assocUp);
+               assertFalse(this.assDataClt3.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertFalse(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.assDataSrv.get(1).assocUp);
+               assertFalse(this.assDataSrv.get(1).assocDown);
+               assertTrue(this.clientAssociation1.isConnected());
+               assertTrue(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted());
+               assertTrue(this.assDataSrv.get(1).ass.isConnected());
+               assertTrue(this.assDataSrv.get(1).ass.isStarted());
+               assertTrue(Arrays.equals(SERVER_MESSAGE, 
this.assDataClt2.rsvdMsg));
+ assertTrue(Arrays.equals(CLIENT_MESSAGE, this.assDataSrv.get(1).rsvdMsg));

-               // test6 - transfer data via conn2
+               // test5 - rejecting the third connection if the connection 
limit is 2
+               this.management3.startAssociation(CLIENT_ASSOCIATION_NAME3);
+               Thread.sleep(CONNECT_DELAY + 2000);

-               // test7 - close conn2 from client side
-
-
-
-
-
-
-
-
-//             for (int i1 = 0; i1 < 40; i1++) {
-//                     if (serverAssocUp)
-//                             break;
-//                     Thread.sleep(1000 * 5); // was: 40
-//             }
-//             Thread.sleep(1000 * 1); // was: 40
-//
-//             this.management.stopAssociation(CLIENT_ASSOCIATION_NAME);
-//
-//             Thread.sleep(1000);
-//
-//             this.management.stopAssociation(SERVER_ASSOCIATION_NAME);
-//             this.management.stopServer(SERVER_NAME);
-//
-//             Thread.sleep(1000 * 2);
-//
-//             assertTrue(Arrays.equals(SERVER_MESSAGE, clientMessage));
-//             assertTrue(Arrays.equals(CLIENT_MESSAGE, serverMessage));
-//
-//             assertTrue(clientAssocUp);
-//             assertTrue(serverAssocUp);
-//
-//             assertTrue(clientAssocDown);
-//             assertTrue(serverAssocDown);
-//
-//             assertTrue(this.clientMaxInboundStreams> 0 );
-//             assertTrue(this.clientMaxOutboundStreams > 0);
-//
-//             assertTrue(this.serverMaxInboundStreams> 0 );
-//             assertTrue(this.serverMaxOutboundStreams > 0);
+               assertEquals(this.server.anonymAssociations.size(), 2);
+               assertEquals(this.assDataSrv.size(), 2);
+               assertTrue(this.assDataClt1.assocUp);
+               assertFalse(this.assDataClt1.assocDown);
+               assertTrue(this.assDataClt2.assocUp);
+               assertFalse(this.assDataClt2.assocDown);
+               assertTrue(this.assDataClt3.assocUp);
+               assertTrue(this.assDataClt3.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertFalse(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.assDataSrv.get(1).assocUp);
+               assertFalse(this.assDataSrv.get(1).assocDown);
+               assertTrue(this.clientAssociation1.isConnected());
+               assertTrue(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted());
+               assertTrue(this.assDataSrv.get(1).ass.isConnected());
+               assertTrue(this.assDataSrv.get(1).ass.isStarted());
+               this.management3.stopAssociation(CLIENT_ASSOCIATION_NAME3);
+               Thread.sleep(500);
+
+               // test6 - close conn1 from client side
+               this.management.stopAssociation(CLIENT_ASSOCIATION_NAME1);
+               Thread.sleep(500);
+
+               assertEquals(this.server.anonymAssociations.size(), 1);
+               assertEquals(this.assDataSrv.size(), 2);
+               assertTrue(this.assDataClt1.assocUp);
+               assertTrue(this.assDataClt1.assocDown);
+               assertTrue(this.assDataClt2.assocUp);
+               assertFalse(this.assDataClt2.assocDown);
+               assertTrue(this.assDataClt3.assocUp);
+               assertTrue(this.assDataClt3.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertTrue(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.assDataSrv.get(1).assocUp);
+               assertFalse(this.assDataSrv.get(1).assocDown);
+               assertFalse(this.clientAssociation1.isConnected());
+               assertTrue(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertFalse(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted()); // !!!
+               assertTrue(this.assDataSrv.get(1).ass.isConnected());
+               assertTrue(this.assDataSrv.get(1).ass.isStarted());
+
+               // test7 - transfer data via conn2
+ PayloadData pd = new PayloadData(CLIENT_MESSAGE2.length, CLIENT_MESSAGE2, true, false, 3, 1);
+               this.clientAssociation2.send(pd);
+               Thread.sleep(500);
+
+               assertEquals(this.server.anonymAssociations.size(), 1);
+               assertEquals(this.assDataSrv.size(), 2);
+               assertTrue(this.assDataClt1.assocUp);
+               assertTrue(this.assDataClt1.assocDown);
+               assertTrue(this.assDataClt2.assocUp);
+               assertFalse(this.assDataClt2.assocDown);
+               assertTrue(this.assDataClt3.assocUp);
+               assertTrue(this.assDataClt3.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertTrue(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.assDataSrv.get(1).assocUp);
+               assertFalse(this.assDataSrv.get(1).assocDown);
+               assertFalse(this.clientAssociation1.isConnected());
+               assertTrue(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertFalse(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted()); // !!!
+               assertTrue(this.assDataSrv.get(1).ass.isConnected());
+               assertTrue(this.assDataSrv.get(1).ass.isStarted());
+               assertTrue(Arrays.equals(SERVER_MESSAGE, 
this.assDataClt2.rsvdMsg));
+ assertTrue(Arrays.equals(CLIENT_MESSAGE2, this.assDataSrv.get(1).rsvdMsg));
+
+               // test8 - close conn2 from server side
+               this.assDataSrv.get(1).ass.stopAnonymousAssociation();
+               Thread.sleep(500);
+
+               assertEquals(this.server.anonymAssociations.size(), 0);
+               assertEquals(this.assDataSrv.size(), 2);
+               assertTrue(this.assDataClt1.assocUp);
+               assertTrue(this.assDataClt1.assocDown);
+               assertTrue(this.assDataClt2.assocUp);
+               assertTrue(this.assDataClt2.assocDown);
+               assertTrue(this.assDataClt3.assocUp);
+               assertTrue(this.assDataClt3.assocDown);
+               assertTrue(this.assDataSrv.get(0).assocUp);
+               assertTrue(this.assDataSrv.get(0).assocDown);
+               assertTrue(this.assDataSrv.get(1).assocUp);
+               assertTrue(this.assDataSrv.get(1).assocDown);
+               assertFalse(this.clientAssociation1.isConnected());
+               assertFalse(this.clientAssociation2.isConnected());
+               assertFalse(this.clientAssociation3.isConnected());
+               assertFalse(this.assDataSrv.get(0).ass.isConnected());
+               assertTrue(this.assDataSrv.get(0).ass.isStarted()); // !!!
+               assertFalse(this.assDataSrv.get(1).ass.isConnected());
+               assertFalse(this.assDataSrv.get(1).ass.isStarted());
+               this.management2.stopAssociation(CLIENT_ASSOCIATION_NAME2);
+
+               this.management.stopServer(SERVER_NAME);

                this.tearDown();
        }

+       private class ServerAssociationListener implements AssociationListener {
+
+ private final Logger logger = Logger.getLogger(ClientAssociationListener.class);
+               AssociationData assData;
+
+               ServerAssociationListener(AssociationData assData) {
+                       this.assData = assData;
+               }
+
+               @Override
+ public void onCommunicationUp(Association association, int maxInboundStreams, int maxOutboundStreams) {
+                       System.out.println(this + " onCommunicationUp");
+
+                       assData.assocUp = true;
+
+ PayloadData payloadData = new PayloadData(SERVER_MESSAGE.length, SERVER_MESSAGE, true, false, 3, 1);
+
+                       try {
+                               association.send(payloadData);
+                       } catch (Exception e) {
+                               e.printStackTrace();
+                       }
+               }
+
+               @Override
+               public void onCommunicationShutdown(Association association) {
+                       System.out.println(this + " onCommunicationShutdown");
+                       assData.assocDown = true;
+               }
+
+               @Override
+               public void onCommunicationLost(Association association) {
+                       System.out.println(this + " onCommunicationLost");
+               }
+
+               @Override
+               public void onCommunicationRestart(Association association) {
+                       System.out.println(this + " onCommunicationRestart");
+               }
+
+               @Override
+               public void onPayload(Association association, PayloadData 
payloadData) {
+                       assData.rsvdMsg = new byte[payloadData.getDataLength()];
+ System.arraycopy(payloadData.getData(), 0, assData.rsvdMsg, 0, payloadData.getDataLength());
+                       logger.debug("SERVER received " + new 
String(assData.rsvdMsg));
+               }
+
+               @Override
+               public void inValidStreamId(PayloadData payloadData) {
+                       // TODO Auto-generated method stub
+
+               }
+       }
+
+       private class ClientAssociationListener implements AssociationListener {
+
+               AssociationData assData;
+
+               ClientAssociationListener(AssociationData assData) {
+                       this.assData = assData;
+               }
+
+ private final Logger logger = Logger.getLogger(ClientAssociationListener.class);
+
+               @Override
+ public void onCommunicationUp(Association association, int maxInboundStreams, int maxOutboundStreams) {
+                       System.out.println(this + " onCommunicationUp");
+
+                       assData.assocUp = true;
+
+ PayloadData payloadData = new PayloadData(CLIENT_MESSAGE.length, CLIENT_MESSAGE, true, false, 3, 1);
+
+                       try {
+                               association.send(payloadData);
+                       } catch (Exception e) {
+                               e.printStackTrace();
+                       }
+               }
+
+               @Override
+               public void onCommunicationShutdown(Association association) {
+                       System.out.println(this + " onCommunicationShutdown");
+                       assData.assocDown = true;
+               }
+
+               @Override
+               public void onCommunicationLost(Association association) {
+                       System.out.println(this + " onCommunicationLost");
+               }
+
+               @Override
+               public void onCommunicationRestart(Association association) {
+                       System.out.println(this + " onCommunicationRestart");
+               }
+
+               @Override
+               public void onPayload(Association association, PayloadData 
payloadData) {
+                       assData.rsvdMsg = new byte[payloadData.getDataLength()];
+ System.arraycopy(payloadData.getData(), 0, assData.rsvdMsg, 0, payloadData.getDataLength());
+                       logger.debug("CLIENT received " + new 
String(assData.rsvdMsg));
+               }
+
+               @Override
+               public void inValidStreamId(PayloadData payloadData) {
+                       // TODO Auto-generated method stub
+
+               }
+       }
+
+       private class AssociationData {
+               public boolean assocUp = false;
+               public boolean assocDown = false;
+               public byte[] rsvdMsg;
+               public Association ass;
+       }
+
+       @Override
+ public void onNewRemoteConnection(Server server, Association association) {
+               if (this.rejectConn) {
+                       association.rejectAnonymousAssociation();
+               } else {
+                       try {
+                               AssociationData ad = new AssociationData();
+                               this.assDataSrv.add(ad);
+                               ad.ass = association;
+ association.acceptAnonymousAssociation(new ServerAssociationListener(ad));
+                       } catch (Exception e) {
+                               // TODO Auto-generated catch block
+                               e.printStackTrace();
+                       }
+               }
+       }
 }

Reply via email to