prune.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463
  1. package daemon
  2. import (
  3. "fmt"
  4. "regexp"
  5. "sync/atomic"
  6. "time"
  7. "github.com/Sirupsen/logrus"
  8. "github.com/docker/distribution/reference"
  9. "github.com/docker/docker/api/types"
  10. "github.com/docker/docker/api/types/filters"
  11. timetypes "github.com/docker/docker/api/types/time"
  12. "github.com/docker/docker/image"
  13. "github.com/docker/docker/layer"
  14. "github.com/docker/docker/pkg/directory"
  15. "github.com/docker/docker/runconfig"
  16. "github.com/docker/docker/volume"
  17. "github.com/docker/libnetwork"
  18. digest "github.com/opencontainers/go-digest"
  19. "golang.org/x/net/context"
  20. )
  21. var (
  22. // errPruneRunning is returned when a prune request is received while
  23. // one is in progress
  24. errPruneRunning = fmt.Errorf("a prune operation is already running")
  25. containersAcceptedFilters = map[string]bool{
  26. "label": true,
  27. "label!": true,
  28. "until": true,
  29. }
  30. volumesAcceptedFilters = map[string]bool{
  31. "label": true,
  32. "label!": true,
  33. }
  34. imagesAcceptedFilters = map[string]bool{
  35. "dangling": true,
  36. "label": true,
  37. "label!": true,
  38. "until": true,
  39. }
  40. networksAcceptedFilters = map[string]bool{
  41. "label": true,
  42. "label!": true,
  43. "until": true,
  44. }
  45. )
  46. // ContainersPrune removes unused containers
  47. func (daemon *Daemon) ContainersPrune(ctx context.Context, pruneFilters filters.Args) (*types.ContainersPruneReport, error) {
  48. if !atomic.CompareAndSwapInt32(&daemon.pruneRunning, 0, 1) {
  49. return nil, errPruneRunning
  50. }
  51. defer atomic.StoreInt32(&daemon.pruneRunning, 0)
  52. rep := &types.ContainersPruneReport{}
  53. // make sure that only accepted filters have been received
  54. err := pruneFilters.Validate(containersAcceptedFilters)
  55. if err != nil {
  56. return nil, err
  57. }
  58. until, err := getUntilFromPruneFilters(pruneFilters)
  59. if err != nil {
  60. return nil, err
  61. }
  62. allContainers := daemon.List()
  63. for _, c := range allContainers {
  64. select {
  65. case <-ctx.Done():
  66. logrus.Warnf("ContainersPrune operation cancelled: %#v", *rep)
  67. return rep, ctx.Err()
  68. default:
  69. }
  70. if !c.IsRunning() {
  71. if !until.IsZero() && c.Created.After(until) {
  72. continue
  73. }
  74. if !matchLabels(pruneFilters, c.Config.Labels) {
  75. continue
  76. }
  77. cSize, _ := daemon.getSize(c.ID)
  78. // TODO: sets RmLink to true?
  79. err := daemon.ContainerRm(c.ID, &types.ContainerRmConfig{})
  80. if err != nil {
  81. logrus.Warnf("failed to prune container %s: %v", c.ID, err)
  82. continue
  83. }
  84. if cSize > 0 {
  85. rep.SpaceReclaimed += uint64(cSize)
  86. }
  87. rep.ContainersDeleted = append(rep.ContainersDeleted, c.ID)
  88. }
  89. }
  90. return rep, nil
  91. }
  92. // VolumesPrune removes unused local volumes
  93. func (daemon *Daemon) VolumesPrune(ctx context.Context, pruneFilters filters.Args) (*types.VolumesPruneReport, error) {
  94. if !atomic.CompareAndSwapInt32(&daemon.pruneRunning, 0, 1) {
  95. return nil, errPruneRunning
  96. }
  97. defer atomic.StoreInt32(&daemon.pruneRunning, 0)
  98. // make sure that only accepted filters have been received
  99. err := pruneFilters.Validate(volumesAcceptedFilters)
  100. if err != nil {
  101. return nil, err
  102. }
  103. rep := &types.VolumesPruneReport{}
  104. pruneVols := func(v volume.Volume) error {
  105. select {
  106. case <-ctx.Done():
  107. logrus.Warnf("VolumesPrune operation cancelled: %#v", *rep)
  108. return ctx.Err()
  109. default:
  110. }
  111. name := v.Name()
  112. refs := daemon.volumes.Refs(v)
  113. if len(refs) == 0 {
  114. detailedVolume, ok := v.(volume.DetailedVolume)
  115. if ok {
  116. if !matchLabels(pruneFilters, detailedVolume.Labels()) {
  117. return nil
  118. }
  119. }
  120. vSize, err := directory.Size(v.Path())
  121. if err != nil {
  122. logrus.Warnf("could not determine size of volume %s: %v", name, err)
  123. }
  124. err = daemon.volumes.Remove(v)
  125. if err != nil {
  126. logrus.Warnf("could not remove volume %s: %v", name, err)
  127. return nil
  128. }
  129. rep.SpaceReclaimed += uint64(vSize)
  130. rep.VolumesDeleted = append(rep.VolumesDeleted, name)
  131. }
  132. return nil
  133. }
  134. err = daemon.traverseLocalVolumes(pruneVols)
  135. return rep, err
  136. }
  137. // ImagesPrune removes unused images
  138. func (daemon *Daemon) ImagesPrune(ctx context.Context, pruneFilters filters.Args) (*types.ImagesPruneReport, error) {
  139. if !atomic.CompareAndSwapInt32(&daemon.pruneRunning, 0, 1) {
  140. return nil, errPruneRunning
  141. }
  142. defer atomic.StoreInt32(&daemon.pruneRunning, 0)
  143. // make sure that only accepted filters have been received
  144. err := pruneFilters.Validate(imagesAcceptedFilters)
  145. if err != nil {
  146. return nil, err
  147. }
  148. rep := &types.ImagesPruneReport{}
  149. danglingOnly := true
  150. if pruneFilters.Include("dangling") {
  151. if pruneFilters.ExactMatch("dangling", "false") || pruneFilters.ExactMatch("dangling", "0") {
  152. danglingOnly = false
  153. } else if !pruneFilters.ExactMatch("dangling", "true") && !pruneFilters.ExactMatch("dangling", "1") {
  154. return nil, fmt.Errorf("Invalid filter 'dangling=%s'", pruneFilters.Get("dangling"))
  155. }
  156. }
  157. until, err := getUntilFromPruneFilters(pruneFilters)
  158. if err != nil {
  159. return nil, err
  160. }
  161. var allImages map[image.ID]*image.Image
  162. if danglingOnly {
  163. allImages = daemon.imageStore.Heads()
  164. } else {
  165. allImages = daemon.imageStore.Map()
  166. }
  167. allContainers := daemon.List()
  168. imageRefs := map[string]bool{}
  169. for _, c := range allContainers {
  170. select {
  171. case <-ctx.Done():
  172. return nil, ctx.Err()
  173. default:
  174. imageRefs[c.ID] = true
  175. }
  176. }
  177. // Filter intermediary images and get their unique size
  178. allLayers := daemon.layerStore.Map()
  179. topImages := map[image.ID]*image.Image{}
  180. for id, img := range allImages {
  181. select {
  182. case <-ctx.Done():
  183. return nil, ctx.Err()
  184. default:
  185. dgst := digest.Digest(id)
  186. if len(daemon.referenceStore.References(dgst)) == 0 && len(daemon.imageStore.Children(id)) != 0 {
  187. continue
  188. }
  189. if !until.IsZero() && img.Created.After(until) {
  190. continue
  191. }
  192. if img.Config != nil && !matchLabels(pruneFilters, img.Config.Labels) {
  193. continue
  194. }
  195. topImages[id] = img
  196. }
  197. }
  198. canceled := false
  199. deleteImagesLoop:
  200. for id := range topImages {
  201. select {
  202. case <-ctx.Done():
  203. // we still want to calculate freed size and return the data
  204. canceled = true
  205. break deleteImagesLoop
  206. default:
  207. }
  208. dgst := digest.Digest(id)
  209. hex := dgst.Hex()
  210. if _, ok := imageRefs[hex]; ok {
  211. continue
  212. }
  213. deletedImages := []types.ImageDeleteResponseItem{}
  214. refs := daemon.referenceStore.References(dgst)
  215. if len(refs) > 0 {
  216. shouldDelete := !danglingOnly
  217. if !shouldDelete {
  218. hasTag := false
  219. for _, ref := range refs {
  220. if _, ok := ref.(reference.NamedTagged); ok {
  221. hasTag = true
  222. break
  223. }
  224. }
  225. // Only delete if it's untagged (i.e. repo:<none>)
  226. shouldDelete = !hasTag
  227. }
  228. if shouldDelete {
  229. for _, ref := range refs {
  230. imgDel, err := daemon.ImageDelete(ref.String(), false, true)
  231. if err != nil {
  232. logrus.Warnf("could not delete reference %s: %v", ref.String(), err)
  233. continue
  234. }
  235. deletedImages = append(deletedImages, imgDel...)
  236. }
  237. }
  238. } else {
  239. imgDel, err := daemon.ImageDelete(hex, false, true)
  240. if err != nil {
  241. logrus.Warnf("could not delete image %s: %v", hex, err)
  242. continue
  243. }
  244. deletedImages = append(deletedImages, imgDel...)
  245. }
  246. rep.ImagesDeleted = append(rep.ImagesDeleted, deletedImages...)
  247. }
  248. // Compute how much space was freed
  249. for _, d := range rep.ImagesDeleted {
  250. if d.Deleted != "" {
  251. chid := layer.ChainID(d.Deleted)
  252. if l, ok := allLayers[chid]; ok {
  253. diffSize, err := l.DiffSize()
  254. if err != nil {
  255. logrus.Warnf("failed to get layer %s size: %v", chid, err)
  256. continue
  257. }
  258. rep.SpaceReclaimed += uint64(diffSize)
  259. }
  260. }
  261. }
  262. if canceled {
  263. logrus.Warnf("ImagesPrune operation cancelled: %#v", *rep)
  264. return nil, ctx.Err()
  265. }
  266. return rep, nil
  267. }
  268. // localNetworksPrune removes unused local networks
  269. func (daemon *Daemon) localNetworksPrune(ctx context.Context, pruneFilters filters.Args) *types.NetworksPruneReport {
  270. rep := &types.NetworksPruneReport{}
  271. until, _ := getUntilFromPruneFilters(pruneFilters)
  272. // When the function returns true, the walk will stop.
  273. l := func(nw libnetwork.Network) bool {
  274. select {
  275. case <-ctx.Done():
  276. return true
  277. default:
  278. }
  279. if nw.Info().ConfigOnly() {
  280. return false
  281. }
  282. if !until.IsZero() && nw.Info().Created().After(until) {
  283. return false
  284. }
  285. if !matchLabels(pruneFilters, nw.Info().Labels()) {
  286. return false
  287. }
  288. nwName := nw.Name()
  289. if runconfig.IsPreDefinedNetwork(nwName) {
  290. return false
  291. }
  292. if len(nw.Endpoints()) > 0 {
  293. return false
  294. }
  295. if err := daemon.DeleteNetwork(nw.ID()); err != nil {
  296. logrus.Warnf("could not remove local network %s: %v", nwName, err)
  297. return false
  298. }
  299. rep.NetworksDeleted = append(rep.NetworksDeleted, nwName)
  300. return false
  301. }
  302. daemon.netController.WalkNetworks(l)
  303. return rep
  304. }
  305. // clusterNetworksPrune removes unused cluster networks
  306. func (daemon *Daemon) clusterNetworksPrune(ctx context.Context, pruneFilters filters.Args) (*types.NetworksPruneReport, error) {
  307. rep := &types.NetworksPruneReport{}
  308. until, _ := getUntilFromPruneFilters(pruneFilters)
  309. cluster := daemon.GetCluster()
  310. if !cluster.IsManager() {
  311. return rep, nil
  312. }
  313. networks, err := cluster.GetNetworks()
  314. if err != nil {
  315. return rep, err
  316. }
  317. networkIsInUse := regexp.MustCompile(`network ([[:alnum:]]+) is in use`)
  318. for _, nw := range networks {
  319. select {
  320. case <-ctx.Done():
  321. return rep, ctx.Err()
  322. default:
  323. if nw.Ingress {
  324. // Routing-mesh network removal has to be explicitly invoked by user
  325. continue
  326. }
  327. if !until.IsZero() && nw.Created.After(until) {
  328. continue
  329. }
  330. if !matchLabels(pruneFilters, nw.Labels) {
  331. continue
  332. }
  333. // https://github.com/docker/docker/issues/24186
  334. // `docker network inspect` unfortunately displays ONLY those containers that are local to that node.
  335. // So we try to remove it anyway and check the error
  336. err = cluster.RemoveNetwork(nw.ID)
  337. if err != nil {
  338. // we can safely ignore the "network .. is in use" error
  339. match := networkIsInUse.FindStringSubmatch(err.Error())
  340. if len(match) != 2 || match[1] != nw.ID {
  341. logrus.Warnf("could not remove cluster network %s: %v", nw.Name, err)
  342. }
  343. continue
  344. }
  345. rep.NetworksDeleted = append(rep.NetworksDeleted, nw.Name)
  346. }
  347. }
  348. return rep, nil
  349. }
  350. // NetworksPrune removes unused networks
  351. func (daemon *Daemon) NetworksPrune(ctx context.Context, pruneFilters filters.Args) (*types.NetworksPruneReport, error) {
  352. if !atomic.CompareAndSwapInt32(&daemon.pruneRunning, 0, 1) {
  353. return nil, errPruneRunning
  354. }
  355. defer atomic.StoreInt32(&daemon.pruneRunning, 0)
  356. // make sure that only accepted filters have been received
  357. err := pruneFilters.Validate(networksAcceptedFilters)
  358. if err != nil {
  359. return nil, err
  360. }
  361. if _, err := getUntilFromPruneFilters(pruneFilters); err != nil {
  362. return nil, err
  363. }
  364. rep := &types.NetworksPruneReport{}
  365. if clusterRep, err := daemon.clusterNetworksPrune(ctx, pruneFilters); err == nil {
  366. rep.NetworksDeleted = append(rep.NetworksDeleted, clusterRep.NetworksDeleted...)
  367. }
  368. localRep := daemon.localNetworksPrune(ctx, pruneFilters)
  369. rep.NetworksDeleted = append(rep.NetworksDeleted, localRep.NetworksDeleted...)
  370. select {
  371. case <-ctx.Done():
  372. logrus.Warnf("NetworksPrune operation cancelled: %#v", *rep)
  373. return nil, ctx.Err()
  374. default:
  375. }
  376. return rep, nil
  377. }
  378. func getUntilFromPruneFilters(pruneFilters filters.Args) (time.Time, error) {
  379. until := time.Time{}
  380. if !pruneFilters.Include("until") {
  381. return until, nil
  382. }
  383. untilFilters := pruneFilters.Get("until")
  384. if len(untilFilters) > 1 {
  385. return until, fmt.Errorf("more than one until filter specified")
  386. }
  387. ts, err := timetypes.GetTimestamp(untilFilters[0], time.Now())
  388. if err != nil {
  389. return until, err
  390. }
  391. seconds, nanoseconds, err := timetypes.ParseTimestamps(ts, 0)
  392. if err != nil {
  393. return until, err
  394. }
  395. until = time.Unix(seconds, nanoseconds)
  396. return until, nil
  397. }
  398. func matchLabels(pruneFilters filters.Args, labels map[string]string) bool {
  399. if !pruneFilters.MatchKVList("label", labels) {
  400. return false
  401. }
  402. // By default MatchKVList will return true if field (like 'label!') does not exist
  403. // So we have to add additional Include("label!") check
  404. if pruneFilters.Include("label!") {
  405. if pruneFilters.MatchKVList("label!", labels) {
  406. return false
  407. }
  408. }
  409. return true
  410. }