Skip to content

Commit e52de0f

Browse files
s0xattakdefands0xattakdefand
committed
Description of changes
1 parent e8a9632 commit e52de0f

3 files changed

Lines changed: 294 additions & 0 deletions

File tree

‎wiki/Home.md‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
# Core Web Wiki
2+
3+
Welcome to the Core Web Wiki! This is the central documentation hub for the Core Web project, a production-ready, multi-protocol web platform built with Rust.
4+
5+
## 🚀 Getting Started
6+
7+
If you're new to Core Web, start here:
8+
9+
- [Introduction](Introduction.md) - Overview of the project and its goals
10+
- [Quick Start Guide](Quick-Start-Guide.md) - Step-by-step instructions to get up and running
11+
- [Installation](Installation.md) - Detailed installation instructions
12+
13+
## 📚 Documentation
14+
15+
### Core Concepts
16+
- [Architecture](Architecture.md) - System architecture and design patterns
17+
- [Crate Stack](Crate-Stack.md) - Overview of Rust crates used in the project
18+
- [Feature Flags](Feature-Flags.md) - Available feature flags and their usage
19+
- [API Reference](API-Reference.md) - API endpoints and usage
20+
21+
### Development
22+
- [Contributing](Contributing.md) - How to contribute to the project
23+
- [Development Setup](Development-Setup.md) - Setting up your development environment
24+
- [Testing](Testing.md) - Running and writing tests
25+
- [Code Style](Code-Style.md) - Coding standards and conventions
26+
27+
### Deployment & Operations
28+
- [Deployment](Deployment.md) - Deployment guides for different environments
29+
- [Configuration](Configuration.md) - Configuration options and management
30+
- [Monitoring](Monitoring.md) - Observability and monitoring setup
31+
- [Security](Security.md) - Security considerations and best practices
32+
33+
### Components
34+
- [Web Server](Web-Server.md) - Main web server functionality
35+
- [Jobs Worker](Jobs-Worker.md) - Background job processing
36+
- [WebSocket Gateway](WebSocket-Gateway.md) - Real-time communication
37+
- [CLI Tool](CLI-Tool.md) - Command-line interface
38+
- [WASM Plugins](WASM-Plugins.md) - WebAssembly plugin system
39+
40+
## 🛠️ Tools & Technologies
41+
42+
- [Rust](Rust.md) - Rust language usage in the project
43+
- [Databases](Databases.md) - Database integration and usage
44+
- [Docker](Docker.md) - Containerization with Docker
45+
- [Kubernetes](Kubernetes.md) - Kubernetes deployment and management
46+
47+
## 📖 Project Information
48+
49+
- [Roadmap](Roadmap.md) - Project roadmap and future plans
50+
- [Changelog](Changelog.md) - Release history and changes
51+
- [FAQ](FAQ.md) - Frequently asked questions
52+
- [Troubleshooting](Troubleshooting.md) - Common issues and solutions
53+
54+
## 🤝 Community
55+
56+
- [Support](Support.md) - How to get help and support
57+
- [Code of Conduct](Code-of-Conduct.md) - Community guidelines
58+
- [License](License.md) - Licensing information
59+
60+
---
61+
62+
_Core Web is built with ❤️ and 🦀 Rust_

