mirror of
https://github.com/docker/compose.git
synced 2025-04-08 17:05:13 +02:00
caad72713b
By default, `compose up` attaches to all services (i.e. shows log output from every associated container). If a service is specified, e.g. `compose up foo`, then only `foo`'s logs are tailed. The `--attach-dependencies` flag can also be used, so that if `foo` depended upon `bar`, then `bar`'s logs would also be followed. It's also possible to use `--no-attach` to filter out one or more services explicitly, e.g. `compose up --no-attach=noisy` would launch all services, including `noisy`, and would show log output from every service _except_ `noisy`. Lastly, it's possible to use `up --attach` to explicitly restrict to a subset of services (or their dependencies). How these flags interact with each other is also worth thinking through. There were a few different connected issues here, but the primary issue was that running `compose up foo` was always attaching dependencies regardless of `--attach-dependencies`. The filtering logic here has been updated so that it behaves predictably both when launching all services (`compose up`) or a subset (`compose up foo`) as well as various flag combinations on top of those. Notably, this required making some changes to how it watches containers. The logic here between attaching for logs and monitoring for lifecycle changes is tightly coupled, so some changes were needed to ensure that the full set of services being `up`'d are _watched_ and the subset that should have logs shown are _attached_. (This does mean faking the attach with an event but not actually doing it.) While handling that, I adjusted the context lifetimes here, which improves error handling that gets shown to the user and should help avoid potential leaks by getting rid of a `context.Background()`. Signed-off-by: Milas Bowman <milas.bowman@docker.com>
94 lines
1.7 KiB
Go
94 lines
1.7 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 utils
|
|
|
|
type Set[T comparable] map[T]struct{}
|
|
|
|
func NewSet[T comparable](v ...T) Set[T] {
|
|
if len(v) == 0 {
|
|
return make(Set[T])
|
|
}
|
|
|
|
out := make(Set[T], len(v))
|
|
for i := range v {
|
|
out.Add(v[i])
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s Set[T]) Has(v T) bool {
|
|
_, ok := s[v]
|
|
return ok
|
|
}
|
|
|
|
func (s Set[T]) Add(v T) {
|
|
s[v] = struct{}{}
|
|
}
|
|
|
|
func (s Set[T]) AddAll(v ...T) {
|
|
for _, e := range v {
|
|
s[e] = struct{}{}
|
|
}
|
|
}
|
|
|
|
func (s Set[T]) Remove(v T) bool {
|
|
_, ok := s[v]
|
|
if ok {
|
|
delete(s, v)
|
|
}
|
|
return ok
|
|
}
|
|
|
|
func (s Set[T]) Clear() {
|
|
for v := range s {
|
|
delete(s, v)
|
|
}
|
|
}
|
|
|
|
func (s Set[T]) Elements() []T {
|
|
elements := make([]T, 0, len(s))
|
|
for v := range s {
|
|
elements = append(elements, v)
|
|
}
|
|
return elements
|
|
}
|
|
|
|
func (s Set[T]) RemoveAll(elements ...T) {
|
|
for _, e := range elements {
|
|
s.Remove(e)
|
|
}
|
|
}
|
|
|
|
func (s Set[T]) Diff(other Set[T]) Set[T] {
|
|
out := make(Set[T])
|
|
for k := range s {
|
|
if _, ok := other[k]; !ok {
|
|
out[k] = struct{}{}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s Set[T]) Union(other Set[T]) Set[T] {
|
|
out := make(Set[T])
|
|
for k := range s {
|
|
out[k] = struct{}{}
|
|
}
|
|
for k := range other {
|
|
out[k] = struct{}{}
|
|
}
|
|
return out
|
|
}
|