* @param accessKey the AWS access key
     * @param secretKey the AWS secret key
     * @param bucket the bucket name
     * @param region the AWS region
     */
    public S3StorageClient(final String endpoint, final String accessKey, final String secretKey, final String bucket,
            final String region) {
        this.bucket = bucket;

        final AwsBasicCredentials credentials = AwsBasicCredentials.create(accessKey, secretKey);

            }

            try {
                final software.amazon.awssdk.services.s3.S3ClientBuilder builder =
                        S3Client.builder().endpointOverride(URI.create(endpoint)).region(Region.of(region)).forcePathStyle(true);

                if (StringUtil.isNotBlank(accessKey) && StringUtil.isNotBlank(secretKey)) {

    
    public void cleanup() {
        // Clean up all pooled regions
        RdmaMemoryRegion region;
        
        while ((region = availableSendRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }
        
        while ((region = availableReceiveRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }

            // Set credentials
            builder.credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey, secretKey)));

            // Set region
            builder.region(Region.of(region));

            // Set path-style access (required for MinIO and other S3-compatible services)
            builder.forcePathStyle(true);

            awsS3Client = builder.build();

à
m
n
s
t
y
été
étée
étées
étés
étant
suis
es
est
sommes
êtes
sont
serai
seras
sera
serons
serez
seront
serais
serait
serions
seriez
seraient
étais
était
étions
étiez
étaient
fus
fut
fûmes
fûtes
furent
sois
soit
soyons
soyez
soient
fusse
fusses
fût
fussions
fussiez
fussent
ayant
eu

        RdmaMemoryRegion region = provider.registerMemory(buffer, access);
        assertNotNull(region, "Memory region should not be null");
        assertEquals(buffer, region.getBuffer(), "Buffer should match");
        assertEquals(1024, region.getSize(), "Size should match buffer size");
        assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ), "Should have local read access");

    /**
     * Send data using RDMA
     *
     * @param data data buffer to send
     * @param region registered memory region for the data
     * @throws IOException if send fails
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;

    /**
     * Receive data using RDMA
     *
     * @param timeout timeout in milliseconds

     */
    RdmaConnection connect(String hostname, int port) throws IOException;

    /**
     * Register memory region for RDMA operations
     *
     * @param buffer memory buffer to register
     * @param access access permissions for the memory region
     * @return registered memory region
     * @throws IOException if memory registration fails
     */

    /**
     * Create new RDMA channel info
     *
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

    /**

    /**
     * Get request type
     *
     * @return type of request
     */
    public RequestType getType() {
        return type;
    }

    /**
     * Get associated memory region
     *
     * @return memory region for this request
     */
    public RdmaMemoryRegion getMemoryRegion() {
        return memoryRegion;
    }

    /**
     * Check if request is completed
     *