}

        @Override
        void attachToCycle(List<String> displayValue) {
            displayValue.add(getPath().toString());
        }
    }

    private class Discover extends ModelNodeGoal {
        public Discover(ModelPath path) {
            super(path);
        }

        @Override
        public boolean doIsAchieved() {
            return node.isAtLeast(Discovered);
        }

    def setup() {
        // Discard init script content generated by superclass
        initScript.text = ""
    }

    @ToBeFixedForConfigurationCache
    def "can discover tool chain in environment"() {
        given:
        toolChain.initialiseEnvironment()

        and:
        buildFile << """
apply plugin: 'cpp'
model {
    toolChains {

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * A method that can be used to visit classes for an instrumentation from other projects.
 * TODO: We should discover classes to visit automatically.
 */
@Retention(RetentionPolicy.CLASS)
@Target({ElementType.TYPE})
public @interface VisitForInstrumentation {
    Class<?>[] value();

 *
 * Note that when a type implements this interface, dynamic Groovy dispatch will not be used to discover opaque methods. That is, methods such as methodMissing() will be ignored.
 */
public interface MethodMixIn {
    MethodAccess getAdditionalMethods();

import org.apache.maven.di.impl.InjectorImpl;

public interface Injector {

    //
    // Builder API
    //

    static Injector create() {
        return new InjectorImpl();
    }

    Injector discover(ClassLoader classLoader);

    Injector bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope);

    Injector bindScope(Class<? extends Annotation> scopeAnnotation, Supplier<Scope> scope);

		EnvoyPrometheusPort:         envoyPrometheusPortEnv,
		MinimumDrainDuration:        minimumDrainDurationEnv,
		ExitOnZeroActiveConnections: exitOnZeroActiveConnectionsEnv,
		Platform:                    platform.Discover(proxy.SupportsIPv6()),
		GRPCBootstrapPath:           grpcBootstrapEnv,
		DisableEnvoy:                disableEnvoyEnv,
		ProxyXDSDebugViaAgent:       proxyXDSDebugViaAgent,

COPY static /opt/microservices/static
COPY requirements.txt /opt/microservices/

ARG flood_factor
ENV FLOOD_FACTOR ${flood_factor:-0}

EXPOSE 9080
WORKDIR /opt/microservices
RUN python -m unittest discover

CMD ["gunicorn", "-b", "[::]:9080", "productpage:app", "-w", "8", "--keep-alive", "2", "-k", "gevent"]

func (w *Watcher) Start(stopCh <-chan struct{}) error {
	klog.V(2).InfoS("Plugin Watcher Start", "path", w.path)

	// Creating the directory to be watched if it doesn't exist yet,
	// and walks through the directory to discover the existing plugins.
	if err := w.init(); err != nil {
		return err
	}

	fsWatcher, err := fsnotify.NewWatcher()
	if err != nil {
		return fmt.Errorf("failed to start plugin fsWatcher, err: %v", err)
	}

		)

		rq.quotaMonitor = qm

		// do initial quota monitor setup.  If we have a discovery failure here, it's ok. We'll discover more resources when a later sync happens.
		resources, err := GetQuotableResources(options.DiscoveryFunc)
		if discovery.IsGroupDiscoveryFailedError(err) {
			utilruntime.HandleError(fmt.Errorf("initial discovery check failure, continuing and counting on future sync update: %v", err))
		} else if err != nil {

	s.base = base
}

func (s *Slice) Line() int {
	return s.line
}

func (s *Slice) Col() int {
	// TODO: Col is only called when defining a macro and all it cares about is increasing
	// position to discover whether there is a blank before the parenthesis.
	// We only get here if defining a macro inside a macro.
	// This imperfect implementation means we cannot tell the difference between
	//	#define A #define B(x) x
	// and