local from_env

from_env="$(go env GOBIN)"

if [[ -n "${from_env}" ]]; then

echo "${from_env}"

else

echo "$(go env GOPATH)/bin"

fi

# We use `find` rather than `git ls-files` because sometimes external

# projects use this across repos. This is an imperfect wrapper of find,

# but good enough for this script.

find "$@" -print0

# We use `grep` rather than `git grep` because sometimes external projects

# use this across repos.

grep "$@" \

--exclude-dir .git \

--exclude-dir _output \

--exclude-dir vendor

local in_dir=""

local boilerplate="${KUBE_CODEGEN_ROOT}/hack/boilerplate.go.txt"

local v="${KUBE_VERBOSE:-0}"

local extra_peers=()

while [ "$#" -gt 0 ]; do

case "$1" in

"--boilerplate")

boilerplate="$2"

shift 2

;;

"--extra-peer-dir")

extra_peers+=("$2")

shift 2

;;

*)

if [[ "$1" =~ ^-- ]]; then

echo "unknown argument: $1" >&2

return 1

fi

if [ -n "$in_dir" ]; then

echo "too many arguments: $1 (already have $in_dir)" >&2

return 1

fi

in_dir="$1"

shift

;;

esac

done

if [ -z "${in_dir}" ]; then

echo "input-dir argument is required" >&2

return 1

fi

(

# To support running this from anywhere, first cd into this directory,

# and then install with forced module mode on and fully qualified name.

cd "${KUBE_CODEGEN_ROOT}"

BINS=(

conversion-gen"${CODEGEN_VERSION_SPEC}"

deepcopy-gen"${CODEGEN_VERSION_SPEC}"

defaulter-gen"${CODEGEN_VERSION_SPEC}"

validation-gen"${CODEGEN_VERSION_SPEC}"

)

# shellcheck disable=2046 # printf word-splitting is intentional

GO111MODULE=on go install $(printf "k8s.io/code-generator/cmd/%s " "${BINS[@]}")

)

# Deepcopy

#

local input_pkgs=()

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating deepcopy code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.deepcopy.go \

| xargs -0 rm -f

"${GOBIN}/deepcopy-gen" \

-v "${v}" \

--output-file zz_generated.deepcopy.go \

--go-header-file "${boilerplate}" \

"${input_pkgs[@]}"

fi

# Validations

#

local input_pkgs=()

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating validation code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.validations.go \

| xargs -0 rm -f

local readonly_args=()

for pkg in "${KUBE_CODEGEN_READONLY_PKGS[@]}"; do

readonly_args+=("--readonly-pkg" "${pkg}")

done

"${GOBIN}/validation-gen" \

-v "${v}" \

--output-file zz_generated.validations.go \

"${readonly_args[@]}" \

--go-header-file "${boilerplate}" \

"${input_pkgs[@]}"

fi

# Defaults

#

local input_pkgs=()

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating defaulter code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.defaults.go \

| xargs -0 rm -f

"${GOBIN}/defaulter-gen" \

-v "${v}" \

--output-file zz_generated.defaults.go \

--go-header-file "${boilerplate}" \

"${input_pkgs[@]}"

fi

# Conversions

#

local input_pkgs=()

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating conversion code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.conversion.go \

| xargs -0 rm -f

local extra_peer_args=()

for arg in "${extra_peers[@]:+"${extra_peers[@]}"}"; do

extra_peer_args+=("--extra-peer-dirs" "$arg")

done

"${GOBIN}/conversion-gen" \

-v "${v}" \

--output-file zz_generated.conversion.go \

--go-header-file "${boilerplate}" \

"${extra_peer_args[@]:+"${extra_peer_args[@]}"}" \

"${input_pkgs[@]}"

fi

local in_dir=""

local out_dir=""

local out_pkg=""

local extra_pkgs=()

local report="/dev/null"

local output_model_name_file=""

local update_report=""

local boilerplate="${KUBE_CODEGEN_ROOT}/hack/boilerplate.go.txt"

local v="${KUBE_VERBOSE:-0}"

while [ "$#" -gt 0 ]; do

case "$1" in

"--output-dir")

out_dir="$2"

shift 2

;;

"--output-pkg")

out_pkg="$2"

shift 2

;;

"--extra-pkgs")

extra_pkgs+=("$2")

shift 2

;;

"--report-filename")

report="$2"

shift 2

;;

"--output-model-name-file")

output_model_name_file="$2"

shift 2

;;

"--update-report")

update_report="true"

shift

;;

"--boilerplate")

boilerplate="$2"