‎wiki/Introduction.md‎

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
# Introduction to Core Web
2+
3+
Core Web is a comprehensive, production-ready web platform built with Rust that provides everything you need to build scalable, secure, and high-performance web applications. With support for multiple protocols, advanced security features, and enterprise-grade observability, Core Web is designed to handle the most demanding workloads.
4+
5+
## 🎯 Project Goals
6+
7+
Core Web was created with the following goals in mind:
8+
9+
1. **Performance**: Leverage Rust's zero-cost abstractions and memory safety to deliver exceptional performance
10+
2. **Scalability**: Design for horizontal scaling and high concurrency
11+
3. **Security**: Implement security best practices at every level
12+
4. **Observability**: Provide comprehensive monitoring and debugging capabilities
13+
5. **Developer Experience**: Offer excellent tooling and documentation
14+
6. **Flexibility**: Support multiple protocols and deployment options
15+
16+
## ✨ Key Features
17+
18+
### 🌐 Multi-Protocol Support
19+
- **REST API** with full CRUD operations, pagination, and ETags
20+
- **GraphQL** with schema and resolvers
21+
- **gRPC** with Protocol Buffer service contracts
22+
- **WebSocket/SSE** for real-time communication
23+
24+
### 🗄️ Multi-Database Integration
25+
- **MySQL** - Primary transactional database
26+
- **Redis** - Caching, session storage, and pub/pub messaging
27+
- **MongoDB** - Document storage for flexible schemas
28+
- **ClickHouse** - Analytics and time-series data warehouse
29+
30+
### 🔒 Advanced Security
31+
- **Authentication**: JWT, OIDC, and API key support
32+
- **Authorization**: RBAC and ABAC with Casbin/Cedar
33+
- **Security Headers**: HSTS, CSP, CORS/CSRF protection
34+
- **Compliance**: Data protection regulation compliance
35+
36+
### 📈 Observability & Monitoring
37+
- **Distributed Tracing** with OpenTelemetry
38+
- **Metrics Collection** and dashboarding
39+
- **Structured Logging** with multiple output formats
40+
- **Health Checks** with Kubernetes-ready endpoints
41+
42+
### ⚡ Performance & Resilience
43+
- **Caching Layers**: In-memory (Moka) and Redis distributed caching
44+
- **Resilience Patterns**: Retry, Circuit Breaker, Bulkhead, Timeout
45+
- **Rate Limiting**: Token bucket algorithm
46+
- **Idempotency**: Redis-backed POST idempotency
47+
48+
## 🏗️ Architecture Overview
49+
50+
```
51+
┌─────────────────────────────────────────────────────────────┐
52+
│ Load Balancer/Proxy │
53+
└─────────────────────┬───────────────────────────────────────┘
54+
│
55+
┌─────────────────────┴───────────────────────────────────────┐
56+
│ Core Web Server (8080) │
57+
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
58+
│ │ REST API │ │ GraphQL │ │ gRPC │ │
59+
│ └─────────────┘ └─────────────┘ └─────────────────────┘ │
60+
│ ┌─────────────────────────────────────────────────────────┐ │
61+
│ │ Authentication & AuthZ │ │
62+
│ └─────────────────────────────────────────────────────────┘ │
63+
└─────────────────────┬───────────────────────────────────────┘
64+
│
65+
┌─────────────┼─────────────┐ ┌────────────┐
66+
│ │ │ │ │
67+
┌───────▼──┐ ┌──────▼──┐ ┌───────▼──┐ ┌──────▼──┐ ┌─────▼──────┐
68+
│ MySQL │ │ Redis │ │ MongoDB │ │ClickHouse│ │ WASM Host │
69+
│ (Primary)│ │(Caching)│ │(Documents)│ │(Analytics)│ │ (Plugins) │
70+
└──────────┘ └─────────┘ └──────────┘ └──────────┘ └────────────┘
71+
│ │ │ │ │
72+
└─────────────┼─────────────┘ │ │
73+
│ │ │
74+
┌───────▼───────┐ ┌───────▼──────┐ │
75+
│ Job Workers │ │ Events │ │
76+
│ (Background) │ │ (Streaming) │ │
77+
└───────────────┘ └──────────────┘ │
78+
│ │ │
79+
┌───────▼───────┐ ┌───────▼──────┐ │
80+
│ Outbox Pattern│ │ Redis Streams│ │
81+
│ Publisher │ │ Consumer │ │
82+
└───────────────┘ └──────────────┘ │
83+
│
84+
┌───────▼───────┐
85+
│ Admin Dashboard│
86+
│ (Yew/WASM) │
87+
└───────────────┘
88+
```
89+
90+
## 📦 Components
91+
92+
Core Web consists of several components working together:
93+
94+
1. **Main Web Server** - The primary application server handling HTTP requests
95+
2. **Jobs Worker** - Background job processing service
96+
3. **WebSocket Gateway** - Real-time communication gateway
97+
4. **CLI Tool** - Command-line interface for managing the application
98+
5. **WASM Plugin Host** - WebAssembly plugin system for extensibility
99+
100+
## 🚀 Why Core Web?
101+
102+
Core Web stands out from other web frameworks because:
103+
104+
- **Built with Rust**: Memory safety without garbage collection
105+
- **Production Ready**: Enterprise-grade features out of the box
106+
- **Multi-Protocol**: Support for REST, GraphQL, gRPC, and WebSockets
107+
- **Observability First**: Comprehensive monitoring and tracing
108+
- **Security Focused**: Multiple authentication and authorization methods
109+
- **Highly Scalable**: Designed for horizontal scaling
110+
- **Extensible**: Plugin system for custom functionality
111+
112+
## 📚 Next Steps
113+
114+
To get started with Core Web:
115+
116+
1. Check out the [Quick Start Guide](Quick-Start-Guide.md)
117+
2. Review the [Architecture](Architecture.md) documentation
118+
3. Explore the [API Reference](API-Reference.md)
119+
4. Learn about [Deployment](Deployment.md) options
120+
121+
Join our community and start building amazing applications with Core Web today!

