PkgDu.h

Go to the documentation of this file.

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

  File:       PkgDu.h

  Author:     Michael Andres <ma@suse.de>
  Maintainer: Michael Andres <ma@suse.de>

  Purpose: Helper classes to collect package disk usage info.

/-*/
#ifndef PkgDu_h
#define PkgDu_h

#include <iosfwd>
#include <string>
#include <list>
#include <set>

#include <y2util/FSize.h>

#include <y2pm/PMPackagePtr.h>

//
//      CLASS NAME : PkgDu
class PkgDu {

  public:

    //
    //  CLASS NAME : PkgDu::Entry
    struct Entry {

      friend std::ostream & operator<<( std::ostream & str, const Entry & obj );

      std::string _dirname;
      mutable FSize    _size;
      mutable unsigned _files;

      Entry( const std::string & dirname_r, const FSize & size_r = 0, const unsigned & files_r = 0 )
        : _dirname( dirname_r ), _size( size_r ), _files( files_r )
      {
        if ( _dirname.size() && _dirname[_dirname.size()-1] != '/' ) {
          _dirname += '/';
        }
      }

      Entry() : _files( 0 ) {}
      bool operator==( const Entry & rhs ) const {
        return  _dirname == rhs._dirname;
      }
      bool operator<( const Entry & rhs ) const {
        return  _dirname < rhs._dirname;
      }

      bool isBelow( const Entry & rhs ) const {
        // whether _dirname has prefix rhs._dirname
        return( _dirname.compare( 0, rhs._dirname.size(), rhs._dirname ) == 0 );
      }
      bool isBelow( const std::string & dirname_r ) const {
        return  isBelow( Entry( dirname_r ) );
      }

      const Entry & operator+=( const Entry & rhs ) const {
        _size  += rhs._size;
        _files += rhs._files;
        return *this;
      }
      const Entry & operator-=( const Entry & rhs ) const {
        _size  -= rhs._size;
        _files -= rhs._files;
        return *this;
      }
    };


  private:

    typedef std::set<Entry> EntrySet;

    EntrySet _dirs;

  public:

    PkgDu() {}

    void add( const Entry & newent_r ) {
      std::pair<EntrySet::iterator,bool> res = _dirs.insert( newent_r );
      if ( !res.second ) {
        *res.first += newent_r;
      }
    }

    void add( const std::string & dirname_r, const FSize & size_r = 0, const unsigned & files_r = 0 ) {
      add( Entry( dirname_r, size_r, files_r ) );
    }

    unsigned size() const { return _dirs.size(); }

    void clear() { _dirs.clear(); }

  public:

    void addFrom( const std::list<std::string> & dudata_r );

    void setFrom( const std::list<std::string> & dudata_r ) {
      clear();
      addFrom( dudata_r );
    }

  public:

    Entry extract( const std::string & dirname_r );

  public:

   typedef EntrySet::iterator               iterator;
   typedef EntrySet::reverse_iterator       reverse_iterator;

   iterator begin() { return _dirs.begin(); }
   iterator end() { return _dirs.end(); }
   reverse_iterator rbegin() { return _dirs.rbegin(); }
   reverse_iterator rend() { return _dirs.rend(); }

   typedef EntrySet::const_iterator         const_iterator;
   typedef EntrySet::const_reverse_iterator const_reverse_iterator;

   const_iterator begin() const { return _dirs.begin(); }
   const_iterator end() const { return _dirs.end(); }
   const_reverse_iterator rbegin() const { return _dirs.rbegin(); }
   const_reverse_iterator rend()const { return _dirs.rend(); }

  public:

   friend std::ostream & operator<<( std::ostream & str, const PkgDu & obj );
};


//
//      CLASS NAME : PkgDuMaster
class PkgDuMaster {

  //PkgDuMaster & operator=( const PkgDuMaster & ); // no assign
  //PkgDuMaster            ( const PkgDuMaster & ); // no copy

  public:

    //
    //  CLASS NAME : PkgDuMaster::MountPoint
    //
    class MountPoint {
      public:
        // vital data (must not be modified)
        const std::string _mountpoint;
        const FSize       _blocksize;
      public:
        // additional MountPoint data
        mutable FSize     _total;
        mutable FSize     _used;
        mutable bool      _readonly;
      public:
        // statistics counted by add/sub
        // contains the change of diskusage
        mutable FSize     _pkgusage;
      public:
        const std::string & mountpoint()        const { return _mountpoint; }
        FSize               total()             const { return _total; }
        bool                readonly()          const { return _readonly; }
        // current usage without packages taken into accout
        FSize               initial_used()      const { return _used; }
        FSize               initial_available() const { return total() - initial_used(); }
        int                 initial_u_percent() const { return( total() ? initial_used() * 100 / total() : 0 ); }
        // current usage with packages taken into accout
        FSize               pkg_diff()          const { return _pkgusage; }
        FSize               pkg_used()          const { return _used + _pkgusage; }
        FSize               pkg_available()     const { return total() - pkg_used(); }
        int                 pkg_u_percent()     const { return( total() ? pkg_used() * 100 / total() : 0 ); }
      public:
        MountPoint( const std::string & mountpoint_r,
                    const FSize & blocksize_r = 1024,
                    const FSize & total_r = 0,
                    const FSize & used_r  = 0,
                    bool readonly_r = false )
          : _mountpoint( mountpoint_r )
          , _blocksize( blocksize_r )
          , _total( total_r )
          , _used( used_r )
          , _readonly( readonly_r )
          , _pkgusage( 0 )
        {}
        ~MountPoint() {}
      public:
        bool assignData( const MountPoint & rhs ) const;
      public:
        friend std::ostream & operator<<( std::ostream & str, const MountPoint & obj );
      public:
        bool operator==( const MountPoint & rhs ) const { return( _mountpoint == rhs._mountpoint ); }
        bool operator<( const MountPoint & rhs )  const { return( _mountpoint < rhs._mountpoint ); }
    };

  private:

    static unsigned _counter;

    unsigned _count;

    void newcount();

  private:

    std::set<MountPoint> _mountpoints;

    FSize _pkg_diff;

    std::string _src_on;

  private:

    friend class PkgDuSlave;

    void add( FSize * data_r );
    void sub( FSize * data_r );

  public:

    PkgDuMaster();
    ~PkgDuMaster();

  public:

    unsigned sync_count() const { return _count; }

    unsigned resetStats();

    void setMountPoints( const std::set<MountPoint> & mountpoints_r );

    const std::set<MountPoint> & mountpoints() const { return _mountpoints; }

    FSize pkg_diff() const { return _pkg_diff; }

    void addSrcPkgs( const FSize & srcSize_r );

  public:

    friend std::ostream & operator<<( std::ostream & str, const PkgDuMaster & obj );
    friend std::ostream & operator<<( std::ostream & str, const std::set<MountPoint> & obj );
};


//
//      CLASS NAME : PkgDuSlave
class PkgDuSlave {

  PkgDuSlave & operator=( const PkgDuSlave & ); // no assign
  PkgDuSlave            ( const PkgDuSlave & ); // no copy

  private:

    friend class PMPackage;

    PkgDuSlave();
    ~PkgDuSlave();

    typedef PkgDuMaster::MountPoint MountPoint;

  private:

    mutable unsigned _count;

    mutable FSize * _data;

    bool sync( const PMPackage & pkg_r, PkgDuMaster & master_r ) const;

    bool add( const PMPackage & pkg_r, PkgDuMaster & master_r ) const;

    bool sub( const PMPackage & pkg_r, PkgDuMaster & master_r ) const;
};


#endif // PkgDu_h

---