* Puis il récupère la **réponse** générée par l’application (par un *chemin d'accès*).
* Il peut faire quelque chose avec cette **réponse** ou exécuter tout code nécessaire.
* Enfin, il renvoie la **réponse**.

/// note | Détails techniques

Si vous avez des dépendances avec `yield`, le code de sortie s’exécutera après le middleware.

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),
			},

  ':example-plugins:painless-whitelist',
  ':example-plugins:rescore',
  ':example-plugins:rest-handler',
  ':example-plugins:script-expert-scoring',
  ':example-plugins:security-authorization-engine',
  ':libs:elasticsearch-cli',
  ':libs:elasticsearch-core',
  ':libs:elasticsearch-dissect',
  ':libs:elasticsearch-geo',
  ':libs:elasticsearch-grok',
  ':libs:elasticsearch-lz4',
  ':libs:elasticsearch-nio',

	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]()

import org.codelibs.fess.util.JobProcess;
import org.codelibs.fess.util.SystemUtil;

import jakarta.servlet.ServletContext;

/**
 * Job for executing Python scripts within the Fess search engine environment.
 * This job extends ExecJob to provide Python-specific functionality for running
 * Python scripts with proper environment setup and argument passing.
 *

///

By using a `with` block, we make sure that the file-like object is closed after the generator function (the function with `yield`) is done. So, after it finishes sending the response.

It wouldn't be that important in this specific example because it's a fake in-memory file (with `io.BytesIO`), but with a real file, it would be important to make sure the file is closed after the work with it is done.

        String fileName = name + "-" + type;

        if (counters.containsKey(fileName) == false) {
            // try the other suffix...TODO: get rid of this, just support ending in .txt
            return fileName + ".txt";
        }

        return fileName;
    }

    @Input
    @Optional
    public LinkedHashSet<String> getIgnoreFiles() {

    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
  }

  /**
   * Regression test for an edge case where closing response body in the HTTP engine doesn't release
   * the corresponding stream allocation. This test keeps those response bodies alive and reads
   * them after the redirect has completed. This forces a connection to not be reused where it would

import org.opensearch.monitor.os.OsProbe;
import org.opensearch.monitor.process.ProcessProbe;

import jakarta.annotation.Resource;

/**
 * Main executable class for running crawling operations in the Fess search engine.
 * This class serves as the entry point for crawling web content, file systems, and data stores.
 * It manages the crawling lifecycle, including initialization, execution coordination,
 * monitoring, and cleanup operations.
 *

	maxWorkers int64

	// workerStartMu sync.Mutex
	lastStarted time.Time

	wg sync.WaitGroup

	// Channel of log entries.
	// Reading logCh must hold read lock on logChMu (to avoid read race)
	// Sending a value on logCh must hold read lock on logChMu (to avoid closing)
	logCh   chan any
	logChMu sync.RWMutex

	// If this webhook is being re-configured we will
	// assign the new webhook target to this field.