}
    }

    /**
     * Returns new builder from scratch.
     */
    static Builder newBuilder() {
        return new Builder().withStartTime(MonotonicClock.now());
    }

    class Builder {
        private Map<String, String> userProperties;
        private Map<String, String> systemProperties;
        private Instant startTime;
        private Path topDirectory;

    private static final Pattern FILTER_1 = Pattern.compile("[^\\d._-]");
    private static final Pattern FILTER_2 = Pattern.compile("[._-]");
    private static final Pattern FILTER_3 = Pattern.compile("\\."); // used for split now

    @Override
    public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        Activation activation = profile.getActivation();

        if (activation == null) {

	req := mustNewRequest(method, urlStr, contentLength, body, t)
	cred := globalActiveCred
	if err := preSignV2(req, cred.AccessKey, cred.SecretKey, time.Now().Add(10*time.Minute).Unix()); err != nil {
		t.Fatalf("Unable to initialized new signed http request %s", err)
	}
	return req
}

// This is similar to mustNewRequest but additionally the request

    yum-config-manager -y --add-repo https://download.docker.com/linux/centos/docker-ce.repo

    # Install Docker
    yum install -y docker-ce docker-ce-cli containerd.io

    # Start Docker
    systemctl enable --now docker

    # Add vagrant to the Docker group, so that it can run commands
    usermod -aG docker vagrant
  SHELL
end

def dnf_common(config, name)
  # Autodetect doesn't work....

    public void test_isOperationRunning_expired() {
        setupMockFessConfig();
        final long now = System.currentTimeMillis();
        final String opJson = "{\"found\":true,\"_source\":{\"type\":\"operation\",\"name\":\"reindex\","
                + "\"instanceId\":\"node1@host1\",\"status\":\"running\"," + "\"expiredTime\":" + (now - 1000L) + "}}";

			return nil, err
		}
		fn := filepath.Join(dirPath, "cpuio.out")
		f, err := Create(fn)
		if err != nil {
			return nil, err
		}
		stop := fgprof.Start(f, fgprof.FormatPprof)
		startedAt := time.Now()
		prof.stopFn = func() ([]byte, error) {
			if elapsed := time.Since(startedAt); elapsed < 100*time.Millisecond {
				// Light hack around https://github.com/felixge/fgprof/pull/34

    }


def test_custom_encoders():
    class safe_datetime(datetime):
        pass

    class MyDict(TypedDict):
        dt_field: safe_datetime

    instance = MyDict(dt_field=safe_datetime.now())

    encoded_instance = jsonable_encoder(
        instance, custom_encoder={safe_datetime: lambda o: o.strftime("%H:%M:%S")}
    )
    assert encoded_instance["dt_field"] == instance["dt_field"].strftime("%H:%M:%S")

			continue
		}

		// If zero or earlier modtime, set to current.
		// Otherwise the resulting objects will be invalid.
		if header.ModTime.UnixNano() <= 0 {
			header.ModTime = time.Now()
		}

		// Sync upload.
		rc := disconnectReader{r: tarReader}
		if err := putObject(&rc, header.FileInfo(), name); err != nil {
			rc.Close()
			if o.ignoreErrs {
				s3LogIf(ctx, err)
				continue

		IsLatest:         true,
		Deleted:          false,
		TransitionStatus: "",
		DataDir:          "bffea160-ca7f-465f-98bc-9b4f1c3ba1ef",
		XLV1:             false,
		ModTime:          time.Now().UTC(),
		Size:             0,
		Mode:             0,
		Metadata:         nil,
		Parts:            nil,
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,

	outReq.RequestURI = "" // Outgoing request should not have RequestURI

	// Do not pass client Host header unless requested.
	if !f.PassHost {
		outReq.Host = target.Host
	}

	// TODO: only supports HTTP 1.1 for now.
	outReq.Proto = "HTTP/1.1"
	outReq.ProtoMajor = 1
	outReq.ProtoMinor = 1

	f.rewriter.Rewrite(outReq)

	// Disable closeNotify when method GET for http pipelining
	if outReq.Method == http.MethodGet {