load.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 <math.h>

#include <string>
#include <vector>

#include <archon/util/text.H>
#include <archon/util/stream.H>
#include <archon/util/pipe.H>
#include <archon/util/image.H>

//#include <archon/x3d/server/parse_vrml.H>
#include <archon/x3d/server/parse_xml.H>

#include <archon/x3d/server/load.H>
#include <archon/x3d/server/server.H>

using namespace std;

namespace Archon
{
  using namespace Math;
  using namespace Utilities;

  namespace X3D
  {
    namespace
    {
      long sourceNameCounter(string sourceName)
      {
        static map<string, long> m;
        return m[sourceName]++;
      }

      struct PrefixLogger: Utilities::Logger
      {
        string prefix;
        Logger *logger;
        PrefixLogger(string prefix, Logger *logger):
          prefix(prefix), logger(logger) {}

        void log(string message) throw()
        {
          logger->log(prefix + message);
        }

        virtual ~PrefixLogger()
        {
        }
      };
    }

    struct ImageLoadTracker: Image::ProgressTracker
    {
      void progress(double fraction) throw()
      {
        //progressTracker->progress(chars_loaded);
      }
    };

    Loader::Job::Job(Ref<Loader> loader, Uri baseUri,
                     const vector<string> &uriList, UriType uriType,
                     Ref<AbstractFileServer> fileServer):
      loader(loader), webClient(loader->webClient), baseUri(baseUri),
      uriList(uriList), uriType(uriType), completed(false),
      fileServer(fileServer)
    {
    }

    Loader::Job::~Job()
    {
    }

    void Loader::Job::wait()
    {
      Mutex::Lock l(loader->mutex);
      while(!completed) loader->jobCompletion.wait();
    }

    void Loader::Job::kill()
    {
      Mutex::Lock l(loader->mutex);
      loader->jobQueue.cancel(this);
    }

    Ref<const Loader::Contents> Loader::Job::getContents()
    {
      Mutex::Lock l(loader->mutex);
      return contents;
    }

    Ref<const Loader::Contents>
    Loader::Job::loadX3D(Ref<Stream::Reader> reader, string contentType,
                         Uri sourceUri, int sourceLine, Logger *logger)
    {
      Ref<Server> server;
      try { server = loader->server.getRef(); }
      catch(ForwardDestroyedException &) { return 0; }
      bool progressive = server->getProgressiveLoad();
      Ref<Scene> rootScene = new Scene(server, sourceUri);
      Ref<Group> rootGroup = new Group(Ref<ExecutionContext>(rootScene));
      XML::parse(rootScene, rootGroup, reader, progressive);
      rootScene->setRootGroup(rootGroup);
      return new X3DContents(rootScene);
    }

    Ref<const Loader::Contents>
    Loader::Job::loadImage(Ref<Stream::Reader> reader, string contentType,
                           Uri sourceUri, Logger *logger)
    {
      Ref<ImageContents> c = new ImageContents;
      // progressTracker->setInitialContents(c);
      c->image.load(reader, sourceUri.getFile(), "", 0, logger);
      return c;
    }

    Ref<const Loader::Contents>
    Loader::Job::loadMovie(Ref<Stream::Reader> reader, string contentType,
                           Uri sourceUri, Logger *logger)
    {
      return new MovieContents;
    }

    Ref<const Loader::Contents>
    Loader::Job::loadScript(Ref<Stream::Reader> reader, string contentType,
                            Uri sourceUri, int sourceLine, Logger *logger)
    {
      string s = Stream::readIntoString(reader);
      return new ScriptContents("ecmascript", string(s), sourceUri.getFile(),
                                sourceLine);
    }

    Ref<const Loader::Contents>
    Loader::Job::load(Ref<Stream::Reader> reader, string contentType,
                      Uri sourceUri, int sourceLine, Logger *logger)
    {
      switch(uriType)
      {
      case uriType_X3D:
        return loadX3D(reader, contentType, sourceUri, sourceLine, logger);
      case uriType_Image:
        return loadImage(reader, contentType, sourceUri, logger);
      case uriType_Movie:
        return loadMovie(reader, contentType, sourceUri, logger);
      case uriType_Script:
        return loadScript(reader, contentType, sourceUri, sourceLine, logger);
      default:
        ARCHON_THROW1(InternalException,
                      "X3D::Loader::Job: Unexpected Uri type");
      }
    }

