includeFilter.processUrl("http://example.com/");

        assertEquals(1, includeFilter.cachedIncludeSet.size());
        assertEquals(0, includeFilter.cachedExcludeSet.size());
        assertEquals("http://example.com/.*", includeFilter.cachedIncludeSet.toArray()[0]);

        includeFilter.processUrl("https://test.com");

multiprecision library gmp's integer type mpz_t wrapped to look like
the Go package big's integer type Int.

This is a syntactically valid Go program—it can be parsed with the Go
parser and processed by godoc—but it is not compiled directly by gc.
Instead, a separate tool, cgo, processes it to produce three output
files.  The first two, 6g.go and 6c.c, are a Go source file for 6g and
a C source file for 6c; both compile as part of the named package

        List<InterpolationPostProcessor> processors = new ArrayList<>(2);
        if (projectDir != null) {
            processors.add(new PathTranslatingPostProcessor(
                    getProjectPrefixes(config), TRANSLATED_PATH_EXPRESSIONS, projectDir, pathTranslator));
        }
        processors.add(new UrlNormalizingPostProcessor(urlNormalizer));
        return processors;
    }

        gradlew --> daemon
        tapi --> daemon
        
        worker["Worker process"]
        daemon --> worker

        worker2["Worker process"]
        daemon --> worker2

        worker3["Worker process"]
        daemon --> worker3
    
```

These are all Java processes. Each process has a corresponding "runtime".
All source code in Gradle is written to target one or more of these runtimes.

# Extendendo o OpenAPI

Existem alguns casos em que pode ser necessário modificar o esquema OpenAPI gerado.

Nesta seção, você verá como fazer isso.

## O processo normal

O processo normal (padrão) é o seguinte:

Uma aplicação (instância) do `FastAPI` possui um método `.openapi()` que deve retornar o esquema OpenAPI.

Isso significa que no lugar do processo normal de seus usuários enviarem requisições para a sua API, é a **sua API** (ou sua aplicação) que poderia **enviar requisições para o sistema deles** (para a API deles, a aplicação deles).

Isso normalmente é chamado de **webhook**.

## Etapas dos Webhooks

        return jvmObj;
    }

    private ProcessObj getProcessObj() {
        final ProcessObj processObj = new ProcessObj();
        final ProcessProbe processProbe = ProcessProbe.getInstance();
        final ProcessFileDescriptorObj processFileDescriptorObj = new ProcessFileDescriptorObj();
        processObj.fileFescriptor = processFileDescriptorObj;

```

</div>

////

The only new option here is `--workers` telling Uvicorn to start 4 worker processes.

You can also see that it shows the **PID** of each process, `27365` for the parent process (this is the **process manager**) and one for each worker process: `27368`, `27369`, `27370`, and `27367`.

## Deployment Concepts

	processIOReadBytesMD              = NewCounterMD(processIOReadBytes, "Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes")

A container is running as long as the **main process** (command or program) is running.

A container normally has a **single process**, but it's also possible to start subprocesses from the main process, and that way you will have **multiple processes** in the same container.

But it's not possible to have a running container without **at least one running process**. If the main process stops, the container stops.