Design (LLD) NGROK Tool - Machine Coding

11 Aug 20249 min read

Features Required:

Port Forwarding:
- Allows exposing a local server behind a NAT or firewall to the internet.
- Supports both HTTP and TCP protocols.
Dynamic DNS:
- Provides a dynamic subdomain to access the forwarded ports, which updates when the IP address changes.
Access Control:
- Restricts access to the forwarded services via authentication or IP whitelisting.
Load Balancing:
- Distributes incoming traffic across multiple local servers.
Logging and Monitoring:
- Logs incoming requests and provides monitoring capabilities for the forwarded traffic.
Secure Tunnels:
- Encrypts the data passing through the tunnel to ensure privacy and security.
Rate Limiting:
- Limits the number of requests per unit of time to prevent abuse or DoS attacks.

Design Patterns Involved:

Singleton Pattern:
- Reason: Ensures that only one instance of the NGROK service runs, managing all the tunnels and configuration.
- Implementation: A singleton class will manage all the tunnels and connections.
Factory Pattern:
- Reason: To create different types of tunnels (HTTP, TCP) based on user input dynamically.
- Implementation: A factory class will produce the appropriate tunnel object depending on the protocol.
Observer Pattern:
- Reason: For logging and monitoring features, the Observer pattern will allow different modules to react to incoming requests and connections.
- Implementation: Observers will listen to tunnel events, such as connections and data transmission.
Strategy Pattern:
- Reason: To implement different load balancing strategies (Round Robin, Least Connections, etc.).
- Implementation: The load balancer will use the strategy pattern to switch between different algorithms dynamically.
Decorator Pattern:
- Reason: For adding features like logging, access control, and encryption to tunnels without altering their structure.
- Implementation: Decorators will wrap around tunnel objects, adding extra functionality.
Builder Pattern:
- Reason: For constructing complex tunnel configurations step by step.
- Implementation: A builder will be used to configure and create a tunnel with various features like encryption, access control, etc.

Multiple Algorithms Involved:

Load Balancing Algorithms:
- Round Robin: Distributes traffic sequentially across servers.
- Least Connections: Directs traffic to the server with the fewest active connections.
- IP Hash: Routes traffic based on the client’s IP address.
Rate Limiting Algorithms:
- Token Bucket: Limits requests based on tokens that are replenished over time.
- Leaky Bucket: Ensures a constant rate of request handling, useful for smoothing bursts.
Encryption Algorithms:
- AES (Advanced Encryption Standard): For securing the data transmission through tunnels.
Logging Algorithms:
- Asynchronous Logging: Ensures that logging operations do not block the main flow of traffic.

Code Implementation (Java):

// Singleton for managing NGROK Service
class NgrokService {
    private static NgrokService instance;
    private List<Tunnel> tunnels = new ArrayList<>();

    private NgrokService() {}

    public static synchronized NgrokService getInstance() {
        if (instance == null) {
            instance = new NgrokService();
        }
        return instance;
    }

    public void addTunnel(Tunnel tunnel) {
        tunnels.add(tunnel);
        System.out.println("Tunnel added: " + tunnel.getType());
    }

    public void startAllTunnels() {
        for (Tunnel tunnel : tunnels) {
            tunnel.start();
        }
    }
}

// Factory for creating tunnels
class TunnelFactory {
    public static Tunnel createTunnel(String type, String localAddress) {
        switch (type.toUpperCase()) {
            case "HTTP":
                return new HttpTunnel(localAddress);
            case "TCP":
                return new TcpTunnel(localAddress);
            default:
                throw new IllegalArgumentException("Unknown tunnel type: " + type);
        }
    }
}

// Tunnel Interface
interface Tunnel {
    void start();
    String getType();
}

// Concrete Tunnel Implementations
class HttpTunnel implements Tunnel {
    private String localAddress;

    public HttpTunnel(String localAddress) {
        this.localAddress = localAddress;
    }

    @Override
    public void start() {
        System.out.println("Starting HTTP Tunnel on " + localAddress);
    }

    @Override
    public String getType() {
        return "HTTP";
    }
}

class TcpTunnel implements Tunnel {
    private String localAddress;

    public TcpTunnel(String localAddress) {
        this.localAddress = localAddress;
    }

    @Override
    public void start() {
        System.out.println("Starting TCP Tunnel on " + localAddress);
    }

    @Override
    public String getType() {
        return "TCP";
    }
}

// Observer for logging and monitoring
interface TunnelObserver {
    void update(Tunnel tunnel, String event);
}

class LoggingObserver implements TunnelObserver {
    @Override
    public void update(Tunnel tunnel, String event) {
        System.out.println("Logging event: " + event + " on tunnel " + tunnel.getType());
    }
}

