21374897774

Committed 26 Jan 2026 09:37PM UTC coverage: 80.008% (-0.3%) from 80.269%

Build # 21374897774

Build Type

Pull #23037

github

Committed by

web-flow

Commit Message

Merge 4023b9eee into 09b8ecaa1

Pull Request Pull Request #23037: Enable publish without package 2

Run Details

105 of 178 new or added lines in 11 files covered. (58.99%)

238 existing lines in 14 files now uncovered.

78628 of 98275 relevant lines covered (80.01%)

3.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.68

/src/python/pants/backend/docker/goals/publish.py

# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import annotations

import logging
from collections import defaultdict
from dataclasses import dataclass
from itertools import chain
from typing import DefaultDict, cast

from pants.backend.docker.goals.package_image import (
    BuiltDockerImage,
    DockerPackageFieldSet,
    GetImageTagsRequest,
    get_image_tags,
)
from pants.backend.docker.registries import DockerRegistryOptions
from pants.backend.docker.subsystems.docker_options import DockerOptions
from pants.backend.docker.target_types import DockerImageRegistriesField, DockerImageSkipPushField
from pants.backend.docker.util_rules.docker_binary import DockerBinary
from pants.core.goals.package import PackageFieldSet
from pants.core.goals.publish import (
    PreemptiveSkipRequest,
    PublishFieldSet,
    PublishOutputData,
    PublishPackages,
    PublishProcesses,
    PublishRequest,
    SkippedPublishPackages,
)
from pants.core.util_rules.env_vars import environment_vars_subset
from pants.engine.env_vars import EnvironmentVarsRequest
from pants.engine.process import InteractiveProcess, Process
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.unions import UnionRule

logger = logging.getLogger(__name__)


class PublishDockerImageRequest(PublishRequest):
    pass


@dataclass(frozen=True)
class PublishDockerImageFieldSet(PublishFieldSet):
    publish_request_type = PublishDockerImageRequest
    required_fields = (DockerImageRegistriesField,)

    registries: DockerImageRegistriesField
    skip_push: DockerImageSkipPushField

    def make_skip_request(
        self, package_fs: PackageFieldSet
    ) -> PublishDockerImageSkipRequest | None:
        return (
            PublishDockerImageSkipRequest(publish_fs=self, package_fs=package_fs)
            if isinstance(package_fs, DockerPackageFieldSet)
            else None
        )

    def get_output_data(self) -> PublishOutputData:
        return PublishOutputData(
            {
                "publisher": "docker",
                "registries": self.registries.value or (),
                **super().get_output_data(),
            }
        )


class PublishDockerImageSkipRequest(PreemptiveSkipRequest[PublishDockerImageFieldSet]):
    pass


@rule
async def check_if_skip_push(
    request: PublishDockerImageSkipRequest, options: DockerOptions
) -> SkippedPublishPackages:
    skip_registries = {
        registry for registry in options.registries().registries.values() if registry.skip_push
    }
    if not (request.publish_fs.skip_push.value or skip_registries):
        return SkippedPublishPackages.no_skip()
    image_refs = await get_image_tags(
        GetImageTagsRequest(
            field_set=cast(DockerPackageFieldSet, request.publish_fs), build_upstream_images=False
        ),
        **implicitly(),
    )
    if request.publish_fs.skip_push.value:
        return SkippedPublishPackages.skip(
            names=[tag.full_name for registry in image_refs for tag in registry.tags],
            description=f"(by `{request.publish_fs.skip_push.alias}` on {request.address})",
        )
    return (
        SkippedPublishPackages(
            PublishPackages(
                names=tuple(tag.full_name for tag in image_ref.tags),
                description=f"(by skip_push on @{cast(DockerRegistryOptions, image_ref.registry).alias})",
            )
            for image_ref in image_refs
        )
        if all(image_ref.registry in skip_registries for image_ref in image_refs)
        else SkippedPublishPackages.no_skip()
    )