    void Loader::Job::main()
    {
      for(unsigned i=0; i<uriList.size(); ++i)
      {
        string s = uriList[i];

        /*
         * Intercept the "ecmascript:" / "javascript:" (deprecated) URI
         * schemes.
         * Note that these inlined schemes are non-cachable.
         */
        const string::size_type p = s.find(':');
        if(p != string::npos)
        {
          string scheme(s, 0, p);
          if(Text::compareIgnoreCase(scheme, "ecmascript") == 0 ||
             Text::compareIgnoreCase(scheme, "javascript") == 0)
          {
            static unsigned long counter = 0;

            PrefixLogger
              logger("[inlined ECMAScript]" +
                     string(counter ? "[" + Text::toString(counter) +
                            "]" : "") + ": ", loader->logger);
            ++counter;

            try
            {
              Ref<Stream::Reader> reader = Stream::makeStringReader(s.substr(p+1));
              Ref<const Contents> c =
                load(reader, "text/ecmascript", Uri(), -1, &logger);
              reader.reset();

              Mutex::Lock l(loader->mutex);
              contents = c;
              break;
            }
            catch(InternalException &)
            {
              throw;
            }
            catch(ThreadTerminatedException &)
            {
              logger.log("Loading canceled");
              break;
            }
            catch(Image::UnknownFormatException &)
            {
              logger.log("Unknown image format");
            }
            catch(...)
            {
              logger.log("Loading failed");
            }
            continue;
          }
        }


        Uri uri;

        try
        {
          uri = Uri(s, baseUri);
        }
        catch(Uri::SyntaxException &e)
        {
          loader->logger->log("Malformed URI:\n" + Uri::explain(e));
          continue;
        }

        string absoluteUriString = uri.toString();
        bool cachable = uriType != uriType_X3D;

        // Consult the cache
        if(cachable)
        {
          if(uri.isFileScheme() && fileServer)
            absoluteUriString = "archon://" +
              Text::toString(fileServer->getFileServerId()) +
              uri.getPath();

          Mutex::Lock l(loader->mutex);
          for(;;)
          {
            map<string, Ref<const Contents> >::iterator i =
              loader->cache.find(absoluteUriString);
            if(i == loader->cache.end()) break;
            contents = i->second;
            if(contents) break;
            loader->cacheChange.wait();
          }
          if(contents) break;

          // No hit so allocate a new cache entry
          loader->cache[absoluteUriString];
        }

        string sourceName = uri.getFile();
        int counter = sourceNameCounter(sourceName);
        PrefixLogger
          logger(sourceName + (counter ? "[" + Text::toString(counter) +
                               "]" : "") + ": ", loader->logger);

        bool quit = false;
        try
        {
          Ref<Stream::Reader> reader;
          string contentType;

          if(uri.isFileScheme() && fileServer)
          {
            string path = uri.getPath();
            logger.log("Requesting: " + absoluteUriString);
            reader = fileServer->request(path);
            logger.log("Found");
          }
          else
          {
            logger.log("Requesting: " + absoluteUriString);
            Ref<Web::Client::Response> response =
              webClient->request(Web::Client::Request::get(uri));
            contentType = response->getContentType();
            logger.log("Found: " + contentType);
            reader = response;
          }
          Ref<const Contents> c = load(reader, contentType, uri, 1, &logger);
          reader.reset();
          logger.log("Loaded");

          {
            Mutex::Lock l(loader->mutex);
            contents = c;
            if(cachable) loader->cache[absoluteUriString] = c;
          }
          if(cachable) loader->cacheChange.notifyAll();
          break;
        }
        catch(InternalException &)
        {
          throw;
        }
        catch(ThreadTerminatedException &)
        {
          logger.log("Loading canceled");
          quit = true;
        }
        catch(Image::UnknownFormatException &)
        {
          logger.log("Unknown image format");
        }
        catch(AbstractFileServer::RequestException &e)
        {
          logger.log("Loading failed: " + e.getMessage());
        }
        catch(Web::RequestException &e)
        {
          logger.log("Loading failed: " + e.getMessage());
        }
        catch(...)
        {
          logger.log("Loading failed");
        }

        // Remove cache entry for faulty URI
        if(cachable)
        {
          {
            Mutex::Lock l(loader->mutex);
            loader->cache.erase(absoluteUriString);
          }
          loader->cacheChange.notifyAll();
        }
        if(quit) break;
      }

      // Signal completion
      onCompletion();
      completed = true;
      loader->jobCompletion.notifyAll();
    }


    Loader::Loader(Ref<Server> server, Ref<Web::Client> webClient):
      server(server),
      logger(server->getLogger()),
      webClient(webClient),
      jobQueue(5, Time(30l)),
      cacheChange(mutex), jobCompletion(mutex)
    {
    }

    Loader::~Loader()
    {
      wait();
    }

    void Loader::submitJob(Ref<Job> j)
    {
      jobQueue.add(j.get());
    }
  }
}

---