private final HashCode buildCacheKey;
    private final Duration executionTime;

    public OriginMetadata(String buildInvocationId, HashCode buildCacheKey, Duration executionTime) {
        this.buildInvocationId = buildInvocationId;
        this.buildCacheKey = buildCacheKey;
        this.executionTime = executionTime;
    }

    public String getBuildInvocationId() {
        return buildInvocationId;
    }

        controller.store(key, cacheableEntity, snapshots, executionTime)

        then:
        noExceptionThrown()

        and:
        1 * local.storeLocally(key, _)
    }

    def "does not store to local if local push is disabled"() {
        given:
        localPush = false

        when:
        controller.store(key, cacheableEntity, snapshots, executionTime)

        then:

    @Override
    public Integer getExecutionTime() {
        return executionTime;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * org.codelibs.fess.crawler.entity.AccessResult#setExecutionTime(java.lang.Integer)
     */
    @Override
    public void setExecutionTime(final Integer executionTime) {
        this.executionTime = executionTime;
    }

    @Override
    public Long getContentLength() {

            builder.field(MIME_TYPE, mimeType);
        }
        if (createTime != null) {
            builder.field(CREATE_TIME, createTime);
        }
        if (executionTime != null) {
            builder.field(EXECUTION_TIME, executionTime);
        }
        if (contentLength != null) {
            builder.field(CONTENT_LENGTH, contentLength);
        }
        if (lastModified != null) {

    public void setSessionId(final String sessionId) {
        this.sessionId = sessionId;
    }

    public long getExecutionTime() {
        return executionTime;
    }

    public void setExecutionTime(final long executionTime) {
        this.executionTime = executionTime;
    }

    public String getRedirectLocation() {
        return redirectLocation;
    }

                                executionTime: executionTime
                            ]
                        } else {
                            assert executionTime == null
                            assert originBuildCacheKey == null
                        }
                        origins[buildOperation.details.task.getIdentityPath()] = entry
                    }
                }

        String buildInvocationId = decoder.readString();
        HashCode buildCacheKey = hashCodeSerializer.read(decoder);
        Duration executionTime = Duration.ofMillis(decoder.readSmallLong());
        return new OriginMetadata(
            buildInvocationId,
            buildCacheKey,
            executionTime
        );
    }

    @Override
    public void write(Encoder encoder, OriginMetadata originMetadata) throws IOException {

      },
      "mimeType": {
        "type": "keyword"
      },
      "sessionId": {
        "type": "keyword"
      },
      "url": {
        "type": "keyword"
      },
      "executionTime": {
        "type": "long"
      },
      "createTime": {
        "type": "long"
      },
      "accessResultData": {
        "properties": {
          "transformerName": {
            "type": "keyword"

        if (!local.canStore() && !remote.canStore()) {
            return;
        }
        tmp.withTempFile(((BuildCacheKeyInternal) key).getHashCodeInternal(), file -> {
            packExecutor.pack(file, key, entity, snapshots, executionTime);
            remote.maybeStore(key, file);
            local.maybeStore(key, file);

    Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity);

    void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime);