DOCSEARCHbyAlgolia
Submit Docs

Rama

repository·main·Indexed 22 days ago

https://github.com/plabayo/rama

A modular, explicit service framework for Rust designed for building programmable network services such as proxies, HTTP clients, and servers. Built on Tokio, Rama provides a composable stack of transports, protocols, and middleware. It includes specialized support for gRPC, ttRPC, WebSockets, and TLS (via Rustls and BoringSSL), as well as Apple-optimized telemetry and XPC service implementations.

Tokens
165K
Snippets
363
Records
800
Agent score
75%

What's inside rama

  1. Overview of rama-http-core

    main

    The rama-http-core crate provides the HTTP protocol implementation and low-level utilities for the Rama framework. It is a fork of hyper and hyper-util designed to allow for greater low-level control and the ability to deviate from RFCs where necessary for Rama's specific networking requirements.

    This crate serves as the foundation for:

    • rama-http-backend
    • The main rama crate

    It is intended for use by authors of Rama's HTTP-related crates and end-users of the rama framework.

  2. Overview of rama-dns

    main
    The rama-dns crate provides DNS support for the Rama modular service framework. It is designed to allow users to move and transform network packets specifically for DNS protocols within the Rama ecosystem. This crate is primarily intended to be used by the end-user rama crate.

  3. Overview of rama-utils

    main
    The rama-utils crate provides a collection of shared utilities used across the Rama ecosystem. These utilities are designed to be modular and are not strictly tied to a single specific Rama crate, making them available for use by various components within the framework or by other crates that require common Rama-related helper functions.

  4. Introduction to Rama

    main
    rama® is a modular service framework for the Rust language designed for building network clients, servers, proxies, and combinations thereof. Unlike frameworks that rely on hidden configuration or magic, Rama is intentionally explicit: you compose your network stack from services, layers, transports, protocols, and state directly in your code. This makes the system's architecture visible and provides fine-grained control over how traffic enters, is decoded, inspected, transformed, and routed. It is built on a Tokio-native foundation and is suitable for high-performance proxies, security analysis tools, web services, and custom network emulators.

  5. Overview of rama-tls

    main
    The rama-tls crate provides TLS-agnostic types and utilities for the Rama framework. It is designed to support the modular service framework's ability to move and transform network packets. This crate is primarily used as a dependency by the main rama crate to provide TLS capabilities.

  6. Overview of rama-net

    main

    The rama-net crate provides core network types and utilities for the Rama framework. It serves as a foundational layer used by both end-users of the rama crate and the authors of the Rama ecosystem.

    Note on Protocols: rama-net does not explicitly implement specific protocols like tcp, http, or tls. Instead, these are implemented in their respective specialized rama crates. Use rama-net for low-level network abstractions and utilities required to build or extend network-based services.

  7. Overview of rama-http-types

    main
    rama-http-types is a crate providing HTTP types and utilities for the Rama modular service framework. It is a foundational crate used by both end-users of the rama crate and authors of rama HTTP-related crates to ensure consistent handling of HTTP data structures and utilities within the Rama ecosystem.

  8. Overview of rama-crypto

    main

    The rama-crypto crate provides the cryptographic primitives and dependencies used throughout the Rama framework. It is primarily used by the core rama crate but can be utilized for specific security tasks in your own Rama-based services.

    Key capabilities include:

    • Certificates: Management and handling of digital certificates.
    • JOSE (Javascript Object Signing and Encryption): Support for standards including JWS (Signing), JWK (Keys), JWT (Tokens), and JWE (Encryption).
    • Key Management: Handling of public and private keys.
    • Signing: Digital signature operations.

  9. Overview of rama-http-backend

    main
    The rama-http-backend crate serves as the default HTTP backend for the rama framework. It provides implementation for the HTTP protocol and contains the underlying client and server driver logic built on top of tokio. This crate is primarily used by end-users through the main rama crate to enable HTTP-based network packet transformation and movement.

  10. Overview of Rama framework capabilities

    main

    Rama is a modular, async-first network service and proxy framework for Rust, built on top of tokio. It provides fine-grained, programmable control over packet movement through the networking stack, allowing developers to operate at the transport, application, or intermediate layers.

    Key Capabilities:

    • Transports: TCP, UDP, UDS, middleware, and instrumentation.
    • HTTP: Support for HTTP/1.1 and HTTP/2, automatic protocol detection, routing, and middleware.
    • TLS: Support for rustls and BoringSSL.
    • Proxy Protocols: HTTP CONNECT, HTTPS CONNECT, SOCKS5, and HAProxy PROXY protocol.
    • Web Protocols: WebSocket and Server-Sent Events (SSE).
    • Fingerprinting & Emulation: JA3, JA4, JA4H, PeetPrint, Akamai h2, and User Agent emulation (HTTP + TLS profiles).
    • Telemetry: Integration with tracing and OpenTelemetry.
    • Diagnostics: HAR and cURL export capabilities.
    • Utilities: Error handling, graceful shutdown, and connection pooling.

  11. Overview of rama-error

    main
    The rama-error crate provides standardized error types and utilities used across the Rama ecosystem. It is primarily a foundational crate used by authors of the core rama crate and the rama HTTP crate to ensure consistent error handling when moving and transforming network packets.