class MonitoringObserver implements TunnelObserver {
    @Override
    public void update(Tunnel tunnel, String event) {
        System.out.println("Monitoring event: " + event + " on tunnel " + tunnel.getType());
    }
}

// Strategy for load balancing
interface LoadBalancingStrategy {
    Tunnel selectTunnel(List<Tunnel> tunnels);
}

class RoundRobinStrategy implements LoadBalancingStrategy {
    private int currentIndex = 0;

    @Override
    public Tunnel selectTunnel(List<Tunnel> tunnels) {
        Tunnel tunnel = tunnels.get(currentIndex);
        currentIndex = (currentIndex + 1) % tunnels.size();
        return tunnel;
    }
}

class LeastConnectionsStrategy implements LoadBalancingStrategy {
    @Override
    public Tunnel selectTunnel(List<Tunnel> tunnels) {
        // Simplified for this example, assume the first one is always the least connected
        return tunnels.get(0);
    }
}

// Decorator for adding features like logging, access control, etc.
abstract class TunnelDecorator implements Tunnel {
    protected Tunnel decoratedTunnel;

    public TunnelDecorator(Tunnel decoratedTunnel) {
        this.decoratedTunnel = decoratedTunnel;
    }

    @Override
    public void start() {
        decoratedTunnel.start();
    }

    @Override
    public String getType() {
        return decoratedTunnel.getType();
    }
}

class LoggingTunnelDecorator extends TunnelDecorator {
    public LoggingTunnelDecorator(Tunnel decoratedTunnel) {
        super(decoratedTunnel);
    }

    @Override
    public void start() {
        super.start();
        System.out.println("Logging enabled for tunnel: " + decoratedTunnel.getType());
    }
}

class SecureTunnelDecorator extends TunnelDecorator {
    public SecureTunnelDecorator(Tunnel decoratedTunnel) {
        super(decoratedTunnel);
    }

    @Override
    public void start() {
        super.start();
        System.out.println("Encryption enabled for tunnel: " + decoratedTunnel.getType());
    }
}

// Builder for creating complex tunnel configurations
class TunnelBuilder {
    private Tunnel tunnel;
    private boolean loggingEnabled = false;
    private boolean encryptionEnabled = false;

    public TunnelBuilder(String type, String localAddress) {
        this.tunnel = TunnelFactory.createTunnel(type, localAddress);
    }

    public TunnelBuilder enableLogging() {
        this.loggingEnabled = true;
        return this;
    }

    public TunnelBuilder enableEncryption() {
        this.encryptionEnabled = true;
        return this;
    }

    public Tunnel build() {
        if (loggingEnabled) {
            tunnel = new LoggingTunnelDecorator(tunnel);
        }
        if (encryptionEnabled) {
            tunnel = new SecureTunnelDecorator(tunnel);
        }
        return tunnel;
    }
}

// Main Application
public class NgrokApplication {
    public static void main(String[] args) {
        NgrokService ngrokService = NgrokService.getInstance();

        Tunnel httpTunnel = new TunnelBuilder("HTTP", "localhost:8080")
                                .enableLogging()
                                .enableEncryption()
                                .build();

        Tunnel tcpTunnel = new TunnelBuilder("TCP", "localhost:9090")
                                .enableLogging()
                                .build();

        ngrokService.addTunnel(httpTunnel);
        ngrokService.addTunnel(tcpTunnel);

        ngrokService.startAllTunnels();
    }
}

Explanation:

Singleton Pattern: NgrokService is implemented as a singleton to manage all tunnels centrally. This ensures there’s only one instance handling the service, avoiding conflicts.
Factory Pattern: TunnelFactory is responsible for creating tunnels of different types based on the input (HTTP or TCP). This encapsulates the creation logic and makes it easy to extend the tool with more tunnel types in the future.
Observer Pattern: The TunnelObserver interface and its implementations (LoggingObserver and MonitoringObserver) allow different parts of the system to react to tunnel events, such as starting or receiving data, facilitating logging and monitoring functionalities.
Strategy Pattern: LoadBalancingStrategy and its implementations (RoundRobinStrategy and LeastConnectionsStrategy) allow the selection of a load balancing strategy, providing flexibility to switch between algorithms as needed.
Decorator Pattern: The TunnelDecorator and its subclasses (LoggingTunnelDecorator and SecureTunnelDecorator) add extra functionalities (like logging and encryption) to the tunnel objects without modifying their core implementation. This promotes flexibility and code reuse.
Builder Pattern: The TunnelBuilder class is used to create complex tunnel configurations in a step-by-step manner, making it easier to manage multiple optional features like logging and encryption.