session.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/x3d/proxy/session.H>

#include <archon/x3d/proxy/node.H>
#include <archon/x3d/proxy/application.H>
#include <archon/x3d/proxy/event.H>

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

#define CORBA_ENTRY_V(x) try { session->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidApplicationException(); } \
catch(...) { string m = Proxy::exceptionCatchShortExplanation(); \
throw x3d::sai::ApplicationErrorException(m.c_str()); }

#define CORBA_ENTRY_R(x) try { return session->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidApplicationException(); } \
catch(...) { string m = Proxy::exceptionCatchShortExplanation(); \
throw x3d::sai::ApplicationErrorException(m.c_str()); }

namespace Archon
{
  namespace X3D
  {
    namespace Proxy
    {
      struct Session::Servant:
        POA_x3d::sai::Application, PortableServer::RefCountServantBase
      {
        const BackRef<Session> session;

        Servant(Ref<Session> s): session(s) {}

        void handleEvent(const x3d::sai::EventSeq &s)
        {
          CORBA_ENTRY_V(handleEvent(s));
        }

        x3d::sai::StreamReader_ptr requestFile(const char *path)
        {
          CORBA_ENTRY_R(requestFile(path));
        }

        void log(const char *message)
        {
          CORBA_ENTRY_V(log(message));
        }
      };


      template<typename T>
      struct AutoArrayPtr
      {
        AutoArrayPtr(unsigned long n): p(new T[n]) {}
        ~AutoArrayPtr() {{ delete[] p; }}
        T *p;
      };


      Ref<Session> Session::create(string serverName,
                                   int corbaEndpointPort,
                                   Logger *l)
        throw(ConnectionException)
      {
        Ref<Session> s = new Session(serverName, corbaEndpointPort, l);
        s->activate();
        return s;
      }

      Session::Session(string serverName, int corbaEndpointPort, Logger *l)
        throw(ConnectionException):
        logger(l), orb(corbaEndpointPort), active(false)
      {
        // Attempt to contact the server
        server = getServerReference(serverName);

        nodeTypeIdBits = server->getNodeTypeBitsInId();
        nodeTypeIdMask = (1 << nodeTypeIdBits) - 1;
        nodeTypeIdRoof = 0;

        for(unsigned long i=0; i<numberOfNodeTypes; ++i)
        {
          const NodeDef &d = nodeDefs[i];
          NodeLink &l = nodeLinks[i];
          try
          {
            unsigned long ti = server->getNodeType(d.name);
            if(ti >= nodeTypeIdRoof) nodeTypeIdRoof = ti+1;
            l.id = ti + 1;
          }
          catch(x3d::sai::InvalidNameException &)
          {
            logger->log("Server does not support node type '" +
                        string(d.name) + "'");
            continue;
          }

          if(!d.numberOfFields) continue;

          l.fields = new FieldLink[d.numberOfFields];

          for(unsigned long j=0; j<d.numberOfFields; ++j)
          {
            try
            {
              l.fields[j].id = server->
                getImmediateField(l.id-1, d.fields[j].name) + 1;
            }
            catch(x3d::sai::InvalidNameException &)
            {
              logger->log("Server does not support field '" +
                          string(d.name) + "." +
                          string(d.fields[j].name) + "'");
              continue;
            }

            l.fields[j].id = 0;
          }
        }


        // Create a mapping from Node type IDs to locally known Node
        // type indices.
        if(nodeTypeIdRoof > 1024)
          ARCHON_THROW1(ProtocolException, "Suspiciously many node types: " +
                        Text::toString(nodeTypeIdRoof));
        nodeTypeMap.reset(Array<unsigned long>(nodeTypeIdRoof).out());
        for(unsigned long i=0; i<nodeTypeIdRoof; ++i) nodeTypeMap[i] = 0;
        for(unsigned long i=0; i<numberOfNodeTypes; ++i)
        {
          unsigned long id = nodeLinks[i].id;
          if(!id) continue;
          nodeTypeMap[id-1] = i+1;
        }
      }

      void Session::refForwardDestroy()
      {
        if(active)
        {
          orb.getPoa()->deactivate_object(servantId);
          disposer->terminate();
          disposer.reset();
        }
      }

      void Session::activate()
      {
        // Create a session on the server
        ServantRef<Servant> servant = new Servant(this);
        servantId = orb.getPoa()->activate_object(servant.get());
        x3d::sai::Application_var ref = servant->_this();
        session = server->createSession(ref);
        active = true;
        server = 0; // Release the server reference

        // Startup the disposer thread
        disposer = new Disposer(session);
        Thread::start(disposer);
      }



