libzypp 17.25.10
DiskUsageCounter.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_DISKUSAGE_COUNTER_H
13 #define ZYPP_DISKUSAGE_COUNTER_H
14 
15 #include <set>
16 #include <string>
17 #include <iosfwd>
18 
19 #include <zypp/ResPool.h>
20 #include <zypp/Bitmap.h>
21 #include <zypp/base/Flags.h>
22 
24 namespace zypp
25 {
26 
32  {
33 
34  public:
42  struct MountPoint
43  {
44  friend std::ostream & operator<<( std::ostream & str, const MountPoint & obj );
45  std::string dir;
46  std::string fstype;
47  long long block_size;
48  long long total_size;
49  long long used_size;
50  mutable long long pkg_size;
51  // hint bits:
52  bool readonly:1;
53  bool growonly:1;
54 
55 
57  enum Hint
58  {
59  NoHint = 0,
60  Hint_readonly = (1<<0),
61  Hint_growonly = (1<<1),
62  };
64 
66  MountPoint( const std::string & d = "/",
67  const std::string & f = std::string(),
68  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
69  HintFlags hints = NoHint )
70  : dir(d), fstype(f)
71  , block_size(bs), total_size(total), used_size(used), pkg_size(pkg)
72  , readonly(hints.testFlag(Hint_readonly))
73  , growonly(hints.testFlag(Hint_growonly))
74  {}
80  MountPoint( const char * d,
81  const std::string & f = std::string(),
82  long long bs = 0LL, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
83  HintFlags hints = NoHint )
84  : MountPoint( std::string(d?d:""), f, bs, total, used, pkg, hints )
85  {}
86 
87 
89  MountPoint( const std::string & d,
90  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
91  HintFlags hints = NoHint )
92  : MountPoint( d, std::string(), bs, total, used, pkg, hints )
93  {}
95  MountPoint( const char * d,
96  long long bs, long long total = 0LL, long long used = 0LL, long long pkg = 0LL,
97  HintFlags hints = NoHint )
98  : MountPoint( std::string(d?d:""), bs, total, used, pkg, hints )
99  {}
100 
101 
103  MountPoint( const std::string & d, HintFlags hints )
104  : MountPoint( d, std::string(), 0LL, 0LL, 0LL, 0LL, hints )
105  {}
107  MountPoint( const char * d, HintFlags hints )
108  : MountPoint( std::string(d?d:""), hints )
109  {}
111  MountPoint( const std::string & d, Hint hint )
112  : MountPoint( d, HintFlags(hint) )
113  {}
115  MountPoint( const char * d, Hint hint )
116  : MountPoint( std::string(d?d:""), HintFlags(hint) )
117  {}
118 
120  bool operator<( const MountPoint & rhs ) const
121  { return dir < rhs.dir; }
122 
125  { return ByteCount( block_size, ByteCount::B ); }
126 
129  { return ByteCount( total_size, ByteCount::K ); }
130 
133  { return ByteCount( used_size, ByteCount::K ); }
134 
138 
141  { return ByteCount( pkg_size, ByteCount::K ); }
142 
145  { return ByteCount( total_size-pkg_size, ByteCount::K ); }
146 
149  { return ByteCount( pkg_size-used_size, ByteCount::K ); }
150  };
152 
153  typedef std::set<MountPoint> MountPointSet;
154 
156  {}
157 
160  : _mps( mps_r )
161  {}
162 
164  void setMountPoints( const MountPointSet & mps_r )
165  { _mps = mps_r; }
166 
169  { return _mps; }
170 
176  static MountPointSet detectMountPoints( const std::string & rootdir = "/" );
177 
180 
181 
183  MountPointSet disk_usage( const ResPool & pool ) const;
184 
186  MountPointSet disk_usage( sat::Solvable solv_r ) const;
188  MountPointSet disk_usage( const PoolItem & pi_r ) const
189  { return disk_usage( sat::asSolvable()( pi_r ) ); }
192  { return disk_usage( sat::asSolvable()( obj_r ) ); }
193 
195  MountPointSet disk_usage( const Bitmap & bitmap_r ) const;
196 
198  template<class Iterator>
199  MountPointSet disk_usage( Iterator begin_r, Iterator end_r ) const
200  {
201  Bitmap bitmap( Bitmap::poolSize );
202  for_( it, begin_r, end_r )
203  bitmap.set( sat::asSolvable()( *it ).id() );
204  return disk_usage( bitmap );
205  }
206 
207  private:
209  };
211 
212  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags);
213 
215  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPoint & obj );
216 
218  std::ostream & operator<<( std::ostream & str, const DiskUsageCounter::MountPointSet & obj );
219 
221  inline std::ostream & operator<<( std::ostream & str, const DiskUsageCounter & obj )
222  { return str << obj.getMountPoints(); }
223 
225 } // namespace zypp
227 #endif // ZYPP_DISKUSAGE_COUNTER_H
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:28
Store and operate with byte count.
Definition: ByteCount.h:31
static const Unit K
1024 Byte
Definition: ByteCount.h:45
static const Unit B
1 Byte
Definition: ByteCount.h:42
Compute disk space occupied by packages across partitions/directories.
static MountPointSet justRootPartition()
Only one entry for "/" to collect total sizes.
MountPointSet disk_usage(Iterator begin_r, Iterator end_r) const
Compute disk usage of a collection (convertible by asSolvable).
MountPointSet disk_usage(const ResPool &pool) const
Compute disk usage if the current transaction woud be commited.
void setMountPoints(const MountPointSet &mps_r)
Set a MountPointSet to compute.
std::set< MountPoint > MountPointSet
static MountPointSet detectMountPoints(const std::string &rootdir="/")
Get mountpoints of system below rootdir If we happen to detect snapshotting btrfs partitions,...
MountPointSet disk_usage(const PoolItem &pi_r) const
const MountPointSet & getMountPoints() const
Get the current MountPointSet.
MountPointSet disk_usage(const ResObject::constPtr &obj_r) const
std::ostream & operator<<(std::ostream &str, const DiskUsageCounter &obj)
Stream output.
DiskUsageCounter(const MountPointSet &mps_r)
Ctor taking the MountPointSet to compute.
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:51
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
Global ResObject pool.
Definition: ResPool.h:61
Libsolv (bit)Map wrapper.
Definition: Map.h:34
static constexpr PoolSizeType poolSize
An object indicating the bitmap should match the current pools capacity.
Definition: Map.h:41
void set(size_type idx_r)
Set bit idx_r.
Definition: Map.cc:81
A Solvable object within the sat Pool.
Definition: Solvable.h:54
Definition: Arch.h:348
String related utilities and Regular expression matching.
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
std::ostream & operator<<(std::ostream &str, const Exception &obj)
Definition: Exception.cc:147
ZYPP_DECLARE_OPERATORS_FOR_FLAGS(DiskUsageCounter::MountPoint::HintFlags)
Mount point description If block_size is set DiskUsageCoutner will assume half a block_size is wasted...
MountPoint(const std::string &d, long long bs, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
Ctor initialize directory and sizes.
long long used_size
Used size of the filesystem in KiB (0 if you don't care)
MountPoint(const std::string &d, Hint hint)
ByteCount commitDiff() const
Size change due to installation as ByteCount for convenience.
MountPoint(const std::string &d, HintFlags hints)
Ctor just name and hints, all sizes 0.
ByteCount usedSize() const
Used size of the filesystem as ByteCount for convenience.
ByteCount freeSize() const
Free size of the filesystem as ByteCount for convenience.
@ Hint_growonly
growonly partitions (e.g. snapshotting btrfs)
MountPoint(const char *d, const std::string &f=std::string(), long long bs=0LL, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
long long block_size
Block size of the filesystem in B (0 if you don't care)
MountPoint(const char *d, HintFlags hints)
ByteCount freeAfterCommit() const
Free size after installation as ByteCount for convenience.
long long total_size
Total size of the filesystem in KiB (0 if you don't care)
MountPoint(const char *d, long long bs, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
bool readonly
hint for readonly partitions
std::string dir
Directory name.
ByteCount blockSize() const
Block size of the filesystem as ByteCount for convenience.
MountPoint(const char *d, Hint hint)
long long pkg_size
Used size after installation in KiB (computed by DiskUsageCoutner)
MountPoint(const std::string &d="/", const std::string &f=std::string(), long long bs=0LL, long long total=0LL, long long used=0LL, long long pkg=0LL, HintFlags hints=NoHint)
Ctor initialize directory, fstype and sizes.
bool growonly
hint for growonly partitions (e.g. snapshotting btrfs)
bool operator<(const MountPoint &rhs) const
Sort by directory name.
friend std::ostream & operator<<(std::ostream &str, const MountPoint &obj)
ByteCount usedAfterCommit() const
Used size after installation as ByteCount for convenience.
std::string fstype
Filesystem type (provided by detectMountPoints)
ByteCount totalSize() const
Total size of the filesystem as ByteCount for convenience.
To Solvable transform functor.
Definition: Solvable.h:529