}

    protected Stream<BuildStep> nonEmptyPredecessors(BuildStep step) {
        HashSet<BuildStep> preds = new HashSet<>();
        nonEmptyPredecessors(step, preds, new HashSet<>());
        return preds.stream();
    }

    private void nonEmptyPredecessors(BuildStep step, Set<BuildStep> preds, Set<BuildStep> visited) {
        if (visited.add(step)) {

func (r *Record) Raw() (sql.SelectObjectFormat, any) {
	return sql.SelectFmtCSV, r
}

// Replace - is not supported for CSV
func (r *Record) Replace(_ any) error {
	return errors.New("Replace is not supported for CSV")
}

// NewRecord - creates new CSV record.
func NewRecord() *Record {
	return &Record{}

                new ProcessBuilder(path, "-cp", classpath, CIDetectorHelperRunner.class.getName());
        processBuilder.environment().putAll(add);
        ALL.stream()
                .filter(s -> !add.containsKey(s))
                .forEach(k -> processBuilder.environment().remove(k));
        Process process = processBuilder.start();
        process.waitFor();
        return new String(process.getInputStream().readAllBytes());

    Writer getWriter();

    @Nonnull
    T getContent();

    @Nullable
    Function<Object, String> getInputLocationFormatter();

    static <T> XmlWriterRequestBuilder<T> builder() {
        return new XmlWriterRequestBuilder<>();
    }

    class XmlWriterRequestBuilder<T> {
        Path path;
        OutputStream outputStream;
        Writer writer;
        T content;

	if st.IsDir() {
		f.Close()
		return nil, &os.PathError{
			Op:   "open",
			Path: path,
			Err:  syscall.EISDIR,
		}
	}

	return &LockedFile{File: f}, nil
}

// TryLockedOpenFile - tries a new write lock, functionality
// it is similar to LockedOpenFile with with syscall.LOCK_EX
// mode but along with syscall.LOCK_NB such that the function
// doesn't wait forever but instead returns if it cannot
// acquire a write lock.

// initCallhome will start the callhome task in the background.
func initCallhome(ctx context.Context, objAPI ObjectLayer) {
	if !globalCallhomeConfig.Enabled() {
		return
	}

	go func() {
		r := rand.New(rand.NewSource(time.Now().UnixNano()))
		// Leader node (that successfully acquires the lock inside runCallhome)
		// will keep performing the callhome. If the leader goes down for some reason,

	@(env bash $(PWD)/buildscripts/verify-healing-with-root-disks.sh)

verify-healing-with-rewrite: install-race ## verify healing to rewrite old xl.meta -> new xl.meta
	@echo "Verify healing with rewrite"
	@(env bash $(PWD)/buildscripts/rewrite-old-new.sh)

verify-healing-inconsistent-versions: install-race ## verify resolving inconsistent versions
	@echo "Verify resolving inconsistent versions build with race"

		if p.Database == "" {
			return fmt.Errorf("database unspecified")
		}
	}

	if p.QueueDir != "" {
		if !filepath.IsAbs(p.QueueDir) {
			return errors.New("queueDir path should be absolute")
		}
	}

	if p.MaxOpenConnections < 0 {
		return errors.New("maxOpenConnections cannot be less than zero")
	}

	return nil
}

// PostgreSQLTarget - PostgreSQL target.
type PostgreSQLTarget struct {

type ReplicationLatency struct {
	// Single & Multipart PUTs latency
	UploadHistogram LastMinuteHistogram
}

// Merge two replication latency into a new one
func (rl ReplicationLatency) merge(other ReplicationLatency) (newReplLatency ReplicationLatency) {
	newReplLatency.UploadHistogram = rl.UploadHistogram.Merge(other.UploadHistogram)
	return newReplLatency
}

/**
 * Signals a failure to locate a lifecycle.
 *
 */
public class LifecycleNotFoundException extends Exception {

    private final String lifecycleId;

    /**
     * Creates a new exception to indicate that the specified lifecycle is unknown.
     *
     * @param lifecycleId The identifier of the lifecycle that could not be located, may be {@code null}.
     */