@Test
    public void testRdmaProviderSelectionAlwaysReturnsProvider() {
        // This should always return at least the TCP fallback provider
        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();
        assertNotNull(provider, "Should always select an RDMA provider (at minimum TCP fallback)");
        assertNotNull(provider.getProviderName(), "Provider name should not be null");

	"gorm.io/driver/postgres"
	"gorm.io/driver/sqlite"
	"gorm.io/driver/sqlserver"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	. "gorm.io/gorm/utils/tests"
)

var DB *gorm.DB
var (
	mysqlDSN     = "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local"
	postgresDSN  = "user=gorm password=gorm dbname=gorm host=localhost port=9920 sslmode=disable TimeZone=Asia/Shanghai"

      with:
        path: ~/go/pkg/mod
        key: ${{ runner.os }}-go-${{ matrix.go }}-${{ hashFiles('tests/go.mod') }}

    - name: Tests
      run: GITHUB_ACTION=true GORM_DIALECT=mysql GORM_DSN="gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True" ./tests/tests_all.sh

  mariadb:
    strategy:
      matrix:
        dbversion: [ 'mariadb:latest' ]
        go: ['1.23', '1.24']
        platform: [ ubuntu-latest ]

Added context aware dial functions for TCP, UDP, IP and Unix networks....

Después de esto, el cliente y el servidor tienen una **conexión TCP encriptada**, esto es lo que proporciona TLS. Y luego pueden usar esa conexión para iniciar la comunicación **HTTP real**.

Y eso es lo que es **HTTPS**, es simplemente HTTP simple **dentro de una conexión TLS segura** en lugar de una conexión TCP pura (sin encriptar).

/// tip | Consejo

        // Runtime exceptions and other errors are likely not recoverable
        return false;
    }

    /**
     * Check if error suggests fallback to TCP is needed
     *
     * @param error the error to check
     * @return true if TCP fallback is recommended
     */
    public boolean shouldFallbackToTcp(Exception error) {
        // Hardware errors suggest RDMA is not working

    * Ils expirent.
    * Puis ils doivent être renouvelés et acquis à nouveau auprès de la tierce partie.
* Le cryptage de la connexion se fait au niveau du protocole TCP.
    * C'est une couche en dessous de HTTP.
    * Donc, le certificat et le traitement du cryptage sont faits avant HTTP.
* TCP ne connaît pas les "domaines", seulement les adresses IP.
    * L'information sur le domaine spécifique demandé se trouve dans les données HTTP.

        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

        if (connectResult.isSuccess) {
          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

          // Finish connecting. We won't have to if the winner is from the connection pool.

# Reduce CPU utilization
net.ipv4.tcp_timestamps=0

# Increase throughput
net.ipv4.tcp_sack=1

# Low latency mode for TCP
net.ipv4.tcp_low_latency=1

# The following variable is used to tell the kernel how 
# much of the socket buffer space should be used for TCP 
# window size, and how much to save for an application buffer.
net.ipv4.tcp_adv_win_scale=1

# disable RFC2861 behavior

import java.net.SocketAddress;
import jnr.unixsocket.UnixSocket;
import jnr.unixsocket.UnixSocketAddress;
import jnr.unixsocket.UnixSocketChannel;

/**
 * Subtype UNIX socket for a higher-fidelity impersonation of TCP sockets. This is named "tunneling"
 * because it assumes the ultimate destination has a hostname and port.
 */
final class TunnelingUnixSocket extends UnixSocket {
  private final File path;