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

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

     */
    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),

    public void access(final OptionalThing<FessUserBean> user, final String path, final String execute) {
        final Map<String, String> valueMap = new LinkedHashMap<>();
        valueMap.put("action", Action.ACCESS.name());
        valueMap.put("user", user.map(FessUserBean::getUserId).orElse("-"));
        valueMap.put("path", path);
        valueMap.put("execute", execute);
        log(valueMap);
    }

   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks
   * may execute concurrently, and listeners may execute in an order different from the one in which
   * they were registered.
   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and

   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks
   * may execute concurrently, and listeners may execute in an order different from the one in which
   * they were registered.
   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and

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

        try (CurlResponse response = ComponentUtil.getCurlHelper().get("/_configsync/file").param("fields", "path,@timestamp")
                .param("size", ComponentUtil.getFessConfig().getPageDictionaryMaxFetchSize()).execute()) {
            final Map<String, Object> contentMap = response.getContent(OpenSearchCurl.jsonParser());
            @SuppressWarnings("unchecked")

    // 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);
                    }

          // If the delegate is already done, run the execution list immediately on the current
          // thread.
          executionList.execute();
          return;
        }

        // TODO(lukes): handle RejectedExecutionException
        adapterExecutor.execute(
            () -> {
              try {
                /*
                 * Threads from our private pool are never interrupted. Threads from a