crawler.data.env.param.key.pattern=^FESS_ENV_.*
# Whether to ignore robots.txt during crawling.
crawler.ignore.robots.txt=false
# Whether to ignore robots meta tags during crawling.
crawler.ignore.robots.tags=false
# Whether to ignore content exceptions during crawling.
crawler.ignore.content.exception=true
# HTTP status codes considered as failure URLs.
crawler.failure.url.status.codes=404

        final String ignore = configMap.get(Config.IGNORE_ROBOTS_TAGS);
        if (ignore == null) {
            if (fessConfig.isCrawlerIgnoreRobotsTags()) {
                return;
            }
        } else if (Boolean.parseBoolean(ignore)) {
            return;
        }

        // meta tag
        try {

                    this.leftCalendar.month.add(1, 'month');
            }
            this.updateCalendars();
        },

        hoverDate: function(e) {

            //ignore dates that can't be selected
            if (!$(e.target).hasClass('available')) return;

            var title = $(e.target).attr('data-title');
            var row = title.substr(1, 1);

    val socket = peer.openSocket()
    val connection =
      Http2Connection
        .Builder(true, TaskRunner.INSTANCE)
        .socket(socket.asBufferedSocket(), "peer")
        .pushObserver(IGNORE)
        .build()
    connection.start(sendConnectionPreface = false)
    socket.shutdownOutput()
    assertFailsWith<IOException> {
      connection.newStream(headerEntries("a", longString), false)
    }

                    log.debug("Session setup failed", se);
                    if (this.connectionState.compareAndSet(1, 0)) {
                        // only try to logoff if we have not completed the session setup, ignore errors from chained
                        // responses
                        logoff(true, true);
                    }
                    throw se;
                } finally {

  }

  @Test
  fun hostnameMappingLastMappedCodePoint() {
    assertThat(parse("http://\uD87E\uDE1D").host).isEqualTo("xn--pu5l")
  }

  // The java.net.IDN implementation doesn't ignore characters that it should.
  @Ignore
  @Test
  fun hostnameMappingLastIgnoredCodePoint() {
    assertThat(parse("http://ab\uDB40\uDDEFcd").host).isEqualTo("abcd")
  }

  @Test
  fun hostnameMappingLastDisallowedCodePoint() {

                }
            } catch (SmbException e) {
                // Ignore listing errors during cleanup
                log.debug("Error listing files during cleanup", e);
            }
        }

        try {
            file.delete();
        } catch (SmbException e) {
            // Ignore deletion errors during cleanup
            log.debug("Error deleting file during cleanup", e);

                t.printStackTrace(pw);
                pw.flush();
                buf.append(" [ ").append(sw.toString()).append(" ]");
            } catch (final IOException ignore) {}
            return buf.toString();
        };
        final String message;
        if (Constants.TRUE.equalsIgnoreCase(ComponentUtil.getFessConfig().getApiJsonResponseExceptionIncluded())) {

   * simply use the standard method-chaining idiom, as illustrated in the documentation at top,
   * configuring a {@code CacheBuilder} and building your {@link Cache} all in a single statement.
   *
   * <p><b>Warning:</b> if you ignore the above advice, and use this {@code CacheBuilder} to build a
   * cache whose key or value type is incompatible with the weigher, you will likely experience a

        final String value = getSystemProperty(key);
        if (value != null) {
            try {
                return Integer.parseInt(value);
            } catch (final NumberFormatException e) {
                // ignore
            }
        }
        return defaultValue;
    }

    default void setSystemPropertyAsInt(final String key, final int value) {
        setSystemProperty(key, Integer.toString(value));
    }