// Verify response fields are initialized
        assertNotNull(queryFieldConfig.getResponseFields());
        assertTrue(queryFieldConfig.getResponseFields().length > 0);
        assertEquals(QueryFieldConfig.SCORE_FIELD, queryFieldConfig.getResponseFields()[0]);
        assertEquals("id", queryFieldConfig.getResponseFields()[1]);

        // Verify scroll response fields are initialized

    }

    /**
     * Updates the response data based on the FTP file information.
     * This method handles different file types (files, directories, symbolic links)
     * and populates the response data accordingly.
     *
     * @param uri The original URI being accessed
     * @param includeContent Whether to include the actual content in the response
     * @param responseData The response data to update

     */
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {
        final HttpServletRequest req = (HttpServletRequest) request;
        final HttpServletResponse resp = (HttpServletResponse) response;
        NtlmPasswordAuthentication ntlm = negotiate(req, resp, false);

        if (ntlm == null) {

    // Packet Types (ptype)
    /**
     * Request packet type
     */
    int RPC_PT_REQUEST = 0x00;
    /**
     * Ping packet type
     */
    int RPC_PT_PING = 0x01;
    /**
     * Response packet type
     */
    int RPC_PT_RESPONSE = 0x02;
    /**
     * Fault packet type - indicates an error
     */
    int RPC_PT_FAULT = 0x03;
    /**
     * Bind packet type - establishes context
     */

        }
        final GetIndexResponse response =
                client.admin().indices().prepareGetIndex().addIndices("*").execute().actionGet(suggestSettings.getIndicesTimeout());
        Stream.of(response.getIndices()).filter(s -> {
            if (!isSuggestIndex(s)) {
                return false;
            }
            final List<AliasMetadata> list = response.getAliases().get(s);
            if (list == null) {

                }
                final BulkResponse response = bulkRequest.execute().actionGet(30_000L);
                if (response.hasFailures()) {
                    logger.warn("Failed to write log notifications: {}", response.buildFailureMessage());
                }
            }
        } catch (final Exception e) {

        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success
        response.setSelectedVersion(request.getMaxVersion());
        response.setCreditsGranted(request.getCreditsRequested());
        response.setMaxReceiveSize(request.getMaxReceiveSize());
        response.setMaxReadWriteSize(request.getMaxFragmentedSize());

import org.codelibs.fess.app.web.base.FessSearchAction;
import org.codelibs.fess.app.web.base.SearchForm;
import org.codelibs.fess.util.RenderDataUtil;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;

/**
 * The action for the root of the application.
 */
public class RootAction extends FessSearchAction {

    /**
     * Constructor.
     */
    public RootAction() {
        super();

# Background Tasks - `BackgroundTasks`

You can declare a parameter in a *path operation function* or dependency function with the type `BackgroundTasks`, and then you can use it to schedule the execution of background tasks after the response is sent.

You can import it directly from `fastapi`:

```python
from fastapi import BackgroundTasks
```

    Note over Server: Server interprets headers<br/>(if --forwarded-allow-ips is set)

    Server->>Proxy: HTTP Response<br/>with correct HTTPS URLs

    Proxy->>Client: HTTPS Response
```

The **proxy** intercepts the original client request and adds the special *forwarded* headers (`X-Forwarded-*`) before passing the request to the **application server**.