wait.JitterUntil(func() {
		succeeded = le.tryAcquireOrRenew(ctx)
		le.maybeReportTransition()
		if !succeeded {
			klog.V(4).Infof("failed to acquire lease %v", desc)
			return
		}
		le.config.Lock.RecordEvent("became leader")
		le.metrics.leaderOn(le.config.Name)
		klog.Infof("successfully acquired lease %v", desc)
		cancel()
	}, le.config.RetryPeriod, JitterFactor, true, ctx.Done())
	return succeeded
}

	kl.recorder.Eventf(kl.nodeRef, eventType, event, "Node %s status is now: %s", kl.nodeName, event)
}

// recordEvent records an event for this node, the Kubelet's nodeRef is passed to the recorder
func (kl *Kubelet) recordEvent(eventType, event, message string) {
	kl.recorder.Eventf(kl.nodeRef, eventType, event, message)
}

// record if node schedulable change.

    if (UseMultipleStreams()) {
      TF_ASSIGN_OR_RETURN(std::shared_ptr<se::Event> event,
                          stream_->parent()->CreateEvent());
      TF_RETURN_IF_ERROR(host_to_device_stream_->RecordEvent(event.get()));
      xla_tensor->ResetDefinitionEvent(std::move(event),
                                       host_to_device_stream_.get());
    }

    return absl::OkStatus();
  }();
  if (!status.ok()) {

    }

    TF_ASSIGN_OR_RETURN(std::shared_ptr<se::Event> definition_event,
                        dst_xla_context->stream()->parent()->CreateEvent());
    TF_RETURN_IF_ERROR(
        dst_device_to_device_stream->RecordEvent(definition_event.get()));
    xla_output->ResetDefinitionEvent(std::move(definition_event),
                                     dst_device_to_device_stream);

  TF_ASSERT_OK_AND_ASSIGN(auto event, executor->CreateEvent());
  TF_ASSERT_OK_AND_ASSIGN(auto stream, executor->CreateStream());
  ASSERT_FALSE(record_called);
  TF_ASSERT_OK(stream->RecordEvent(event.get()));
  ASSERT_TRUE(record_called);
  ASSERT_FALSE(wait_called);
  TF_ASSERT_OK(stream->WaitFor(event.get()));
  ASSERT_TRUE(wait_called);
}

TEST_F(StreamExecutorTest, MemcpyToHost) {

	nodeAllocatableReservationFunc func() v1.ResourceList, // typically Kubelet.containerManager.GetNodeAllocatableReservation
	recordEventFunc func(eventType, event, message string), // typically Kubelet.recordEvent
	localStorageCapacityIsolation bool,
) Setter {
	return func(ctx context.Context, node *v1.Node) error {
		// Note: avoid blindly overwriting the capacity in case opaque
		//       resources are being advertised.

  }

  std::shared_ptr<se::Event> definition_event;
  if (use_multiple_streams_ && stream) {
    TF_ASSIGN_OR_RETURN(definition_event, stream->parent()->CreateEvent());
    TF_RETURN_IF_ERROR(stream->RecordEvent(definition_event.get()));
  }

  for (const XlaOutputDescription& descr : compilation_result->outputs) {
    if (descr.type == DT_VARIANT) {
      return errors::Unimplemented(