# Conditional OpenAPI

If you needed to, you could use settings and environment variables to configure OpenAPI conditionally depending on the environment, and even disable it entirely.

## About security, APIs, and docs

Hiding your documentation user interfaces in production *shouldn't* be the way to protect your API.

That doesn't add any extra security to your API, the *path operations* will still be available where they are.

apiVersion: release-notes/v2
kind: bug-fix
area: installation
releaseNotes:
  - |
    **Fixed** an issue preventing the gateway chart from being used with a custom HorizontalPodAutoscaler resource.

upgradeNotes:
  - title: don't set spec.replicas unless user supplies a real number
    content: |
      When using the gateway chart, the user had to either pick between
      explicitly setting `spec.replicas`, or using the chart-supplied

    %1:2 = tf_executor.island {
      %0 = "tf.Const"() {value = dense<2.000000e+00> : tensor<f32>} : () -> tensor<f32>
      tf_executor.yield %0 : tensor<f32>
    }
// Uses two islands for no other reason than preventing canonicalization from
// eliminating the graph entirely.
    %2:2 = tf_executor.island(%1#1) {
      %4 = "tf.opB"(%1#0) : (tensor<f32>) -> tensor<f32>
      tf_executor.yield %4 : tensor<f32>
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package abi

import "unsafe"

// NoEscape hides the pointer p from escape analysis, preventing it
// from escaping to the heap. It compiles down to nothing.
//
// WARNING: This is very subtle to use correctly. The caller must
// ensure that it's truly safe for p to not escape to the heap by

// the comment with any comment markers ("//", "/*", or "*/") stripped.
// The position for each comment is the position of the token immediately
// preceding the comment, with all comments that are on the same line
// collected in a slice, in source order. If there is no preceding token
// (the matching comment appears at the beginning of the file), then the
// recorded position is unknown (line, col = 0, 0).

        """

package main

import (
	"fmt"
	"math"
	"runtime"
)

const ulp = (1.0 + (2.0 / 3.0)) - (5.0 / 3.0)

func main() {
	// adjust precision depending on compiler
	var prec float64
	switch runtime.Compiler {
	case "gc":
		prec = math.Inf(1) // exact precision using rational arithmetic
	case "gccgo":
		prec = 256
	default:
		// unknown compiler
		return

image::structuring-builds-2.png[]

This is a common use case for multi-project builds.
Gradle offers <<declaring_dependencies.adoc#sub:project_dependencies,project dependencies>> for this.

[[sec:project_jar_dependencies]]
== Depending on another project

Let's explore a theoretical multi-project build with the following layout:

[.multi-language-sample]
=====
[source, kotlin]
----
.
├── api
│   ├── src
│   │   └──...

					if ok {
						return fmt.Sprintf("Pod has %s=%s label, preventing injection", me.Key, v), false
					}
				case metav1.LabelSelectorOpNotIn:
					v, ok := podLabels[me.Key]
					if !ok {
						continue
					}
					for _, nv := range me.Values {
						if nv == v {
							return fmt.Sprintf("Pod has %s=%s label, preventing injection", me.Key, v), false
						}
					}
				}
			}

package os

// Executable returns the path name for the executable that started
// the current process. There is no guarantee that the path is still
// pointing to the correct executable. If a symlink was used to start
// the process, depending on the operating system, the result might
// be the symlink or the path it pointed to. If a stable result is
// needed, [path/filepath.EvalSymlinks] might help.
//
// Executable returns an absolute path unless an error occurred.