// because of this loop.
		for {
			if !globalCallhomeConfig.Enabled() {
				return
			}

			if !runCallhome(ctx, objAPI) {
				// callhome was disabled or context was canceled
				return
			}

			// callhome running on a different node.
			// sleep for some time and try again.
			duration := max(time.Duration(r.Float64()*float64(globalCallhomeConfig.FrequencyDur())),

//
//	e.g. Send the log to a http server
type Target interface {
	String() string
	Endpoint() string
	Stats() types.TargetStats
	Init(ctx context.Context) error
	IsOnline(ctx context.Context) bool
	Cancel()
	Send(ctx context.Context, entry any) error
	Type() types.TargetType
}

type targetsList struct {
	list []Target
	mu   sync.RWMutex
}

func newTargetsList() *targetsList {
	return &targetsList{}

  @Throws(IOException::class)
  internal fun cancelStreamIfNecessary() {
    assertLockNotHeld()

    val open: Boolean
    val cancel: Boolean
    withLock {
      cancel = !source.finished && source.closed && (sink.finished || sink.closed)
      open = isOpen
    }
    if (cancel) {
      // RST this stream to prevent additional data from being sent. This is safe because the input

  }

  @Override
  public void addListener(Runnable listener, Executor executor) {
    delegate.addListener(listener, executor);
  }

  @Override
  public boolean cancel(boolean mayInterruptIfRunning) {
    return delegate.cancel(mayInterruptIfRunning);
  }

  @Override
  public boolean isCancelled() {
    return delegate.isCancelled();
  }

  @Override
  public boolean isDone() {

		t.Fatal(err)
	}
	return fsDir, locker, token
}

// Test function to remove lock entries from map based on name & uid combination
func TestLockRpcServerRemoveEntry(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	testPath, locker, _ := createLockTestServer(ctx, t)
	defer os.RemoveAll(testPath)

	lockRequesterInfo1 := lockRequesterInfo{
		Owner:           "owner",
		Writer:          true,

labels.crawling_info_created_time=Creado
labels.crawling_info_delete_all_link=Eliminar todo
labels.crawling_info_delete_all_confirmation=¿Está seguro de que desea eliminar todo?
labels.crawling_info_delete_all_cancel=Cancelar
labels.crawling_info_thread_dump=Volcado de hilos
labels.crawling_info_CrawlerStartTime=Hora de inicio del rastreador
labels.crawling_info_CrawlerEndTime=Hora de finalización del rastreador

      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()
  }

  override fun close() {
    javaNetSocket.close()
  }

  fun awaitClosed() {
    closedLatch.await()
  }

  fun noNewExchangesOnConnection() {
    codec.carrier.noNewExchanges()
  }

  fun cancel() {
    codec.cancel()
  }

  /**
   * Revoke this exchange's access to streams. This is necessary when a follow-up request is
   * required but the preceding exchange hasn't completed yet.
   */
  fun detachWithViolence() {
    codec.cancel()
    call.messageDone(
      exchange = this,
      requestDone = true,

        ) = TODO()

        override fun callEnd(call: Call) = TODO()

        override fun callFailed(
          call: Call,
          ioe: IOException,
        ) = TODO()

        override fun canceled(call: Call) = TODO()
      }
    val none: EventListener = EventListener.NONE
  }

  @Test
  fun eventListenerBuilder() {
    var builder: EventListener.Factory = EventListener.Factory { TODO() }
  }

				}
			}
		})
	}
}

// Tests initializing new object layer.
func TestNewObjectLayer(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()
	// Tests for ErasureSD object layer.
	nDisks := 1
	disks, err := getRandomDisks(nDisks)
	if err != nil {
		t.Fatal("Failed to create drives for the backend")
	}
	defer removeRoots(disks)