A major advantage of certificate-based authentication compared to other STS authentication methods, like OpenID Connect or LDAP/AD, is that client authentication works without any additional/external component that must be constantly available. Therefore, certificate-based authentication may provide better availability / lower operational complexity.

  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for
   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.
   * @param subscriberMethod the subscribed method.
   */

- Choice of erasure set size is automatic based on the number of drives available, let's say for example if there are 32 servers and 32 drives which is a total of 1024 drives. In this scenario 16 becomes the erasure set size. This is decided based on the greatest common divisor (GCD) of acceptable erasure set sizes ranging from *4 to 16*.

// functions for creating SHAKE and cSHAKE instances, as well as utility
// functions for hashing bytes to arbitrary-length output.
//
//
// SHAKE implementation is based on FIPS PUB 202 [1]
// cSHAKE implementations is based on NIST SP 800-185 [2]
//
// [1] https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf
// [2] https://doi.org/10.6028/NIST.SP.800-185

import (
	"encoding/binary"
	"hash"
	"io"

	TokenDiscovery = "discovery-token"

	// TokenDiscoveryCAHash flag instructs kubeadm to validate that the root CA public key matches this hash (for token-based discovery)
	TokenDiscoveryCAHash = "discovery-token-ca-cert-hash"

	// TokenDiscoverySkipCAHash flag instructs kubeadm to skip CA hash verification (for token-based discovery)

# HTTP Based Overlay Network (HBONE)

HTTP Based Overlay Network (HBONE) is the protocol used by Istio for communication between workloads in the mesh.
At a high level, the protocol consists of tunneling TCP connections over HTTP/2 CONNECT, over mTLS.

## Specification

TODO

## Implementations

### Clients

#### CLI

A CLI client is available using the `client` binary.

Usage examples:

```shell

import spock.lang.Subject

class ComponentMetadataRuleContainerTest extends Specification {

    @Subject
    def container = new ComponentMetadataRuleContainer()

    def 'is empty and class based by default'() {
        expect:
        container.isEmpty()
        container.isClassBasedRulesOnly()
    }

    def 'records added rules in order'() {
        given:
        def rule1 = Mock(SpecRuleAction)

@AnalyzeClasses(packages = "org.gradle")
public final class ConfigurationCreationTest {

    /**
     * This test ensures that <strong>ONLY</strong> the role-based API is used to create configurations in Gradle core plugins.
     * <p>
     * It is important to maintain this condition, because the role-based API will allow us to (eventually) split
     * the implementation of configurations into separate classes per role.  If new configurations are created using

Por exemplo, estava claro que idealmente ele deveria ser baseado nos _type hints_ padrões do Python.

Também, a melhor abordagem era usar padrões já existentes.

# ADR-0003 - Avoid introducing Groovy types to public API

## Date

2024-01-12

## Context

Gradle's public API requires equal access from all JVM-based languages.
Kotlin, Groovy, Java, and other JVM-based languages should be able to use the Gradle API without relying on another language's standard library.

Historically, Gradle has shipped with some Groovy types in very prominent APIs.