*/

package jcifs.smb1.netbios;

import java.io.IOException;
import java.io.InputStream;

/**
 * NetBIOS session request packet for establishing sessions.
 * This packet is sent to request a NetBIOS session with a remote host.
 */
public class SessionRequestPacket extends SessionServicePacket {

    private final Name calledName, callingName;

    SessionRequestPacket() {

    """
    A file uploaded in a request.

    Define it as a *path operation function* (or dependency) parameter.

    If you are using a regular `def` function, you can use the `upload_file.file`
    attribute to access the raw standard Python file (blocking, not async), useful and
    needed for non-async code.

    Read more about it in the

		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	wrapServer := func(handler http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			t.Logf("Got a %s request for: %v", r.Method, r.URL)
			handler.ServeHTTP(w, r)
		})
	}
	connReady := make(chan struct{})
	// We fake a local and remote server.
	localHost := hosts[0]
	remoteHost := hosts[1]

          handshakeCertificates.trustManager,
        )
    }

    val client = clientBuilder.build()

    val request =
      Request
        .Builder()
        .url("https://valid-isrgrootx1.letsencrypt.org/robots.txt")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(404)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }

        field.set(reader, eventDispatcher);

        ArtifactDescriptorRequest request = new ArtifactDescriptorRequest();

        request.addRepository(newTestRepository());

        request.setArtifact(new DefaultArtifact("org.apache.maven.its", "dep-mng5459", "jar", "0.4.0-SNAPSHOT"));

        // execute
        reader.readArtifactDescriptor(session, request);

        // verify
        verify(eventDispatcher).dispatch(event.capture());

如果有任何后台任务（会在[后台任务](background-tasks.md)一节中介绍，你稍后会看到），它们会在所有中间件之后运行。

///

## 创建中间件 { #create-a-middleware }

要创建中间件，你可以在函数的顶部使用装饰器 `@app.middleware("http")`。

中间件函数会接收：

* `request`。
* 一个函数 `call_next`，它会把 `request` 作为参数接收。
    * 这个函数会把 `request` 传递给相应的*路径操作*。
    * 然后它返回由相应*路径操作*生成的 `response`。
* 在返回之前，你可以进一步修改 `response`。

{* ../../docs_src/middleware/tutorial001_py310.py hl[8:9,11,14] *}

/// tip

import org.codelibs.fess.app.web.api.admin.BaseSearchBody;

/**
 * Search request body for request header administration API.
 */
public class SearchBody extends BaseSearchBody {

    /**
     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    /** Request header configuration ID */
    public String id;

         * direct dependencies from the request will be merged with the direct dependencies from the root dependency's
         * artifact descriptor, giving higher priority to the dependencies from the request.
         *
         * @param dependencies the direct dependencies, may be {@code null}
         * @return this request for chaining, never {@code null}
         */

     * @param request The HTTP servlet request containing authentication data.
     * @return The login credential or null if processing fails.
     */
    protected LoginCredential processAuthenticationData(final HttpServletRequest request) {
        final StringBuilder urlBuf = new StringBuilder(request.getRequestURL());
        final String queryStr = request.getQueryString();
        if (queryStr != null) {

        // search

    }

    /**
     * Get the permissions.
     * @param request The request.
     * @return The permissions.
     */
    public OptionalEntity<Set<String>> getPermissions(final HttpServletRequest request) {
        final String token = ComponentUtil.getAccessTokenHelper().getAccessTokenFromRequest(request);
        if (StringUtil.isNotBlank(token)) {
            return accessTokenBhv.selectEntity(cb -> {