},
        "definition": "label_values(minio_node_drive_total,server)",
        "hide": 0,
        "includeAll": false,
        "label": "Server",
        "multi": false,
        "name": "server",
        "options": [],
        "query": {
          "qryType": 1,
          "query": "label_values(minio_node_drive_total,server)",
          "refId": "PrometheusVariableQueryEditor-VariableQuery"
        },

install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio ``` ### Installing certificates from third party CAs MinIO can connect to other servers, including MinIO nodes or other server types such as NATs and Redis. If these servers use certificates that were not registered with a known CA, add trust for these certificates to MinIO Server by bundling these certificates into a Kubernetes secret and providing it to Helm via the `trustedCertsSecret` value. If `.Values.tls.enabled` is `true`...

install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio ``` ### Installing certificates from third party CAs MinIO can connect to other servers, including MinIO nodes or other server types such as NATs and Redis. If these servers use certificates that were not registered with a known CA, add trust for these certificates to MinIO Server by bundling these certificates into a Kubernetes secret and providing it to Helm via the `trustedCertsSecret` value. If `.Values.tls.enabled` is `true`...

install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio ``` ### Installing certificates from third party CAs MinIO can connect to other servers, including MinIO nodes or other server types such as NATs and Redis. If these servers use certificates that were not registered with a known CA, add trust for these certificates to MinIO Server by bundling these certificates into a Kubernetes secret and providing it to Helm via the `trustedCertsSecret` value. If `.Values.tls.enabled` is `true`...

        requestWithPath.setFullUNCPath(domain, server, fullPath);

        verify(requestWithPath, times(1)).setFullUNCPath(domain, server, fullPath);

        // Test with implementation
        testImplementation.setFullUNCPath(domain, server, fullPath);
        assertEquals(domain, testImplementation.getDomain());
        assertEquals(server, testImplementation.getServer());

        .Builder()
        .heldCertificate(heldCertificate)
        .build()
    server.useHttps(serverCertificates.sslSocketFactory())
    server.enqueue(MockResponse())

    val clientCertificates =
      HandshakeCertificates
        .Builder()
        .addPlatformTrustedCertificates()
        .addInsecureHost(server.hostName)
        .build()

    val client =
      clientTestRule

        ).build()
    server.useHttps(serverHandshakeCertificates.sslSocketFactory())
    server.enqueue(MockResponse())

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()

    public static final String PROXY_HTTP = "HTTP";

    /**
     * Proxy server host
     */
    private String host;

    /**
     * Username used to access the proxy server
     */
    private String userName;

    /**
     * Password associated with the proxy server
     */
    private String password;

    /**
     * Proxy server port
     */
    private int port;

    /**

    val callB = client.newCall(Request(server.url("/")))
    callB.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
    }
  }

  private fun makeSimpleCall() {
    server.enqueue(MockResponse(body = "healthy"))
    val callB = client.newCall(Request(server.url("/")))
    callB.execute().use { response ->

    void testConstructor_NullServer() throws IOException {
        // Test case: Constructor with null server, should default to "\\\\"
        String server = null;
        int access = 123;

        doNothing().when(mockHandle).sendrecv(any(MsrpcSamrConnect4.class));

        try (SamrPolicyHandle handle = new SamrPolicyHandle(mockHandle, server, access)) {
            assertNotNull(handle);