listener.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <archon/util/cxx_demangle.H>
#include <archon/util/mutex.H>

#include <archon/x3d/sai/listener.H>

#define CORBA_ENTRY_D(x) try { listener->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) {} \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

#define CORBA_ENTRY_V(x) try { listener->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidSessionException(); } \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

#define CORBA_ENTRY_R(x) try { return listener->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidSessionException(); } \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

namespace Archon
{
  namespace X3D
  {
    namespace SAI
    {
      struct Listener::Servant:
        POA_x3d::sai::Server, PortableServer::RefCountServantBase
      {
        const BackRef<Listener> listener;

        Servant(Ref<Listener> listener): listener(listener) {}

        CORBA::ULong getNodeTypeBitsInId()
        {
          CORBA_ENTRY_R(getNodeTypeBitsInId());
        }

        CORBA::ULong getNodeType(const char *typeName)
        {
          CORBA_ENTRY_R(getNodeType(typeName));
        }

        CORBA::ULong getImmediateField(CORBA::ULong nodeTypeId,
                                       const char *fieldName)
        {
          CORBA_ENTRY_R(getImmediateField(nodeTypeId, fieldName));
        }

        x3d::sai::Session_ptr createSession(x3d::sai::Application_ptr a)
        {
          CORBA_ENTRY_R(createSession(a));
        }
      };


      Listener::Listener(Ref<Server> server,
                         Time applicationHeartbeat,
                         int corbaEndpointPort):
        server(server),
        applicationHeartbeat(applicationHeartbeat),
        orb(corbaEndpointPort), active(false)
      {
      }

      Listener::~Listener()
      {{
      }}

      void Listener::activate() throw(NameServerException)
      {
        if(active) return;
        ServantRef<Servant> servant = new Servant(this);
        servantId = orb.getPoa()->activate_object(servant.get());
        x3d::sai::Server_var ref = servant->_this();

        CosNaming::NamingContext_var context;
        CosNaming::Name label;
        label.length(1);

        try
        {
          // Fetch the root naming context
          CORBA::Object_var obj =
            orb.getCorbaOrb()->resolve_initial_references("NameService");
          context = CosNaming::NamingContext::_narrow(obj);
          if(CORBA::is_nil(context))
            ARCHON_THROW1(NameServerException,
                         "CORBA naming service is not available1.");
        }
        catch(CORBA::Exception &e)
        {
          ARCHON_THROW1(NameServerException,
                        "CORBA naming service is not available.");
        }

        try
        {
          label[0].id = "x3d";
          context = context->bind_new_context(label);
        }
        catch(CosNaming::NamingContext::AlreadyBound &ex)
        {
          CORBA::Object_var obj = context->resolve(label);
          context = CosNaming::NamingContext::_narrow(obj);
          if(CORBA::is_nil(context))
            ARCHON_THROW1(NameServerException,
                          "'/x3d.context' is not a naming context.");
        }

        try
        {
          label[0].id = "sai";
          context = context->bind_new_context(label);
        }
        catch(CosNaming::NamingContext::AlreadyBound &ex)
        {
          CORBA::Object_var obj = context->resolve(label);
          context = CosNaming::NamingContext::_narrow(obj);
          if(CORBA::is_nil(context))
            ARCHON_THROW1(NameServerException,
                          "'/x3d.context/sai.context' is not a naming "
                          "context.");
        }

        string name = server->getName();
        label[0].id = name.c_str();
        try
        {
          context->bind(label, ref);
        }
        catch(CosNaming::NamingContext::AlreadyBound &)
        {
          CORBA::Object_var boundObj = context->resolve(label);
          for(;;)
          {
            try
            {
              if(boundObj->_non_existent()) break;
            }
            catch(CORBA::Exception &) { break; }
            ARCHON_THROW1(NameServerException,
                          "'/x3d.context/sai.context/" +
                          name + ".object' is in use.");
          }
          context->rebind(label, ref);
        }

        active = true;
      }

      void Listener::deactivate()
      {
        if(!active) return;
        orb.getPoa()->deactivate_object(servantId);
        active = false;
      }

      void Listener::startServingClientRequests(Ref<GroupingNode> applicationContainer)
        throw(NameServerException)
      {
        Mutex::Lock lock(mutex);
        this->applicationContainer = applicationContainer;
        activate();
      }

      CORBA::ULong Listener::getNodeTypeBitsInId()
      {
        return NodeType::maxIndexBits;
      }

      CORBA::ULong Listener::getNodeType(const char *n)
      {
        const NodeType *t = NodeType::lookup(n);
        if(!t) throw x3d::sai::InvalidNameException();
        return t->getIndex();
      }

      CORBA::ULong Listener::getImmediateField(CORBA::ULong ti, const char *n)
      {
        if(ti >= NodeType::getTotalNumber())
          throw x3d::sai::InvalidTypeException();
        const NodeType *t = NodeType::get(ti);
        const FieldBase *f = t->lookupImmediateField(n);
        if(!f) throw x3d::sai::InvalidNameException();
        return f->getId();
      }

      x3d::sai::Session_ptr Listener::
      createSession(x3d::sai::Application_ptr a)
      {
        Ref<Session> session = new Session(this, a);
        x3d::sai::Session_var ref =
          session->createServant(applicationHeartbeat);
        {
          Mutex::Lock lock(mutex);
          sessions.push_back(session);
        }
        return ref._retn();
      }

      void Listener::removeSession(Ref<Session> s)
      {
        Mutex::Lock lock(mutex);
        sessions.remove(s);
      }

      void Listener::refForwardDestroy()
      {
        deactivate();
        sessions.clear();
        applicationContainer.reset();
      }
    }
  }
}

---