Lighttp v1.0

1. Introduction

Welcome to Lighttp — the lightweight content management system.

Lighttp is a high-performance, secure, and elegant CMS built with PHP, MySQL, and Redis. It is designed for developers and content creators who value speed, code quality, and simplicity.

Key Features

• Blazing Fast Performance — Redis-powered caching delivers sub-100ms page loads
• Secure by Default — PDO prepared statements, password hashing, CSRF protection
• Clean MVC Architecture — Maintainable and scalable code structure
• SEO Friendly — Custom slugs, meta tags, and sitemap support
• Responsive Design — Works seamlessly on all devices
• Lightweight Core — Under 200KB core, no unnecessary dependencies
• Open Source — MIT licensed, free to use and modify

2. System Requirements

Minimum Requirements

Required PHP Extensions

• php-mysql — PDO MySQL driver
• php-redis — Redis extension
• php-mbstring — Multibyte string support
• php-json — JSON handling
• php-curl — HTTP requests (recommended)
• php-gd — Image processing (optional)
• php-opcache — Performance optimization

Verify PHP Extensions

# Check installed PHP extensions
php -m | grep -E "mysql|redis|mbstring|json|curl"

3. Installation Guide

Quick Installation (Recommended)

# Step 1: Create project via Composer
composer create-project lighttp/cms my-site

# Step 2: Navigate to project directory
cd my-site

# Step 3: Run installation script
php lighttp install

# Step 4: Follow interactive prompts
# - Enter database credentials
# - Set admin username and password
# - Configure Redis settings

# Step 5: Start development server
php -S localhost:8080 -t public

Manual Installation

# Step 1: Clone the source code
git clone https://github.com/Drliehuo/inetpub.github.io/tree/main/lighttp/src my-site
cd my-site

# Step 2: Install dependencies
composer install --no-dev

# Step 3: Configure environment
cp .env.example .env
nano .env  # Edit database and Redis settings

# Step 4: Run database migration
php lighttp migrate

# Step 5: Create admin user
php lighttp user:create admin admin@example.com password123

# Step 6: Set file permissions
chmod -R 755 var/
chmod -R 755 public/uploads/

Web Server Configuration

Nginx

