} else if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                logger.info("Starting Job {}.", id);
            }

            final Object ret = jobExecutor.execute(Constants.DEFAULT_SCRIPT, script);
            if (ret == null) {
                if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                    logger.info("Finished Job {}.", id);
                }

  }

  @Override
  @CanIgnoreReturnValue
  public List<Runnable> shutdownNow() {
    return delegate().shutdownNow();
  }

  @Override
  public void execute(Runnable command) {
    delegate().execute(command);
  }

  @Override
  public <T extends @Nullable Object> Future<T> submit(Callable<T> task) {
    return delegate().submit(task);
  }

  @Override

     */
    object Params {
        const val sourceRoots = "sourceRoots"
        const val sourceCompilationClasspath = "sourceCompilationClasspath"
    }

    @Suppress("unchecked_cast")
    override fun execute(context: ViolationCheckContext) {
        (context.userData as MutableMap<String, Any?>)[REPOSITORY_CONTEXT_KEY] = BinaryCompatibilityRepository.openRepositoryFor(
            param(Params.sourceRoots),

            } else {
                excludedPackages.add(excludePattern);
            }
        }

        repository.each(new Action<ClassMetaData>() {
            @Override
            public void execute(ClassMetaData classMetaData) {
                if (classMetaData.getOuterClassName() != null) {
                    // Ignore inner classes
                    return;
                }

import org.codelibs.fess.util.SearchEngineUtil;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.JsonResponse;
import org.lastaflute.web.response.StreamResponse;

/**
 * @author Keiichi Watanabe
 */
public class ApiAdminBackupAction extends FessApiAdminAction {

    // GET /api/admin/backup/files
    @Execute
    public JsonResponse<ApiResult> files() {

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {

    // Copy to customize OkHttp for this request.
    OkHttpClient client1 = client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build();
    try (Response response = client1.newCall(request).execute()) {
      System.out.println("Response 1 succeeded: " + response);
    } catch (IOException e) {
      System.out.println("Response 1 failed: " + e);
    }

    // Copy to customize OkHttp for this request.

        StreamUtil.split(slackWebhookUrls, "[,\\s]").of(stream -> stream.filter(StringUtil::isNotBlank).forEach(url -> {
            try (CurlResponse response = Curl.post(url).header("Content-Type", "application/json").body(body).execute()) {
                if (response.getHttpStatusCode() == 200) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Sent {} to {}.", body, url);
                    }

{* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}

**FastAPI** créera l'objet de type `BackgroundTasks` pour vous et le passera comme paramètre.

## Créer une fonction de tâche

Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.

Elle peut être une fonction asynchrone (`async def`) ou une fonction normale (`def`), **FastAPI** saura la gérer correctement.

### Configuração de Plugins para OpenSearch

Execute antrun:run para baixar os plugins no diretório de plugins:

    $ mvn antrun:run

### Executar o Fess

Execute ou depure `org.codelibs.fess.FessBoot` no seu IDE, e depois acesse http://localhost:8080/

### Criar Pacote

Execute o objetivo `package` e o arquivo de lançamento será criado em target/releases.