}
}

// uaTransport - User-Agent  transport
type uaTransport struct {
	ua string
	rt http.RoundTripper
}

func (u *uaTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	req2 := req.Clone(req.Context())
	req2.Header.Set("User-Agent", u.ua)
	return u.rt.RoundTrip(req2)
}

// WithUserAgent wraps an existing transport with custom User-Agent

         .add("*.publicobject.com", "sha1/T5x9IXmcrQ7YuQxXnxoCmeeQ84c=")
         .build());
    ```

 *  **Interceptors lists are now deep-copied by `OkHttpClient.clone()`.**
    Previously clones shared interceptors, which made it difficult to customize
    the interceptors on a request-by-request basis.

 *  New: `Headers.toMultimap()`.
 *  New: `RequestBody.create(MediaType, ByteString)`.

        protected int numOfThreads = 1;

        /**
         * Whether to run in cleanup mode to remove old thumbnails.
         */
        @Option(name = "-c", aliases = "--cleanup", usage = "Clean-Up mode")
        protected boolean cleanup;

        /**
         * Default constructor for command-line options.
         */
        protected Options() {
            // nothing
        }

                fail("REPOSITORY LEAKAGE DETECTED: Shared request contains repositories from both children!");
            }

        } finally {
            // Clean up
            deleteRecursively(tempDir.toFile());
        }
    }

    private void deleteRecursively(File file) {
        if (file.isDirectory()) {
            File[] children = file.listFiles();

			tm, err := time.Parse(time.RFC3339Nano, string(val))
			if err == nil {
				j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicaTimestamp] = []byte(tm.UTC().Format(time.RFC3339Nano))
			}
		}
	}

	// Clean up PartEtags on v1
	if j.ObjectV2 != nil {
		allEmpty := true
		for _, tag := range j.ObjectV2.PartETags {
			if len(tag) != 0 {
				allEmpty = false
				break
			}
		}
		if allEmpty {

        return handles.size();
    }

    private void periodicMaintenance() {
        if (shutdown) {
            return;
        }

        lock.writeLock().lock();
        try {
            // Clean up expired handles
            handles.entrySet().removeIf(entry -> {
                HandleInfo info = entry.getValue();
                if (info.isExpired() && !info.isReconnecting()) {

This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model.

## Use Case { #use-case }

Let's start with an example **use case** and then see how to solve it with this.

				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}
		}

		for _, serverAddr := range listener.Addrs() {
			conn, err := net.Dial("tcp", serverAddr.String())
			if err != nil {
				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}
			conn.Close()
		}

		listener.Close()
	}
}

func TestHTTPListenerAddr(t *testing.T) {
	if runtime.GOOS == "windows" {

      this.serverSocket = new ServerSocket(0);
      this.cleanable = cleaner.register(this, closeServerSocketRunnable(serverSocket, cleanerRan));
    }

    @Override
    public void close() {
      cleanable.clean();
    }
  }

  @SuppressWarnings("Java8ApiChecker")
  private ServerSocket makeMyServerExampleWithCleaner(AtomicBoolean cleanerRan) throws IOException {

        // Session keep tracks of the Project per project id,
        // so we cannot use session.getProject(p) for forked projects
        // which are temporary clones
        return Optional.ofNullable(getMavenProject(project).getExecutionProject())
                .map(p -> new DefaultProject(session, p));
    }

    private MavenProject getMavenProject(Project project) {