‎wiki/Quick-Start-Guide.md‎

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
# Quick Start Guide
2+
3+
This guide will help you get Core Web up and running quickly on your local machine.
4+
5+
## 📋 Prerequisites
6+
7+
Before you begin, ensure you have the following installed:
8+
9+
- **Rust** (latest stable version) - [Install Rust](https://www.rust-lang.org/tools/install)
10+
- **Docker and Docker Compose** - [Install Docker](https://docs.docker.com/get-docker/)
11+
- **Git** - [Install Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
12+
13+
## 🚀 Installation Steps
14+
15+
### 1. Clone the Repository
16+
17+
```bash
18+
git clone https://github.com/your-org/core-web.git
19+
cd core-web
20+
```
21+
22+
### 2. Start Supporting Services
23+
24+
Core Web requires several services to run. Start them using the development script:
25+
26+
```bash
27+
./scripts/dev-up.sh
28+
```
29+
30+
This script will:
31+
- Create necessary data directories
32+
- Start MySQL, Redis, MongoDB, ClickHouse, and OpenTelemetry collector using Docker Compose
33+
- Display the ports on which each service is running
34+
35+
### 3. Run the Main Web Server
36+
37+
In a new terminal, start the main web server:
38+
39+
```bash
40+
cd apps/core-web
41+
cargo run
42+
```
43+
44+
The server will start on port 8080 by default. You can access the API at `http://localhost:8080`.
45+
46+
### 4. Verify Installation
47+
48+
Check that the server is running by accessing the health endpoint:
49+
50+
```bash
51+
curl http://localhost:8080/healthz
52+
```
53+
54+
You should receive a response indicating the service is healthy.
55+
56+
## 🧪 Testing
57+
58+
Run the full test suite to ensure everything is working correctly:
59+
60+
```bash
61+
cargo test
62+
```
63+
64+
## 🛠️ CLI Tool
65+
66+
Core Web includes a powerful CLI tool for managing the application:
67+
68+
```bash
69+
# Navigate to the CLI crate
70+
cd crates/core-cli
71+
72+
# Run CLI commands
73+
cargo run -- --help # Show help
74+
cargo run -- start # Start the server
75+
cargo run -- status # Check server status
76+
cargo run -- health # Run health checks
77+
cargo run -- logs # View logs
78+
```
79+
80+
## 🌐 Accessing Services
81+
82+
Once everything is running, you can access the following services:
83+
84+
| Service | URL | Description |
85+
|---------|-----|-------------|
86+
| Main Web Server | http://localhost:8080 | Primary application server |
87+
| Metrics | http://localhost:8081/metrics | Prometheus metrics endpoint |
88+
| MySQL Database | localhost:3306 | Primary relational database |
89+
| Redis | localhost:6379 | In-memory data structure store |
90+
| MongoDB | localhost:27017 | Document-based database |
91+
| ClickHouse | http://localhost:8123 | Analytical database |
92+
| OpenTelemetry | http://localhost:4318 | Observability collector |
93+
94+
## 📚 Next Steps
95+
96+
After completing the quick start:
97+
98+
1. Explore the [API Reference](API-Reference.md) to learn about available endpoints
99+
2. Check out the [Configuration](Configuration.md) guide to customize your setup
100+
3. Review the [Development Setup](Development-Setup.md) for a full development environment
101+
4. Learn about [Deployment](Deployment.md) options for production environments
102+
103+
## 🤔 Need Help?
104+
105+
If you encounter any issues during the quick start process:
106+
107+
1. Check the [Troubleshooting](Troubleshooting.md) guide
108+
2. Review the [FAQ](FAQ.md)
109+
3. [Open an issue](https://github.com/your-org/core-web/issues) on GitHub
110+
111+
Happy coding with Core Web!

0 commit comments

Comments
 (0)