1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
package daemon
import (
"context"
"fmt"
"github.com/docker/docker/api/types/backend"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/image"
"github.com/docker/docker/api/types/volume"
"github.com/pkg/errors"
"golang.org/x/sync/errgroup"
)
// containerDiskUsage obtains information about container data disk usage
// and makes sure that only one calculation is performed at the same time.
func (daemon *Daemon) containerDiskUsage(ctx context.Context) (*container.DiskUsage, error) {
res, _, err := daemon.usageContainers.Do(ctx, struct{}{}, func(ctx context.Context) (*container.DiskUsage, error) {
// Retrieve container list
containers, err := daemon.Containers(ctx, &container.ListOptions{
Size: true,
All: true,
})
if err != nil {
return nil, fmt.Errorf("failed to retrieve container list: %v", err)
}
// Remove image manifest descriptor from the result as it should not be included.
// https://github.com/moby/moby/pull/49407#discussion_r1954396666
for _, c := range containers {
c.ImageManifestDescriptor = nil
}
isActive := func(ctr *container.Summary) bool {
return ctr.State == container.StateRunning ||
ctr.State == container.StatePaused ||
ctr.State == container.StateRestarting
}
du := &container.DiskUsage{Items: containers}
for _, ctr := range du.Items {
du.TotalSize += ctr.SizeRw
if !isActive(ctr) {
du.Reclaimable += ctr.SizeRw
}
}
return du, nil
})
return res, err
}
// imageDiskUsage obtains information about image data disk usage from image service
// and makes sure that only one calculation is performed at the same time.
func (daemon *Daemon) imageDiskUsage(ctx context.Context) ([]*image.Summary, error) {
imgs, _, err := daemon.usageImages.Do(ctx, struct{}{}, func(ctx context.Context) ([]*image.Summary, error) {
// Get all top images with extra attributes
imgs, err := daemon.imageService.Images(ctx, image.ListOptions{
Filters: filters.NewArgs(),
SharedSize: true,
})
if err != nil {
return nil, errors.Wrap(err, "failed to retrieve image list")
}
return imgs, nil
})
return imgs, err
}
// localVolumesSize obtains information about volume disk usage from volumes service
// and makes sure that only one size calculation is performed at the same time.
func (daemon *Daemon) localVolumesSize(ctx context.Context) (*volume.DiskUsage, error) {
volumes, _, err := daemon.usageVolumes.Do(ctx, struct{}{}, func(ctx context.Context) (*volume.DiskUsage, error) {
volumes, err := daemon.volumes.LocalVolumesSize(ctx)
if err != nil {
return nil, err
}
du := &volume.DiskUsage{Items: volumes}
for _, v := range du.Items {
if v.UsageData.Size != -1 {
if v.UsageData.RefCount == 0 {
du.Reclaimable += v.UsageData.Size
}
du.TotalSize += v.UsageData.Size
}
}
return du, nil
})
return volumes, err
}
// layerDiskUsage obtains information about layer disk usage from image service
// and makes sure that only one size calculation is performed at the same time.
func (daemon *Daemon) layerDiskUsage(ctx context.Context) (int64, error) {
usage, _, err := daemon.usageLayer.Do(ctx, struct{}{}, func(ctx context.Context) (usage int64, err error) {
return daemon.imageService.ImageDiskUsage(ctx)
})
return usage, err
}
// SystemDiskUsage returns information about the daemon data disk usage.
// Callers must not mutate contents of the returned fields.
func (daemon *Daemon) SystemDiskUsage(ctx context.Context, opts backend.DiskUsageOptions) (*backend.DiskUsage, error) {
eg, ctx := errgroup.WithContext(ctx)
du := &backend.DiskUsage{}
if opts.Containers {
eg.Go(func() (err error) {
du.Containers, err = daemon.containerDiskUsage(ctx)
return err
})
}
var (
layersSize int64
images []*image.Summary
)
if opts.Images {
eg.Go(func() (err error) {
images, err = daemon.imageDiskUsage(ctx)
return err
})
eg.Go(func() (err error) {
layersSize, err = daemon.layerDiskUsage(ctx)
return err
})
}
if opts.Volumes {
eg.Go(func() (err error) {
du.Volumes, err = daemon.localVolumesSize(ctx)
return err
})
}
if err := eg.Wait(); err != nil {
return nil, err
}
if opts.Images {
reclaimable := layersSize
for _, i := range images {
if i.Containers != 0 {
if i.Size == -1 || i.SharedSize == -1 {
continue
}
reclaimable -= i.Size - i.SharedSize
}
}
du.Images = &image.DiskUsage{
TotalSize: layersSize,
Reclaimable: reclaimable,
Items: images,
}
}
return du, nil
}
|