      void Session::beginUpdate()
      {
        session->beginUpdate();
      }

      void Session::endUpdate()
      {
        session->endUpdate();
      }



      Ref<Application> Session::createApplication(const Uri &u)
      {
        CORBA::Boolean localFileUri = true;
        Ref<ExecutionContext> c =
          id2context(session->createApplicationScene(u.toString().c_str(),
                                                     localFileUri), true);
        return dynamic_cast<Application *>(c.get());
      }

      Ref<Application> Session::loadApplication(const Uri &u)
      {
        CORBA::Boolean localFileUri = true;
        Ref<ExecutionContext> c =
          id2context(session->loadApplicationScene(u.toString().c_str(),
                                                   localFileUri), true);
        return dynamic_cast<Application *>(c.get());
      }

      void Session::destroyContext(ExecutionContext *c)
      {
        unsigned long ci = c->id;
        {
          Mutex::Lock l(contextMapMutex);
          ExecutionContext *&m = contextMap[ci];
          if(m == c) m = 0;
        }

        disposer->addContext(c->id, c->transCount);
      }

      Ref<ExecutionContext> Session::id2context(unsigned long id, bool isApplication)
      {
        if(!id) return 0;
        if(id > 1024L)
          ARCHON_THROW1(ProtocolException,
                        "Got suspiciously large context ID: " +
                        Text::toString(id));
        Mutex::Lock l(contextMapMutex);
        if(contextMap.size() <= id) contextMap.resize(id+1, 0);
        ExecutionContext *&m = contextMap[id];
        Ref<ExecutionContext> c(m, RefSafeIncTag());
        if(!c) c = isApplication ? new Application(this, id) :
          new ExecutionContext(this, id);
        ++c->transCount;
        m = c.get();
        return c;
      }

      unsigned long Session::context2id(Ref<ExecutionContext> c)
      {
        return c ? c->id : 0;
      }




      Ref<NodeBase> Session::createNode(ExecutionContext *c, unsigned long i)
      {
        unsigned long ti = nodeLinks[i].id;
        if(!ti)
        {
          ARCHON_THROW1(SupportException,
                        "Node type '" + string(nodeDefs[i].name) +
                        "' is not supported by the server");
          return 0;
        }
        --ti;
        return id2node(session->createNodeFast(c->id, ti));
      }

      void Session::destroyNode(NodeBase *n)
      {
        unsigned long ni = n->id >> nodeTypeIdBits;
        {
          Mutex::Lock l(nodeMapMutex);
          NodeBase *&m = nodeMap[ni];
          if(m == n) m = 0;
        }

        disposer->addNode(n->id, n->transCount);
      }

      Ref<NodeBase> Session::id2node(unsigned long id)
        throw(IllegalNodeIdException)
      {
        if(!id) return 0;
        unsigned long i = id >> nodeTypeIdBits;
        if(i > 1048576UL)
          ARCHON_THROW1(ProtocolException,
                        "Got suspiciously large node index: " +
                        Text::toString(i));
        Mutex::Lock l(nodeMapMutex);
        if(nodeMap.size() <= i) nodeMap.resize(i+1, 0);
        NodeBase *&m = nodeMap[i];
        Ref<NodeBase> n(m, RefSafeIncTag());
        if(!n)
        {
          unsigned long ti = id & nodeTypeIdMask;
          if(ti >= nodeTypeIdRoof)
            ARCHON_THROW1(ProtocolException,
                          "Got invalid node type ID from server: " +
                          Text::toString(ti));
          unsigned long i = nodeTypeMap[ti];
          if(!i) ARCHON_THROW1(ProtocolException,
                               "Got invalid node type ID from server: " +
                               Text::toString(ti));
          NodeInstantiator p = nodeDefs[i-1].instantiator;
          if(!p) ARCHON_THROW1(ProtocolException,
                               "Got abstract node type ID from server: " +
                               Text::toString(ti));
          n = (*p)(this, id);
        }
        ++n->transCount;
        m = n.get();
        return n;
      }

      unsigned long Session::node2id(Ref<NodeBase> n)
      {
        return n ? n->id : 0;
      }