@rule
async def push_docker_images(
    request: PublishDockerImageRequest,
    docker: DockerBinary,
    options: DockerOptions,
    options_env_aware: DockerOptions.EnvironmentAware,
) -> PublishProcesses:
    tags = tuple(
        chain.from_iterable(
            cast(BuiltDockerImage, image).tags
            for pkg in request.packages
            for image in pkg.artifacts
        )
    )

    if request.field_set.skip_push.value:
        return PublishProcesses(
            [
                PublishPackages(
                    names=tags,
                    description=f"(by `{request.field_set.skip_push.alias}` on {request.field_set.address})",
                ),
            ]
        )

    env = await environment_vars_subset(
        EnvironmentVarsRequest(options_env_aware.env_vars), **implicitly()
    )
    skip_push_reasons: DefaultDict[str, DefaultDict[str, set[str]]] = defaultdict(
        lambda: defaultdict(set)
    )
    jobs: list[PublishPackages] = []
    refs: list[str] = []
    processes: list[Process | InteractiveProcess] = []

    for tag in tags:
        for registry in options.registries().registries.values():
            if registry.skip_push and tag.startswith(f"{registry.address}/"):
                skip_push_reasons["skip_push"][registry.alias].add(tag)
                break
            if registry.use_local_alias and tag.startswith(f"{registry.alias}/"):
                skip_push_reasons["use_local_alias"][registry.alias].add(tag)
                break
        else:
            refs.append(tag)
            push_process = docker.push_image(tag, env)
            if options.publish_noninteractively:
                processes.append(push_process)
            else:
                processes.append(InteractiveProcess.from_process(push_process))

    for ref, process in zip(refs, processes):
        jobs.append(
            PublishPackages(
                names=(ref,),
                process=process,
            )
        )

    for reason, skip_push in skip_push_reasons.items():
        for name, skip_tags in skip_push.items():
            jobs.append(
                PublishPackages(
                    names=tuple(skip_tags),
                    description=f"(by `{reason}` on registry @{name})",
                ),
            )

    return PublishProcesses(jobs)


def rules():
    return (
        *collect_rules(),
        *PublishDockerImageFieldSet.rules(),
        UnionRule(PreemptiveSkipRequest, PublishDockerImageSkipRequest),
    )

