Remove generated file rules in make

This is all covered by update-codegen.sh now.

The old `make generated_files` rule still exists, but just prints a
warning.

Makefile.generated_files

@@ -1 +0,0 @@
-build/root/Makefile.generated_files

api/api-rules/README.md

@@ -29,7 +29,7 @@ exception.
 If you're removing violations from the exception list, or if you have good
 reasons to add new violations to this list, please update the file using:
 
- - `make generated_files UPDATE_API_KNOWN_VIOLATIONS=true`
+ - `UPDATE_API_KNOWN_VIOLATIONS=true ./hack/update-codegen.sh`
 
 It is up to API reviewers to review the list and make sure new APIs follow our API conventions.
 

build/common.sh

@@ -667,8 +667,6 @@ function kube::build::sync_to_container() {
     --filter='- /_tmp/' \
     --filter='- /_output/' \
     --filter='- /' \
-    --filter='H zz_generated.*' \
-    --filter='H generated.proto' \
     "${KUBE_ROOT}/" "rsync://k8s@${KUBE_RSYNC_ADDR}/k8s/"
 
   kube::build::stop_rsyncd_container

build/root/Makefile

@@ -45,7 +45,6 @@ MAKEFLAGS += --no-builtin-rules
 OUT_DIR ?= _output
 BIN_DIR := $(OUT_DIR)/bin
 PRJ_SRC_PATH := k8s.io/kubernetes
-GENERATED_FILE_PREFIX := zz_generated.
 
 # Metadata for driving the build lives here.
 META_DIR := .make
@@ -92,7 +91,7 @@ ifeq ($(PRINT_HELP),y)
 all:
 	echo "$$ALL_HELP_INFO"
 else
-all: generated_files
+all:
 	hack/make-rules/build.sh $(WHAT)
 endif
 
@@ -148,7 +147,7 @@ quick-verify:
 endif
 
 define UPDATE_HELP_INFO
-# Runs all the generated updates.
+# Runs all the update scripts.
 #
 # Example:
 # make update
@@ -158,8 +157,8 @@ ifeq ($(PRINT_HELP),y)
 update:
 	echo "$$UPDATE_HELP_INFO"
 else
-update: generated_files
+update:
-	CALLED_FROM_MAIN_MAKEFILE=1 hack/make-rules/update.sh
+	hack/make-rules/update.sh
 endif
 
 define CHECK_TEST_HELP_INFO
@@ -184,7 +183,7 @@ ifeq ($(PRINT_HELP),y)
 check test:
 	echo "$$CHECK_TEST_HELP_INFO"
 else
-check test: generated_files
+check test:
 	hack/make-rules/test.sh $(WHAT) $(TESTS)
 endif
 
@@ -203,7 +202,7 @@ ifeq ($(PRINT_HELP),y)
 test-integration:
 	echo "$$TEST_IT_HELP_INFO"
 else
-test-integration: generated_files
+test-integration:
 	hack/make-rules/test-integration.sh $(WHAT)
 endif
 
@@ -272,7 +271,7 @@ ifeq ($(PRINT_HELP),y)
 test-e2e-node:
 	echo "$$TEST_E2E_NODE_HELP_INFO"
 else
-test-e2e-node: ginkgo generated_files
+test-e2e-node: ginkgo
 	hack/make-rules/test-e2e-node.sh
 endif
 
@@ -291,7 +290,7 @@ ifeq ($(PRINT_HELP),y)
 test-cmd:
 	echo "$$TEST_CMD_HELP_INFO"
 else
-test-cmd: generated_files
+test-cmd:
 	hack/make-rules/test-cmd.sh
 endif
 
@@ -300,8 +299,6 @@ define CLEAN_HELP_INFO
 #
 # Example:
 #   make clean
-#
-# TODO(thockin): call clean_generated when we stop committing generated code.
 endef
 .PHONY: clean
 ifeq ($(PRINT_HELP),y)
@@ -328,21 +325,11 @@ clean_meta:
 	rm -rf $(META_DIR)
 endif
 
-define CLEAN_GENERATED_HELP_INFO
+# TODO(thockin): Remove this in v1.29.
-# Remove all auto-generated artifacts. Generated artifacts in staging folder should not be removed as they are not
+.PHONY: generated_files
-# generated using generated_files.
+generated_files:
-#
+	echo "'make generated_files' is deprecated.  Please use hack/update-codgen.sh instead."
-# Example:
+	true # TODO(thockin): change to false once tests are updated
-#   make clean_generated
-endef
-.PHONY: clean_generated
-ifeq ($(PRINT_HELP),y)
-clean_generated:
-	echo "$$CLEAN_GENERATED_HELP_INFO"
-else
-clean_generated:
-	find . -type f -name '$(GENERATED_FILE_PREFIX)*'  | xargs rm -f
-endif
 
 define VET_HELP_INFO
 # Run 'go vet'.
@@ -361,8 +348,8 @@ ifeq ($(PRINT_HELP),y)
 vet:
 	echo "$$VET_HELP_INFO"
 else
-vet: generated_files
+vet:
-	CALLED_FROM_MAIN_MAKEFILE=1 hack/make-rules/vet.sh $(WHAT)
+	hack/make-rules/vet.sh $(WHAT)
 endif
 
 define RELEASE_HELP_INFO
@@ -509,25 +496,10 @@ ifeq ($(PRINT_HELP),y)
 $(CMD_TARGET):
 	echo "$$CMD_HELP_INFO"
 else
-$(CMD_TARGET): generated_files
+$(CMD_TARGET):
 	hack/make-rules/build.sh cmd/$@
 endif
 
-define GENERATED_FILES_HELP_INFO
-# Produce auto-generated files needed for the build.
-#
-# Example:
-#   make generated_files
-endef
-.PHONY: generated_files
-ifeq ($(PRINT_HELP),y)
-generated_files:
-	echo "$$GENERATED_FILES_HELP_INFO"
-else
-generated_files gen_openapi:
-	$(MAKE) -f Makefile.generated_files $@ CALLED_FROM_MAIN_MAKEFILE=1 SHELL="$(SHELL)"
-endif
-
 define HELP_INFO
 # Print make targets and help info
 #

build/root/Makefile.generated_files

@@ -1,670 +0,0 @@
-# Copyright 2016 The Kubernetes 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.
-
-# Don't allow users to call this directly.  There are too many variables this
-# assumes to inherit from the main Makefile.  This is not a user-facing file.
-ifeq ($(CALLED_FROM_MAIN_MAKEFILE),)
-    $(error Please use the main Makefile, e.g. `make generated_files`)
-endif
-
-# Don't allow an implicit 'all' rule.  This is not a user-facing file.
-ifeq ($(MAKECMDGOALS),)
-    $(error This Makefile requires an explicit rule to be specified)
-endif
-
-ifeq ($(DBG_MAKEFILE),1)
-    ifeq ($(MAKE_RESTARTS),)
-        $(warning ***** starting Makefile.generated_files for goal(s) "$(MAKECMDGOALS)")
-    else
-        $(warning ***** restarting Makefile.generated_files for goal(s) "$(MAKECMDGOALS)")
-    endif
-    $(warning ***** $(shell date))
-endif
-
-
-# Define variables so `make --warn-undefined-variables` works.
-DBG_CODEGEN ?=
-UPDATE_API_KNOWN_VIOLATIONS ?=
-
-# This rule collects all the generated file sets into a single rule.  Other
-# rules should depend on this to ensure generated files are rebuilt.
-.PHONY: generated_files
-generated_files: gen_prerelease_lifecycle gen_deepcopy gen_defaulter gen_conversion gen_openapi
-
-#
-# Helper logic to calculate Go's dependency DAG ourselves.
-#
-
-# This is a file that will be emitted by the go2make tool, containing a
-# variable for each Go package in the project (including deps) which lists all
-# of the transitive deps of that package.  Each variable is named the same as
-# the package - for example the variable for `k8s.io/kubernetes/pkg/api` is
-# $(k8s.io/kubernetes/pkg/api).  This is roughly the same DAG that the Go
-# compiler uses.  These variables can be used to figure out if, for example,
-# generated code needs to be regenerated.
-GO_PKGDEPS_FILE = go-pkgdeps.mk
-
-# Include the Go package dependencies file.  This will cause the rule of
-# the same name to be considered and if it is updated, make will restart and
-# reload the updated deps.
-include $(META_DIR)/$(GO_PKGDEPS_FILE)
-
-# Only build and run go2make on the first pass.  If that generates a new
-# GO_PKGDEPS_FILE, make will restart the whole process and set MAKE_RESTARTS to
-# a numeric value.
-ifeq ($(MAKE_RESTARTS),)
-# Update the set of Go deps for our project.  This will let us determine if
-# we really need to do expensive codegen.  We use FORCE because it is not a
-# PHONY file, but we do want it to be re-evaluated every time make is run.  The
-# file will only be touched if it actually changes.
-$(META_DIR)/$(GO_PKGDEPS_FILE): FORCE
-	if [[ "$(DBG_CODEGEN)" == 1 ]]; then          \
-	    echo "DBG: calculating Go dependencies";  \
-	fi
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh hack/make-rules/helpers/go2make
-	hack/run-in-gopath.sh go2make            \
-	    k8s.io/kubernetes/...                \
-	    --prune  k8s.io/kubernetes/staging   \
-	    --prune  k8s.io/kubernetes/vendor    \
-	    k8s.io/kubernetes/vendor/k8s.io/...  \
-	    > $@.tmp
-	if [[ -s $@.tmp ]]; then                             \
-	    if ! cmp -s $@.tmp $@; then                      \
-	        if [[ "$(DBG_CODEGEN)" == 1 ]]; then         \
-	            echo "DBG: $(GO_PKGDEPS_FILE) changed";  \
-	        fi;                                          \
-	        cat $@.tmp > $@;                             \
-	    fi                                               \
-	else                                                 \
-	    kube::log::error "go2make produced no results";  \
-	    rm -f $@;                                        \
-	    false;                                           \
-	fi
-	rm -f $@.tmp
-endif # MAKE_RESTARTS
-
-.PHONY: FORCE
-FORCE:
-
-#
-# Helper logic to find which directories need codegen as quickly as possible.
-#
-
-# This variable holds a list of every directory that contains Go files in this
-# project.  Other rules and variables can use this as a starting point to
-# reduce filesystem accesses.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all *.go dirs)
-endif
-ALL_GO_DIRS := $(shell                                                   \
-    hack/make-rules/helpers/cache_go_dirs.sh $(META_DIR)/all_go_dirs.mk  \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(ALL_GO_DIRS) | wc -w) *.go dirs)
-endif
-
-# Generate a list of all files that have a `+k8s:` comment-tag.  This will be
-# used to derive lists of files/dirs for generation tools.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all +k8s: tags)
-endif
-ALL_K8S_TAG_FILES := $(shell                             \
-    find $(ALL_GO_DIRS) -maxdepth 1 -type f -name \*.go  \
-        | xargs grep --color=never -l '^// *+k8s:'       \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(ALL_K8S_TAG_FILES) | wc -w) +k8s: tagged files)
-endif
-
-#
-# Code generation logic.
-#
-
-
-# This is the header we stick at the top of every generated file.
-BOILERPLATE_FILENAME := staging/src/k8s.io/code-generator/hack/boilerplate.go.txt
-
-# prerelease-lifecycle generation
-#
-# Any package that wants prerelease-lifecycle functions generated must include a
-# comment-tag in column 0 of one file of the form:
-#     // +k8s:prerelease-lifecycle-gen=true
-#
-
-# The result file, in each pkg, of prerelease-lifecycle generation.
-PRERELEASE_LIFECYCLE_BASENAME := $(GENERATED_FILE_PREFIX)prerelease-lifecycle
-PRERELEASE_LIFECYCLE_FILENAME := $(PRERELEASE_LIFECYCLE_BASENAME).go
-
-# The tool used to generate prerelease-lifecycle code.
-PRERELEASE_LIFECYCLE_GEN := $(BIN_DIR)/prerelease-lifecycle-gen
-
-# Find all the directories that request prerelease-lifecycle generation.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all +k8s:prerelease-lifecycle-gen tags)
-endif
-PRERELEASE_LIFECYCLE_DIRS := $(shell                                                 \
-    grep --color=never -l '+k8s:prerelease-lifecycle-gen=true' $(ALL_K8S_TAG_FILES)  \
-        | xargs -n1 dirname                                                          \
-        | LC_ALL=C sort -u                                                           \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(PRERELEASE_LIFECYCLE_DIRS) | wc -w) +k8s:prerelease-lifecycle-gen tagged dirs)
-endif
-PRERELEASE_LIFECYCLE_FILES := $(addsuffix /$(PRERELEASE_LIFECYCLE_FILENAME), $(PRERELEASE_LIFECYCLE_DIRS))
-
-# Reset the list of packages that need generation.
-$(shell mkdir -p $$(dirname $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN)))
-$(shell rm -f $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo)
-
-# This rule aggregates the set of files to generate and then generates them all
-# in a single run of the tool.
-.PHONY: gen_prerelease_lifecycle
-gen_prerelease_lifecycle: $(PRERELEASE_LIFECYCLE_GEN) $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo
-	if [[ -s $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo ]]; then                 \
-	    pkgs=$$(cat $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo | paste -sd, -);  \
-	    if [[ "$(DBG_CODEGEN)" == 1 ]]; then                                       \
-	        echo "DBG: running $(PRERELEASE_LIFECYCLE_GEN) for $$pkgs";            \
-	    fi;                                                                        \
-	    N=$$(cat $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo | wc -l);            \
-	    kube::log::status "Generating prerelease lifecycle code for $$N targets";  \
-	    ./hack/run-in-gopath.sh $(PRERELEASE_LIFECYCLE_GEN)                        \
-	        --v $(KUBE_VERBOSE)                                                    \
-	        --logtostderr                                                          \
-	        -h $(BOILERPLATE_FILENAME)                                             \
-	        -i "$$pkgs"                                                            \
-	        -O $(PRERELEASE_LIFECYCLE_BASENAME)                                    \
-	        "$$@";                                                                 \
-	fi
-
-# For each dir in PRERELEASE_LIFECYCLE_DIRS, this establishes a dependency between the
-# output file and the input files that should trigger a rebuild.
-#
-# Note that this is a deps-only statement, not a full rule (see below).  This
-# has to be done in a distinct step because wildcards don't work in static
-# pattern rules.
-#
-# The 'eval' is needed because this has a different RHS for each LHS, and
-# would otherwise produce results that make can't parse.
-$(foreach dir, $(PRERELEASE_LIFECYCLE_DIRS), $(eval                            \
-    $(dir)/$(PRERELEASE_LIFECYCLE_FILENAME): $(GODEPS_$(PRJ_SRC_PATH)/$(dir))  \
-))
-
-# How to regenerate prerelease-lifecycle code.  This is a little slow to run,
-# so we batch it up and trigger the batch from the 'generated_files' target.
-$(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo: $(PRERELEASE_LIFECYCLE_FILES)
-
-$(PRERELEASE_LIFECYCLE_FILES): $(PRERELEASE_LIFECYCLE_GEN)
-	if [[ "$(DBG_CODEGEN)" == 1 ]]; then                    \
-	    echo "DBG: prerelease-lifecycle needed in $(@D):";  \
-	    ls -lft --full-time $@ || true;                     \
-	    ls -lft --full-time $? || true;                     \
-	fi
-	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(PRERELEASE_LIFECYCLE_GEN).todo
-
-# How to build the generator tool.  The deps for this are defined in
-# the $(GO_PKGDEPS_FILE), above.
-#
-# A word on the need to touch: This rule might trigger if, for example, a
-# non-Go file was added or deleted from a directory on which this depends.
-# This target needs to be reconsidered, but Go realizes it doesn't actually
-# have to be rebuilt.  In that case, make will forever see the dependency as
-# newer than the binary, and try to "rebuild" it over and over.  So we touch
-# it, and make is happy.
-$(PRERELEASE_LIFECYCLE_GEN): $(GODEPS_k8s.io/kubernetes/vendor/k8s.io/code-generator/cmd/prerelease-lifecycle-gen)
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh k8s.io/code-generator/cmd/prerelease-lifecycle-gen
-	touch $@
-
-
-# Deep-copy generation
-#
-# Any package that wants deep-copy functions generated must include a
-# comment-tag in column 0 of one file of the form:
-#     // +k8s:deepcopy-gen=<VALUE>
-#
-# The <VALUE> may be one of:
-#     generate: generate deep-copy functions into the package
-#     register: generate deep-copy functions and register them with a
-#               scheme
-
-# The result file, in each pkg, of deep-copy generation.
-DEEPCOPY_BASENAME := $(GENERATED_FILE_PREFIX)deepcopy
-DEEPCOPY_FILENAME := $(DEEPCOPY_BASENAME).go
-
-# The tool used to generate deep copies.
-DEEPCOPY_GEN := $(BIN_DIR)/deepcopy-gen
-
-# Find all the directories that request deep-copy generation.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all +k8s:deepcopy-gen tags)
-endif
-DEEPCOPY_DIRS := $(shell                                             \
-    grep --color=never -l '+k8s:deepcopy-gen=' $(ALL_K8S_TAG_FILES)  \
-        | xargs -n1 dirname                                          \
-        | LC_ALL=C sort -u                                           \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(DEEPCOPY_DIRS) | wc -w) +k8s:deepcopy-gen tagged dirs)
-endif
-DEEPCOPY_FILES := $(addsuffix /$(DEEPCOPY_FILENAME), $(DEEPCOPY_DIRS))
-
-# Reset the list of packages that need generation.
-$(shell mkdir -p $$(dirname $(META_DIR)/$(DEEPCOPY_GEN)))
-$(shell rm -f $(META_DIR)/$(DEEPCOPY_GEN).todo)
-
-# This rule aggregates the set of files to generate and then generates them all
-# in a single run of the tool.
-.PHONY: gen_deepcopy
-gen_deepcopy: $(DEEPCOPY_GEN) $(META_DIR)/$(DEEPCOPY_GEN).todo
-	if [[ -s $(META_DIR)/$(DEEPCOPY_GEN).todo ]]; then                 \
-	    pkgs=$$(cat $(META_DIR)/$(DEEPCOPY_GEN).todo | paste -sd, -);  \
-	    if [[ "$(DBG_CODEGEN)" == 1 ]]; then                           \
-	        echo "DBG: running $(DEEPCOPY_GEN) for $$pkgs";            \
-	    fi;                                                            \
-	    N=$$(cat $(META_DIR)/$(DEEPCOPY_GEN).todo | wc -l);            \
-	    kube::log::status "Generating deepcopy code for $$N targets";  \
-	    ./hack/run-in-gopath.sh $(DEEPCOPY_GEN)                        \
-	        --v $(KUBE_VERBOSE)                                        \
-	        --logtostderr                                              \
-	        -h $(BOILERPLATE_FILENAME)                                 \
-	        -i "$$pkgs"                                                \
-	        --bounding-dirs $(PRJ_SRC_PATH),"k8s.io/api"               \
-	        -O $(DEEPCOPY_BASENAME)                                    \
-	        "$$@";                                                     \
-	fi
-
-# For each dir in DEEPCOPY_DIRS, this establishes a dependency between the
-# output file and the input files that should trigger a rebuild.
-#
-# Note that this is a deps-only statement, not a full rule (see below).  This
-# has to be done in a distinct step because wildcards don't work in static
-# pattern rules.
-#
-# The 'eval' is needed because this has a different RHS for each LHS, and
-# would otherwise produce results that make can't parse.
-$(foreach dir, $(DEEPCOPY_DIRS), $(eval                            \
-    $(dir)/$(DEEPCOPY_FILENAME): $(GODEPS_$(PRJ_SRC_PATH)/$(dir))  \
-))
-
-# How to regenerate deep-copy code.  This is a little slow to run, so we batch
-# it up and trigger the batch from the 'generated_files' target.
-$(META_DIR)/$(DEEPCOPY_GEN).todo: $(DEEPCOPY_FILES)
-
-$(DEEPCOPY_FILES): $(DEEPCOPY_GEN)
-	if [[ "$(DBG_CODEGEN)" == 1 ]]; then        \
-	    echo "DBG: deepcopy needed in $(@D):";  \
-	    ls -lft --full-time $@ || true;         \
-	    ls -lft --full-time $? || true;         \
-	fi
-	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(DEEPCOPY_GEN).todo
-
-# How to build the generator tool.  The deps for this are defined in
-# the $(GO_PKGDEPS_FILE), above.
-#
-# A word on the need to touch: This rule might trigger if, for example, a
-# non-Go file was added or deleted from a directory on which this depends.
-# This target needs to be reconsidered, but Go realizes it doesn't actually
-# have to be rebuilt.  In that case, make will forever see the dependency as
-# newer than the binary, and try to "rebuild" it over and over.  So we touch
-# it, and make is happy.
-$(DEEPCOPY_GEN): $(GODEPS_k8s.io/kubernetes/vendor/k8s.io/code-generator/cmd/deepcopy-gen)
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh k8s.io/code-generator/cmd/deepcopy-gen
-	touch $@
-
-
-# Defaulter generation
-#
-# Any package that wants defaulter functions generated must include a
-# comment-tag in column 0 of one file of the form:
-#     // +k8s:defaulter-gen=<VALUE>
-#
-# The <VALUE> depends on context:
-#     on types:
-#       true:  always generate a defaulter for this type
-#       false: never generate a defaulter for this type
-#     on functions:
-#       covers: if the function name matches SetDefault_NAME, instructs
-#               the generator not to recurse
-#     on packages:
-#       FIELDNAME: any object with a field of this name is a candidate
-#                  for having a defaulter generated
-
-# The result file, in each pkg, of defaulter generation.
-DEFAULTER_BASENAME := $(GENERATED_FILE_PREFIX)defaults
-DEFAULTER_FILENAME := $(DEFAULTER_BASENAME).go
-
-# The tool used to generate defaulters.
-DEFAULTER_GEN := $(BIN_DIR)/defaulter-gen
-
-# All directories that request any form of defaulter generation.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all +k8s:defaulter-gen tags)
-endif
-DEFAULTER_DIRS := $(shell                                            \
-    grep --color=never -l '+k8s:defaulter-gen=' $(ALL_K8S_TAG_FILES) \
-        | xargs -n1 dirname                                          \
-        | LC_ALL=C sort -u                                           \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(DEFAULTER_DIRS) | wc -w) +k8s:defaulter-gen tagged dirs)
-endif
-DEFAULTER_FILES := $(addsuffix /$(DEFAULTER_FILENAME), $(DEFAULTER_DIRS))
-DEFAULTER_EXTRA_PEER_PKGS := \
-    $(addprefix $(PRJ_SRC_PATH)/, $(DEFAULTER_DIRS))
-
-# Reset the list of packages that need generation.
-$(shell mkdir -p $$(dirname $(META_DIR)/$(DEFAULTER_GEN)))
-$(shell rm -f $(META_DIR)/$(DEFAULTER_GEN).todo)
-
-# This rule aggregates the set of files to generate and then generates them all
-# in a single run of the tool.
-.PHONY: gen_defaulter
-gen_defaulter: $(DEFAULTER_GEN) $(META_DIR)/$(DEFAULTER_GEN).todo
-	if [[ -s $(META_DIR)/$(DEFAULTER_GEN).todo ]]; then                 \
-	    pkgs=$$(cat $(META_DIR)/$(DEFAULTER_GEN).todo | paste -sd, -);  \
-	    if [[ "$(DBG_CODEGEN)" == 1 ]]; then                            \
-	        echo "DBG: running $(DEFAULTER_GEN) for $$pkgs";            \
-	    fi;                                                             \
-	    N=$$(cat $(META_DIR)/$(DEFAULTER_GEN).todo | wc -l);            \
-	    kube::log::status "Generating defaulter code for $$N targets";  \
-	    ./hack/run-in-gopath.sh $(DEFAULTER_GEN)                        \
-	        --v $(KUBE_VERBOSE)                                         \
-	        --logtostderr                                               \
-	        -h $(BOILERPLATE_FILENAME)                                  \
-	        -i "$$pkgs"                                                 \
-	        --extra-peer-dirs $$(echo $(DEFAULTER_EXTRA_PEER_PKGS) | sed 's/ /,/g') \
-	        -O $(DEFAULTER_BASENAME)                                    \
-	        "$$@";                                                      \
-	fi
-
-# For each dir in DEFAULTER_DIRS, this establishes a dependency between the
-# output file and the input files that should trigger a rebuild.
-#
-# Note that this is a deps-only statement, not a full rule (see below for that).
-#
-# The 'eval' is needed because this has a different RHS for each LHS, and
-# would otherwise produce results that make can't parse.
-$(foreach dir, $(DEFAULTER_DIRS), $(eval                            \
-    $(dir)/$(DEFAULTER_FILENAME): $(GODEPS_$(PRJ_SRC_PATH)/$(dir))  \
-))
-
-# How to regenerate defaulter code.  This is a little slow to run, so we batch
-# it up and trigger the batch from the 'generated_files' target.
-$(META_DIR)/$(DEFAULTER_GEN).todo: $(DEFAULTER_FILES)
-
-$(DEFAULTER_FILES): $(DEFAULTER_GEN)
-	if [[ "$(DBG_CODEGEN)" == 1 ]]; then         \
-	    echo "DBG: defaulter needed in $(@D):";  \
-	    ls -lft --full-time $@ || true;          \
-	    ls -lft --full-time $? || true;          \
-	fi
-	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(DEFAULTER_GEN).todo
-
-# How to build the generator tool.  The deps for this are defined in
-# the $(GO_PKGDEPS_FILE), above.
-#
-# A word on the need to touch: This rule might trigger if, for example, a
-# non-Go file was added or deleted from a directory on which this depends.
-# This target needs to be reconsidered, but Go realizes it doesn't actually
-# have to be rebuilt.  In that case, make will forever see the dependency as
-# newer than the binary, and try to "rebuild" it over and over.  So we touch
-# it, and make is happy.
-$(DEFAULTER_GEN): $(GODEPS_k8s.io/kubernetes/vendor/k8s.io/code-generator/cmd/defaulter-gen)
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh k8s.io/code-generator/cmd/defaulter-gen
-	touch $@
-
-
-# Conversion generation
-
-# Any package that wants conversion functions generated into it must
-# include one or more comment-tags in its `doc.go` file, of the form:
-#     // +k8s:conversion-gen=<INTERNAL_TYPES_DIR>
-#
-# The INTERNAL_TYPES_DIR is a project-local path to another directory
-# which should be considered when evaluating peer types for
-# conversions.  An optional additional comment of the form
-#     // +k8s:conversion-gen-external-types=<EXTERNAL_TYPES_DIR>
-#
-# identifies where to find the external types; if there is no such
-# comment then the external types are sought in the package where the
-# `k8s:conversion` tag is found.
-#
-# Conversions, in both directions, are generated for every type name
-# that is defined in both an internal types package and the external
-# types package.
-#
-# TODO: it might be better in the long term to make peer-types explicit in the
-# IDL.
-
-# The result file, in each pkg, of conversion generation.
-CONVERSION_BASENAME := $(GENERATED_FILE_PREFIX)conversion
-CONVERSION_FILENAME := $(CONVERSION_BASENAME).go
-
-# The tool used to generate conversions.
-CONVERSION_GEN := $(BIN_DIR)/conversion-gen
-
-# The name of the metadata file listing conversion peers for each pkg.
-CONVERSIONS_META := conversions.mk
-
-# All directories that request any form of conversion generation.
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** finding all +k8s:conversion-gen tags)
-endif
-CONVERSION_DIRS := $(shell                                              \
-    grep --color=never '^// *+k8s:conversion-gen=' $(ALL_K8S_TAG_FILES) \
-        | cut -f1 -d:                                                   \
-        | xargs -n1 dirname                                             \
-        | LC_ALL=C sort -u                                              \
-)
-ifeq ($(DBG_MAKEFILE),1)
-    $(warning ***** found $(shell echo $(CONVERSION_DIRS) | wc -w) +k8s:conversion-gen tagged dirs)
-endif
-CONVERSION_FILES := $(addsuffix /$(CONVERSION_FILENAME), $(CONVERSION_DIRS))
-CONVERSION_EXTRA_PEER_PKGS := \
-    k8s.io/kubernetes/pkg/apis/core \
-    k8s.io/kubernetes/pkg/apis/core/v1 \
-    k8s.io/api/core/v1
-CONVERSION_EXTRA_PKGS := $(addprefix $(PRJ_SRC_PATH)/, $(CONVERSION_DIRS))
-
-# Reset the list of packages that need generation.
-$(shell mkdir -p $$(dirname $(META_DIR)/$(CONVERSION_GEN)))
-$(shell rm -f $(META_DIR)/$(CONVERSION_GEN).todo)
-
-# This rule aggregates the set of files to generate and then generates them all
-# in a single run of the tool.
-.PHONY: gen_conversion
-gen_conversion: $(CONVERSION_GEN) $(META_DIR)/$(CONVERSION_GEN).todo
-	if [[ -s $(META_DIR)/$(CONVERSION_GEN).todo ]]; then                 \
-	    pkgs=$$(cat $(META_DIR)/$(CONVERSION_GEN).todo | paste -sd, -);  \
-	    if [[ "$(DBG_CODEGEN)" == 1 ]]; then                             \
-	        echo "DBG: running $(CONVERSION_GEN) for $$pkgs";            \
-	    fi;                                                              \
-	    N=$$(cat $(META_DIR)/$(CONVERSION_GEN).todo | wc -l);            \
-	    kube::log::status "Generating conversion code for $$N targets";  \
-	    ./hack/run-in-gopath.sh $(CONVERSION_GEN)                        \
-	        --extra-peer-dirs $$(echo $(CONVERSION_EXTRA_PEER_PKGS) | sed 's/ /,/g') \
-	        --extra-dirs $$(echo $(CONVERSION_EXTRA_PKGS) | sed 's/ /,/g') \
-	        --v $(KUBE_VERBOSE)                                          \
-	        --logtostderr                                                \
-	        -h $(BOILERPLATE_FILENAME)                                   \
-	        -i "$$pkgs"                                                  \
-	        -O $(CONVERSION_BASENAME)                                    \
-	        "$$@";                                                       \
-	fi
-
-# For each dir in CONVERSION_DIRS, this establishes a dependency between the
-# output file and the input files that should trigger a rebuild.
-#
-# Note that this is a deps-only statement, not a full rule (see below for that).
-#
-# The 'eval' is needed because this has a different RHS for each LHS, and
-# would otherwise produce results that make can't parse.
-$(foreach dir, $(CONVERSION_DIRS), $(eval                            \
-    $(dir)/$(CONVERSION_FILENAME): $(GODEPS_$(PRJ_SRC_PATH)/$(dir))  \
-))
-
-# How to regenerate conversion code.  This is a little slow to run, so we batch
-# it up and trigger the batch from the 'generated_files' target.
-$(META_DIR)/$(CONVERSION_GEN).todo: $(CONVERSION_FILES)
-
-$(CONVERSION_FILES): $(CONVERSION_GEN)
-	if [[ "$(DBG_CODEGEN)" == 1 ]]; then          \
-	    echo "DBG: conversion needed in $(@D):";  \
-	    ls -lft --full-time $@ || true;           \
-	    ls -lft --full-time $? || true;           \
-	fi
-	echo $(PRJ_SRC_PATH)/$(@D) >> $(META_DIR)/$(CONVERSION_GEN).todo
-
-# How to build the generator tool.  The deps for this are defined in
-# the $(GO_PKGDEPS_FILE), above.
-#
-# A word on the need to touch: This rule might trigger if, for example, a
-# non-Go file was added or deleted from a directory on which this depends.
-# This target needs to be reconsidered, but Go realizes it doesn't actually
-# have to be rebuilt.  In that case, make will forever see the dependency as
-# newer than the binary, and try to rebuild it over and over.  So we touch it,
-# and make is happy.
-$(CONVERSION_GEN): $(GODEPS_k8s.io/kubernetes/vendor/k8s.io/code-generator/cmd/conversion-gen)
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh k8s.io/code-generator/cmd/conversion-gen
-	touch $@
-
-
-# OpenAPI generation
-#
-# Any package that wants open-api functions generated must include a
-# comment-tag in column 0 of one file of the form:
-#     // +k8s:openapi-gen=true
-#
-# The result file, in each pkg, of open-api generation.
-OPENAPI_BASENAME := $(GENERATED_FILE_PREFIX)openapi
-OPENAPI_FILENAME := $(OPENAPI_BASENAME).go
-IGNORED_REPORT_FILENAME := $(OUT_DIR)/ignored_violations.report
-
-API_RULE_CHECK_FAILURE_MESSAGE = "ERROR: \n\t $(1) API rule check failed. Reported violations differ from known violations. Please read api/api-rules/README.md to resolve the failure in $(2). \n"
-
-# The tool used to generate open apis.
-OPENAPI_GEN := $(BIN_DIR)/openapi-gen
-
-KUBE_KNOWN_VIOLATION_FILENAME := api/api-rules/violation_exceptions.list
-AGGREGATOR_KNOWN_VIOLATION_FILENAME := api/api-rules/aggregator_violation_exceptions.list
-APIEXTENSIONS_KNOWN_VIOLATION_FILENAME := api/api-rules/apiextensions_violation_exceptions.list
-CODEGEN_KNOWN_VIOLATION_FILENAME := api/api-rules/codegen_violation_exceptions.list
-SAMPLEAPISERVER_KNOWN_VIOLATION_FILENAME := api/api-rules/sample_apiserver_violation_exceptions.list
-
-APIMACHINERY_DEFAULT_TAG_FILES := vendor/k8s.io/apimachinery/pkg/apis/meta/v1/% vendor/k8s.io/apimachinery/pkg/runtime/% vendor/k8s.io/apimachinery/pkg/version/%
-
-KUBE_OPENAPI_TAG_FILES :=            $(filter-out vendor/k8s.io/code-generator/% vendor/k8s.io/sample-apiserver/%, $(ALL_K8S_TAG_FILES))
-AGGREGATOR_OPENAPI_TAG_FILES :=      $(filter $(APIMACHINERY_DEFAULT_TAG_FILES) vendor/k8s.io/kube-aggregator/%, $(ALL_K8S_TAG_FILES))
-APIEXTENSIONS_OPENAPI_TAG_FILES :=   $(filter $(APIMACHINERY_DEFAULT_TAG_FILES) vendor/k8s.io/apiextensions/% vendor/k8s.io/api/autoscaling/v1/%, $(ALL_K8S_TAG_FILES))
-CODEGEN_OPENAPI_TAG_FILES :=         $(filter $(APIMACHINERY_DEFAULT_TAG_FILES) vendor/k8s.io/code-generator/%, $(ALL_K8S_TAG_FILES))
-SAMPLEAPISERVER_OPENAPI_TAG_FILES := $(filter $(APIMACHINERY_DEFAULT_TAG_FILES) vendor/k8s.io/sample-apiserver/%, $(ALL_K8S_TAG_FILES))
-
-KUBE_OPENAPI_OUTPUT_PKG := pkg/generated/openapi
-AGGREGATOR_OPENAPI_OUTPUT_PKG := staging/src/k8s.io/kube-aggregator/pkg/generated/openapi
-APIEXTENSIONS_OPENAPI_OUTPUT_PKG := staging/src/k8s.io/apiextensions-apiserver/pkg/generated/openapi
-CODEGEN_OPENAPI_OUTPUT_PKG := staging/src/k8s.io/code-generator/examples/apiserver/openapi
-SAMPLEAPISERVER_OPENAPI_OUTPUT_PKG := staging/src/k8s.io/sample-apiserver/pkg/generated/openapi
-
-OPENAPI_TARGETS := KUBE AGGREGATOR APIEXTENSIONS CODEGEN SAMPLEAPISERVER
-
-# Find all the directories that request openapi generation.
-# - required input: $(prefix)
-define OPENAPI_DIR_DEF
-ifeq ($$(DBG_MAKEFILE),1)
-    $$(warning ***** finding all +k8s:openapi-gen tags for $(prefix))
-endif
-$(prefix)_OPENAPI_DIRS := $$(shell                                            \
-    grep --color=never -l '+k8s:openapi-gen=' $$($(prefix)_OPENAPI_TAG_FILES) \
-        | xargs -n1 dirname                                                   \
-        | LC_ALL=C sort -u                                                    \
-)
-ifeq ($$(DBG_MAKEFILE),1)
-    $$(warning ***** found $$(shell echo $$($(prefix)_OPENAPI_TAG_FILES) | wc -w) +k8s:openapi-gen tagged dirs for $(prefix))
-endif
-endef # OPENAPI_DIR_DEF
-$(foreach prefix, $(OPENAPI_TARGETS), $(eval $(OPENAPI_DIR_DEF)))
-
-# Compute all openapi output file names
-$(foreach prefix, $(OPENAPI_TARGETS), $(eval                                         \
-    $(prefix)_OPENAPI_OUTFILE := $($(prefix)_OPENAPI_OUTPUT_PKG)/$(OPENAPI_FILENAME) \
-))
-
-# For each openapi target compute the spec
-# - required input: $(prefix)
-define OPENAPI_TARGETS_DEF
-# For each dir in $(prefix)_OPENAPI_DIRS, this establishes a dependency
-# between the output file and the input files that should trigger a rebuild.
-#
-# Note that this is a deps-only statement, not a full rule
-# (see below for that).
-#
-# The 'eval' is needed because this has a different RHS for each LHS, and
-# would otherwise produce results that make can't parse.
-$$(foreach dir, $$($(prefix)_OPENAPI_DIRS), $$(eval                     \
-    $$($(prefix)_OPENAPI_OUTFILE): $$(GODEPS_$$(PRJ_SRC_PATH)/$$(dir))  \
-))
-
-# When UPDATE_API_KNOWN_VIOLATIONS is set to be true, let the generator to write
-# updated API violations to the known API violation exceptions list.
-ifeq ($$(UPDATE_API_KNOWN_VIOLATIONS),true)
-    $(prefix)_REPORT_FILENAME := $$($(prefix)_KNOWN_VIOLATION_FILENAME)
-    # When UPDATE_API_KNOWN_VIOLATIONS is set to be true, touch the exceptions
-    # list so that the $(prefix)_OPENAPI_OUTFILE target re-run instead of being cached.
-    $$(shell touch $$($(prefix)_KNOWN_VIOLATION_FILENAME))
-else
-    $(prefix)_REPORT_FILENAME := $$(OUT_DIR)/$(prefix)_violations.report
-endif
-
-# How to regenerate open-api code.  This emits a single file for all results.
-# The Make rule fails if generated API rule violation report differs from the
-# checked-in violation file, and prints error message to request developer to
-# fix either the API source code, or the known API rule violation file.
-$$($(prefix)_OPENAPI_OUTFILE): $$(OPENAPI_GEN) $$($(prefix)_KNOWN_VIOLATION_FILENAME)
-	kube::log::status "Generating openapi code for $(prefix)";                                   \
-	./hack/run-in-gopath.sh $$(OPENAPI_GEN)                                                      \
-	    --v $$(KUBE_VERBOSE)                                                                     \
-	    --logtostderr                                                                            \
-	    -h $$(BOILERPLATE_FILENAME)                                                              \
-	    -i $$$$(echo $$(addprefix $(PRJ_SRC_PATH)/, $$($(prefix)_OPENAPI_DIRS)) | sed 's/ /,/g') \
-	    -p $$(PRJ_SRC_PATH)/$$($(prefix)_OPENAPI_OUTPUT_PKG)                                     \
-	    -O $$(OPENAPI_BASENAME)                                                                  \
-	    -r $$($(prefix)_REPORT_FILENAME)                                                         \
-	    "$$$$@"
-	test -f $$($(prefix)_KNOWN_VIOLATION_FILENAME) || touch $$($(prefix)_KNOWN_VIOLATION_FILENAME)
-	diff $$($(prefix)_REPORT_FILENAME) $$($(prefix)_KNOWN_VIOLATION_FILENAME) || \
-	(echo -e $$(call API_RULE_CHECK_FAILURE_MESSAGE,$(prefix),$$($(prefix)_KNOWN_VIOLATION_FILENAME)); exit 1)
-endef # OPENAPI_TARGETS_DEF
-$(foreach prefix, $(OPENAPI_TARGETS), $(eval $(OPENAPI_TARGETS_DEF)))
-
-# This rule is the user-friendly entrypoint for openapi generation.
-.PHONY: gen_openapi
-gen_openapi: $(OPENAPI_GEN) $(KUBE_OPENAPI_OUTFILE) $(AGGREGATOR_OPENAPI_OUTFILE) $(APIEXTENSIONS_OPENAPI_OUTFILE) $(CODEGEN_OPENAPI_OUTFILE) $(SAMPLEAPISERVER_OPENAPI_OUTFILE)
-
-# How to build the generator tool.  The deps for this are defined in
-# the $(GO_PKGDEPS_FILE), above.
-#
-# A word on the need to touch: This rule might trigger if, for example, a
-# non-Go file was added or deleted from a directory on which this depends.
-# This target needs to be reconsidered, but Go realizes it doesn't actually
-# have to be rebuilt.  In that case, make will forever see the dependency as
-# newer than the binary, and try to "rebuild" it over and over.  So we touch
-# it, and make is happy.
-$(OPENAPI_GEN): $(GODEPS_k8s.io/kubernetes/vendor/k8s.io/kube-openapi/cmd/openapi-gen)
-	KUBE_BUILD_PLATFORMS="" \
-	    hack/make-rules/build.sh k8s.io/kube-openapi/cmd/openapi-gen
-	touch $@

