// 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.

// This is a sample chained plugin that supports multiple CNI versions. It
// parses prevResult according to the cniVersion
package plugin

type iptables struct{}

func newIPTables() InterceptRuleMgr {
	return &iptables{}

                }
            }
        """
    }

    @TargetGradleVersion(">=6.8")
    def "nested actions that query a project model run in parallel when target Gradle version supports it and --parallel is used"() {
        given:
        setupBuildWithDependencyResolution()

        expect:
        server.expectConcurrent('root', 'a', 'b')
        def models = withConnection {

            dependencies {
                constraints {
                    implementation("org.codehaus.groovy:groovy:${GroovyCoverage.MINIMAL_GROOVY_3}") {
                        because("need a version of Groovy that supports the current JDK")
                    }
                }
            }

            testing {
                suites {
                    test {
                        useSpock()
                    }

				},
			},
			wantVolume: &v1.Volume{
				Name: migratedVolume,
				VolumeSource: v1.VolumeSource{
					HostPath: hostPath,
				},
			},
		},
		{
			desc:           "inline volume type that supports csi migration",
			createNodeName: nodeName,
			pod: &v1.Pod{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "kube-apiserver",
					Namespace: "default",
				},
				Spec: v1.PodSpec{

}

// IsWebSocketRequestWithStreamCloseProtocol returns true if the request contains headers
// identifying that it is requesting a websocket upgrade with a remotecommand protocol
// version that supports the "CLOSE" signal; false otherwise.
func IsWebSocketRequestWithStreamCloseProtocol(req *http.Request) bool {
	if !IsWebSocketRequest(req) {
		return false
	}

// license that can be found in the LICENSE file.

//go:build solaris

// Package lif provides basic functions for the manipulation of
// logical network interfaces and interface addresses on Solaris.
//
// The package supports Solaris 11 or above.
package lif

import (
	"syscall"
)

type endpoint struct {
	af int
	s  uintptr
}

func (ep *endpoint) close() error {
	return syscall.Close(int(ep.s))
}

package cgo

// Import "unsafe" because we use go:linkname.
import _ "unsafe"

// When using cgo, call the C library for mmap, so that we call into
// any sanitizer interceptors. This supports using the memory
// sanitizer with Go programs. The memory sanitizer only applies to
// C/C++ code; this permits that code to see the Go code as normal
// program addresses that have been initialized.

 */
@NonNullApi
public class NestedValidationUtil {

    /**
     * Validates that the {@link org.gradle.api.tasks.Nested} annotation
     * supports the given bean type.
     * <p>
     * Nested types are expected to either declare some annotated properties,
     * which themselves are checked for annotations, or some conditional

** Amazon Linux 2 or later
* macOS 10.14 (Mojave) or later on Intel and ARM architectures

== Supported File Systems

File system watching supports the following file system types:

* APFS
* btrfs
* ext3
* ext4
* XFS
* HFS+
* NTFS

Gradle also supports VirtualBox's shared folders.

Network file systems like Samba and NFS are not supported.

.Symlinks
--

. . .
```

Refer [Prometheus documentation](https://prometheus.io/docs/introduction/first_steps/) for more details.

### 2. Configure authentication type for Prometheus metrics

MinIO supports two authentication modes for Prometheus either `jwt` or `public`, by default MinIO runs in `jwt` mode. To allow public access without authentication for prometheus metrics set environment as follows.

```