CGIApplication.cc

/*
 * $Id: CGIApplication.cc,v 1.8 2006/04/03 19:47:25 brook Exp $
 */

/*
 * ClearSilver++ Software License.
 *
 * Copyright (c) 2006 Brook Milligan <brook@nmsu.edu>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "CGIApplication.h"
#include <fstream>
#include <stdexcept>
#include <syslog.h>
#include "ClearSilverException.h"

using namespace std;

namespace ClearSilver
{

                                // constructors
  CGIApplication::CGIApplication ()
    : TraceObject(debug(), "CGIApplication"), cgi_()
  {}

  CGIApplication::CGIApplication (const char* name)
    : TraceObject(debug(), "CGIApplication", "const char*"), cgi_()
  {
    if (name)
      {
        ifstream f (name);
        if (!f)
          {
            string message;
            message += "ClearSilver::CGIApplication::CGIApplication(";
            message += name;
            message += "):  cannot read HDF file ";
            message += name;
            throw invalid_argument (message);
          }
        f.close();
        HDF hdf (name);
        cgi_ = CGI(hdf);
      }
  }

  CGIApplication::CGIApplication (const std::string& name)
    : TraceObject(debug(), "CGIApplication", "const std::string&"),
      cgi_()
  {
    if (!name.empty())
      {
        ifstream f (name.c_str());
        if (!f)
          {
            string message;
            message += "ClearSilver::CGIApplication::CGIApplication(";
            message += name;
            message += "):  cannot read HDF file ";
            message += name;
            throw invalid_argument (message);
          }
        f.close();
        HDF hdf (name);
        cgi_ = CGI(hdf);
      }
  }

  CGIApplication::CGIApplication (const HDF& hdf)
    : TraceObject(debug(), "CGIApplication", "const HDF&"),
      cgi_(hdf)
  {}

  CGIApplication::CGIApplication (const CGI& cgi)
    : TraceObject(debug(), "CGIApplication", "const CGI&"),
      cgi_(cgi)
  {}

  CGIApplication::CGIApplication (const CGIApplication& a)
    : TraceObject(a), cgi_(a.cgi_)
  {}

  CGIApplication::~CGIApplication () throw()
  {}

                                // assignment
                                // XXX - cannot use construct/swap idiom
                                //       because of pure abstract functions
  CGIApplication&
  CGIApplication::operator = (const CGIApplication& a)
  {
    TraceObject::operator = (a);
    cgi_ = a.cgi_;
    return *this;
  }

  CGIApplication&
  CGIApplication::operator = (const CGI& cgi)
  {
    if (debug())
      syslog (LOG_DEBUG, "%s: this=0x%x, CGI=0x%x",
              "ClearSilver::CGIApplication::operator = (const CGI&)",
              this, &cgi);
    cgi_ = cgi;
    return *this;
  }

                                // swap contents
  void
  CGIApplication::swap (CGIApplication& a) throw()
  {
    TraceObject::swap (a);
    cgi_.swap (a.cgi_);
  }


                                // CGI application entry point
  void
  CGIApplication::operator () ()
  {
    if (debug())
      syslog (LOG_DEBUG, "%s", "ClearSilver::CGIApplication::operator()()");
    try
      {
        initialize ();
        if (authenticate ())
          {
            execute ();
            display ();
          }
        else
          {
            execute_unauthenticated ();
            display_unauthenticated ();
          }
        terminate ();
        cgi_.hdf().remove_cgi();
        if (debug())
          syslog (LOG_DEBUG, "%s",
                  "ClearSilver::CGIApplication::operator()() done");
      }
    catch (const ClearSilverException& e)
      {
        string message;
        message += "ClearSilverException:  ";
        message += e.what ();
        syslog (LOG_ERR, "%s", message.c_str());
        handle_exception (message);
      }
    catch (const invalid_argument& e)
      {
        string message;
        message += "std::invalid_argument:  ";
        message += e.what ();
        syslog (LOG_ERR, "%s", message.c_str());
        handle_exception (message);
      }
    catch (const logic_error& e)
      {
        string message;
        message += "std::logic_error:  ";
        message += e.what ();
        syslog (LOG_ERR, "%s", message.c_str());
        handle_exception (message);
      }
    catch (const runtime_error& e)
      {
        string message;
        message += "std::runtime_error:  ";
        message += e.what ();
        syslog (LOG_ERR, "%s", message.c_str());
        handle_exception (message);
      }
    catch (...)
      {
        string message;
        message += "Unknown exception caught.";
        syslog (LOG_ERR, "%s", message.c_str());
        handle_exception (message);
      }
  }

                                // access data structures
  CGI
  CGIApplication::cgi () const
  {
    return cgi_;
  }

  HDF
  CGIApplication::hdf ()
  {
    return cgi_.hdf();
  }

                                // CGI application hooks
  void
  CGIApplication::initialize () {}

  void
  CGIApplication::execute () {}

  void
  CGIApplication::display ()
  {
    if (debug())
      syslog (LOG_DEBUG, "%s", "ClearSilver::CGIApplication::display()");
    if (cgi())
      {
        HDF::const_iterator ti = hdf().find("hdf.templates.authenticated");
        if (ti != hdf().end())
          cgi().display(ti->value());
        else
          {
            ti = hdf().find("hdf.template");
            if (ti != hdf().end())
              cgi().display(ti->value());
            else
              throw ClearSilverException ("No ClearSilver template found.");
          }
      }
    else
      throw ClearSilverException ("Not running in a CGI environment.");
    if (debug())
      syslog (LOG_DEBUG, "%s",
              "ClearSilver::CGIApplication::display(): done");
  }

  void
  CGIApplication::execute_unauthenticated () {}

  void
  CGIApplication::display_unauthenticated ()
  {
    if (debug())
      syslog (LOG_DEBUG, "%s",
              "ClearSilver::CGIApplication::display_unauthenticated()");
    if (cgi())
      {
        HDF::const_iterator ti = hdf().find("hdf.templates.unauthenticated");
        if (ti != hdf().end())
          cgi().display(ti->value());
        else
          {
            ti = hdf().find("hdf.template");
            if (ti != hdf().end())
              cgi().display(ti->value());
            else
              throw ClearSilverException ("No ClearSilver template found.");
          }
      }
    else
      throw ClearSilverException ("Not running in a CGI environment.");
    if (debug())
      syslog (LOG_DEBUG, "%s",
              "ClearSilver::CGIApplication::display_unauthenticated(): done");
  }

  void
  CGIApplication::terminate () {}

  void
  CGIApplication::handle_exception (const string& message)
  {
    ClearSilverException e (message);
    throw e;
  }

  // debuging flag
  bool&
  CGIApplication::debug ()
  {
    static bool debug_ = false;
    return debug_;
  }

};                              // namespace ClearSilver

---