hack/jenkins/test-dockerized.sh

@@ -47,7 +47,6 @@ export LOG_LEVEL=4
 
 cd "${GOPATH}/src/k8s.io/kubernetes"
 
-make generated_files
 go install ./cmd/...
 ./hack/install-etcd.sh
 

hack/make-rules/update.sh

@@ -22,14 +22,6 @@ set -o pipefail
 KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
 source "${KUBE_ROOT}/hack/lib/init.sh"
 
-# If called directly, exit.
-if [[ "${CALLED_FROM_MAIN_MAKEFILE:-""}" == "" ]]; then
-    echo "ERROR: $0 should not be run directly." >&2
-    echo >&2
-    echo "Please run this command using \"make update\""
-    exit 1
-fi
-
 SILENT=${SILENT:-true}
 ALL=${FORCE_ALL:-false}
 

hack/make-rules/vet.sh

@@ -23,14 +23,6 @@ source "${KUBE_ROOT}/hack/lib/init.sh"
 
 cd "${KUBE_ROOT}"
 
-# If called directly, exit.
-if [[ "${CALLED_FROM_MAIN_MAKEFILE:-""}" == "" ]]; then
-    echo "ERROR: $0 should not be run directly." >&2
-    echo >&2
-    echo "Please run this command using \"make vet\""
-    exit 1
-fi
-
 # Filter out arguments that start with "-" and move them to goflags.
 targets=()
 for arg; do

