sc = objInfo.StorageClass
	}
	putOpts = minio.PutObjectOptions{
		UserMetadata:    meta,
		ContentType:     objInfo.ContentType,
		ContentEncoding: objInfo.ContentEncoding,
		Expires:         objInfo.Expires,
		StorageClass:    sc,
		Internal: minio.AdvancedPutOptions{
			SourceVersionID:    objInfo.VersionID,
			ReplicationStatus:  minio.ReplicationStatusReplica,
			SourceMTime:        objInfo.ModTime,

	// TransitionVersionID stores a version ID of the object associate
	// with the remote tier.
	TransitionVersionID string `msg:"tv"`
	// ExpireRestored indicates that the restored object is to be expired.
	ExpireRestored bool `msg:"exp"`

	// DataDir of the file
	DataDir string `msg:"dd"`

	// Indicates if this object is still in V1 format.
	XLV1 bool `msg:"v1"`

        // cid
        final String configId = crawlingConfig.getConfigId();
        if (configId != null) {
            putResultDataBody(dataMap, fessConfig.getIndexFieldConfigId(), configId);
        }
        //  expires
        if (documentExpires != null) {
            putResultDataBody(dataMap, fessConfig.getIndexFieldExpires(), documentExpires);
        }
        // segment

    }
}
```

## 9. Performance Considerations

### 9.1 Memory Management
- Lease entries should be evicted based on LRU when max leases reached
- Implement periodic cleanup of expired leases

### 9.2 Thread Safety
- Use concurrent data structures for lease storage
- Minimize lock contention in hot paths
- Async handling of lease breaks

### 9.3 Network Efficiency

            Pattern.compile("[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}", Pattern.CASE_INSENSITIVE);

    /**
     * Cache for storing resource file modification timestamps to enable cache busting.
     * The cache expires after 10 minutes and has a maximum size of 1000 entries.
     */
    private static LoadingCache<String, Long> resourceHashCache =

        response.header("Pragma", "no-cache");
        response.header("Cache-Control", "no-cache");
        response.header("Expires", "Thu, 01 Dec 1994 16:00:00 GMT");
        response.contentTypeOctetStream();
        return response.stream(out -> {
            try {
                downloadObject(getObjectName(pi.getPath(), pi.getName()), out);

                            if (!downloaded) {
                                // prevent additional checks of this artifact until it expires again
                                destination.setLastModified(System.currentTimeMillis());
                            }
                        } catch (UnsupportedOperationException e) {

                                }
                            }
                            log.debug("Session expired, trying reauth", e);
                            return reauthenticate(trans, this.targetDomain, request, response, params);
                        }
                    }
                    if (log.isTraceEnabled()) {

			// Just return the first error.
			return err
		}
		d.Policy = doc.Policy
		return nil
	}
	*d = doc
	return nil
}

// key options
type options struct {
	ttl int64 // expiry in seconds
}

type iamWatchEvent struct {
	isCreated bool // !isCreated implies a delete event.
	keyPath   string
}

// iamCache contains in-memory cache of IAM data.
type iamCache struct {

            public String getResponseFieldUrlLink() {
                return "url_link";
            }

            @Override
            public String getIndexFieldExpires() {
                return "expires";
            }

            @Override
            public String getIndexFieldParentId() {
                return "parent_id";
            }

            @Override