shift 2

;;

*)

if [[ "$1" =~ ^-- ]]; then

echo "unknown argument: $1" >&2

return 1

fi

if [ -n "$in_dir" ]; then

echo "too many arguments: $1 (already have $in_dir)" >&2

return 1

fi

in_dir="$1"

shift

;;

esac

done

if [ -z "${in_dir}" ]; then

echo "input-dir argument is required" >&2

return 1

fi

if [ -z "${out_dir}" ]; then

echo "--output-dir is required" >&2

return 1

fi

if [ -z "${out_pkg}" ]; then

echo "--output-pkg is required" >&2

return 1

fi

local new_report

new_report="$(mktemp -t "$(basename "$0").api_violations.XXXXXX")"

if [ -n "${update_report}" ]; then

new_report="${report}"

fi

(

# To support running this from anywhere, first cd into this directory,

# and then install with forced module mode on and fully qualified name.

cd "${KUBE_CODEGEN_ROOT}"

BINS=(

openapi-gen"${CODEGEN_VERSION_SPEC}"

)

# shellcheck disable=2046 # printf word-splitting is intentional

GO111MODULE=on go install $(printf "k8s.io/kube-openapi/cmd/%s " "${BINS[@]}")

)

local input_pkgs=( "${extra_pkgs[@]:+"${extra_pkgs[@]}"}")

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating openapi code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.openapi.go \

| xargs -0 rm -f

local readonly_args=()

for pkg in "${KUBE_CODEGEN_READONLY_PKGS[@]}"; do

readonly_args+=("--readonly-pkg" "${pkg}")

done

# These apimachinery packages are passed as explicit inputs

# because they contain types referenced by most API types

# (e.g. ObjectMeta, Quantity). openapi-gen needs them for

# type resolution even though they are not in the caller's

# input directory.

"${GOBIN}/openapi-gen" \

-v "${v}" \

--output-file zz_generated.openapi.go \

--go-header-file "${boilerplate}" \

--output-dir "${out_dir}" \

--output-pkg "${out_pkg}" \

--report-filename "${new_report}" \

--output-model-name-file="${output_model_name_file}" \

"${readonly_args[@]}" \

"k8s.io/apimachinery/pkg/apis/meta/v1" \

"k8s.io/apimachinery/pkg/runtime" \

"k8s.io/apimachinery/pkg/version" \

"k8s.io/apimachinery/pkg/api/resource" \

"${input_pkgs[@]}"

fi

if [ ! -e "${report}" ]; then

touch "${report}" # in case it doesn't exist yet

fi

if ! diff -u "${report}" "${new_report}"; then

echo -e "ERROR:"

echo -e "\tAPI rule check failed for ${report}: new reported violations"

echo -e "\tPlease read api/api-rules/README.md"

return 1

fi

local in_dir=""

local boilerplate="${KUBE_CODEGEN_ROOT}/hack/boilerplate.go.txt"

local v="${KUBE_VERBOSE:-0}"

while [ "$#" -gt 0 ]; do

case "$1" in

"--boilerplate")

boilerplate="$2"

shift 2

;;

*)

if [[ "$1" =~ ^-- ]]; then

echo "unknown argument: $1" >&2

return 1

fi

if [ -n "$in_dir" ]; then

echo "too many arguments: $1 (already have $in_dir)" >&2

return 1

fi

in_dir="$1"

shift

;;

esac

done

if [ -z "${in_dir}" ]; then

echo "input-dir argument is required" >&2

return 1

fi

(

# To support running this from anywhere, first cd into this directory,

# and then install with forced module mode on and fully qualified name.

cd "${KUBE_CODEGEN_ROOT}"

BINS=(

register-gen"${CODEGEN_VERSION_SPEC}"

)

# shellcheck disable=2046 # printf word-splitting is intentional

GO111MODULE=on go install $(printf "k8s.io/code-generator/cmd/%s " "${BINS[@]}")

)

# Register

#

local input_pkgs=()

while read -r dir; do

pkg="$(cd "${dir}" && GO111MODULE=on go list -find .)"

input_pkgs+=("${pkg}")

done < <(

if [ "${#input_pkgs[@]}" != 0 ]; then

echo "Generating register code for ${#input_pkgs[@]} targets"

kube::codegen::internal::findz \

"${in_dir}" \

-type f \

-name zz_generated.register.go \

| xargs -0 rm -f

"${GOBIN}/register-gen" \

-v "${v}" \

--output-file zz_generated.register.go \

--go-header-file "${boilerplate}" \

"${input_pkgs[@]}"

fi