ergo-services/ergo

Features

• Erlang Distribution Protocol Implementations - Implements the Erlang DIST protocol and Term Format for transparent messaging between Go and Erlang/OTP nodes.
• Distributed Actor Frameworks - Building resilient, concurrent applications using the actor model with isolated processes and asynchronous message passing.
• Distributed Node Registrars - Ergo retrieves connection parameters from a registrar service and uses them to establish links between nodes.
• Topology-Agnostic Deployments - Ergo runs the same application code as a monolith or distributed across nodes by changing only the entry point configuration.
• Process Spawning - Creates lightweight actor processes in their own goroutines with priority-ordered mailboxes for concurrent message handling.
• Meta-Process Spawnings - Launches processes with two goroutines to separate blocking I/O from sequential message handling.
• Erlang Term Format Encoding - Ergo converts Go data types to and from the Erlang Term Format (ETF) for network transmission.
• Message Callback Handlings - Implements message and call handlers via a high-level actor abstraction that hides mailbox mechanics.
• Actor Startup Sequences - Ergo launches the listed actors sequentially, registering named ones for discovery, and aborts the group if any single process fails to start.
• Actor Pool Routers - Ergo routes incoming messages and requests to one of several identical worker actors, automatically balancing load and handling worker lifecycle.
• Priority Mailboxes - Implements priority-ordered mailboxes with four queues per actor process for urgent system messages.
• Cluster Membership Coordination - Ergo notifies actors when peers join or leave the cluster, and supports dynamic peer addition via a Join method.
• Registrar-Based Node Discoveries - Ergo finds other nodes using a local registrar or a centralized registry service like etcd.
• Distributed Leader Election - Ergo elects a single leader among distributed actor instances using a consensus protocol, with automatic failover and heartbeat-based health checks.
• Quorum-Based Elections - Elects a single leader among distributed nodes using a Raft-inspired consensus protocol with automatic failover.
• Restart Strategies - Chooses whether to restart only the failed child, all children, or children in dependency order based on their relationships.
• Supervised Process Restarts - Monitors child processes and automatically restarts them when they crash using configurable restart strategies.
• Automatic Worker Replacement - Automatically detects worker crashes and spawns replacement actors to maintain processing capacity.
• Actor Management - Provides an actor model framework for spawning and managing concurrent actors with lifecycle control.
• Actor Message Handlings - Processes messages from priority-ordered mailboxes via callbacks that receive the sender and message.
• Split-Brain Prevention Mechanisms - Ergo ensures only one leader exists per term by requiring a majority vote, preventing split-brain scenarios during network partitions.
• Raft Consensus Implementations - Provides a Raft-inspired consensus protocol for leader election and automatic failover across distributed nodes.
• Node Handshake Implementations - Ergo executes the Erlang node handshake protocol to authenticate and establish connections between nodes.
• Erlang Distribution Protocols - Implements the Erlang DIST protocol for transparent messaging between Go and Erlang/OTP nodes.
• Erlang Port Mapper Daemon Registrations - Ergo registers a node with the Erlang Port Mapper Daemon so other nodes can discover and connect to it.
• Location-Transparent Message Transmission - Ergo delivers messages to processes on the same or remote nodes using identical code, with automatic connection management and message encoding.
• Message Passing - Exchanges data between isolated processes through asynchronous messages and synchronous request-response patterns.
• Message Routing - Delivers messages directly to local mailboxes or establishes network connections for remote delivery, hiding distribution complexity.
• TCP Connection Pooling - Ergo creates TCP connection pools between nodes, negotiating protocol version and compression during handshake.
• Server-Sent Events - Streams unidirectional server-to-client updates over HTTP using SSE with each connection as an addressable actor.
• Typed SSE Event Dispatchers - Ergo sends structured events with optional event type, data, message ID, and retry hint to a specific SSE connection or broadcasts to all connections.
• Process Lifecycle Managers - Ergo transitions a process through init, sleep, running, and terminated states, with automatic cleanup of resources on exit.
• Blocking I/O Offloading - Spawns each actor with two goroutines for blocking I/O and sequential message handling to prevent actor freezing.
• Actor Name Registries - Ergo registers actors under symbolic names so they can be reached without knowing their runtime identifier.
• Actor Name Registrations - Ergo maps human-readable names to process identifiers so well-known services can be addressed without tracking dynamic PIDs.
• Supervision Trees - Organizes processes into hierarchical supervision trees that automatically detect crashes and restart workers.
• Distributed Orchestration Platforms - Manages actor lifecycles, supervision trees, and transparent message routing across a cluster of nodes.
• Distributed Service Coordination - Managing cluster membership, leader election, and service discovery across multiple nodes for coordinated application deployment.
• Supervision Recovery Strategies - Organizes actors into supervision hierarchies with configurable restart strategies for automatic crash recovery.
• Message Versioning - Ergo creates a new Go type for each version of a message so that old and new nodes can coexist during a rolling upgrade.
• Distributed Node Lifecycles - Ergo starts, stops, and configures a node instance, including application management and network settings.
• Actor Node Lifecycles - Ergo starts and controls a node, spawning processes, managing applications, and configuring networking from any goroutine.
• Application Grouping - Groups related actors into a single unit with defined startup order, lifecycle management, and fault-tolerance rules.
• Nested Supervisor Hierarchies - Nests supervisors as children of other supervisors to form a tree where each level manages its own recovery scope.
• Actor Request-Reply Patterns - Ergo responds to a blocking caller by returning a result from a callback, with separate channels for transport and application errors.
• OTP-Style Supervision Trees - Automatically detecting and restarting failed processes using OTP-style supervision trees with configurable recovery strategies.
• Crontab-Based Schedulers - Schedules recurring jobs using crontab syntax with automatic timezone and daylight saving handling.
• Process Termination - Stops processes gracefully by returning an error from the handler, running cleanup callbacks, and freeing resources.
• Meta-Process Lifecycle Cascades - Ergo automatically stops all meta-processes when their owning process exits, keeping the supervision tree clean.
• Deferred Response Processing - Defers synchronous request replies by returning nil from the callback and later sending the response via a request reference.
• External Event Ingestions - Reads data from blocking sources in an external reader and sends it as messages to actors.
• Message Visibility Levels - Enforces message visibility levels to control which actors can send, receive, or serialize specific message types.
• High-Priority Pool Interceptions - Handles urgent system-level messages directly in the pool actor rather than forwarding them to workers.
• Process Identifiers - Ergo assigns each process a unique PID containing node name, sequential ID, and creation timestamp to detect node restarts.
• Cross-Stack Type Contracts - Defines cross-application message contracts in a separate types package for decoupled data exchange.
• Remote Application Restart Policies - Ergo specifies whether a remotely started application restarts on failure by choosing Temporary, Transient, or Permanent behavior.
• Termination Policies - Sets a mode controlling whether the application stops on any process exit, only abnormal exits, or continues until all finish.
• Module Dependency Declarations - Ensures that required applications or services are running before starting the current application.
• Remote Reference Staleness Detections - Ergo compares creation timestamps on every remote operation to prevent sending messages to restarted nodes.
• Leader Election Event Handlers - Ergo triggers application-defined callbacks when a node becomes leader or follower, allowing custom logic for each state.
• Graceful Shutdowns - Ergo sends exit signals to all processes and waits for cleanup, or kills them immediately without waiting.
• Application Shutdown Lifecycles - Stops the entire application when a process terminates abnormally or normally, based on the configured mode.
• Leader Status Inspections - Ergo provides methods to check if the current process is the leader, retrieve the leader's PID, and inspect the current election term.
• Actor-Based Application Units - Organizes code into independent applications with their own actors, supervision trees, and message contracts.
• Dynamic Pool Scalings - Adds or removes worker actors at runtime to adjust processing capacity without restarting the pool.
• Publish-Subscribe Messaging - Sends messages to all subscribers of a registered event, with the event producer explicitly publishing each message.
• Cross-Application Event Pub-Sub - Ergo broadcasts typed events from one application and lets other applications subscribe to them without knowing the publisher's location.
• Actor-Driven SSE Push - Ergo allows backend actors to push formatted SSE events to connected clients at any time through the actor message system.
• Remote Delivery Failure Detection - Ergo provides immediate error notification for missing remote processes when using the Important delivery flag, matching local failure semantics.
• Cluster Peer Broadcasting - Ergo sends a message to all discovered peers or bootstrap peers, enabling state dissemination across the cluster.
• Connection Lifecycle Management - Handles connection establishment, heartbeat keep-alives, and cleanup with actor notifications on connect and disconnect.
• External Resource Writes - Receives commands from actors and writes to external resources like sockets or processes.
• Remote Application Launches - Ergo launches a loaded but inactive application on another cluster node, running it under that node's supervision tree.
• SSE Sources - Establishes client-side SSE connections to external servers, reading and parsing events for actor delivery.
• Cluster-Wide SSE Addressing - Ergo sends events to any SSE connection from any node in the cluster using its alias, enabling distributed push notifications.
• SSE Connection Lifecycle Events - Ergo receives connect, disconnect, and reconnection messages for each SSE connection, enabling tracking and cleanup of client state.
• Meta-Process Connection Acceptances - Accepts incoming network connections in the external reader and spawns child meta-processes to handle each one.
• Actor Exit Signal Trapping - Converts exit signals from linked processes into regular messages so actors can handle failures without terminating.
• Graceful Actor Terminations - Stops actors gracefully by returning a termination reason from a handler and running cleanup callbacks.
• Blocking I/O Message Sends - Lets the blocking I/O goroutine push events into the actor system without blocking the message handler.
• Client Certificate Authentication - Verifies client certificates against a CA pool for mutual TLS authentication of connections.
• Cluster Communication Security - Authenticates and encrypts cluster-internal communication using mutual TLS with configurable certificate management.
• Temporary Process Aliases - Ergo generates multiple temporary identifiers for a single process to support flexible addressing patterns like request-response.
• Event Subscribers - Receives high-priority event messages for cross-cutting concerns like configuration changes or cache invalidation.
• Topology-Agnostic Decompositions - Ergo splits a single application into separate packages and creates new entry points without changing any application code.
• Lock-Free - Queues log messages in a lock-free MPSC queue and writes them in a background goroutine so actors never block on disk I/O.
• Process Pools - Generates a pool of worker processes with configurable size for concurrent task execution via CLI scaffolding.
• Address-Type Message Routings - Ships a message routing system that dispatches to different callbacks based on the address type of the recipient.
• Asynchronous Logging - Ergo queues log messages in a lock-free MPSC queue and writes them in a background goroutine, so actors never block on disk I/O.
• Custom Metric Collectors - Registers custom Prometheus collectors updated via periodic callbacks or event-driven message handling.
• Real-Time Node Health Monitors - Displays live graphs of process count, running processes, and memory usage over the last 60 seconds.
• Centralized Logging Architectures - Centralizes log distribution from all sources through a single subsystem with severity-based fan-out.
• Node and Process Inspectors - Ships a web-based inspector for examining nodes, network stacks, applications, and all active processes.
• Node Status Web Interfaces - Opens a web interface displaying node status, network activity, and all running processes.
• Process State Inspection - Views internal state of any process or meta-process running on the node through a web interface.
• Prometheus System Metrics Exporters - Collects and exposes runtime metrics, process statistics, and application telemetry in Prometheus format.
• System Telemetry Collectors - Ergo automatically gathers process counts, memory usage, CPU time, and network traffic across the actor system.
• Actor Test Sandboxing - Tests individual actors and full applications in isolated environments, including multi-node distributed scenarios.
• Shared Message Contracts - Places inter-application message types in a shared package so applications communicate without compile-time dependencies.
• Private Service Contracts - Ergo defines private messages for direct service-to-service communication where the receiver owns the contract.
• Developer Tools - Actor-based framework with network transparency.

Star history