// name.
	objectCaches   = make(map[string]*ObjectCache)
	objectCachesMu sync.RWMutex
)

// FlushObjectCaches flushes all object caches.
func FlushObjectCaches() {
	objectCachesMu.Lock()
	defer objectCachesMu.Unlock()
	objectCaches = make(map[string]*ObjectCache)
	metrics.CacheFlushTotal.Increment()
}

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

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Connection decorator that synchronizes dispatching and always flushes after each message.
 *
 * The plan is to replace this with a Connection implementation that queues outgoing messages and dispatches them from a worker thread.
 */

	t0 := time.Now()
	log.WithLabels("host", r.Host, "source", r.RemoteAddr).Info("Received CONNECT")
	// Send headers back immediately so we can start getting the body
	w.(http.Flusher).Flush()
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	dst, err := (&net.Dialer{}).DialContext(ctx, "tcp", r.Host)
	if err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)

	}
}

// GetVersion is part of interface.
func (f *FakeIPSet) GetVersion() (string, error) {
	return f.Version, nil
}

// FlushSet is part of interface.  It deletes all entries from a named set but keeps the set itself.
func (f *FakeIPSet) FlushSet(set string) error {
	if f.Entries == nil {
		return fmt.Errorf("entries map can't be nil")
	}

	// delete all entry elements
	for true {

	flag.CommandLine.Parse([]string{"-test.coverprofile", tempCoveragePath()})

	// Begin periodic logging
	go wait.Forever(FlushCoverage, flushInterval)
}

// FlushCoverage flushes collected coverage information to disk.
// The destination file is configured at startup and cannot be changed.
// Calling this function also sends a line like "coverage: 5% of statements" to stdout.
func FlushCoverage() {

     */
    fun loadOrCreateProjectMetadata(identityPath: Path, creator: () -> LocalComponentGraphResolveState): LocalComponentGraphResolveState

    /**
     * Flushes any remaining state to the cache and closes any resources
     */
    fun finalizeCacheEntry()

    // This is a temporary property to allow migration from a root build scoped cache to a build tree scoped cache

      -
        name: Add a comment with the pushed containers
        uses: mshick/add-pr-comment@a65df5f64fc741e91c59b8359a4bc56e57aaf5b1 # v2
        if: contains(github.event.pull_request.labels.*.name, 'build and push to gcr.io for staging')
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          message: |
            I pushed these containers:
            

  <groupId>org.codehaus.plexus</groupId>
  <artifactId>plexus-components</artifactId>
  <packaging>pom</packaging>
  <version>1.1.6</version>
  <name>Plexus Components Parent Project</name>
  <!--
    TODO: should this be pushed down to all the dependencies?
      - a more stable API JAR may be useful, for the interfaces and classes such as AbstractLogEnabled
  -->
  <dependencies>
    <dependency>
      <groupId>org.codehaus.plexus</groupId>

		lrw.writeHeaders(&lrw.headers, code, lrw.ResponseWriter.Header())
		lrw.headersLogged = true
		lrw.ResponseWriter.WriteHeader(code)
	}
}

// Flush - Calls the underlying Flush.
func (lrw *ResponseRecorder) Flush() {
	lrw.ResponseWriter.(http.Flusher).Flush()
}

// Size - returns  the number of bytes written
func (lrw *ResponseRecorder) Size() int {
	return lrw.bytesWritten
}

    /**
     * Whether the <a href="https://www.jetbrains.com/help/teamcity/configuring-vcs-triggers.html">VCS trigger</a>
     * should be enabled, i.e. when new commits are pushed to this branch, should a ReadyForNightly job
     * be triggered automatically?
     *
     * Currently, we only enable VCS trigger for `master`/`release`/`releaseNx` branches.
     */