      void Session::registerFieldInterest(unsigned long ni, unsigned long fi,
                                          EventHandlerBase *h, bool destroy)
      {
        unsigned long cookie = 0;
        {
          Mutex::Lock l(eventHandlersMutex);
          while(cookie < eventHandlers.size() && eventHandlers[cookie])
            ++cookie;
          if(cookie == eventHandlers.size()) eventHandlers.resize(cookie+1);
          eventHandlers[cookie].reset(h);
        }
        session->registerFieldInterest(ni, fi, cookie);
      }


      struct Session::StreamReaderServant:
        POA_x3d::sai::StreamReader, PortableServer::RefCountServantBase
      {
        StreamReaderServant(Ref<Session> s, Ref<Stream::Reader> r):
          session(s), reader(r) {}

        virtual ~StreamReaderServant()
        {
        }

        x3d::sai::chararray *read(CORBA::Long n)
        {
          AutoArrayPtr<char> buffer(n);
          try
          {
            int m = reader->readAll(buffer.p, n);
            x3d::sai::chararray_var a(new x3d::sai::chararray(m));
            a->length(m);
            for(int i=0; i<m; ++i) a[i] = buffer.p[i];
            return a._retn();
          }
          catch(Archon::Utilities::Stream::ReadException &e)
          {
            string m = e.getMessage();
            throw x3d::sai::StreamReadException(m.c_str());
          }
          catch(ThreadTerminatedException &)
          {
            throw x3d::sai::StreamReadException("Reader was terminated");
          }
          catch(...)
          {
            string m = Proxy::exceptionCatchShortExplanation();
            throw x3d::sai::StreamReadException(m.c_str());
          }
        }

        void dispose()
        {
          session->orb.getPoa()->deactivate_object(servantId);
        }

        Ref<Session> session;
        Ref<Stream::Reader> reader;
        PortableServer::ObjectId_var servantId;
      };


      void Session::handleEvent(const x3d::sai::EventSeq &s)
      {
        for(unsigned i=0; i<s.length(); ++i)
        {
          const x3d::sai::Event &e = s[i];
          if(e.cookie < eventHandlers.size())
          {
            Mutex::Lock l(eventHandlersMutex);
            Ref<EventHandlerBase> h = eventHandlers[e.cookie];
            if(h)
            {
              h->handle(this, e.val);
              continue;
            }
          }
          ARCHON_THROW1(InternalException, "Illegal event handler index");
        }
      }

      x3d::sai::StreamReader_ptr Session::requestFile(const char *p)
      {
        logger->log("Request for file \"" + string(p) + "\"");
        try
        {
          Ref<Stream::Reader> r = Stream::makeFileReader(p);
          ServantRef<StreamReaderServant> servant =
            new StreamReaderServant(this, r);
          servant->servantId = orb.getPoa()->activate_object(servant.get());
          x3d::sai::StreamReader_var ref = servant->_this();
          return ref._retn();
        }
        catch(Stream::FileOpenException &e)
        {
          string m = e.getMessage();
          throw x3d::sai::FileRequestException(m.c_str());
        }
      }

      void Session::log(const char *m)
      {
        logger->log(m);
      }



      x3d::sai::Server_ptr Session::getServerReference(string name)
        throw(ConnectionException)
      {
        CosNaming::NamingContext_var context;

        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(ConnectionException,
                          "CORBA naming service is not available.");
        }
        catch(CORBA::Exception &)
        {
          ARCHON_THROW1(ConnectionException,
                        "CORBA naming service is not available.");
        }

        CORBA::Object_var obj;
        try
        {
          CosNaming::Name path;
          path.length(3);
          path[0].id = "x3d";
          path[1].id = "sai";
          path[2].id = name.c_str();
          obj = context->resolve(path);
        }
        catch(CosNaming::NamingContext::NotFound &)
        {
          ARCHON_THROW1(ConnectionException,
                        "Server '" + name + "' not found.");
        }

        x3d::sai::Server_var server;
        try
        {
          if(obj->_non_existent()) 
            ARCHON_THROW1(ConnectionException,
                          "Server '" + name + "' not found.");
          server = x3d::sai::Server::_narrow(obj);
        }
        catch(CORBA::Exception &)
        {
          ARCHON_THROW1(ConnectionException,
                        "Server '" + name + "' not found.");
        }
        if(CORBA::is_nil(server))
          ARCHON_THROW1(ConnectionException,
                        "Server '" + name + "' not found.");

        return server._retn();
      }
    }
  }
}

---