Skip to content

WEBcodeX1/http-1.2

BranchesTags

Repository files navigation

🚀 HTTP/1.2 - FalconAS

Lightning-Fast, Next-Level Python / Java Application Server with HTTP/1.2 Protocol

📌 Overview

HTTP/1.2 is a revolutionary approach to web protocols, designed as a simpler, more secure, and significantly faster alternative to HTTP/2 and probably HTTP/3.

We've built HTTP/1.2 - a much more lightweight solution.

  • ✅ Lightning-Fast Performance: Optimized for modern hardware with epoll-based architecture
  • ✅ Rock-Solid Security: Runs with tight backend process-separation model (non-threaded)
  • ✅ SPA Realtime Demands: Built for modern browser applications (SPAs) real-time demands
  • ✅ Zero Bloat: Eliminates unnecessary complexity while maintaining compatibility
  • ✅ Python-Powered: FalconAS application server with embedded Python scripting
  • ✅ Java-Powered: FalconAS application server with embedded Java scripting

📑 Table of Contents

  1. Quick Start
  2. Features
  3. Why HTTP/1.2?
  4. Build & Installation
  5. Testing
  6. Technical Architecture
  7. Documentation
  8. Community & Support
  9. Contributing
  10. Future Milestones
  11. License

🐎 Quick Start

Get HTTP/1.2 FalconAS running in minutes:

# clone repository
git clone https://github.com/WEBcodeX1/http-1.2.git
cd http-1.2

# install dependencies (Ubuntu 22.04/Debian 12)
apt-get install git cmake python3-pip libboost-all-dev python3-dev nlohmann-json3-dev

# build and install
cmake CMakeLists.txt .
make
make install

# configure system
. ./scripts/ulimit.sh
. ./scripts/set-transparent-hugepages.sh

# start server
/usr/local/bin/falcon-as

The server will be available with test applications at:

  • http://testapp1.local/
  • http://testapp2.local/

For detailed installation instructions, see BUILD.md.

🌟 Features

Core Advantages

  • 🚀 Lightning-Fast: Epoll-based architecture for maximum performance
  • 🔒 Secure by Design: Interpreters run non-threaded / unix process isolated
  • ⚡ Zero Bloat: Eliminates HTTP/2's excessive complexity
  • 🎯 SPA-Optimized: Perfect for modern Single Page Applications real time demands
  • 🐍 Python-Powered: Embedded Python interpreter / scripting integration
  • ☕ Java-Powered: Embedded Java JNI / scripting integration

Protocol Innovations

  • Fixed HTTP/1.1 Pipelining: Resolves misordered request/reply pairs with UUID headers
  • Permanent Keep-Alive: Single socket per client for optimal TCP/IP utilization
  • Request UUID System: Eliminates response ordering requirements
  • Simplified Architecture: Text-based protocol maintaining HTTP/1.1 simplicity

Technical Features

  • Static Content Server: High-performance file serving with sendfile()
  • Application Server: Python scripting with shared memory architecture
  • Memory Management: Huge pages support and optimized memory layout
  • Process Architecture: Separate processes to avoid Python GIL limitations
  • JSON Configuration: Clean, maintainable configuration system
  • JSON Powered By: nlohmann/json C++ JSON library

📣 Why HTTP/1.2?

The Problem with HTTP/2 & HTTP/3

HTTP/2 Complexity Crisis:

  • Excessive complexity destroys HTTP/1.1's elegant simplicity
  • Everything packed into one "black box" without logical separation
  • Libraries are confusing and difficult to understand
  • TLS/SSL handling unnecessarily embedded in protocol

HTTP/3 UDP Issues:

  • Works only for precalculated CDN data
  • Creates new complexity without solving core issues

Our Solution: HTTP/1.2

HTTP/1.2 fixes HTTP/1.1's single major flaw (broken pipelining) while avoiding HTTP/2's complexity:

🎯 Key Innovation: Adding a simple Request-UUID header eliminates response ordering issues, making HTTP/2's complex Layer-7 multiplexing unnecessary.

🛠️ Build & Installation

Prerequisites

