Event Gateways - Gateway Types

package com.example.gateway;

import coldfusion.eventgateway.*;
import java.util.Map;

/**
 * Custom event gateway for processing webhook events
 */
public class WebhookGateway implements Gateway {

  private String gatewayID;
  private GatewayServices gatewayServices;
  private int listenPort = 8080;
  private WebhookServer server;

  /**
   * Initialize the gateway
   */
  public void setGatewayID(String id) {
    this.gatewayID = id;
  }

  /**
   * Receive gateway services from ColdFusion
   */
  public void setGatewayServices(GatewayServices services) {
    this.gatewayServices = services;
  }

  /**
   * Start the gateway
   */
  public void start() throws GatewayException {
    try {
      // Read configuration
      Map config = gatewayServices.getGatewayConfiguration(gatewayID);
      if (config.containsKey("port")) {
        listenPort = Integer.parseInt((String)config.get("port"));
      }

      // Start webhook server
      server = new WebhookServer(listenPort);
      server.setMessageHandler(new MessageHandler() {
        public void handleMessage(String payload) {
          processIncomingWebhook(payload);
        }
      });

      server.start();

      gatewayServices.info(gatewayID,
        "Webhook gateway started on port " + listenPort);

    } catch (Exception e) {
      throw new GatewayException("Failed to start gateway: " + e.getMessage());
    }
  }

  /**
   * Stop the gateway
   */
  public void stop() throws GatewayException {
    try {
      if (server != null) {
        server.stop();
      }
      gatewayServices.info(gatewayID, "Webhook gateway stopped");
    } catch (Exception e) {
      throw new GatewayException("Failed to stop gateway: " + e.getMessage());
    }
  }

  /**
   * Handle outgoing messages from ColdFusion
   */
  public String outgoingMessage(CFEvent event) {
    Map data = event.getData();

    // Process outgoing webhook
    String url = (String)data.get("url");
    String payload = (String)data.get("payload");

    try {
      // Send HTTP request
      sendWebhook(url, payload);
      return "success";
    } catch (Exception e) {
      gatewayServices.error(gatewayID,
        "Error sending webhook: " + e.getMessage());
      return "error: " + e.getMessage();
    }
  }

  /**
   * Process incoming webhook
   */
  private void processIncomingWebhook(String payload) {
    // Create event data
    Map<String, String> data = new HashMap<>();
    data.put("payload", payload);
    data.put("timestamp", String.valueOf(System.currentTimeMillis()));

    // Create CF event
    CFEvent event = new CFEvent(gatewayID);
    event.setData(data);

    // Route to CFC
    boolean success = gatewayServices.addEvent(event);

    if (!success) {
      gatewayServices.warning(gatewayID,
        "Failed to route webhook event to CFC");
    }
  }

  /**
   * Send outgoing webhook
   */
  private void sendWebhook(String url, String payload)
      throws Exception {
    // HTTP client implementation
    // ... webhook sending logic ...
  }
}

# webhook.cfg - Gateway configuration file

# HTTP server port
port=8080

# Timeout for outgoing webhooks (milliseconds)
timeout=30000

# Retry attempts for failed webhooks
retryAttempts=3

# Security token for incoming webhooks
securityToken=your-secret-token-here

# Enable SSL/TLS
useSSL=false

# SSL certificate path (if useSSL=true)
# sslCertPath=/path/to/certificate.jks

# SSL certificate password
# sslCertPassword=password