}

    public void migrate() {
        new Thread(() -> {
            final Path basePath = baseDir.toPath();
            final String suffix = "." + imageExtention;
            try (Stream<Path> paths = Files.walk(basePath)) {
                paths.filter(path -> path.toFile().getName().endsWith(imageExtention)).forEach(path -> {
                    final Path subPath = basePath.relativize(path);

	wk, err := workers.New(workerSize)
	if err != nil {
		// invalid worker size.
		return err
	}

	ctx, cancel := context.WithCancel(ctx)

	results := make(chan itemOrErr[ObjectInfo], 100)
	if err := api.Walk(ctx, r.Bucket, r.Prefix, results, WalkOptions{
		Marker: lastObject,
		Filter: selectObj,
	}); err != nil {
		cancel()
		// Do not need to retry if we can't list objects on source.
		return err
	}

   *     JDK 8 and on all Android versions. Use {@link Throwable#getStackTrace()} directly, or where
   *     possible use the {@code java.lang.StackWalker.walk} method introduced in JDK 9.
   */
  @Deprecated
  @J2ktIncompatible
  @GwtIncompatible // lazyStackTraceIsLazy, jlaStackTrace
  public static List<StackTraceElement> lazyStackTrace(Throwable throwable) {

		}
	})
	return local.ReaderSource{Name: f, Reader: r}, nil
}

func gatherFilesInDirectory(cmd *cobra.Command, dir string) ([]local.ReaderSource, error) {
	var readers []local.ReaderSource

	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		if !isValidFile(path) {

	// .metadata.bin healing is not needed here, it is automatically healed via read() call.
	return z.s3Peer.HealBucket(ctx, bucket, opts)
}

// Walk a bucket, optionally prefix recursively, until we have returned
// all the contents of the provided bucket+prefix.
func (z *erasureServerPools) Walk(ctx context.Context, bucket, prefix string, results chan<- itemOrErr[ObjectInfo], opts WalkOptions) error {

	go func() {
		prefixes := r.Prefix.F()
		if len(prefixes) == 0 {
			prefixes = []string{""}
		}
		for _, prefix := range prefixes {
			prefixResultCh := make(chan itemOrErr[ObjectInfo], workerSize)
			err := api.Walk(ctx, r.Bucket, prefix, prefixResultCh, WalkOptions{
				Marker:       lastObject,
				LatestOnly:   false, // we need to visit all versions of the object to implement purge: retainVersions
				VersionsSort: WalkVersionsSortDesc,

                    if ( log.isTraceEnabled() ) {
                        log.trace("Found at " + link);
                    }
                    break;
                }

                // walk up trying to find a match, do not go up to the root
                int nextSep = link.lastIndexOf('\\');
                if ( nextSep > 0 ) {
                    link = link.substring(0, nextSep);
                }

	}
	// mark resync status as resync started
	if !heal {
		s.markStatus(ResyncStarted, opts, objectAPI)
	}

	// Walk through all object versions - Walk() is always in ascending order needed to ensure
	// delete marker replicated to target after object version is first created.
	if err := objectAPI.Walk(ctx, opts.bucket, "", objInfoCh, WalkOptions{}); err != nil {
		replLogIf(ctx, err)
		return
	}

	s.RLock()

	ch := make(chan itemOrErr[string])

	go func() {
		defer xioutil.SafeClose(ch)

		// Allocate new results channel to receive ObjectInfo.
		objInfoCh := make(chan itemOrErr[ObjectInfo])

		if err := objAPI.Walk(ctx, minioMetaBucket, pathPrefix, objInfoCh, WalkOptions{}); err != nil {
			select {
			case ch <- itemOrErr[string]{Err: err}:
			case <-ctx.Done():
			}
			return
		}

		for obj := range objInfoCh {

for this time the Mouse was bristling all over, and she felt
certain it must be really offended.  `We won't talk about her any
more if you'd rather not.'

  `We indeed!' cried the Mouse, who was trembling down to the end
of his tail.  `As if I would talk on such a subject!  Our family
always HATED cats:  nasty, low, vulgar things!  Don't let me hear
the name again!'