select {
		case entry, ok := <-diffCh:
			if !ok {
				return
			}
			if err := enc.Encode(entry); err != nil {
				return
			}
			if len(diffCh) == 0 {
				// Flush if nothing is queued
				xhttp.Flush(w)
			}
		case <-keepAliveTicker.C:
			if len(diffCh) > 0 {
				continue
			}
			if _, err := w.Write([]byte(" ")); err != nil {
				return
			}
			xhttp.Flush(w)

        return true;
    }

    /**
     * Stores child URLs from the given set into the crawling queue for future processing.
     * This method filters out blank URLs and increments the depth for child URLs.
     *
     * @param urlQueue the parent URL queue item
     * @param childUrlSet the set of child URLs to be queued for crawling
     */

            CopyUtil.copy(in, out);
            asyncImport(fileName, tempFile);

            if (logger.isInfoEnabled()) {
                logger.info("Backup file uploaded successfully and queued for import: fileName={}, tempFile={}", fileName,
                        tempFile.getAbsolutePath());
            }
        } catch (final IOException e) {

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.

		// these could be stale buckets lying around, queue a heal
		// of such a bucket. This is needed here as we identify such
		// buckets here while listing buckets. As part of regular
		// globalBucketMetadataSys.Init() call would get a valid
		// buckets only and not the quourum lost ones like this, so
		// explicit call
		for bktName, count := range bucketsMap {
			if count < quorum {
				// Queue a bucket heal task

	for {
		select {
		case entry := <-traceCh:
			if _, err := w.Write(entry); err != nil {
				return
			}
			grid.PutByteBuffer(entry)
			if len(traceCh) == 0 {
				// Flush if nothing is queued
				xhttp.Flush(w)
			}
		case <-keepAliveTicker.C:
			if len(traceCh) > 0 {
				continue
			}
			if _, err := w.Write([]byte(" ")); err != nil {
				return
			}
			xhttp.Flush(w)

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been
 * on the queue the longest time. The tail of the queue is that element that has been on
 * the queue the shortest time. New elements are inserted at the tail of the queue, and the queue
 * retrieval operations obtain elements at the head of the queue.

		if serverDebugLog {
			fmt.Printf("Task in the queue: %#v\n", task)
		}
	case <-h.ctx.Done():
		return nil
	}

	countOKDrives := func(drives []madmin.HealDriveInfo) (count int) {
		for _, drive := range drives {
			if drive.State == madmin.DriveStateOk {
				count++
			}
		}
		return count
	}

	// task queued, now wait for the response.
	select {
	case res := <-task.respCh:

			}
		case "ReplicaCount":
			z.ReplicaCount, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ReplicaCount")
				return
			}
		case "Queued":
			err = z.Queued.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Queued")
				return
			}
		case "Proxied":
			err = z.Proxied.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Proxied")
				return
			}

			sz += t.Size
		}
	}
	return sz
}

// ReplicationAttempted returns true if replication was attempted on any of the targets for the object version
// queued
func (ri replicatedInfos) ReplicationResynced() bool {
	for _, t := range ri.Targets {
		if t.Empty() || !t.ReplicationResynced {
			continue
		}
		return true
	}
	return false
}