installerInterface.h

Go to the documentation of this file.

/* -*- Mode: c++ -*- */
/*
 *  this is part of Spm
 *
 *  Copyright (c) 2005 Guillaume Chevallereau
 *
 *  This program 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.
 *
 *  This program is distributed in the hope that it will be usefull 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 this program; if not, write to the Free Software Foundation, Inc., 
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
 */
#ifndef __INSTALLER_INTERFACE_H__
#define __INSTALLER_INTERFACE_H__

#include "interface.h"
#include "stepInterface.h"
#include <list>
#include <util/compressed.h>
#include <boost/signals.hpp>
#include <boost/thread/recursive_mutex.hpp>

#define SPM_INSTALLER_PLUGIN(plugin)                                    \
  extern "C"                                                            \
  {                                                                     \
    plugin * getSpmPluginInfo ()                                        \
    {                                                                   \
      return new plugin ();                                             \
    }                                                                   \
                                                                        \
    Spm::Plugin::pluginDescription_t getSpmPluginDescription ()         \
    {                                                                   \
      return plugin ().getDescription ();                               \
    }                                                                   \
                                                                        \
    plugin * getSpmInstallerPlugin (Spm::Util::Compressed * compressed, \
                                    const Spm::Util::PropertyList & pList) \
    {                                                                   \
      return new plugin (compressed,                                    \
                         pList);                                        \
    }                                                                   \
                                                                        \
    int spmHandleCompressed (Spm::Util::Compressed * compressed,        \
                             Spm::Util::PropertyList & pList)           \
    {                                                                   \
      return plugin::handle(compressed,                                 \
                            pList);                                     \
    }                                                                   \
                                                                        \
    int spmHandleUrl (miniXml::ustring & url,                           \
                      Spm::Util::PropertyList & pList)                  \
    {                                                                   \
      return plugin::handle(url,                                        \
                            pList);                                     \
    }                                                                   \
  }

namespace Spm
{
  namespace Plugin
  {
    const int NOT_HANDLING = -1;
    class InstallerInterface : public Interface
    {
    protected:
      boost::filesystem::path prefix_;
      boost::filesystem::path runningDir_;
      Util::Compressed * compressed_;
      miniXml::ustring name_;
      miniXml::ustring version_;
      std::list<miniXml::ustring> dependency_;
      boost::signal<void (StepInterface *)> changedStep_;
      boost::signal<void (InstallerInterface *)> metaDataParsed_;
      boost::signal<void (InstallerInterface *)> haveOptions_;
      boost::recursive_mutex mutex_;
      std::list<StepInterface *> steps_;
      std::list<StepInterface *>::iterator itStep_;
 
      InstallerInterface () : Interface()
      {
        description_.pluginType_ = INSTALLER_TYPE;
        compressed_ = NULL;
      }
      
      InstallerInterface (Util::Compressed * archive,
                          const Util::PropertyList & pList = Util::PropertyList()) : Interface()
      {
        description_.pluginType_ = INSTALLER_TYPE;
        compressed_ = archive;
        options_ = pList;
      }

      void setState (state_e pluginState)
      {
        currentState_ = pluginState;
      }

    public:
      ~InstallerInterface ()
      {
        for(itStep_ = steps_.begin ();
            itStep_ != steps_.end ();
            itStep_++)
          delete (*itStep_);
        steps_.clear ();

        if(compressed_)
          delete (compressed_);
        compressed_ = NULL;
      }

      virtual void init ()
      {
      }
      
      virtual void postInstall ()
      {
      }

      virtual void install ()
      {
        try
          {
            setState(INITIALIZATION);
            init ();
            setState(RUNNING);
            itStep_ = steps_.begin ();
            while (itStep_ != steps_.end ())
              {
                changedStep_ ((*itStep_));
                (*itStep_)->run (runningDir_.string ());
                {
                  boost::recursive_mutex::scoped_lock lock (mutex_);
                  itStep_++;
                }
              }
            postInstall ();
            setState(ENDED);
          }
        catch (Spm::Plugin::InstallException & ie)
          {
            setState(FAILED);
            throw;
          }
      }

      virtual const StepInterface * getActualStep ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        if (currentState_ != RUNNING)
          return NULL;
        if (!steps_.size())
          return NULL;
        if (itStep_ == steps_.end ())
          return NULL;
        return *itStep_;
      }

      virtual const std::list<boost::filesystem::path> getInstalledElement () = 0;

      virtual std::map<miniXml::ustring,
                       miniXml::ustring> getUsedOptions () = 0;

      virtual std::map<miniXml::ustring,
                       boost::tuple<miniXml::ustring,
                                    int,
                                    Util::PropertyList::propertyType_e> > getOptions () = 0;

      const boost::filesystem::path & getPrefix ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return prefix_;
      }
      
      virtual const miniXml::ustring & getPackageName ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return name_;
      }

      virtual const miniXml::ustring & getPackageVersion ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return version_;
      }

      virtual const std::list<miniXml::ustring> & getDependency ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return dependency_;
      }
      
      Util::PropertyList & installOptions ()
      {
        return options_;
      }

      virtual void installOptions (const Util::PropertyList & pList)
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        options_ = pList;
        haveOptions_(this);
      }

      boost::signal<void (StepInterface *)> & signalChangedStep ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return changedStep_;
      }
      
      boost::signal<void (InstallerInterface *)> & signalMetaDataParsed ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return metaDataParsed_;
      }
      
      boost::signal<void (InstallerInterface *)> & signalHaveOptions ()
      {
        boost::recursive_mutex::scoped_lock lock (mutex_);
        return haveOptions_;
      }
    };
  }
}

#endif

---