1	# Copyright 2021 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	6✔
5
6	import logging	6✔
7	from collections import defaultdict	6✔
8	from dataclasses import dataclass	6✔
9	from itertools import chain	6✔
10	from typing import DefaultDict, cast	6✔
11
12	from pants.backend.docker.goals.package_image import (	6✔
13	BuiltDockerImage,
14	DockerPackageFieldSet,
15	GetImageTagsRequest,
16	get_image_tags,
17	)
18	from pants.backend.docker.registries import DockerRegistryOptions	6✔
19	from pants.backend.docker.subsystems.docker_options import DockerOptions	6✔
20	from pants.backend.docker.target_types import DockerImageRegistriesField, DockerImageSkipPushField	6✔
21	from pants.backend.docker.util_rules.docker_binary import DockerBinary	6✔
22	from pants.core.goals.package import PackageFieldSet	6✔
23	from pants.core.goals.publish import (	6✔
24	PreemptiveSkipRequest,
25	PublishFieldSet,
26	PublishOutputData,
27	PublishPackages,
28	PublishProcesses,
29	PublishRequest,
30	SkippedPublishPackages,
31	)
32	from pants.core.util_rules.env_vars import environment_vars_subset	6✔
33	from pants.engine.env_vars import EnvironmentVarsRequest	6✔
34	from pants.engine.process import InteractiveProcess, Process	6✔
35	from pants.engine.rules import collect_rules, implicitly, rule	6✔
36	from pants.engine.unions import UnionRule	6✔
37
38	logger = logging.getLogger(__name__)	6✔
39
40
41	class PublishDockerImageRequest(PublishRequest):	6✔
42	pass	6✔
43
44
45	@dataclass(frozen=True)	6✔
46	class PublishDockerImageFieldSet(PublishFieldSet):	6✔
47	publish_request_type = PublishDockerImageRequest	6✔
48	required_fields = (DockerImageRegistriesField,)	6✔
49
50	registries: DockerImageRegistriesField	6✔
51	skip_push: DockerImageSkipPushField	6✔
52
53	def make_skip_request(	6✔
54	self, package_fs: PackageFieldSet
55	) -> PublishDockerImageSkipRequest \| None:
NEW 56	return (	×
57	PublishDockerImageSkipRequest(publish_fs=self, package_fs=package_fs)
58	if isinstance(package_fs, DockerPackageFieldSet)
59	else None
60	)
61
62	def get_output_data(self) -> PublishOutputData:	6✔
63	return PublishOutputData(	×
64	{
65	"publisher": "docker",
66	"registries": self.registries.value or (),
67	**super().get_output_data(),
68	}
69	)
70
71
72	class PublishDockerImageSkipRequest(PreemptiveSkipRequest[PublishDockerImageFieldSet]):	6✔
73	pass	6✔
74
75
76	@rule	6✔
77	async def check_if_skip_push(	6✔
78	request: PublishDockerImageSkipRequest, options: DockerOptions
79	) -> SkippedPublishPackages:
NEW 80	skip_registries = {	×
81	registry for registry in options.registries().registries.values() if registry.skip_push
82	}
NEW 83	if not (request.publish_fs.skip_push.value or skip_registries):	×
NEW 84	return SkippedPublishPackages.no_skip()	×
NEW 85	image_refs = await get_image_tags(	×
86	GetImageTagsRequest(
87	field_set=cast(DockerPackageFieldSet, request.publish_fs), build_upstream_images=False
88	),
89	**implicitly(),
90	)
NEW 91	if request.publish_fs.skip_push.value:	×
NEW 92	return SkippedPublishPackages.skip(	×
93	names=[tag.full_name for registry in image_refs for tag in registry.tags],
94	description=f"(by `{request.publish_fs.skip_push.alias}` on {request.address})",
95	)
NEW 96	return (	×
97	SkippedPublishPackages(
98	PublishPackages(
99	names=tuple(tag.full_name for tag in image_ref.tags),
100	description=f"(by skip_push on @{cast(DockerRegistryOptions, image_ref.registry).alias})",
101	)
102	for image_ref in image_refs
103	)
104	if all(image_ref.registry in skip_registries for image_ref in image_refs)
105	else SkippedPublishPackages.no_skip()
106	)
107
108
109	@rule	6✔
110	async def push_docker_images(	6✔
111	request: PublishDockerImageRequest,
112	docker: DockerBinary,
113	options: DockerOptions,
114	options_env_aware: DockerOptions.EnvironmentAware,
115	) -> PublishProcesses:
116	tags = tuple(	×
117	chain.from_iterable(
118	cast(BuiltDockerImage, image).tags
119	for pkg in request.packages
120	for image in pkg.artifacts
121	)
122	)
123
124	if request.field_set.skip_push.value:	×
125	return PublishProcesses(	×
126	[
127	PublishPackages(
128	names=tags,
129	description=f"(by `{request.field_set.skip_push.alias}` on {request.field_set.address})",
130	),
131	]
132	)
133
134	env = await environment_vars_subset(	×
135	EnvironmentVarsRequest(options_env_aware.env_vars), **implicitly()
136	)
137	skip_push_reasons: DefaultDict[str, DefaultDict[str, set[str]]] = defaultdict(	×
138	lambda: defaultdict(set)
139	)
140	jobs: list[PublishPackages] = []	×
141	refs: list[str] = []	×
142	processes: list[Process \| InteractiveProcess] = []	×
143
144	for tag in tags:	×
145	for registry in options.registries().registries.values():	×
146	if registry.skip_push and tag.startswith(f"{registry.address}/"):	×
147	skip_push_reasons["skip_push"][registry.alias].add(tag)	×
148	break	×
149	if registry.use_local_alias and tag.startswith(f"{registry.alias}/"):	×
150	skip_push_reasons["use_local_alias"][registry.alias].add(tag)	×
151	break	×
152	else:
153	refs.append(tag)	×
154	push_process = docker.push_image(tag, env)	×
155	if options.publish_noninteractively:	×
156	processes.append(push_process)	×
157	else:
158	processes.append(InteractiveProcess.from_process(push_process))	×
159
160	for ref, process in zip(refs, processes):	×
161	jobs.append(	×
162	PublishPackages(
163	names=(ref,),
164	process=process,
165	)
166	)
167
168	for reason, skip_push in skip_push_reasons.items():	×
169	for name, skip_tags in skip_push.items():	×
170	jobs.append(	×
171	PublishPackages(
172	names=tuple(skip_tags),
173	description=f"(by `{reason}` on registry @{name})",
174	),
175	)
176
177	return PublishProcesses(jobs)	×
178
179
180	def rules():	6✔
181	return (	6✔
182	*collect_rules(),
183	*PublishDockerImageFieldSet.rules(),
184	UnionRule(PreemptiveSkipRequest, PublishDockerImageSkipRequest),
185	)

pantsbuild / pants / 21374897774

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous