Configuration

The GQLDB Python driver uses GqldbConfig for client configuration. You can create configurations directly or use the ConfigBuilder for a fluent interface.

GqldbConfig

Direct Configuration

Python
from gqldb import GqldbConfig

config = GqldbConfig(
    hosts=["192.168.1.100:9000"],
    username="admin",
    password="password",
    default_graph="myGraph",
    timeout=30
)

Configuration Options

ConfigBuilder

The ConfigBuilder provides a fluent interface for creating configurations:

Python
from gqldb.config import ConfigBuilder

config = (ConfigBuilder()
    .hosts("192.168.1.100:9000", "192.168.1.101:9000")
    .username("admin")
    .password("password")
    .default_graph("myGraph")
    .timeout(60)
    .max_recv_size(128 * 1024 * 1024)  # 128MB
    .pool_size(20)
    .health_check_interval(15.0)
    .retry_count(5)
    .retry_delay(0.5)
    .build())

Builder Methods

SSL/TLS Configuration

Using create_ssl_context

Python
from gqldb import GqldbConfig
from gqldb.config import create_ssl_context

# Create SSL context with certificates
ssl_ctx = create_ssl_context(
    cert_file="/path/to/client.crt",
    key_file="/path/to/client.key",
    ca_file="/path/to/ca.crt",
    verify=True
)

config = GqldbConfig(
    hosts=["192.168.1.100:9000"],
    ssl_context=ssl_ctx
)

SSL Context Options

Disabling Certificate Verification

Python
# For development/testing only
ssl_ctx = create_ssl_context(verify=False)

config = GqldbConfig(
    hosts=["192.168.1.100:9000"],
    ssl_context=ssl_ctx
)

Using Custom SSL Context

Python
import ssl

# Create custom SSL context
ssl_ctx = ssl.create_default_context()
ssl_ctx.load_cert_chain("/path/to/client.crt", "/path/to/client.key")
ssl_ctx.load_verify_locations("/path/to/ca.crt")

config = GqldbConfig(
    hosts=["192.168.1.100:9000"],
    ssl_context=ssl_ctx
)

Multiple Hosts

Configure multiple hosts for high availability:

Python
config = GqldbConfig(
    hosts=[
        "192.168.1.100:9000",
        "192.168.1.101:9000",
        "192.168.1.102:9000"
    ],
    retry_count=3,
    retry_delay=0.5
)

Configuration Validation

The configuration is validated when calling build() on ConfigBuilder or when creating a GqldbClient:

Python
from gqldb import GqldbConfig

# This will raise ValueError
try:
    config = GqldbConfig(hosts=[])  # Empty hosts
    config.validate()
except ValueError as e:
    print(f"Invalid config: {e}")

# Manual validation
config = GqldbConfig(hosts=["192.168.1.100:9000"])
config.validate()  # Raises ValueError if invalid

Complete Example

Python
from gqldb import GqldbClient, GqldbConfig
from gqldb.config import ConfigBuilder, create_ssl_context

def create_production_config():
    """Create configuration for production environment."""
    ssl_ctx = create_ssl_context(
        cert_file="/etc/gqldb/client.crt",
        key_file="/etc/gqldb/client.key",
        ca_file="/etc/gqldb/ca.crt"
    )

    return (ConfigBuilder()
        .hosts(
            "gqldb-1.prod.example.com:9000",
            "gqldb-2.prod.example.com:9000",
            "gqldb-3.prod.example.com:9000"
        )
        .ssl(ssl_ctx)
        .timeout(60)
        .pool_size(50)
        .retry_count(5)
        .retry_delay(1.0)
        .health_check_interval(10.0)
        .build())

def create_development_config():
    """Create configuration for development environment."""
    return GqldbConfig(
        hosts=["192.168.1.100:9000"],
        timeout=30,
        pool_size=5
    )

# Usage
import os

if os.environ.get("ENV") == "production":
    config = create_production_config()
else:
    config = create_development_config()

with GqldbClient(config) as client:
    client.login("admin", "password")
    # ... use the client