hack/verify-typecheck.sh

@@ -28,8 +28,6 @@ kube::golang::verify_go_version
 
 cd "${KUBE_ROOT}"
 
-make --no-print-directory -C "${KUBE_ROOT}" generated_files
-
 # As of June, 2020 the typecheck tool is written in terms of go/packages, but
 # that library doesn't work well with multiple modules.  Until that is done,
 # force this tooling to run in a fake GOPATH.

test/conformance/gen-specsummaries.sh

@@ -23,9 +23,6 @@ KUBE_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")"/../.. && pwd -P)
 cd "${KUBE_ROOT}"
 
 # build ginkgo and e2e.test
-# NOTE: we do *not* use `make WHAT=...` because we do *not* want to be running
-# make generated_files when diffing things (see: hack/verify-conformance-yaml.sh)
-# other update/verify already handle the generated files
 hack/make-rules/build.sh github.com/onsi/ginkgo/v2/ginkgo test/e2e/e2e.test
 
 # dump spec

test/e2e_node/jenkins/conformance/conformance-jenkins.sh

@@ -24,8 +24,6 @@ set -x
 
 . "${1}"
 
-make generated_files
-
 WORKSPACE=${WORKSPACE:-"/tmp/"}
 ARTIFACTS=${WORKSPACE}/_artifacts
 TIMEOUT=${TIMEOUT:-"45m"}

test/integration/ipamperf/README.md

@@ -18,8 +18,6 @@ How to run
 
 ```shell
 # In kubernetes root path
-make generated_files
-
 cd test/integration/ipamperf
 ./test-performance.sh
 ```