/home/croftj/photogrotto/dbPhotoService.cpp

/*********************************************************************************
**
**   $Id: //depot/WorkInProgress/photogrotto/dbPhotoService.cpp#4 $
**   Copyright (c) 2007 Joe Croft joe@croftj.net
**   
**   This file is part of Photogrotto
**
**   Photogrotto is free software; you can redistribute it and/or modify
**   it under the terms of the GNU General Public License as published by
**   the Free Software Foundation; either version 2 of the License, or
**   (at your option) any later version.
**
**   Foobar is distributed in the hope that it will be useful,
**   but WITHOUT ANY WARRANTY; without even the implied warranty of
**   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**   GNU General Public License for more details.
**
**   You should have received a copy of the GNU General Public License
**   along with Foobar; if not, write to the Free Software
**   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
*********************************************************************************/

# include <Magick++.h>
# include <QBuffer>
# include <QBuffer>
# include <QDir>
# include <QImage>
# include <QImageReader>
# include <QSqlDatabase>
# include <QSqlError>
# include <QSqlQuery>
# include "dbPhotoService.h"


using namespace Magick;


static QHash<QString, Image>        photoCache;
static QHash<QString, Image>        photoResizeCache;
static int                          maxPhotos = 250;
static int                          maxResizePhotos = 1000;
static QList<QString>               photoList;
static QList<QString>               photoResizeList;
static QMutex                       photoLock;
static QMutex                       dbLock;

extern FILE *logfp;

/*!
      \class DbPhotoService
      
      \brief Class for processing individual photo requests.
      
      The      DbPhotoService    class    is a subclass for the
      QcjHttpService  class. It handles requests for individual
      photos.  It  will  resize  and properly set the number of
      colors as requested.
*/ 


/*!
      \fn void DbPhotoService::setMaxCache(int n)

       Sets  the maximum number of entries allowed in the photo cache.
       The  photo  resize  cache  is  set  to 5 times the value of the
       parameter <em>n</em> as well.
*/ 
void DbPhotoService::setMaxCache(int n)
{
   maxPhotos = n;
   maxResizePhotos = n * 5;
}

/*!
       This  function  has proven useless, kept just in case it can be
       made  to work later. The point of it is to clear any locks that
       may   be   set  for  this  object.  Unfortunately,  you  cannot
       arbitarely  clear unlocked locks, nor can you test is a lock is
       locked.
*/ 
void DbPhotoService::clearLocks()
{
   fprintf(logfp, "DbPhotoService::clearLocks(%s): Enter, unlocking db and photo locks\n", qPrintable(QString::number(currentThreadId())));
   fflush(logfp);
# if 0
   if ( dbLock.isLocked() ) 
      dbLock.unlock();
   if ( photoLock.isLocked() ) 
      photoLock.unlock();
# endif
   fprintf(logfp, "DbPhotoService::clearLocks(%s): Exit\n", qPrintable(QString::number(currentThreadId())));
   fflush(logfp);
}


