Python SDK

pip install git+https://gitlab.com/molo17-public/gluesync/gluesync-python-corehub-handshake-sdk.git

import asyncio
from gluesync_sdk import GluesyncClient

async def main():
    # Initialize the client with CoreHub address and license file path
    # For fixed address:
    client = GluesyncClient(
        host="localhost",
        port=1717,
        license_file_path="/path/to/gs-license.dat",
        module_tag="my-module",
        use_ssl=True,  # Enable SSL/TLS
        verify_ssl=False  # Disable SSL certificate verification
    )

    # Or use UDP autodiscovery (set host to None)
    # client = GluesyncClient(
    #    host=None,  # Will use UDP autodiscovery to find CoreHub
    #    port=1717,
    #    license_file_path="/path/to/gs-license.dat",
    #    module_tag="my-module",
    #    use_ssl=True,  # Enable SSL/TLS
    #    verify_ssl=False  # Disable SSL certificate verification
    # )

    # Connect to CoreHub
    await client.connect()

    # The JWT token for API requests is available after connection
    jwt_token = client.token
    print(f"Connected with token: {jwt_token}")

    # Do your work here

    # Disconnect when done
    await client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from gluesync_sdk import GluesyncClient

async def on_connected(token):
    print(f"Connected! Received token: {token}")

async def on_disconnected(reason):
    print(f"Disconnected: {reason}")

async def on_error(error):
    print(f"Error: {error}")

async def main():
    client = GluesyncClient(
        host="localhost",
        port=1717,
        license_file_path="/path/to/gs-license.dat",
        module_tag="my-module"
    )

    # Set up event handlers
    client.on_connected = on_connected
    client.on_disconnected = on_disconnected
    client.on_error = on_error

    await client.connect()

    # Keep the connection alive for some time
    await asyncio.sleep(3600)  # 1 hour

    await client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from gluesync_sdk import GluesyncClient

# Reconnection settings
MAX_RECONNECT_ATTEMPTS = 5
RECONNECT_DELAY = 2.0  # Base delay in seconds
reconnecting = False

async def on_disconnected(reason):
    """Handle disconnection and trigger reconnection"""
    global reconnecting
    print(f"Disconnected: {reason}")

    if not reconnecting:
        reconnecting = True
        asyncio.create_task(attempt_reconnect())

async def attempt_reconnect():
    """Attempt to reconnect with exponential backoff"""
    global client, reconnecting
    attempt = 0

    while reconnecting and (attempt < MAX_RECONNECT_ATTEMPTS):
        attempt += 1
        delay = min(RECONNECT_DELAY * (2 ** (attempt - 1)), 30)  # Exponential backoff

        print(f"Reconnecting in {delay:.1f} seconds (attempt {attempt}/{MAX_RECONNECT_ATTEMPTS})")
        await asyncio.sleep(delay)

        try:
            await client.connect()
            print("Reconnected successfully!")
            reconnecting = False
            break
        except Exception as e:
            print(f"Reconnection failed: {e}")

    if reconnecting:
        print(f"Failed to reconnect after {MAX_RECONNECT_ATTEMPTS} attempts")
        reconnecting = False

async def main():
    global client

    client = GluesyncClient(
        host=None,  # Use autodiscovery
        license_file_path="/path/to/gs-license.dat",
        module_tag="resilient-module"
    )

    # Register the disconnection handler
    client.on_disconnected = on_disconnected

    try:
        await client.connect()
        print(f"Connected with token: {client.token[:10]}...")

        # Keep the application running
        while True:
            await asyncio.sleep(1)

    except KeyboardInterrupt:
        await client.disconnect()
        print("Disconnected")

import asyncio
from gluesync_sdk import GluesyncClient
from gluesync_sdk.exceptions import GluesyncAuthenticationError, GluesyncLicenseError

async def main():
    try:
        client = GluesyncClient(
            host="localhost",
            port=1717,
            license_file_path="/path/to/gs-license.dat",
            module_tag="my-module"
        )

        await client.connect()
        # ...

    except GluesyncAuthenticationError as e:
        print(f"Authentication failed: {e}")
    except GluesyncLicenseError as e:
        print(f"License error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")

if __name__ == "__main__":
    asyncio.run(main())