distributed under the License is distributed on an "AS IS" BASIS,
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.
*/

package oom

import v1 "k8s.io/api/core/v1"

// Watcher defines the interface of OOM watchers.
type Watcher interface {
	Start(ref *v1.ObjectReference) error

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.Collection;
import java.util.List;

/**
 * Updater for hierarchical file watchers.
 *
 * For hierarchical watchers, we can use the registered watchable hierarchies as watched directories.
 * Build root directories are always watchable hierarchies.

			t.Error(err)
		}
	}

	// Set up 10 watchers for custom resource.
	// We can't exercise them in a loop the same way as get requests, as watchcache
	// can reject them with 429 and Retry-After: 1 if it is uninitialized and even
	// though 429 is automatically retried, with frequent watchcache terminations and
	// reinitializations they could either end-up being rejected N times and fail or

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  /** Ciphers in order we observed directly on the socket. */
  private lateinit var handshakeEnabledCipherSuites: List<String>

  /** Ciphers in order we observed on sslSocketFactory defaults. */
  private lateinit var defaultEnabledCipherSuites: List<String>

  /** Ciphers in order we observed on sslSocketFactory supported. */

# Futures.getChecked, in both of its variants, is incompatible with proguard.

# Used by AtomicReferenceFieldUpdater and sun.misc.Unsafe
-keepclassmembers class com.google.common.util.concurrent.AbstractFuture** {
  *** waiters;
  *** value;
  *** listeners;
  *** thread;
  *** next;
}
-keepclassmembers class com.google.common.util.concurrent.AtomicDouble {
  *** value;
}

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "File system watchers for keeping the VFS up-to-date"

dependencies {
    api(project(":snapshots"))
    api(project(":build-operations"))
    api(project(":files"))
    api(projects.stdlibJavaExtensions)

    api(libs.jsr305)
    api(libs.nativePlatform)
    api(libs.nativePlatformFileEvents)
    api(libs.slf4jApi)
    implementation(project(":functional"))

        then:
        // There are different reason why this doesn't work for hierarchical and non-hierarchical watchers.
        // We may want to support this use-case at some point.
        // For hierarchical watchers, we don't watch the project directory if the VFS only contains missing files in there.
        // For non-hierarchical watchers, we watch the parent directory of the missing file, the project directory in this case.

		"Number of failed outgoing requests (e.g. to a token exchange server, CA, etc.)",
	)

	numFileWatcherFailures = monitoring.NewSum(
		"num_file_watcher_failures_total",
		"Number of times file watcher failed to add watchers")

	numFileSecretFailures = monitoring.NewSum(
		"num_file_secret_failures_total",
		"Number of times secret generation failed for files",
	)

	certExpirySeconds = monitoring.NewDerivedGauge(

// or implement CORS at your proxy layer.

// WithCORS is a simple CORS implementation that wraps an http Handler.
// Pass nil for allowedMethods and allowedHeaders to use the defaults. If allowedOriginPatterns
// is empty or nil, no CORS support is installed.

  let summary = "Collects various metrics about the input to the lowering "
                "portion of the bridge. This is a logical no-op.";

  let description = [{
    Gathers metrics about the input MLIR to Phase 2 of the TFXLA Bridge, which
    does a strict semantic lowering from Tensorflow ops to XLA HLO.
  }];

  let constructor = "tensorflow::tf2xla::internal::CreateInputLoweringMetricsPass()";