/*!
      \fn void DbPhotoService::processRequest(QMap<QString, QVariant> *req, QMap<QString, QVariant> *rsp)

       Processes  the incoming request parameter <em>req</em>. It then
       formulates  a  response  and puts it into the map pointed to by
       the  parameter  <em>req</em>.  Both  parameters  must  point to
       valid, though possibly emtpy QMaps.
*/ 
void DbPhotoService::processRequest(QMap<QString, QVariant> *req, QMap<QString, QVariant> *rsp)
{
   int t_height, t_width;

   fprintf(logfp, "DbPhotoService::processRequest(%s): Enter\n", qPrintable(QString::number(currentThreadId())));
   fflush(logfp);

   QMapIterator<QString, QVariant> i(*req);
   while (i.hasNext()) 
   {
      i.next();
      fprintf(logfp, "DbPhotoService::processRequest(%s): req: |%s| = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(i.key()), qPrintable(i.value().toString()));
      fflush(logfp);
   }

   /***********************************************/
   /*   Get  the  values  from  the  request map  */
   /*   which   are   required  to  satisfy  the  */
   /*   request                                   */
   /***********************************************/
   QString method = req->value("Method").toString();
   QString resource = req->value("Resource").toString();
   QString args = req->value("Arguments").toString();
   QString host = req->value("Host").toString();

   /***********************************************/
   /*   Parse out the arguments from the request  */
   /*   line                                      */
   /***********************************************/
   QMap<QString, QString> arguments = parseArguments(args);

   QString fileType;
   QString fileBase;

   /***********************************************/
   /*   Here we handle the GET requests.          */
   /***********************************************/
   if ( method == "GET" ) 
   {
      QRegExp re("(.*)\\.(jpg|png|jpeg|ppm|xpm|xbm|bmp|htm|html|pl)");
      re.setCaseSensitive(false);
      re.setMinimal(true);
      if ( re.indexIn(resource) >= 0 ) 
      {
         fprintf(logfp, "DbPhotoService::processRequest(%s): Found name and extension\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         fileType = re.cap(2).toLower();
         fileBase = re.cap(1);
         fileBase.remove(QRegExp("^/"));
      }
      else 
      {
         fprintf(logfp, "DbPhotoService::processRequest(%s): Error in resource, exiting\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         errorResponse(QcjHttpService::NotFound, "Requested resource not found");
         return;
      }

      /***********************************************/
      /*   If  it  a  pl extension, assume it is an  */
      /*   action  an  not  just  a  request  for a  */
      /*   picture                                   */
      /*   Currently untested.                       */
      /***********************************************/
      if ( fileType == "pl" ) 
      {
         fprintf(logfp, "DbPhotoService::processRequest(%s): have %s file type!\n", qPrintable(QString::number(currentThreadId())), qPrintable(fileType));
         fflush(logfp);
         if ( fileBase.toLower() == "import" ) 
         {
            fprintf(logfp, "DbPhotoService::processRequest(%s): request for import\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            int count = 0;
            QString dir;
            QString sfilters;
            if ( arguments.contains("filters") ) 
               sfilters = arguments.value("filters");
            if ( arguments.contains("dir") ) 
            {
               dir = arguments.value("dir");
               fprintf(logfp, "DbPhotoService::processRequest(%s): Looking in directory |%s| for files\n", qPrintable(QString::number(currentThreadId())), qPrintable(dir));
               fflush(logfp);
               QDir dn(dir);
               if ( dn.exists() ) 
               {
                  fprintf(logfp, "DbPhotoService::processRequest(%s): Getting filenames using filter of: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(sfilters));
                  fflush(logfp);


                  dbLock.lock();
                  db = getServerParms(host);
                  dbLock.unlock();

                  QMutexLocker lock(&photoLock);
                  QStringList filters = sfilters.split(",");
                  QStringList files = dn.entryList(filters, QDir::Files|QDir::Readable);
                  QStringList::Iterator it = files.begin();
                  while( it != files.end() ) {
                     fprintf(logfp, "DbPhotoService::processRequest(%s): Have name: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(*it));
                     QFileInfo fi(*it);
                     QString fn = dn.absoluteFilePath(fi.fileName());
                     QImage img;
                     fprintf(logfp, "DbPhotoService::processRequest(%s): Reading image |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(fn));
                     if ( img.load(fn) )
                     {
                        QByteArray ba;
                        QBuffer buffer(&ba);
                        buffer.open(QIODevice::WriteOnly);
                        fprintf(logfp, "DbPhotoService::processRequest(%s): Converting image to PNG\n", qPrintable(QString::number(currentThreadId())));
                        img.save(&buffer, "PNG");
                        buffer.close();

                        dbLock.lock();
                        QSqlQuery q;
                        QString sql = "insert into " + photoTable + " (fn, pic) values (:fn, :pic)"; 
                        q.prepare(sql);
                        q.bindValue(":pic", QVariant(ba));
                        q.bindValue(":fn", QVariant(fn));
                        fprintf(logfp, "DbPhotoService::processRequest(%s): Inserting picture into database using |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(sql));
                        if (! q.exec()) 
                        {
                           fprintf(logfp, "DbPhotoService::processRequest(%s): Error inserting picture: %s - %s\n", qPrintable(QString::number(currentThreadId())),
                                                            qPrintable(q.lastError().driverText()), 
                                                            qPrintable(q.lastError().databaseText()));
                           fprintf(logfp, "DbPhotoService::processRequest(%s): Query was |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(q.executedQuery()));
                        }

                        QStringList textKeys = img.textKeys();
                        QStringListIterator keys(textKeys);
                        fprintf(logfp, "DbPhotoService::processRequest(%s): Have %d text values\n", qPrintable(QString::number(currentThreadId())), textKeys.count());
                        while (keys.hasNext()) 
                        {
                           QString name = keys.next();
                           QString val = img.text(name);
                           fprintf(logfp, "DbPhotoService::processRequest(%s): Have key: |%s|, value: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(name), qPrintable(val));
                           q.prepare("insert into " + photoTable + "_text (photo, name, val) values (:fn, :name, :val)");
                           q.bindValue(":fn", QVariant(fn));
                           q.bindValue(":name", QVariant(name));
                           q.bindValue(":val", QVariant(val));
                           if (! q.exec()) 
                           {
                              fprintf(logfp, "DbPhotoService::processRequest(%s): Error inserting image: %s - %s", qPrintable(QString::number(currentThreadId())),
                                                            qPrintable(q.lastError().driverText()), 
                                                            qPrintable(q.lastError().databaseText()));
                           }
                        }
                        dbLock.unlock();
                     }
                     else 
                     {
                        fprintf(logfp, "DbPhotoService::processRequest(%s): error reading picture\n", qPrintable(QString::number(currentThreadId())));
                     }
                     count++;
                     fprintf(logfp, "DbPhotoService::processRequest(%s): Moving to next picture\n", qPrintable(QString::number(currentThreadId())));
                     ++it;
                  }
               }
            }
            else 
            {
               fprintf(logfp, "DbPhotoService::processRequest(%s): Error in request, exiting\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               errorResponse(QcjHttpService::NotFound, "Required parmaeter, dir, not specified");
               return;
            }
            fprintf(logfp, "DbPhotoService::processRequest(%s): Inserted %d photos\n", qPrintable(QString::number(currentThreadId())), count);
            fflush(logfp);
            QByteArray ba;
            QDataStream buf(&ba, QIODevice::WriteOnly);
            buf <<  "<html>\n";
            buf <<  "   <body>\n";
            buf <<  "      <h2>Inserted " + QString::number(count) + " Photos into the database successfully</h2>\n";
            buf <<  "   </body>\n";
            buf <<  "</html>\n";
            rsp->insert("Status", QcjHttpService::OK);
            rsp->insert("Content-Length", QVariant(ba.size()));
            rsp->insert("Content-Type", QVariant("text/html"));
            rsp->insert("Request-Body", QVariant(ba));
         }
         else
         {
            errorResponse(QcjHttpService::BadRequest, "Requested action not recognized");
         }
         return;
      }

//      QMutexLocker lock(&photoLock);


      /***********************************************/
      /*   Here we handle the requests for images    */
      /***********************************************/
      int width = 0;
      int height = 0;
      QString colors;

      /***********************************************/
      /*   Get  any  arguments passed (at least the  */
      /*   ones we want)                             */
      /***********************************************/
      if ( arguments.contains("width") ) 
         width = arguments.value("width").toInt();
      if ( arguments.contains("height") ) 
         height = arguments.value("height").toInt();
      if ( arguments.contains("colors") ) 
         colors = arguments.value("colors");

      /***********************************************/
      /*   append  the file name to the server name  */
      /*   to be used as a key.                      */
      /***********************************************/
      QString url = req->value("Host").toString() + "/" + fileBase;
      fprintf(logfp, "DbPhotoService::processRequest(%s): file type = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(fileType));
      fflush(logfp);
      fprintf(logfp, "DbPhotoService::processRequest(%s): file base = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(fileBase));
      fflush(logfp);

      /***********************************************/
      /*   Process the image requests here           */
      /***********************************************/
      if ( fileType != "html" && fileType != "htm") 
      {

         /***********************************************/
         /*   Get  the  database  info and other parms  */
         /*   from the config file                      */
         /***********************************************/
         fprintf(logfp, "DbPhotoService::processRequest(%s): locking db lock\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         dbLock.lock();
         db = getServerParms(host);

         if ( ! db.isOpen() || db.isOpenError() ) 
         {
            fprintf(logfp, "DbPhotoService::processRequest(%s): Error opening database\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            errorResponse(QcjHttpService::ServiceUnavailable, "Could not connect to database");
            fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking db lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            dbLock.unlock();
            return;
         }
         fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking db lock\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         dbLock.unlock();

         /***********************************************/
         /*   build a key using the server name, image  */
         /*   name  and  dimension info for the resize  */
         /*   cache                                     */
         /***********************************************/
         /*   If  the  image  is  not  in  the  resize  */
         /*   cache...                                  */
         /***********************************************/
         QString url1 = url + "?width=" + QString::number(width) + "&height=" + QString::number(height);
         fprintf(logfp, "DbPhotoService::processRequest(%s): looking for url1 |%s| in resize cache\n", qPrintable(QString::number(currentThreadId())), qPrintable(url1));
         fflush(logfp);

         /***********************************************/
         /*   This  object is the image to be read in,  */
         /*   maniputated and sent out.                 */
         /***********************************************/
         Image image;

         fprintf(logfp, "DbPhotoService::processRequest(%s): have method: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(method));
         fflush(logfp);
    
         if ( ! photoResizeCache.contains(url1) ) 
         {
            fprintf(logfp, "DbPhotoService::processRequest(%s): looking for url |%s| in cache\n", qPrintable(QString::number(currentThreadId())), qPrintable(url));
            fflush(logfp);

            /***********************************************/
            /*   Check if is is in the image cache         */
            /***********************************************/
            if ( photoCache.contains(url) ) 
            {
               /***********************************************/
               /*   We found the image in the image cache...  */
               /*   get  it  and move it to the front of the  */
               /*   list                                      */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): found resource in cache\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);

               /***********************************************/
               /*   Lock the caches for this threads use      */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.lock();
         
               image = photoCache.value(url);
               photoList.removeAll(url);
               photoList.insert(0, url);

               fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.unlock();
         
            }
            else 
            {
               QByteArray ba;
              
               /***********************************************/
               /*   Obtain the db lock for our thread         */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): locking db lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               dbLock.lock();

               /***********************************************/
               /*   Get  the sql statement needed to get the  */
               /*   photo from the database                   */
               /***********************************************/
               QString sql = sqlTemplate;
               fprintf(logfp, "DbPhotoService::processRequest(%s): sql = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(sql));
               fflush(logfp);
               QSqlQuery q(db);
               q.prepare(sqlTemplate);

               /***********************************************/
               /*   Bind the image name to the :resource tag  */
               /***********************************************/
               q.bindValue(":resource", fileBase + ".jpg");
               fprintf(logfp, "DbPhotoService::processRequest(%s): sql = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(q.lastQuery()));
               fflush(logfp);
               q.exec();
               fprintf(logfp, "DbPhotoService::processRequest(%s): fetching image\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               if ( q.next() ) 
               {
                  /***********************************************/
                  /*   If  we found the image, load it into the  */
                  /*   image object as an Imagemagick Blob       */
                  /***********************************************/
                  fprintf(logfp, "DbPhotoService::processRequest(%s): getting image\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  ba = q.value(0).toByteArray();
               }
               else 
               {
                  /***********************************************/
                  /*   Otherwise,  if  the image was not found,  */
                  /*   build an error and return                 */
                  /***********************************************/
                  fprintf(logfp, "DbPhotoService::processRequest(%s): Did not find resource\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  errorResponse(QcjHttpService::NotFound, "Requested resource not found");

                  fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking db lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  dbLock.unlock();
                  return;
               }

               /***********************************************/
               /*   Release  the database lock for the other  */
               /*   threads to use                            */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): Unlocking db lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);

               dbLock.unlock();

               fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.lock();

               /*
                    Create the image object and get it's geometry
               */ 
               image.read(Blob(ba.data(), ba.size()));
               Geometry geom(image.size());

               fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.unlock();

               fprintf(logfp, "DbPhotoService::processRequest(%s): Checking for resource in cache\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);

               /***********************************************/
               /*   Resize   the  image  to  the  dimensions  */
               /*   specified in the definition file          */
               /***********************************************/

               /***********************************************/
               /*   Work with the largest side setting it to  */
               /*   the specified size                        */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): resizing image for the cache, cacheDimension = %d\n", qPrintable(QString::number(currentThreadId())), cacheDimension);
               fprintf(logfp, "DbPhotoService::processRequest(%s): original image, width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
               if ( geom.width() > cacheDimension || geom.height() > cacheDimension ) 
               {
                  fprintf(logfp, "DbPhotoService::processRequest(%s): One side or another is larger than the cache size...\n", qPrintable(QString::number(currentThreadId())));
                  if ( geom.width() > geom.height() ) 
                  {
                     t_height = (int)( (double)cacheDimension / (double)geom.width() * (double)geom.height() );
                     geom.height(t_height);
                     fprintf(logfp, "DbPhotoService::processRequest(%s): width larger, height scaled to %d\n", qPrintable(QString::number(currentThreadId())), t_height);
                     geom.width(cacheDimension);
                  }
                  else if ( geom.height() > geom.width() )
                  {
                     t_width = (int)( (double)cacheDimension / (double)geom.height() * (double)geom.width() );
                     geom.width(t_width);
                     fprintf(logfp, "DbPhotoService::processRequest(%s): height larger, width scaled to %d\n", qPrintable(QString::number(currentThreadId())), t_width);
                     geom.height(cacheDimension);
                  }
                  else
                  {
                     fprintf(logfp, "DbPhotoService::processRequest(%s): height == width\n", qPrintable(QString::number(currentThreadId())));
                     geom.width(cacheDimension);
                     geom.height(cacheDimension);
                  }
                  fprintf(logfp, "DbPhotoService::processRequest(%s): cached image size, width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
                  fflush(logfp);

                  fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.lock();

                  image.zoom(geom);

                  fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.unlock();

                  fprintf(logfp, "DbPhotoService::processRequest(%s): cached Image scaled\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
               }

               /***********************************************/
               /*   If  we  find  the  image  in  the cache,  */
               /*   remove it, it shouldn;t be there anyways  */
               /***********************************************/
               if ( photoList.contains(url) ) 
               {
                  fprintf(logfp, "DbPhotoService::processRequest(%s): removing from cache, url |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(url));
                  fflush(logfp);
                  /***********************************************/
                  /*   Lock the caches for this threads use      */
                  /***********************************************/
                  fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.lock();
         
                  photoList.removeAll(url);

                  fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.unlock();
               }

               /***********************************************/
               /*   If the cache is already full, remove the  */
               /*   the  oldest  used photos until the cache  */
               /*   can fit ours                              */
               /***********************************************/
               if ( photoCache.size() > maxPhotos ) 
               {
                  fprintf(logfp, "DbPhotoService::processRequest(%s): Removing items from cache, current size = %d\n", qPrintable(QString::number(currentThreadId())), photoCache.size());
                  fflush(logfp);
                  /***********************************************/
                  /*   Lock the caches for this threads use      */
                  /***********************************************/
                  fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.lock();
                  while (photoCache.size() - maxPhotos) 
                  {
                     QString name = photoList.takeLast();
                     photoCache.remove(name);
                     fprintf(logfp, "DbPhotoService::processRequest(%s): item removed current size = %d\n", qPrintable(QString::number(currentThreadId())), photoCache.size());
                     fflush(logfp);
                  }
                  fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  photoLock.unlock();
         
               }
               fprintf(logfp, "DbPhotoService::processRequest(%s): Inserting resource into cache\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);

               /***********************************************/
               /*   Insert  the  image  into  the  cache and  */
               /*   place  it's  key  in  the list up at the  */
               /*   front                                     */
               /***********************************************/
               /***********************************************/
               /*   Lock the caches for this threads use      */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.lock();
         
               photoCache.insert(url, image);
               photoList.insert(0, url);
               /***********************************************/
               /*   Lock the caches for this threads use      */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.unlock();

            }

            fprintf(logfp, "DbPhotoService::processRequest(%s): Creating image\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);

            fprintf(logfp, "DbPhotoService::processRequest(%s): scaling image? width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), width, height);
            fflush(logfp);

            /***********************************************/
            /*   Determine  the   dimensions of the image  */
            /*   as  requested  by  the user. If only one  */
            /*   side  is  specified, calculate the other  */
            /*   side's length                             */
            /***********************************************/
            Geometry geom(image.size());
            fprintf(logfp, "DbPhotoService::processRequest(%s): setting image geometry to requested size, image size currently width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());

            if ( width > 0 && height > 0 ) 
            {
               geom.width(width);
               geom.height(height);
               fprintf(logfp, "DbPhotoService::processRequest(%s): setting image geometery to width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
               geom.aspect(true);
            }
            else if ( width > 0 )
            {
               int height = geom.height();
               height = (int)( ((double)width / geom.width()) * height);
               geom.width(width);
               geom.height(height);
               fprintf(logfp, "DbPhotoService::processRequest(%s): setting image geometery to width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
            }
            else if (height > 0 )
            {
               int width = geom.width();
               geom.width(width);
               geom.height(height);
               fprintf(logfp, "DbPhotoService::processRequest(%s): setting image geometery to width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
            }

            /***********************************************/
            /*   Ensure    that   the   image's   maximum  */
            /*   dimension is not larger than the maximum  */
            /*   for the server                            */
            /***********************************************/
            fprintf(logfp, "DbPhotoService::processRequest(%s): Ensuring max size, maxDimension = %d\n", qPrintable(QString::number(currentThreadId())), maxDimension);
            fprintf(logfp, "DbPhotoService::processRequest(%s): image size now width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
            fflush(logfp);
            if ( geom.width() > maxDimension || geom.height() > maxDimension ) 
            {
               fprintf(logfp, "DbPhotoService::processRequest(%s): One side or another is too large...\n", qPrintable(QString::number(currentThreadId())));

               if ( geom.width() > geom.height() ) 
               {
                  t_height = (int)( (double)maxDimension / (double)geom.width() * (double)geom.height() );
                  geom.height(t_height);
                  fprintf(logfp, "DbPhotoService::processRequest(%s): width larger, height scaled to %d\n", qPrintable(QString::number(currentThreadId())), t_height);
                  geom.width(maxDimension);
               }
               else if ( geom.height() > geom.width() ) 
               {
                  t_width = (int)( (double)maxDimension / (double)geom.height() * (double)geom.width() );
                  geom.width(t_width);
                  fprintf(logfp, "DbPhotoService::processRequest(%s): height larger, width scaled to %d\n", qPrintable(QString::number(currentThreadId())), t_width);
                  geom.height(maxDimension);
               }
               else
               {
                  fprintf(logfp, "DbPhotoService::processRequest(%s): width == height\n", qPrintable(QString::number(currentThreadId())));
                  geom.width(maxDimension);
                  geom.height(maxDimension);
               }
               /***********************************************/
               /*   Lock the caches for this threads use      */
               /***********************************************/
               fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.lock();

               photoCache.insert(url, image);
               photoList.insert(0, url);

               fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               photoLock.unlock();
            }
            fprintf(logfp, "DbPhotoService::processRequest(%s): Scaling image, width = %d, height = %d\n", qPrintable(QString::number(currentThreadId())), geom.width(), geom.height());
            fflush(logfp);

            fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.lock();
            image.zoom(geom);
            fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.unlock();

            /***********************************************/
            /*   Place  the  image  into the resize cache  */
            /*   for later.                                */
            /***********************************************/
            fprintf(logfp, "DbPhotoService::processRequest(%s): checking resize cache size, currently %d photos\n", qPrintable(QString::number(currentThreadId())), photoResizeCache.size());
            fflush(logfp);

            /***********************************************/
            /*   Lock the caches for this threads use      */
            /***********************************************/
            fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.lock();

            /***********************************************/
            /*   If  the resize cache is full, remove the  */
            /*   images  from  the  bottom  of  the cache  */
            /*   until there is room for the new picture   */
            /***********************************************/
            if ( photoResizeCache.size() > maxResizePhotos ) 
            {
               fprintf(logfp, "DbPhotoService::processRequest(%s): Removing items from resize cache, current size = %d\n", qPrintable(QString::number(currentThreadId())), photoResizeCache.size());
               fflush(logfp);
               while (photoResizeCache.size() - maxResizePhotos) 
               {
                  QString name = photoResizeList.takeLast();
                  fprintf(logfp, "DbPhotoService::processRequest(%s): removing item |%s| from resize cache\n", qPrintable(QString::number(currentThreadId())), qPrintable(name));
                  fflush(logfp);
                  photoResizeCache.remove(name);
                  fprintf(logfp, "DbPhotoService::processRequest(%s): item removed current size = %d\n", qPrintable(QString::number(currentThreadId())), photoResizeCache.size());
                  fflush(logfp);
               }
            }
            fprintf(logfp, "DbPhotoService::processRequest(%s): Inserting resource with url of |%s| into resize cache\n", qPrintable(QString::number(currentThreadId())), qPrintable(url1));
            fflush(logfp);
            photoResizeCache.insert(url1, image);
            photoResizeList.insert(0, url1);

            fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.unlock();
         }

         /***********************************************/
         /*   If  the  image  was in the resize cache,  */
         /*   use it sight unseen                       */
         /*   Pull it from its current position in the  */
         /*   list and put it back on top so the least  */
         /*   used will settle to the bottom.           */
         /***********************************************/
         else 
         {
            fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.lock();
            image = photoResizeCache.value(url1);
            photoResizeList.removeAll(url1);
            photoResizeList.insert(0, url1);
            fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            photoLock.unlock();
         }

         /***********************************************/
         /*   Here  we  create  the acutal image to be  */
         /*   sent  in  the  format  specified  by the  */
         /*   extension on the request                  */
         /***********************************************/
         fprintf(logfp, "DbPhotoService::processRequest(%s): Creating to send \n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         Blob imgBlob;
         fprintf(logfp, "DbPhotoService::processRequest(%s): Saving image with type |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(fileType.toUpper()));
         fflush(logfp);
         image.magick(qPrintable(fileType.toUpper()));

         fprintf(logfp, "DbPhotoService::processRequest(%s): colors = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(colors));
         fflush(logfp);

         /***********************************************/
         /*   Make  the  image  BW or reduce the color  */
         /*   palette if either were requested          */
         /***********************************************/
         if ( colors == "monochrome" ) 
         {
            fprintf(logfp, "DbPhotoService::processRequest(%s): Making bw\n", qPrintable(QString::number(currentThreadId())));
            fflush(logfp);
            image.monochrome(true);
            image.type( GrayscaleType );
         }
         else if (colors.length() > 0 )
         {
            bool good;
            int x = colors.toInt(&good);
            if ( good ) 
            {
               fprintf(logfp, "DbPhotoService::processRequest(%s): Setting colors to: %d\n", qPrintable(QString::number(currentThreadId())), x);
               fflush(logfp);
               image.quantizeColors(x);
               image.quantize();
            }
            else 
            {
               fprintf(logfp, "DbPhotoService::processRequest(%s): error converting size, x = %d\n", qPrintable(QString::number(currentThreadId())), x);
               fflush(logfp);
            }
         }

         /***********************************************/
         /*   Save the image into an ImageMagick Blob   */
         /***********************************************/
         fprintf(logfp, "DbPhotoService::processRequest(%s): Writing image to blob\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);

         fprintf(logfp, "DbPhotoService::processRequest(%s): locking photo lock\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         photoLock.lock();
         image.write(&imgBlob);
         fprintf(logfp, "DbPhotoService::processRequest(%s): unlocking photo lock\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);
         photoLock.unlock();
         
         fprintf(logfp, "DbPhotoService::processRequest(%s): Image written\n", qPrintable(QString::number(currentThreadId())));
         fflush(logfp);

         if ( fileType == "jpg" ) 
            fileType = "jpeg";

         /***********************************************/
         /*   Now make a QByteArray out of it           */
         /***********************************************/
         QByteArray newImage((char*)imgBlob.data(), imgBlob.length());

         /***********************************************/
         /*   Build the response.                       */
         /***********************************************/
         rsp->insert("Status", QcjHttpService::OK);
         rsp->insert("Content-Length", QVariant(newImage.size()));
         rsp->insert("Content-Type", QVariant("image/" + fileType));
         rsp->insert("Request-Body", QVariant(newImage));
      }
   }
   fprintf(logfp, "DbPhotoService::processRequest(%s): Exit\n", qPrintable(QString::number(currentThreadId())));
   fflush(logfp);
}


/*!
      \fn QSqlDatabase DbPhotoService::getServerParms(QString host)

       Retrieves  the  parameters from the XML definition file for the
       host  named  by  the parameter \a host and returns a pointer to
       the QSqlDatabase object for accessing it.
*/ 
QSqlDatabase DbPhotoService::getServerParms(QString host)
{
   QSqlDatabase rv;

   fprintf(logfp, "DbPhotoService::getServerParms(%s): Enter, host = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(host));
   fflush(logfp);
   QDomElement docElem = doc.documentElement();
   QDomNode n = docElem.firstChild();
   while ( ! n.isNull() ) 
   {
      QDomElement e = n.toElement();
      fprintf(logfp, "DbPhotoService::getServerParms(%s): Have node: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(e.tagName()));
      fflush(logfp);
      if ( e.tagName() == "server" ) 
      {
         QString sName = e.attribute("name");
         fprintf(logfp, "DbPhotoService::getServerParms(%s): Have server tag, name = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(sName));
         fflush(logfp);
         if ( sName == host ) 
         {
            /***********************************************/
            /*   If we find the database in the cache and  */
            /*   it is open return it                      */
            /***********************************************/
            if ( dbCache.contains(host) && dbCache.value(host).isOpen() ) 
            {
               fprintf(logfp, "DbPhotoService::getServerParms(%s): Found database in cache\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               rv = dbCache.value(host);
            }

            if ( ! rv.isOpen() && dbCache.contains(host) )
            {
               fprintf(logfp, "DbPhotoService::getServerParms(%s): Removing database from cache\n", qPrintable(QString::number(currentThreadId())));
               fflush(logfp);
               dbCache.remove(host);
            }

            QString type = e.attribute("type");
            fprintf(logfp, "DbPhotoService::getServerParms(%s): have type: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(type));
            fflush(logfp);
            if ( type.size() == 0 ) 
               type = "QPSQL";

            fprintf(logfp, "DbPhotoService::getServerParms(%s): have type: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(type));
            fflush(logfp);
            if ( ! rv.isOpen() ) 
               rv =  QSqlDatabase::addDatabase(type);

            QDomNode n1 = e.firstChild();
            while ( ! n1.isNull() ) 
            {
               /***********************************************/
               /*   If  the database is not open and we have  */
               /*   a database definition, get the infor for  */
               /*   the  database and try to open it. Ignore  */
               /*   any  errors,  assume  they will be dealt  */
               /*   with by the caller                        */
               /***********************************************/
               QDomElement e1 = n1.toElement();
               if ( e1.tagName() == "database" ) 
               {
                  QString name = e1.attribute("name");

                  fprintf(logfp, "DbPhotoService::getServerParms(%s): have database node, name = |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(name));
                  fflush(logfp);
                  QDomNode n2 = e1.firstChild();
                  while ( ! n2.isNull() ) 
                  {
                     QDomElement e2 = n2.toElement();

                     /***********************************************/
                     /*   Open the connection                       */
                     /***********************************************/
                     if ( ! rv.isOpen() && e2.tagName() == "connection" ) 
                     {
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): have connection node\n", qPrintable(QString::number(currentThreadId())));
                        fflush(logfp);
                        rv.setUserName(e2.attribute("user"));
                        rv.setPassword(e2.attribute("password"));
                        rv.setPort(e2.attribute("port").toInt());
                        rv.setHostName(e2.attribute("host"));
                        photoTable = e2.attribute("table");
                        rv.setDatabaseName(name);
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): user: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(e2.attribute("user")));
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): password: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(e2.attribute("password")));
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): port: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(e2.attribute("port")));
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): host: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(e2.attribute("host")));
                        fflush(logfp);

                        if ( ! rv.open() )
                        {
                           fprintf(logfp, "DbPhotoService::getServerParms(%s): failed opening db, %s - %s\n", qPrintable(QString::number(currentThreadId())), 
                                       qPrintable(rv.lastError().databaseText()),
                                       qPrintable(rv.lastError().driverText()));
                           fflush(logfp);
                           
                        }
                        else
                           dbCache.insert(host, rv);
                     }
                     else if ( e2.tagName() == "sql" ) 
                     {
                        QDomNode cdata = n2.firstChild();
                        if ( cdata.isText() ) 
                           sqlTemplate = cdata.nodeValue();
                        fprintf(logfp, "DbPhotoService::getServerParms(%s): sql: |%s|\n", qPrintable(QString::number(currentThreadId())), qPrintable(sqlTemplate));
                     }

                     n2 = n2.nextSibling();
                  }
               }

               /***********************************************/
               /*   Here  we get the html template if it was  */
               /*   defined                                   */
               /***********************************************/
               else if ( e1.tagName() == "html_template" ) 
               {
                  QDomNode cdata = n1.firstChild();
                  if ( cdata.isText() ) 
                     htmlTemplate = cdata.nodeValue();
               }
               /***********************************************/
               /*   Get the image dimensions                  */
               /***********************************************/
               else if ( e1.tagName() == "image" ) 
               {
                  fprintf(logfp, "DbPhotoService::getServerParms(%s): have image node\n", qPrintable(QString::number(currentThreadId())));
                  fflush(logfp);
                  if ( e1.attribute("cache_dimension") != QString::null ) 
                     cacheDimension = e1.attribute("cache_dimension").toInt();
                  if ( e1.attribute("max_dimension") != QString::null ) 
                     maxDimension = e1.attribute("max_dimension").toInt();
                  fprintf(logfp, "DbPhotoService::getServerParms(%s): maxDimension = %d\n", qPrintable(QString::number(currentThreadId())), maxDimension);
                  fprintf(logfp, "DbPhotoService::getServerParms(%s): cacheDimension = %d\n", qPrintable(QString::number(currentThreadId())), cacheDimension);
               }
               n1 = n1.nextSibling();
            }
            break;
         }
      }
      n = n.nextSibling();
   }
   fprintf(logfp, "DbPhotoService::getServerParms(%s): Exit, db is open? %d\n", qPrintable(QString::number(currentThreadId())), rv.isOpen());
   fflush(logfp);
   return(rv);
}

---