mirror of
https://github.com/docker/compose.git
synced 2026-11-18 06:07:53 +00:00
- layoutFrame clips its output to the terminal height: height==1 no longer overflows with header + more-marker - the two status-to-color switches merge into eventColor(status, def) - the clear-suspension sequence extracts into unsuspend() - tests drive a manually-advanced fake clock through the injected now(), and the cancel test loses its settling sleep — Done waits for the refresh goroutine itself - roots, per-parent children and the completed count are maintained incrementally by apply(), so a 100ms tick with an unchanged tree no longer rescans every task - the frame<0 clamp in spinGlyph drops: time comes from the writer's single clock and never regresses; the invariant is documented on the model - Start's retire-previous-cycle comment spells out that cancellation only guarantees the old goroutine will exit, not that it already has Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>
140 lines
4 KiB
Go
140 lines
4 KiB
Go
/*
|
|
Copyright 2020 Docker Compose CLI authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package display
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/docker/compose/v5/pkg/api"
|
|
"github.com/docker/compose/v5/pkg/utils"
|
|
)
|
|
|
|
// node is the rendered state of a single task, fed exclusively by
|
|
// taskTree.apply. It holds no rendering concern: no spinner, no strings
|
|
// destined for the screen, no clock reads.
|
|
type node struct {
|
|
id string
|
|
anchor string // first parent seen; only events carrying it update the node
|
|
parents utils.Set[string]
|
|
text string
|
|
details string
|
|
status api.EventStatus
|
|
current int64
|
|
total int64
|
|
percent int
|
|
startedAt time.Time
|
|
endedAt time.Time
|
|
}
|
|
|
|
func (n *node) completed() bool {
|
|
switch n.status {
|
|
case api.Done, api.Error, api.Warning:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// taskTree stores tasks in arrival order and resolves parent/child links.
|
|
// It is a plain data structure: all mutation goes through apply, all time is
|
|
// injected, so its behavior is exhaustively testable without a terminal.
|
|
//
|
|
// Roots, per-parent children and the completed count are maintained
|
|
// incrementally by apply: the layout reads them on every refresh tick, so a
|
|
// frame with an unchanged tree costs O(1) here instead of a full rescan.
|
|
//
|
|
// Every time value handed to apply (and to the layout) must come from the
|
|
// writer's single clock: the model relies on time never regressing between
|
|
// calls — spinner frames and elapsed timers are computed as bare
|
|
// differences against startedAt/endedAt.
|
|
type taskTree struct {
|
|
nodes map[string]*node
|
|
roots []*node // nodes without any parent, in arrival order
|
|
children map[string][]*node // parent id → children, in link-arrival order
|
|
done int // nodes currently in a completed status
|
|
}
|
|
|
|
func newTaskTree() taskTree {
|
|
return taskTree{
|
|
nodes: map[string]*node{},
|
|
children: map[string][]*node{},
|
|
}
|
|
}
|
|
|
|
// apply is the single state transition of the model.
|
|
func (t *taskTree) apply(e api.Resource, now time.Time) {
|
|
n, ok := t.nodes[e.ID]
|
|
if !ok {
|
|
n = &node{
|
|
id: e.ID,
|
|
anchor: e.ParentID,
|
|
parents: utils.NewSet[string](),
|
|
startedAt: now,
|
|
}
|
|
t.nodes[e.ID] = n
|
|
if e.ParentID == "" {
|
|
t.roots = append(t.roots, n)
|
|
}
|
|
}
|
|
if e.ParentID != "" {
|
|
if !n.parents.Has(e.ParentID) {
|
|
n.parents.Add(e.ParentID)
|
|
t.children[e.ParentID] = append(t.children[e.ParentID], n)
|
|
if len(n.parents) == 1 {
|
|
// first parent ever: the node is not a root after all
|
|
t.removeRoot(n)
|
|
}
|
|
}
|
|
// Layers shared by several images receive the same events once per
|
|
// image. Accept updates from the first declared parent only, so the
|
|
// rendered state doesn't flicker between concurrent pull streams.
|
|
if n.anchor != e.ParentID {
|
|
return
|
|
}
|
|
}
|
|
|
|
wasCompleted := n.completed()
|
|
n.status = e.Status
|
|
n.text = e.Text
|
|
n.details = e.Details
|
|
// progress is monotonic: out-of-order events must not move bars backwards
|
|
n.total = max(n.total, e.Total)
|
|
n.current = max(n.current, e.Current)
|
|
n.percent = max(n.percent, e.Percent)
|
|
switch {
|
|
case n.completed() && !wasCompleted:
|
|
n.endedAt = now
|
|
t.done++
|
|
case !n.completed() && wasCompleted:
|
|
t.done--
|
|
}
|
|
}
|
|
|
|
func (t *taskTree) removeRoot(n *node) {
|
|
for i, root := range t.roots {
|
|
if root == n {
|
|
t.roots = append(t.roots[:i], t.roots[i+1:]...)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// counts returns completed and total task counts, children included, to
|
|
// preserve the historical "[+] pull 3/15" header semantics.
|
|
func (t *taskTree) counts() (done, total int) {
|
|
return t.done, len(t.nodes)
|
|
}
|