}
}

func retryWithExponentialBackOff(initialDuration time.Duration, fn wait.ConditionFunc) error {
	backoff := wait.Backoff{
		Duration: initialDuration,
		Factor:   3,
		Jitter:   0,
		Steps:    6,
	}
	return wait.ExponentialBackoff(backoff, fn)
}

type DummyImpl struct{}

func NewDummyImpl() *DummyImpl {
	return &DummyImpl{}
}

	// TODO(ramaraochavali): Think about tieing these failures to liveness probe with a
	// reasonable threshold (when the problem is not transient) and restart the pod.
	go func() {
		b := backoff.NewExponentialBackOff(backoff.DefaultOption())
		_ = b.RetryWithContext(context.TODO(), func() error {
			err := sc.tryAddFileWatcher(file, resourceName)
			return err
		})
	}()
}

// ID defines underlying platform supporting service registry
type ID string

const (
	// Mock is a service registry that contains 2 hard-coded test services
	Mock ID = "Mock"
	// Kubernetes is a service registry backed by k8s API server
	Kubernetes ID = "Kubernetes"
	// External is a service registry for externally provided ServiceEntries
	External ID = "External"
)

func (id ID) String() string {
	return string(id)

    <groupId>org.codehaus.plexus</groupId>
    <version>1.1.6</version>
  </parent>

  <artifactId>plexus-active-collections</artifactId>
  <version>1.0-beta-1</version>
  <name>Plexus Container-Backed Active Collections</name>

  <dependencies>
    <dependency>
      <groupId>org.codehaus.plexus</groupId>
      <artifactId>plexus-component-api</artifactId>
      <version>1.0-alpha-16</version>
    </dependency>

import org.gradle.api.artifacts.Configuration;
import org.gradle.api.component.SoftwareComponentVariant;

import javax.annotation.Nullable;

/**
 * A {@link SoftwareComponentVariant} which is optionally backed by resolution during publication.
 * If enabled, the resolution configuration is resolved in order to override declared dependencies
 * with the resolved coordinates and versions.
 */

 * limitations under the License.
 */

package org.gradle.internal.model;

import java.util.Map;
import java.util.function.Function;

/**
 * A cache backed by calculated values. This map is thread-safe.
 */
public interface CalculatedValueCache<K, V> {

    /**
     * @see Map#computeIfAbsent(Object, Function)
     */
    V computeIfAbsent(K key, Function<K, V> factory);

/**
 * A marker interface that is implemented by views of managed elements.
 */
public interface ManagedInstance {
    /**
     * Returns the node that this managed instance is backed by.
     */
    MutableModelNode getBackingNode();

    /**
     * Returns the original model type of the instance. This can be used to look up the schema for the type.
     */
    ModelType<?> getManagedType();

 */
public interface FileCollectionSnapshotter {
    interface Result {
        FileSystemSnapshot getSnapshot();

        /**
         * Whether any of the snapshot file collections is an archive tree backed by a file.
         */
        boolean containsArchiveTrees();
    }

    /**
     * Snapshot the roots of a file collection.
     */
    Result snapshot(FileCollection fileCollection);

    <groupId>org.codehaus.plexus</groupId>
    <version>1.1.6</version>
  </parent>

  <artifactId>plexus-active-collections</artifactId>
  <version>1.0-beta-1</version>
  <name>Plexus Container-Backed Active Collections</name>

  <dependencies>
    <dependency>
      <groupId>org.codehaus.plexus</groupId>
      <artifactId>plexus-component-api</artifactId>
      <version>1.0-alpha-16</version>
    </dependency>

 *
 *
 * @deprecated instead use {@link UrlSource}
 */
@Deprecated
public class UrlModelSource extends UrlSource implements ModelSource {
    /**
     * Creates a new model source backed by the specified URL.
     *
     * @param pomUrl The POM file, must not be {@code null}.
     */
    public UrlModelSource(URL pomUrl) {
        super(pomUrl);
    }