run codegen

Signed-off-by: Kent Rancourt <[email protected]>

Author: krancour

charts/kargo/README.md

@@ -187,9 +187,8 @@ the Kargo controller is running.
 | `controller.gitClient.email`                                       | Specifies the email of the Kargo controller (used when authoring Git commits).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `[email protected]` |
 | `controller.gitClient.signingKeySecret.name`                       | Specifies the name of an existing `Secret` which contains the Git user's signing key. The value should be accessible under `.data.signingKey` in the same namespace as Kargo. When the signing key is a GPG key, the GPG key's name and email address identity must match the values defined for `controller.gitClient.name` and `controller.gitClient.email`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `""`                |
 | `controller.gitClient.signingKeySecret.type`                       | Specifies the type of the signing key. The currently supported and default option is `gpg`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `""`                |
-| `controller.imageCache.allowUseCachedTags`                         | ALLOWS container image repository subscriptions to improve performance by opting into more aggressive image metadata caching. That option is safe only for cases where it is known with certainty that relevant tags are "immutable" (i.e. the exact images referenced by tags remain constant over time and tags are never "re-used" to point to new/different images). If an operator wishes not to run the risk that users will inappropriately opt into this, this setting can be set to `false` to disallow it. Artifact discovery will FAIL if that policy is violated. Note that this setting does not apply at all to the Digest selection strategy, which always assumes tags are mutable.                                                                                                                                                                                                                                                                  | `true`              |
-| `controller.imageCache.requireUseCachedTags`                       | REQUIRES container images repository subscriptions to improve performance by opting into more aggressive image metadata caching. That option is safe only for cases where it is known with certainty that relevant tags are "immutable" (i.e. the exact images referenced by tags remain constant over time and tags are never "re-used" to point to new/different images). If an operator wishes to ensure performance, this setting can be set to `true`. Artifact discovery will FAIL if that policy is violated. Note that this setting does not apply at all to the Digest selection strategy, which always assumes tags are mutable.                                                                                                                                                                                                                                                                                                                           | `false`             |
-| `controller.imageCache.maxEntries`                                 | specifies the maximum number of entries in the internal image metadata cache.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `100000`            |
+| `controller.imageCache.allowUseCachedTags`                         | ALLOWS container image repository subscriptions to improve performance by opting into more aggressive caching. That option is safe only for cases where it is known with certainty that relevant tags are "immutable" (i.e. the exact images referenced by tags remain constant over time and tags are never "re-used" to point to new/different images). If an operator wishes not to run the risk that users will inappropriately opt into this, this setting can be set to `false` to disallow it. Artifact discovery will FAIL if that policy is violated. Note that this setting does not apply at all to the Digest selection strategy, which always assumes tags are mutable.                                                                                                                                                                                                                                                                                 | `true`              |
+| `controller.imageCache.requireUseCachedTags`                       | REQUIRES container images repository subscriptions to improve performance by opting into more aggressive caching. That option is safe only for cases where it is known with certainty that relevant tags are "immutable" (i.e. the exact images referenced by tags remain constant over time and tags are never "re-used" to point to new/different images). If an operator wishes to ensure performance, this setting can be set to `true`. Artifact discovery will FAIL if that policy is violated. Note that this setting does not apply at all to the Digest selection strategy, which always assumes tags are mutable.                                                                                                                                                                                                                                                                                                                                          | `false`             |
 | `controller.argocd.integrationEnabled`                             | Specifies whether Argo CD integration is enabled. When not enabled, the controller will not watch Argo CD Application resources or factor Application health and sync state into determinations of Stage health. Argo CD-based promotion mechanisms will also fail. When enabled, the controller will perform a sanity check at startup. If Argo CD CRDs are not found, the controller will proceed as if this integration had been explicitly disabled. Explicitly disabling is still preferable if this integration is not desired, as it will grant fewer permissions to the controller.                                                                                                                                                                                                                                                                                                                                                                          | `true`              |
 | `controller.argocd.namespace`                                      | The namespace into which Argo CD is installed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | `argocd`            |
 | `controller.argocd.watchArgocdNamespaceOnly`                       | Specifies whether the reconciler that watches Argo CD Applications for the sake of forcing related Stages to reconcile should only watch Argo CD Application resources residing in Argo CD's own namespace. Note: Older versions of Argo CD only supported Argo CD Application resources in Argo CD's own namespace, but newer versions support Argo CD Application resources in any namespace. This should usually be left as `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `false`             |