server {
    listen 80;
    server_name your-domain.com;
    root /var/www/lighttp/public;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

Apache

<VirtualHost *:80>
    ServerName your-domain.com
    DocumentRoot /var/www/lighttp/public
    <Directory /var/www/lighttp/public>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

4. Directory Structure

Lighttp follows a clean and organized directory structure:

/
├── app/
│   ├── core/           # Core framework classes
│   │   ├── Application.php
│   │   ├── Database.php
│   │   └── RedisCache.php
│   ├── controllers/    # Application controllers
│   │   ├── HomeController.php
│   │   ├── AdminController.php
│   │   └── AuthController.php
│   ├── models/         # Data models
│   │   ├── Article.php
│   │   ├── Category.php
│   │   └── User.php
│   ├── config/         # Configuration files
│   │   └── config.php
│   └── routes.php      # Route definitions
├── public/             # Web root directory
│   ├── index.php       # Entry point
│   ├── .htaccess       # Apache rewrite rules
│   ├── css/            # Stylesheets
│   ├── js/             # JavaScript files
│   └── uploads/        # User uploaded files
├── var/                # Runtime data
│   ├── cache/          # Cache storage
│   ├── logs/           # Application logs
│   └── sessions/       # Session storage
├── .env                # Environment configuration
└── composer.json       # Composer dependencies

5. Configuration

All configuration is managed through the .env file and app/config/config.php.

Environment Variables (.env)

# Database Configuration
DB_HOST=localhost
DB_PORT=3306
DB_NAME=lighttp
DB_USER=root
DB_PASS=your_password

# Redis Configuration
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_PASSWORD=
REDIS_DATABASE=0

# Application Settings
APP_NAME=Lighttp
APP_DEBUG=true
APP_TIMEZONE=Asia/Shanghai
APP_PER_PAGE=10

Application Config (config.php)

return [
    'database' => [
        'host' => env('DB_HOST', 'localhost'),
        'port' => env('DB_PORT', 3306),
        'database' => env('DB_NAME', 'lighttp'),
        'username' => env('DB_USER', 'root'),
        'password' => env('DB_PASS', ''),
        'charset' => 'utf8mb4',
    ],
    'cache' => [
        'enabled' => true,
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'port' => env('REDIS_PORT', 6379),
        'prefix' => 'lighttp:',
        'default_ttl' => 3600,
    ],
    'app' => [
        'name' => env('APP_NAME', 'Lighttp'),
        'debug' => env('APP_DEBUG', false),
        'timezone' => env('APP_TIMEZONE', 'UTC'),
        'per_page' => env('APP_PER_PAGE', 10),
    ],
];

6. Database Setup

Lighttp uses MySQL/MariaDB with PDO for database operations. The system includes 12 core tables:

Run Migrations

# Run all migrations
php lighttp migrate

# Rollback last migration
php lighttp migrate:rollback

# Check migration status
php lighttp migrate:status

7. Admin Dashboard

The admin dashboard provides a comprehensive interface for managing your content and system settings.

Accessing the Dashboard

https://your-domain.com/admin

Default Admin Credentials

Dashboard Sections

• Dashboard — Key metrics and system overview
• Articles — Create, edit, delete, and manage articles
• Categories — Organize content with categories
• Users — Manage user accounts and roles
• Settings — System-wide configuration
• Cache — Clear Redis cache

8. Content Management

8.1 Articles

Articles are the primary content type in Lighttp. Each article includes:

• Title — The article headline
• Slug — URL-friendly identifier (auto-generated)
• Content — Main article body
• Excerpt — Short summary
• Category — Content classification
• Status — Draft, Published, Pending Review
• Meta Data — SEO title, description, keywords

Creating an Article

# Via command line
php lighttp article:create "My First Article" --content="Full content here" --category=1

# Via web interface
# Navigate to /admin/article/create

8.2 Categories

Categories help organize articles. Features include:

• Hierarchical structure (parent-child)
• Custom slugs for SEO
• Sort order control
• Hide/show toggle

8.3 Pages

Static pages for content like About, Contact, and Privacy Policy.

• Independent from article system
• Custom templates support
• Navigation menu integration

9. User Management

Lighttp includes a complete user management system with role-based permissions.

User Roles

User Commands

# Create a new user
php lighttp user:create username email password

# Change user password
php lighttp user:password username newpassword

# List all users
php lighttp user:list

# Delete a user
php lighttp user:delete username

10. Cache System

Lighttp uses Redis for powerful multi-level caching.

Cache Levels

• Page Cache — Full HTML page caching (60s TTL)
• Data Cache — Query result caching (5-300s TTL)
• Session Cache — User session storage (optional)

Cache Commands

# Clear all cache
php lighttp cache:clear

# Clear page cache only
php lighttp cache:clear --type=page

# Clear data cache only
php lighttp cache:clear --type=data

# Check cache status
php lighttp cache:status

Cache Configuration

return [
    'cache' => [
        'enabled' => true,
        'host' => '127.0.0.1',
        'port' => 6379,
        'prefix' => 'lighttp:',
        'default_ttl' => 3600,  // 1 hour
    ],
];

11. Security Features

Lighttp implements multiple security layers to protect your content and users.

Security Measures

• SQL Injection Prevention — PDO prepared statements
• Password Security — bcrypt hashing with salt
• CSRF Protection — Token-based form validation
• XSS Prevention — Auto-escaping of output
• Session Security — Secure session handling with rotation
• Input Validation — Filter and sanitize all user input
• Rate Limiting — Prevent brute force attacks

Security Best Practices

# Always set APP_DEBUG=false in production
APP_DEBUG=false

# Use strong passwords (min 12 characters, mixed case)
# Keep system and PHP updated
# Use HTTPS/SSL in production
# Regularly backup database
# Monitor access logs

12. API Reference

Lighttp provides a RESTful API for content management and integration.

API Endpoints

Authentication

API uses Bearer token authentication:

# Example request
curl -X GET https://your-domain.com/api/articles \
    -H "Authorization: Bearer your_api_token"

Response Format

{
    "status": "success",
    "data": {
        "id": 1,
        "title": "Sample Article",
        "content": "Full article content...",
        "created_at": "2026-06-22 10:00:00"
    }
}

13. Troubleshooting

Common Issues

Error: Database connection failed

• Verify MySQL/MariaDB is running: sudo systemctl status mysql
• Check credentials in .env file
• Test connection: mysql -u user -p -h host

Error: Redis connection failed

• Verify Redis is running: redis-cli ping
• Check Redis configuration in .env
• Ensure Redis extension is installed: php -m | grep redis

Error: 404 Not Found

• Check web server configuration (Nginx/Apache)
• Verify public/ is set as document root
• Check .htaccess or Nginx rewrite rules

Error: Permission denied

• Set correct permissions: chown -R www-data:www-data var/
• Set correct file modes: chmod -R 755 var/
• For sessions: chmod -R 777 var/sessions/

Error: Class not found

• Run Composer autoload: composer dump-autoload
• Check namespace declarations in PHP files

14. Support & Contact

Getting Help

• GitHub Issues — Report bugs and request features
• Documentation — Full documentation portal
• Community — Join our Discord community

Developer Information

Contributing

We welcome contributions from the community! Please read our contributing guidelines before submitting pull requests.

• Fork the repository
• Create a feature branch
• Submit a pull request