<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE components PUBLIC "-//DBFLUTE//DTD LastaDi 1.0//EN" 
	"http://dbflute.org/meta/lastadi10.dtd">
<components namespace="fessCrawler">
	<!-- Crawler Thread -->
	<component name="crawlerThread" class="org.codelibs.fess.crawler.FessCrawlerThread" instance="prototype" >
	</component>

                    break;
                }
                Thread.sleep(50);
            }
            assertEquals(CrawlerStatus.RUNNING, crawler1.crawlerContext.getStatus());
            for (int i = 0; i < 100; i++) {
                if (crawler2.crawlerContext.getStatus() == CrawlerStatus.RUNNING) {
                    break;
                }
                Thread.sleep(50);
            }

  /**
   * Checks whether {@code method} is thread-safe, as indicated by the presence of the {@link
   * AllowConcurrentEvents} annotation.
   */
  private static boolean isDeclaredThreadSafe(Method method) {
    return method.getAnnotation(AllowConcurrentEvents.class) != null;
  }

  /**
   * Subscriber that synchronizes invocations of a method to ensure that only one thread may enter
   * the method at a time.
   */

errors.could_not_delete_logged_in_user=Impossibile eliminare l'utente loggato.
errors.unauthorized_request=Richiesta non autorizzata.
errors.failed_to_print_thread_dump=Impossibile stampare il dump del thread.
errors.file_is_not_supported={0} non è supportato.
errors.plugin_file_is_not_found={0} non trovato.
errors.failed_to_install_plugin=Impossibile installare {0}.
errors.failed_to_find_plugins=Nessun plugin disponibile trovato.

     *
     * @param manager channel manager
     */
    public ChannelFailover(ChannelManager manager) {
        this.manager = manager;
        this.executor = Executors.newCachedThreadPool(r -> {
            Thread t = new Thread(r, "MultiChannelFailover");
            t.setDaemon(true);
            return t;
        });
        this.failoverStates = new ConcurrentHashMap<>();
    }

    /**
     * Handle channel failure
     *

  /**
   * Invoked when a call is canceled.
   *
   * Like all methods in this interface, this is invoked on the thread that triggered the event. But
   * while other events occur sequentially; cancels may occur concurrently with other events. For
   * example, thread A may be executing [responseBodyStart] while thread B executes [canceled].
   * Implementations must support such concurrent calls.
   *

        public void clearRules() {
            rules.clear();
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }
    }

    /**
     * Thread-safe implementation of RuleManager
     */
    public static class ThreadSafeRuleManager implements RuleManager {
        private final List<Rule> rules = new CopyOnWriteArrayList<>();

        @Override

 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.
 *
 * <p>This testing utility is not thread-safe.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public final class MinimalIterable<E extends @Nullable Object> implements Iterable<E> {

                                    BASE_RETRY_DELAY * (1L << Math.min(MAX_BACKOFF_SHIFT, getFailureCount(handle))));
                            Thread.sleep(retryDelay);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }

  }

  /**
   * Creates a TimeLimiter instance using the given executor service to execute method calls.
   *
   * <p><b>Warning:</b> using a bounded executor may be counterproductive! If the thread pool fills
   * up, any time callers spend waiting for a thread may count toward their time limit, and in this
   * case the call may even time out before the target method is ever invoked.
   *