01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyEnd: byteCount=128
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] connectionReleased
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] callEnd
01-01 12:53:32.816 10999 11090 D OkHttp  : [54 ms] responseHeadersStart

/**
 * Represents the FILE_FS_FULL_SIZE_INFORMATION structure used to query comprehensive file system size information.
 * This structure provides complete allocation details including total allocation units, caller-available free units,
 * actual free allocation units, sectors per allocation unit, and bytes per sector.
 */
public class FileFsFullSizeInformation implements AllocInfo, FileSystemInformation, Decodable {

    val call = client.newCall(request)
    val response =
      Response
        .Builder()
        .request(request)
        .code(200)
        .message("")
        .protocol(Protocol.HTTP_2)
        .build()
    val listener = loggingEventListenerFactory.create(call)
    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)

        }

        try {
            // Create SmbFile with cached attributes
            SmbFile file = new SmbFile(filePath, context);
            // Note: We would need to add a method to SmbFile to set cached attributes
            // For now, just return the file object
            return file;
        } catch (Exception e) {
            log.warn("Failed to create SmbFile for {}: {}", filePath, e.getMessage());

 *
 * Other exception types cancel the current call:
 *
 *  * For synchronous calls made with [Call.execute], the exception is propagated to the caller.
 *
 *  * For asynchronous calls made with [Call.enqueue], an [IOException] is propagated to the caller
 *    indicating that the call was canceled. The interceptor's exception is delivered to the current

import org.lastaflute.web.Execute;
import org.lastaflute.web.response.ActionResponse;
import org.lastaflute.web.response.StreamResponse;

/**
 * Action class for handling cached document content requests.
 * Provides functionality to retrieve and display cached versions of crawled documents.
 */
public class CacheAction extends FessSearchAction {

    /**
     * Creates a new instance of CacheAction.
     */
    public CacheAction() {

    call: Call,
    ioe: IOException,
  ) = logEvent(ResponseFailed(System.nanoTime(), call, ioe))

  override fun callEnd(call: Call) = logEvent(CallEnd(System.nanoTime(), call))

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) = logEvent(CallFailed(System.nanoTime(), call, ioe))

  override fun canceled(call: Call) = logEvent(Canceled(System.nanoTime(), call))

    }

    @Override public void callEnd(Call call) {
      printEvent("callEnd");
    }

    @Override public void callFailed(Call call, IOException ioe) {
      printEvent("callFailed");
    }

    @Override public void canceled(Call call) {
      printEvent("canceled");
    }
  }

 *
 * <p>Generally, implementations don't support {@link #put} and {@link #putAll} because there is no
 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *

 *
 * <p>Generally, implementations don't support {@link #put} and {@link #putAll} because there is no
 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *