Alerting with prometheus is two step process. First we setup alerts in Prometheus server and then we need to send alerts to the AlertManager.

	ReplicateIncomingDelete = "replicate:incoming:delete"

	// ReplicateHeal - audit trail for healing of failed/pending replications
	ReplicateHeal = "replicate:heal"
	// ReplicateHealDelete - audit trail of healing of failed/pending delete replications.
	ReplicateHealDelete = "replicate:heal:delete"
)

var (
	globalReplicationPool  = once.NewSingleton[ReplicationPool]()

                );
        request.setMaxOutputResponse(65536);
        request.setFlags(Smb2IoctlRequest.SMB2_O_IOCTL_IS_FSCTL);

        // Note: This IOCTL must be sent on an existing session
        // The actual sending would need integration with the session's transport
        // For now, we're preparing the request structure correctly

        // TODO: Integration point - send request through session.send()

    /** Available send credits for flow control */
    protected final AtomicInteger sendCredits;
    /** Available receive credits for flow control */
    protected final AtomicInteger receiveCredits;
    /** Queue of pending RDMA work requests */
    protected final BlockingQueue<RdmaWorkRequest> pendingRequests;

    // Connection state
    /** Current connection state */
    protected volatile RdmaConnectionState state;

func TestParseRestoreObjStatus(t *testing.T) {
	testCases := []struct {
		restoreHdr     string
		expectedStatus restoreObjStatus
		expectedErr    error
	}{
		{
			// valid: represents a restored object, 'pending' expiry.
			restoreHdr: `ongoing-request="false", expiry-date="Fri, 21 Dec 2012 00:00:00 GMT"`,
			expectedStatus: restoreObjStatus{
				ongoing: false,
				expiry:  time.Date(2012, 12, 21, 0, 0, 0, 0, time.UTC),
			},

    return longBitsToDouble(significand | ONE_BITS);
  }

  static double bigToDouble(BigInteger x) {
    // This is an extremely fast implementation of BigInteger.doubleValue(). JDK patch pending.
    BigInteger absX = x.abs();
    int exponent = absX.bitLength() - 1;
    // exponent == floor(log2(abs(x)))
    if (exponent < Long.SIZE - 1) {
      return x.longValue();
    } else if (exponent > MAX_EXPONENT) {

            w.write(payload, 3, out);
        }

        // Assert: verify the underlying stream was called
        verify(out, timeout(1000)).write(payload, 0, 3);

        // Stop the thread by sending n = -1
        synchronized (w) {
            w.write(new byte[0], -1, out);
        }

        w.join(2000);
        assertFalse(w.isAlive(), "WriterThread should stop after -1 sentinel");
    }

                availableReceiveRegions.size());
    }

    /**
     * Get a send region from the pool or allocate a new one
     *
     * @param minSize minimum required size
     * @return memory region for sending
     * @throws IOException if allocation fails
     */
    public RdmaMemoryRegion getSendRegion(int minSize) throws IOException {
        if (minSize <= sendBufferSize) {

///

/// tip

If you want to call `async` functions in your tests apart from sending requests to your FastAPI application (e.g. asynchronous database functions), have a look at the [Async Tests](../advanced/async-tests.md){.internal-link target=_blank} in the advanced tutorial.

///

```console
$ pip install python-multipart
```

This is because **OAuth2** uses "form data" for sending the `username` and `password`.

///

Run the example with:

<div class="termy">

```console
$ fastapi dev main.py