Operating System Support:

  • Ubuntu 22.04 (Jammy Jellyfish)
  • Ubuntu 24.04 (Noble Numbat)
  • Debian 12

Required Dependencies:

# core build tools
apt-get install git cmake

# c++ boost libraries
apt-get install libboost-all-dev

# python development headers
apt-get install python3-dev

# c++ json library
apt-get install nlohmann-json3-dev

Build Options

Standard Build:

cmake CMakeLists.txt .
make
make install

Debug Build:

cmake -DDEBUG_BUILD=1 CMakeLists.txt .
make
make install

Java Backend Build:

export JAVA_HOME=/usr/lib/jvm/jdk-24.0.2-oracle-x64/
cmake -DJAVA_BACKEND=1 CMakeLists.txt .
make
make install

For complete build instructions, see BUILD.md.

🧪 Testing

Comprehensive testing infrastructure ensures reliability:

  • Unit Tests: Core component validation (/test/unit/)
  • Integration Tests: End-to-end functionality (/test/integration/)
  • Performance Tests: Benchmarking and optimization (/test/performance/)
  • Evaluation Tests: Protocol compliance (/test/eval/)

See test documentation for detailed testing procedures.

⚙️ Technical Architecture

Process Model

+----------------+---------------+---------------+----------------+
| Server Process | AS Process 1  | AS Process x  | Result Process |
|                | Python Interp.| Python Interp.|                |
+-----------------------------------------------------------------+
| Shared Memory                                                   |
|  - StaticFS Requests                                            |
|  - AS Metadata                                                  |
|  - AS Requests                                                  |
|  - AS Results                                                   |
+-----------------------------------------------------------------+

Design Principles:

  • Process-Based: Separate processes avoid Python GIL limitations
  • Shared Memory: High-performance IPC with atomic locks (kernel mutex-less)
  • Huge Pages: Memory optimization for better performance

Performance Philosophy: Epoll vs Coroutines

⚠️ Coroutine Warning: While trending, coroutines can be counterproductive for scalability if implemented incorrectly.

The Problem with incorrectly implemented Coroutines:

  • In case a single connection awaits a syscall read() result
  • Its similar to one poll() for a single connection file descriptor
  • 10,000 connections = 10,000 syscalls (context switches)
  • Massive overhead for checking received data (unscalable)

Our Epoll Advantage:

  • Single syscall informs about multiple FDs with pending data
  • Used by nginx and other high-performance servers

📃 Documentation

Official Documentation

Online Resources

Protocol Specifications

🌐 Community & Support

Get Help & Discuss

Stay Updated

👋 Contributing

We welcome contributions! Whether you're:

  • 🐛 Reporting bugs
  • 💡 Suggesting features
  • 📝 Improving documentation
  • 🔧 Submitting code

Please see CONTRIBUTING.md for guidelines.

Code Quality Standards:

  • Clean, readable, maintainable code
  • Comprehensive testing
  • Security-conscious development
  • Commit signing with GPG/SSH keys

⏰ Future Milestones

Short-term Goals

  • x0 Framework Integration: Seamless SPA framework compatibility
  • Performance Benchmarks: Comprehensive HTTP/1.1, HTTP/2, HTTP/3 comparisons

Long-term Vision

  • Protocol Standardization: Submit HTTP/1.2 as official RFC
  • Enterprise Features: Advanced monitoring, analytics, management
  • Proxy Server Component: Complete the load balancing/reverse proxy module

See GitHub Milestones for detailed roadmap.

📝 License

GNU Affero General Public License v3.0 - See LICENSE for details.

🚀 Ready to experience the future of web protocols?
Made with ❤️ by Claus Prüfer / clickIT / WEBcodeX

About

Lightweight And Fast HTTP/1.1, HTTP/1.2 (XML) Protocol With HTTP/2 Flavour

Topics

python java json cplusplus application-server http-server appserver

Resources

Readme

License

AGPL-3.0 license

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

5 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Sponsor this project

  •  
  •  
Learn more about GitHub Sponsors

Contributors 3

  •  
  •  
  •  

Languages