InstYou.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                    (C) SuSE Linux AG |
\----------------------------------------------------------------------/

  File:       InstYou.h

  Author:     Cornelius Schumacher <cschum@suse.de>
  Maintainer: Cornelius Schumacher <cschum@suse.de>

  Purpose: YaST Online Update

/-*/
#ifndef InstYou_h
#define InstYou_h

#include <list>
#include <string>

#include <y2util/Url.h>
#include <y2util/Pathname.h>
#include <y2util/FSize.h>

#include <y2pm/PMError.h>
#include <y2pm/MediaAccess.h>

#include <y2pm/PMYouPatch.h>
#include <y2pm/PMYouPatchInfo.h>
#include <y2pm/PMYouSettings.h>
#include <y2pm/PMYouServers.h>

//
//      CLASS NAME : InstYou
//
class InstYou {

  public:
    InstYou();

    InstYou( const PMYouPatchInfoPtr &, const PMYouSettingsPtr & );

    ~InstYou();

    PMError initProduct();

    PMError servers( std::list<PMYouServer> & );

    PMError readUserPassword();

    PMError setUserPassword( const std::string &username,
                             const std::string &password, bool persistent );

    PMError retrievePatchDirectory();

    PMError retrievePatchInfo();
    
    PMError processPatches();

    void selectPatches( int kinds );

    void updatePackageStates();

    PMYouSettingsPtr settings() const { return _settings; }

    PMYouPatchInfoPtr patchInfo() const { return _info; }

    PMError removePackages();

    void showPatches( bool verbose = false );

    PMError progress( int );

    PMError patchProgress( int, const std::string &pkg = std::string() );

    PMError showError( const std::string &type, const std::string &text,
                       const std::string &details );

    PMError showError( const PMError &error );

    PMError showMessage( const std::string &type, std::list<PMYouPatchPtr> & );

    void log( const std::string &text );

    int lastUpdate();

    int installedPatches() { return _installedPatches; }

    FSize totalDownloadSize() { return _totalDownloadSize; }

    int quickCheckUpdates();

    /*
      Return currently set username used for authentificaton to the server.
    */
    std::string username() const { return _username; }

    /*
      Return currently set password used for authentificaton to the server.
    */
    std::string password() const { return _password; }

    void filterArchitectures( PMYouPatchPtr &patch );

  public:
    class Callbacks
    {
        public:
          Callbacks() {}
          virtual ~Callbacks() {}
    
          virtual bool progress( int percent ) = 0;
          virtual bool patchProgress( int percent, const std::string &str ) = 0;

          virtual PMError showError( const std::string &type,
                                     const std::string &text,
                                     const std::string &details ) = 0;
          virtual PMError showMessage( const std::string &type,
                                       const std::list<PMYouPatchPtr> & ) = 0;
          virtual void log( const std::string &text ) = 0;

          virtual bool executeYcpScript( const std::string &script ) = 0;
    };

    static void setCallbacks( Callbacks * );

  private:
    static Callbacks *_callbacks;

  private:
    void init();

  protected:
    PMError attachSource();
    PMError releaseSource();

    void resetProgress();
    bool incrementProgress();

    PMYouPatchPtr firstPatch();
    PMYouPatchPtr nextPatch();

    PMError retrieveCurrentPatch();

    PMError installCurrentPatch();
    
    PMError disconnect();

    PMError writeLastUpdate();

    PMError installPatches( const vector<PMYouPatchPtr> & );
    PMError installPatch( const PMYouPatchPtr & );
    PMError retrievePatch( const PMYouPatchPtr & );
    PMError retrievePackage( const PMPackagePtr &pkg, const PMYouProductPtr & );
    PMError retrieveScript( const std::string &script,
                            const PMYouProductPtr & );
    PMError retrieveFile( const PMYouFile &file );
    PMError retrieveDelta( const std::string& name, const PMYouProductPtr& prod, const std::string& md5sum);

    PMError executeScript( const std::string &, const PMYouProductPtr & );

    bool hasOnlyNewPackages( const PMYouPatchPtr &patch );
    bool hasNewPackages( const PMYouPatchPtr &patch );

    bool isNewerPackage( const PMPackagePtr &pkg );

    bool packageToBeInstalled( const PMYouPatchPtr &patch,
                               const PMPackagePtr &pkg );

    bool firesPackageTrigger( const PMYouPatchPtr &patch );
    bool firesScriptTrigger( const PMYouPatchPtr &patch );

    bool hasPatchRpm( const PMPackagePtr &pkg );
    
    PMError verifyMediaNumber( int number, int lastNumber );

  private:
    PMYouPatchInfoPtr _info;
    PMYouSettingsPtr _settings;

    std::vector<PMYouPatchPtr> _patches;

    std::vector<PMYouPatchPtr>::const_iterator _selectedPatchesIt;

    std::map<std::string,int> _mediaMap;

    int _progressTotal;
    int _progressCurrent;
    
    MediaAccess _media;

    std::string _username;
    std::string _password;

    FSize _totalDownloadSize;

    int _installedPatches;

    int _currentMediaNumber;
    
    enum
    {
      NO_DELTAS = 0,  // never use deltas
      ONLY_FS_DELTAS, // use deltas if they apply to installed files
      ANY_DELTAS,     // also use deltas that require a base rpm
    } _usedeltas;

  public:
    class DeltaToApply;

  private:
    std::vector<DeltaToApply*> _deltastoapply;

    DeltaToApply* FetchSuitableDelta(PMYouPatchPtr patch, PMPackagePtr pkg, bool quickcheck = false);

    void withdrawCandidates(void);
};


#endif // InstYou_h

---