# Security Tools

When you need to declare dependencies with OAuth2 scopes you use `Security()`.

But you still need to define what is the dependable, the callable that you pass as a parameter to `Depends()` or `Security()`.

There are multiple tools that you can use to create those dependables, and they get integrated into OpenAPI so they are shown in the automatic docs UI, they can be used by automatically generated clients and SDKs, etc.

    own the intellectual property, then you'll need to sign an [individual
    CLA][]. Please include your GitHub username.
  - If you work for a company that wants to allow you to contribute your work,
    then you'll need to sign a [corporate CLA][].

You generally only need to submit a CLA once, so if you've already submitted
one (even if it was for a different project), you probably don't need to do it
again.

    public void redraw(AnsiContext ansi) {
        if (writePos.row < 0) {
            // Does not need to be redrawn if component is out of bound
            return;
        }

        if (!isVisible && previousVisibility) {
            if (previousWriteRow == absolutePositionRow && writtenSpans.isEmpty()) {
                // Does not need to be redrawn
                return;
            }

            writePos.col = 0;

# This script checks whether the OWNERS files need to be formatted or not by
# `yamlfmt`. Run `hack/update-yamlfmt.sh` to actually format sources.
#
# Usage: `hack/verify-yamlfmt.sh`.


set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/verify-generated.sh"

     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.
     */
    ExecAction newExecAction();

    /**
     * Creates a {@link JavaExecAction} that is not decorated. Use this when the action is not made visible to the DSL.
     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.

# ADR-0002 - Avoid using Java serialization

## Date

2012-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

        succeeds('help')
    }

    def "Can type-safely use ExtensionAware with the Kotlin DSL"() {
        when:
        // Need to use settings.extra because Kotlin DSL needs to be re-compiled
        def answerFile = "answerHolder.settings.gradle.kts"

        // Need to use settings because Kotlin DSL needs to be re-compiled
        testDirectory.file(answerFile) << """
        val theAnswer: () -> Int by settings.extra {
            { 42 }

 *
 * #### Implementation Notes
 *
 * Analysis API platforms need to take care of publishing modification topics via the [analysisMessageBus]. In general, if your platform
 * works with static code and static module structure, you do not need to publish any events. However, keep in mind the contracts of the

func checkExistingKubeConfigFile(cfg *config.InstallConfig, expectedKC kubeconfig) error {
	kubeconfigFilepath := filepath.Join(cfg.MountedCNINetDir, cfg.KubeconfigFilename)

	existingKC, err := os.ReadFile(kubeconfigFilepath)
	if err != nil {
		installLog.Debugf("no preexisting kubeconfig at %s, assuming we need to create one", kubeconfigFilepath)
		return err
	}

			// If the caller set namespaces with literal strings, replace with namespace.Instance objects.
			s = replaceNamespaceStrings(s)

			tpl := s.TemplateOrFail(out.t)
			need := tpl.MissingParams(s.Params())
			needFrom := need.Contains(param.From.String())
			needTo := need.Contains(param.To.String())

			if needFrom && needTo {
				out.needFromAndTo = append(out.needFromAndTo, s)
			} else if needFrom {