Create Manageable Channel in JSDT and invite the clients to join It

Question

I am developing a collaborative application using JSDT where I want to incorporate private messaging between two clients. When the Client chooses the private messaging option I am creating a New channel and inviting the other Client to join the Channel using channel.invite(client) method. It throws the permissionDenied exception. I am wondering if it is a client autentication problem. Since there isn't enough good reference on JSDT I am having hard time understanding this problem. I would greatly appreciate any help to solve this problem.

Answer 1

Sorry I didn't get back to you earlier
Have taken a look at this problem & have built a skeleton app that works
I think your problem is probably due to NOT building in a ChannelManager(???) & thus when your client tries to join the Channel within the Session - No Authentication occurs
Anyhow have a look at the code below (it needs some tidying up)
Run JSDTManager, then JSDTChatApp, then JSDTChatClient
******************* Code for JSDTManager.java *********************
* JSDTManager.java
* Created on 09 December 2003, 17:11
package com.JSDT;
import com.sun.media.jsdt.*;
import com.sun.media.jsdt.event.*;
* @author stefan.maric
public class JSDTManager extends Thread implements RegistryManager, SessionManager, ChannelManager
     private static JSDTManager manager;
     public static final int nCLIENT_PORT_BASE = 5000;
     public static final int nCLIENT_PORT_LIMIT = 5999;
     public static final String sSU = "SU";
     public static final String sSUALLOWED = "SU_ALLOWED";
     public static final String sJOIN_SESSION_ALLOWED = "OK";
     public static final String sCREATE_CHANNEL_ALLOWED = "CREATE_CHANNEL_OK";
     public static final String sJOIN_CHANNEL_ALLOWED = "CHN_OK";
     public static final String sCREATE_CLIENT_ALLOWED = "CLIENT_OK";
     /** Creates a new instance of JSDTManager */
     private JSDTManager()
     public static JSDTManager getInstance()
          if(manager == null)
               manager = new JSDTManager();
               manager.start();
          return manager;
     public void run()
          try{
               if(!RegistryFactory.registryExists("socket"))
                    RegistryFactory.startRegistry("socket", new JSDTManager());
                    System.out.println("JSDTManager:JSDT Registry Started");
               while(true)
          }catch(JSDTException eX){
               eX.printStackTrace();
     public static void channelInvite(String sH, Channel chn, String sCN)
          System.out.println("JSDTManager:channelInvite");
          try{
               Client[] clients = new Client[1];
               int nPort = JSDTManager.nCLIENT_PORT_BASE;
               boolean bFound = false;
               while(!bFound && nPort <= JSDTManager.nCLIENT_PORT_LIMIT)
                    URLString url = URLString.createClientURL(sH, nPort, "socket", sCN);
                    try{
                         System.out.println(url.toString());
                         clients[0] = ClientFactory.lookupClient(url);
                         bFound = true;
                    }catch(NotBoundException eX){
                         nPort++;
               if(bFound)
                    System.out.println("JSDTManager:Inviting '" + clients[0].getName() + "' to join Channel '" + chn.getName() + "'");
                    chn.invite(clients);
               else
                    System.out.println("Could NOT find Client '" + sCN + "' in Registry");
          }catch(JSDTException eX){
               eX.printStackTrace();
     public boolean registryRequest(AuthenticationInfo info, Client client)
          boolean bRetVal = false;
          String sN = client.getName();
          int nAction = info.getAction();
          char chType = info.getType();
          System.out.println("JSDTManager:registryRequest from Client '" + sN + "'");
          if(nAction == AuthenticationInfo.CREATE_SESSION)
               String challenge = "Challenge Session Create";
               String reply = null;
               info.setChallenge(challenge);
               reply = (String) client.authenticate(info);
               if(reply != null)
                    if(reply.equals(sSUALLOWED) || reply.equals(sJOIN_SESSION_ALLOWED))
                         System.out.println("JSDTManager:registryRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' Authenticated");
                         bRetVal = true;
                    else
                         System.out.println("JSDTManager:registryRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' NOT Authenticated");
               else
                    System.out.println("JSDTManager:registryRequest NULL Reply");
          else if(nAction == AuthenticationInfo.CREATE_CLIENT)
               String challenge = "Challenge Client Create";
               String reply = null;
               info.setChallenge(challenge);
               reply = (String) client.authenticate(info);
               if(reply != null)
                    if(reply.equals(sSUALLOWED) || reply.equals(sCREATE_CLIENT_ALLOWED))
                         System.out.println("JSDTManager:registryRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' Authenticated");
                         bRetVal = true;
                    else
                         System.out.println("JSDTManager:registryRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' - NOT Authenticated");
               else
                    System.out.println("JSDTManager:registryRequest NULL Reply");
          return(bRetVal);
     public boolean sessionRequest(Session session, AuthenticationInfo info, Client client)
          boolean bRetVal = false;
          String sN = client.getName();
          int nAction = info.getAction();
          char chType = info.getType();
          System.out.println("JSDTManager:sessionRequest from Client '" + sN + "' for '" + info.toString() + "'");
          if(chType == AuthenticationInfo.SESSION)
               String reply = null;
               String challenge = null;
               switch(nAction)
                    case AuthenticationInfo.JOIN:
                         challenge = "Challenge Session Join";
                         info.setChallenge(challenge);
                         reply = (String) client.authenticate(info);
                         if(reply != null)
                              if(reply.equals(sSUALLOWED) || reply.equals(sJOIN_SESSION_ALLOWED))
                                   System.out.println("JSDTManager:sessionRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' Authenticated");
                                   bRetVal = true;
                              else
                                   System.out.println("JSDTManager:sessionRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' NOT Authenticated");
                         else
                              System.out.println("JSDTManager:sessionRequest NULL Reply");
                         break;
                    case AuthenticationInfo.CREATE_BYTEARRAY:
                    case AuthenticationInfo.CREATE_TOKEN:
                         break;
                    case AuthenticationInfo.CREATE_CHANNEL:
                         challenge = "Challenge Channel Create";
                         info.setChallenge(challenge);
                         reply = (String) client.authenticate(info);
                         if(reply != null)
                              if(reply.equals(sSUALLOWED) || reply.equals(sCREATE_CHANNEL_ALLOWED))
                                   System.out.println("JSDTManager:sessionRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' Authenticated");
                                   bRetVal = true;
                              else
                                   System.out.println("JSDTManager:sessionRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' NOT Authenticated");
                         else
                              System.out.println("JSDTManager:sessionRequest NULL Reply");
                         break;
          return(bRetVal);
     public boolean channelRequest(Channel channel, AuthenticationInfo info, Client client)
          boolean bRetVal = false;
          String sN = client.getName();
          int nAction = info.getAction();
          char chType = info.getType();
          System.out.println("JSDTManager:channelRequest from Client '" + sN + "' for '" + info.toString() + "'");
          if(chType == AuthenticationInfo.CHANNEL && nAction == AuthenticationInfo.JOIN)
               String challenge = "Challenge Channel Join";
               String reply = null;
               info.setChallenge(challenge);
               reply = (String) client.authenticate(info);
               if(reply != null)
                    if(reply.equals(sSUALLOWED) || reply.equals(sJOIN_CHANNEL_ALLOWED))
                         System.out.println("JSDTManager:channelRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' Authenticated");
                         bRetVal = true;
                    else
                         System.out.println("JSDTManager:channelRequest Authentication Reply '" + reply + "' Rxd from Client '" + sN + "' NOT Authenticated");
               else
                    System.out.println("JSDTManager:channelRequest NULL Reply");
          return(bRetVal);
     * @param args the command line arguments
     public static void main(String[] args) throws Exception
          JSDTManager.getInstance();
******************* Code for JSDTManager.java *********************
******************* Code for JSDTChatApp.java *********************
* JsdtChatApp.java
* Created on 08 December 2003, 12:36
package com.JSDT;
import com.sun.media.jsdt.*;
import com.sun.media.jsdt.event.*;
* @author stefan.maric
public class JsdtChatApp implements Client, ClientListener, SessionListener
     public static final String sCHATTER = "Chat Session";
     private String sHost;
     private int nPort;
     private JSDTManager manager;
     private Session session;
     private Channel channel;
     /** Creates a new instance of JsdtChatApp */
     public JsdtChatApp() throws Exception
          manager = JSDTManager.getInstance();
          nPort = 4461;
//          sHost = "BOH-EAAC-IT3.eaac.boh";
          sHost = "localhost";
          int nTry = 1;
          boolean bCreated = false;
          URLString sessionURL = URLString.createSessionURL(sHost, nPort, "socket", sCHATTER);
          while(bCreated == false)
               if(SessionFactory.sessionExists(sessionURL))
                    bCreated = true;
               else
                    try{
                         System.out.println("JsdtChatApp:Session Create Attempt '" + nTry + "'");
                         session = SessionFactory.createSession(this, sessionURL, false, manager);
                    }catch(TimedOutException eX){
                         System.out.println("JsdtChatApp:Session Create Attempt '" + nTry + "' Timed Out");
                         try{
                              Thread.sleep(5000);
                         }catch(InterruptedException iEX){
                              iEX.printStackTrace();
                              System.exit(1);
               nTry++;
          System.out.println("JsdtChatApp:Session created");
          try{
               session.join(this);
               System.out.println("JsdtChatApp:Joined Session");
               session.addSessionListener(this);
               channel = session.createChannel(this, "ChatChannel", true, true, true, manager);
               System.out.println("JsdtChatApp:ChatChannel Created");
//               RegistryFactory.addRegistryListener(sHost, "socket", this);
          }catch(JSDTException eX){
               eX.printStackTrace();
          while(true)
//***********************     Session Listener Inerface     ***********************
     public void byteArrayCreated(SessionEvent event)
     public void byteArrayDestroyed(SessionEvent event)
     public void channelCreated(SessionEvent event)
     public void channelDestroyed(SessionEvent event)
     public void sessionDestroyed(SessionEvent event)
     public void sessionJoined(SessionEvent event)
          String sCN = event.getClientName();
          Session sess = event.getSession();
          String sSN = sess.getName();
          System.out.println("JsdtChatApp: '" + sCN + "' has Joined session '" + sSN + "'");
          manager.channelInvite(sHost, channel, sCN);
     public void sessionLeft(SessionEvent event)
     public void sessionInvited(SessionEvent event)
     public void sessionExpelled(SessionEvent event)
     public void tokenCreated(SessionEvent event)
     public void tokenDestroyed(SessionEvent event)
//***********************     Session Listener Inerface     ***********************
//***********************     Client Inerface     ***********************
     public Object authenticate(AuthenticationInfo info)
          System.out.println("JsdtChatApp:authenticate \n" + info.toString());
          return JSDTManager.sSUALLOWED;
     public String getName()
          return JSDTManager.sSU;
//***********************     Client Inerface     ***********************
//***********************     Client Listener Section     ***********************
     public void byteArrayExpelled(ClientEvent event)
     public void byteArrayInvited(ClientEvent event)
     public void channelExpelled(ClientEvent event)
     public void channelInvited(ClientEvent event)
     public void sessionExpelled(ClientEvent event)
     public void sessionInvited(ClientEvent event)
     public void tokenExpelled(ClientEvent event)
     public void tokenInvited(ClientEvent event)
     public void tokenGiven(ClientEvent event)
//***********************     Client Listener Section     ***********************
     * @param args the command line arguments
     public static void main(String[] args) throws Exception
          new JsdtChatApp();
******************* Code for JSDTChatApp.java *********************
******************* Code for JSDTChatClient.java *********************
* JSDTClient.java
* Created on 08 December 2003, 13:10
package com.JSDT;
import com.sun.media.jsdt.*;
import com.sun.media.jsdt.event.*;
* @author stefan.maric
public class JSDTChatClient implements Client, ClientListener, SessionListener, ChannelListener
     private static JSDTManager manager;
     private Session session;
     private String name;
     /** Creates a new instance of JSDTClient */
     public JSDTChatClient()
          manager = JSDTManager.getInstance();
     public JSDTChatClient(String sN) throws Exception
          this();
          setName(sN);
//          String sHost = "BOH-EAAC-IT3.eaac.boh";
          String sHost = "localhost";
          int nPort = JSDTManager.nCLIENT_PORT_BASE;
          int nTry = 1;
          boolean bCreated = false;
          while(bCreated == false && nPort <= JSDTManager.nCLIENT_PORT_LIMIT)
               URLString clientURL = URLString.createClientURL(sHost, nPort, "socket", sN);
               if(ClientFactory.clientExists(clientURL))
                    bCreated = true;
               else
                    try{
                         System.out.println("JSDTChatClient:Client Create Attempt '" + nTry + "'");
                         ClientFactory.createClient(this, clientURL, this);
                    }catch(AlreadyBoundException eX){
                         eX.printStackTrace();
                         System.exit(1);
                    }catch(PortInUseException eX){
                         nPort++;
                         Thread.sleep(5000);
                    }catch(TimedOutException eX){
                         System.out.println("JSDTChatClient:Client Create Attempt '" + nTry + "' Timed Out");
                         Thread.sleep(5000);
               nTry++;
          if(bCreated)
               System.out.println("JSDTChatClient:Client Created");
          else
               System.out.println("JSDTChatClient:Client NOT Created");
               System.exit(1);
          nPort = 4461;
          nTry = 1;
          bCreated = false;
          URLString sessionURL = null;
          while(bCreated == false)
               sessionURL = URLString.createSessionURL(sHost, nPort, "socket", JsdtChatApp.sCHATTER);
               if(SessionFactory.sessionExists(sessionURL))
                    bCreated = true;
               else
                    try{
                         System.out.println("JSDTChatClient:Session Create Attempt '" + nTry + "'");
                         session = SessionFactory.createSession(this, sessionURL, false);
                    }catch(PortInUseException eX){
                         nPort++;
                         Thread.sleep(5000);
                    }catch(TimedOutException eX){
                         System.out.println("JSDTChatClient:Session Create Attempt '" + nTry + "' Timed Out");
                         Thread.sleep(5000);
               nTry++;
          System.out.println("JSDTChatClient:Found Session '" + JsdtChatApp.sCHATTER + "'");
          try{
               session = SessionFactory.createSession(this, sessionURL, false);
               session.join(this);
               session.addSessionListener(this);
               System.out.println("JSDTChatClient:Joined Session");
          }catch(JSDTException eX){
               eX.printStackTrace();
          while(true)
//***********************     Client Listener Section     ***********************
     public void byteArrayExpelled(ClientEvent event)
     public void byteArrayInvited(ClientEvent event)
     public void channelExpelled(ClientEvent event)
     public void channelInvited(ClientEvent event)
          Session session = event.getSession();
          String sChn = event.getResourceName();
          System.out.println("JSDTChatClient: has been Invited to join Channel '" + sChn + "'");
          try{
               Channel chn = session.createChannel(this, sChn, true, true, false);
               chn.join(this, Channel.READWRITE);
               System.out.println("JSDTChatClient:Joined Channel '" + chn.getName() + "'");
               chn.addChannelListener(this);
          }catch(JSDTException eX){
               eX.printStackTrace();
     public void sessionExpelled(ClientEvent event)
     public void sessionInvited(ClientEvent event)
     public void tokenExpelled(ClientEvent event)
     public void tokenInvited(ClientEvent event)
     public void tokenGiven(ClientEvent event)
//***********************     Client Listener Section     ***********************
//***********************     Channel Listener Inerface     ***********************
     public void channelJoined(ChannelEvent event)
     public void channelLeft(ChannelEvent event)
     public void channelInvited(ChannelEvent event)
          System.out.println("JSDTChatClient:Channel Listener - channelInvited from '" + event.getClientName() + "'");
          Channel chn = event.getChannel();
          try{
               chn.join(this, Channel.READWRITE);
               System.out.println("JSDTChatClient:Joined Channel '" + chn.getName() + "'");
          }catch(JSDTException eX){
               eX.printStackTrace();
     public void channelExpelled(ChannelEvent event)
     public void channelConsumerAdded(ChannelEvent event)
     public void channelConsumerRemoved(ChannelEvent event)
//***********************     Channel Listener Inerface     ***********************
//***********************     Client Inerface     ***********************
     public Object authenticate(AuthenticationInfo info)
          String sRetVal = null;
          System.out.println("JSDTChatClient:authenticate \n" + info.toString());
          int nAction = info.getAction();
          char chType = info.getType();
          if(chType == AuthenticationInfo.SESSION)
               if(nAction == AuthenticationInfo.CREATE_CHANNEL)
                    sRetVal = JSDTManager.sCREATE_CHANNEL_ALLOWED;
               else if(nAction == AuthenticationInfo.JOIN)
                    sRetVal = JSDTManager.sJOIN_SESSION_ALLOWED;
          else if(chType == AuthenticationInfo.CHANNEL)
               sRetVal = JSDTManager.sJOIN_CHANNEL_ALLOWED;
          else if (chType == AuthenticationInfo.REGISTRY)
               sRetVal = JSDTManager.sCREATE_CLIENT_ALLOWED;
          return sRetVal;
     public String getName()
          return name;
//***********************     Client Inerface     ***********************
//***********************     Session Listener Inerface     ***********************
     public void byteArrayCreated(SessionEvent event)
     public void byteArrayDestroyed(SessionEvent event)
     public void channelCreated(SessionEvent event)
     public void channelDestroyed(SessionEvent event)
     public void sessionDestroyed(SessionEvent event)
     public void sessionJoined(SessionEvent event)
          String sN = event.getClientName();
          System.out.println("JSDTChatClient:sessionJoined from '" + sN + "'");
     public void sessionLeft(SessionEvent event)
     public void sessionInvited(SessionEvent event)
     public void sessionExpelled(SessionEvent event)
     public void tokenCreated(SessionEvent event)
     public void tokenDestroyed(SessionEvent event)
//***********************     Session Listener Inerface     ***********************
     public void setName(String sN)
          name = sN;
     * @param args the command line arguments
     public static void main(String[] sArgs) throws Exception
          new JSDTChatClient(sArgs[0]);
******************* Code for JSDTChatClient.java *********************
Hope this helps