if (ComponentUtil.getFessConfig().isIncrementalCrawling()) {

            final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
            final long startTime = systemHelper.getCurrentTimeAsLong();

            final FessConfig fessConfig = ComponentUtil.getFessConfig();
            final CrawlingConfigHelper crawlingConfigHelper = ComponentUtil.getCrawlingConfigHelper();

Or you might have any other way to communicate with the WebSocket endpoint.

---

But for this example, we'll use a very simple HTML document with some JavaScript, all inside a long string.

This, of course, is not optimal and you wouldn't use it for production.

In production you would have one of the options above.

  // and notAfter fields in the issued certificate to determine the actual duration.
  //
  // The v1.22+ in-tree implementations of the well-known Kubernetes signers will
  // honor this field as long as the requested duration is not greater than the
  // maximum duration they will honor per the --cluster-signing-duration CLI
  // flag to the Kubernetes controller manager.
  //

      while (source!!.read(buffer, 16384) != -1L) {
      }
      source.close()
      buffer.readByteString()
    }
  }

  private fun assertFile(
    prefix: ByteString,
    upstreamSize: Long,
    metadataSize: Int,
    upstream: String?,
    metadata: ByteString?,
  ) {
    val source = file.source().buffer()
    assertThat(source.readByteString(prefix.size.toLong())).isEqualTo(prefix)

                        socket.send( out );

                        if( log.level > 3 ) {
                            log.println( request );
                            Hexdump.hexdump( log, snd_buf, 0, out.getLength() );
                        }
                    }

                    long start = System.currentTimeMillis();
                    while (timeout > 0) {

      bitCount += CODE_BIT_COUNTS[byteIn].toLong()
    }

    return ((bitCount + 7) shr 3).toInt() // Round up to an even byte.
  }

  fun decode(
    source: BufferedSource,
    byteCount: Long,
    sink: BufferedSink,
  ) {
    var node = root
    var accumulator = 0
    var accumulatorBitCount = 0
    for (i in 0 until byteCount) {
      val byteIn = source.readByte() and 0xff

    SerializedForm(Map<Class<? extends @NonNull B>, B> backingMap) {
      this.backingMap = backingMap;
    }

    Object readResolve() {
      return create(backingMap);
    }

    private static final long serialVersionUID = 0;
  }

	if err != nil {
		return 0, fmt.Errorf("query() failure for '%s': %v", query, err)
	}

	log.Debugf("executing query: %s  result:%s", query, val)

	switch v := val.(type) {
	case model.Vector:
		if v.Len() < 1 {
			log.Debugf("no values for query: %s", query)
			return 0, nil
		}

		return float64(v[0].Value), nil
	default:

   *   pinnedRoot (trusted by CertificatePinner)
   *     -> pinnedIntermediate (trusted by CertificatePinner)
   *         -> attackerSwitch
   * ```
   *
   * The attacker serves a set of certificates that yields a too-long chain in our certificate
   * pinner. The served certificates (incorrectly) formed a single chain to the pinner:
   *
   * ```
   *   attackerCa
   *     -> attackerIntermediate

    if (name.endsWith(".")) {
      name = name.substring(0, name.length() - 1);
    }

    checkArgument(name.length() <= MAX_LENGTH, "Domain name too long: '%s':", name);
    this.name = name;

    this.parts = ImmutableList.copyOf(DOT_SPLITTER.split(name));
    checkArgument(parts.size() <= MAX_PARTS, "Domain has too many parts: '%s'", name);