message-driven-gateway
Pocat

PoCAT connects everything—Platform to Connect All Things. Run a cloud-native integration stack that pairs a message bus with Enterprise Integration Patterns, declarative XML for services, deploys, and message-bus contexts, with Servit handlers shipped as jars.

deployment
# deployment root
services/<service>/service.xml
contexts/messagebus/connections/*.xml
config/services/<node>/deploy/*.xml
# Lifecycle
bin/launch.sh
# ✓ binding → inbound channel → Servit.handle
# ✓ Message channels + Servit handlers
→Serving traffic...
Architecture

PoCAT topology

A node runs one service. A messagebus binding delivers a ServitMessage to an inbound channel, Servit.handle runs that step, and an outbound channel publishes the next messagebus route.

Connectors & payloads
Protocol plugins (including the Netty-backed HTTP stacks) marshal traffic into exchanges and Messages that move through outbound channels instead of pretending there is one universal SOAP/EDI translator.
Routers & processors
Route XML descriptors wire connectors to upstream endpoints, templated responses, and asynchronous channels so heterogeneous peers can coexist.
Filters
A Servit does not run an auth or rate-limit chain before handle. A business rejection is a normal outbound message.

Platform footprint

Performance
  • • Netty-based framework
  • • Asynchronous event processing
  • • High traffic throughput
Integration
  • • Managed resources declared in XML context descriptors
  • • EIP-friendly composition for heterogeneous peers
  • • Single JVM process hosting many ServiceContainers
Messaging
  • • Message payloads & exchanges
  • • Serializers per connector/upstream
  • • Optional broker-backed channels (for example RabbitMQ)
Enterprise
  • • Modularized design
  • • Resource optimization
  • • Extensible modular libraries for new transports
Enterprise Integration

Seamless System Integration

Connect heterogeneous systems through standardized messaging and unified traffic management.

Declarative shaping

Requests are modeled as Messages and routed with XML—you extend behavior with filters, converters, Servits, and templated responses instead of leaning on hypothetical built-in converters for every legacy format.

XML
JSON
XML
REST
EDI
JSON
# Route pipeline (illustrative)
// messagebus binding delivers a ServitMessage
<channel-name>payment-requested</channel-name>
# Servit.handle, then the outbound channel
// next hop is ServitMessageChannel.publish
{
"note": "Transforms are explicit filters/templates you ship",
"config": "service.xml + deploy.xml",
"jvm": "jars in services/*/libs"
}
Enterprise Benefits

Operational runway

Ship integrations with the same toolchain you use on day one: repeatable XML, observability hooks, broker-backed channels, and disciplined deployment scripts.

Unified Integration
Centralize JDBC pools, outbound HTTP/MQTT clients, and brokers through context-managed resources reused by Servits.
Streaming Pipelines
Establish real-time streaming data pipelines for continuous data flow and processing.
High Performance
Netty-based asynchronous processing ensures optimal performance and resource utilization.
Legacy Support
Seamlessly connect legacy systems with modern APIs through message standardization.
Modular Design
Modularized architecture ensures optimal resource usage and efficient IT asset utilization.
Evolving workloads
The platform exposes flexible extension hooks for automation and Git-driven deployments when your organization layers them on.

Ready to Integrate?

Deploy PoCAT to wire APIs, infra, brokers, and device-style transports through one JVM-native integration core.