bind(SessionScope.class).toInstance(scope);

        bind(MavenSession.class)
                .toProvider(SessionScope.seededKeyProvider(MavenSession.class))
                .in(scope);
        bind(Session.class)
                .toProvider(SessionScope.seededKeyProvider(Session.class))
                .in(scope);
        bind(InternalMavenSession.class)

 */

package org.gradle.internal.serialize.codecs.guava

import org.gradle.internal.serialize.graph.codecs.BindingsBuilder


fun BindingsBuilder.guavaTypes() {
    bind(ImmutableListCodec)
    bind(ImmutableSetCodec)
    bind(ImmutableMapCodec)

    inline fun <reified T> bind(codec: Codec<T>) =
        bind(T::class.java, codec)

    inline fun <reified T> bind(serializer: Serializer<T>) =
        bind(T::class.java, serializer)

    fun bind(type: KClass<*>, codec: Codec<*>) =
        bind(type.java, codec)

    fun bind(type: KClass<*>, serializer: Serializer<*>) =
        bind(type.java, serializer)

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: bind
  labels:
    service: bind
spec:
  selector:
    matchLabels:
      service: bind
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 10%
  template:
    metadata:
      labels:
        service: bind
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:

        bind(MojoExecutionScope.class).toInstance(scope);
        bind(MavenProject.class)
                .toProvider(MojoExecutionScope.seededKeyProvider())
                .in(scope);
        bind(MojoExecution.class)
                .toProvider(MojoExecutionScope.seededKeyProvider())
                .in(scope);
        bind(Log.class).toProvider(MojoExecutionScope.seededKeyProvider()).in(scope);

    }

    def "disallow mutating from named actions using #mutatingMethods.key"() {
        setupContainerDefaults()
        addToContainer(a)
        String methodUnderTest = mutatingMethods.key
        Closure method = bind(mutatingMethods.value)

        when:
        container.named("a").configure(method)
        then:
        def ex = thrown(Throwable)
        assertDoesNotAllowMethod(ex, methodUnderTest)

        when:

import com.example.myproduct.user.table.TableBuilder;
import org.apache.juneau.html.HtmlSerializer;
import org.apache.juneau.serializer.SerializeException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyProductController {

    @RequestMapping("/")
    public String index() throws SerializeException {

        ]
    }

    def "allow query and mutating methods from create with type using #methods.key"() {
        setupContainerDefaults()
        String methodUnderTest = methods.key
        Closure method = bind(methods.value)

        when:
        container.create("a", container.type, method)
        then:
        noExceptionThrown()

        where:
        methods << getQueryMethods() + getMutatingMethods()
    }

# TODO(aojea) remove ConsistentListFromCache after https://issues.k8s.io/123674
kube::log::status "Starting kube-apiserver"
kube-apiserver \
  --bind-address="${API_HOST}" \
  --secure-port="${API_PORT}" \
  --etcd-servers="http://${ETCD_HOST}:${ETCD_PORT}" \
  --advertise-address="10.10.10.10" \
  --cert-dir="${TMP_DIR}/certs" \

        }
        reload
        loop
        bind __PILLAR__LOCAL__DNS__ __PILLAR__DNS__SERVER__
        forward . __PILLAR__CLUSTER__DNS__ {
                force_tcp
        }
        prometheus :9253
        health __PILLAR__LOCAL__DNS__:8080
        }
    in-addr.arpa:53 {
        errors
        cache 30
        reload
        loop
        bind __PILLAR__LOCAL__DNS__ __PILLAR__DNS__SERVER__