export MC_HOST_sitea=http://minio:minio123@127.0.0.1:9001
export MC_HOST_siteb=http://minio:minio123@127.0.0.1:9004

./mc ready sitea
./mc ready siteb

./mc mb sitea/bucket

## Create 100 files
mkdir -p /tmp/data
for i in $(seq 1 10); do
	echo "T" >/tmp/data/file_${i}.txt
done

./mc mirror /tmp/data sitea/bucket/
./mc version enable sitea/bucket

                evictOldestLeases(1);
            }

            // Create new lease
            Smb2LeaseKey newKey = new Smb2LeaseKey();
            LeaseEntry newEntry = new LeaseEntry(newKey, path, requestedState);
            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);

            log.debug("Created new lease for path: {} with key: {}", path, newKey);
            return newKey;

 *
 * OkHttp performs best when you create a single `OkHttpClient` instance and reuse it for all of
 * your HTTP calls. This is because each client holds its own connection pool and thread pools.
 * Reusing connections and threads reduces latency and saves memory. Conversely, creating a client
 * for each request wastes resources on idle pools.
 *
 * Use `new OkHttpClient()` to create a shared instance with the default settings:
 *

import jcifs.internal.smb2.rdma.RdmaChannelInfo;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Write request message.
 *
 * This command is used to write data to a file that has been
 * previously opened with a Create request.
 *
 * @author mbechler
 */
public class Smb2WriteRequest extends ServerMessageBlock2Request<Smb2WriteResponse> implements RequestWithFileId {

    /**

        request = new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, TEST_PREVIOUS_SESSION_ID, TEST_TOKEN);
    }

    @Test
    @DisplayName("Should create request with correct parameters")
    void testConstructorSetsCorrectParameters() throws Exception {
        // Given & When
        int securityMode = 0x03;
        int capabilities = 0x0F;

  companion object {
    val factory =
      object : DeferredSocketAdapter.Factory {
        override fun matchesSocket(sslSocket: SSLSocket): Boolean = isSupported && Conscrypt.isConscrypt(sslSocket)

        override fun create(sslSocket: SSLSocket): SocketAdapter = ConscryptSocketAdapter()
      }

    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.

		kmsRouter.Methods(http.MethodGet).Path(version + "/version").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSVersionHandler)))
		// KMS Key APIs
		kmsRouter.Methods(http.MethodPost).Path(version+"/key/create").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSCreateKeyHandler))).Queries("key-id", "{key-id:.*}")

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.context.SingletonContext;

/**
 * This class now contains only utilities for config parsing.
 *
 * We strongly suggest that you create an explicit {@link jcifs.context.CIFSContextWrapper}
 * with your desired config. It's base implementation {@link jcifs.context.BaseContext}
 * should be sufficient for most needs.
 *

 */
public class CrudMode {
    /**
     * Mode for listing records.
     */
    public static final int LIST = 0;

    /**
     * Mode for creating a new record.
     */
    public static final int CREATE = 1;

    /**
     * Mode for editing an existing record.
     */
    public static final int EDIT = 2;

    /**
     * Mode for deleting a record.
     */
    public static final int DELETE = 3;

    return ImmutableMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);
    return ImmutableMultimap.copyOf(delegate).asMap();
  }