# nftables traffic collection rules
table inet vps_traffic {
    chain traffic_counter {
        type filter hook output priority 0; policy accept;
        counter name "out_global"
        counter name "out_api"
        counter name "out_static"
        counter name "out_backup"
    }
}

# Policy management pseudocode
class TrafficPolicyManager:
    def analyze_and_act(self, traffic_data):
        patterns = self.ai_engine.detect_patterns(traffic_data)
        predictions = self.ai_engine.predict_bandwidth(patterns)
        
        # Dynamically adjust policies based on predictions
        if predictions.p95_peak > self.current_limit * 0.8:
            self.scale_up(predicted_peak * 1.2)
        elif predictions.p95_peak < self.current_limit * 0.3:
            self.scale_down(predicted_peak * 1.5)
        
        # Dynamic priority assignment
        priorities = self.assign_priorities(traffic_data)
        self.apply_qos(priorities)

# HTB hierarchical queue example
tc qdisc add dev eth0 root handle 1: htb default 30

# Priority 1: API traffic (high priority, ensure response speed)
tc class add dev eth0 parent 1: classid 1:1 htb rate 10mbit ceil 20mbit prio 1

# Priority 2: Static resources (medium priority)
tc class add dev eth0 parent 1: classid 1:2 htb rate 5mbit ceil 10mbit prio 2

# Priority 3: Backup/logs (low priority, uses remaining bandwidth when idle)
tc class add dev eth0 parent 1: classid 1:3 htb rate 1mbit ceil 5mbit prio 3

# docker-compose.yml
version: '3.8'

services:
  # Traffic collector
  flow-exporter:
    image: prometheuscommunity/flow-exporter:latest
    container_name: vps-flow-exporter
    network_mode: host
    privileged: true
    volumes:
      - ./config:/etc/flow-exporter
      - /proc:/host/proc:ro
    restart: unless-stopped
    labels:
      org.label-schema.group: "vps-ai-ops"

  # AI analysis engine
  ai-engine:
    build: ./ai-engine
    container_name: vps-ai-engine
    environment:
      - MODEL_PATH=/data/models
      - PREDICTION_HORIZON=24
      - ANOMALY_THRESHOLD=0.85
    volumes:
      - ai-models:/data/models
      - ./data:/data
    depends_on:
      - flow-exporter
    restart: unless-stopped

  # Policy manager
  policy-manager:
    build: ./policy-manager
    container_name: vps-policy-manager
    network_mode: host
    privileged: true
    environment:
      - INTERFACE=eth0
      - BASE_BANDWIDTH=50
      - API_PRIORITY=1
      - STATIC_PRIORITY=2
      - BACKUP_PRIORITY=3
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./config:/etc/policy-manager
    depends_on:
      - ai-engine
    restart: unless-stopped

  # Grafana visualization
  grafana:
    image: grafana/grafana:latest
    container_name: vps-grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - grafana-data:/var/lib/grafana
      - ./dashboards:/etc/grafana/provisioning/dashboards
    depends_on:
      - prometheus
    restart: unless-stopped

  # Prometheus metrics storage
  prometheus:
    image: prom/prometheus:latest
    container_name: vps-prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    restart: unless-stopped

volumes:
  ai-models:
  grafana-data:
  prometheus-data:

# ./ai-engine/Dockerfile
FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    gcc g++ make && \
    rm -rf /var/lib/apt/lists/*

RUN pip install --no-cache-dir \
    numpy==1.26.4 \
    pandas==2.2.1 \
    scikit-learn==1.4.0 \
    tensorflow==2.15.0 \
    prophet==1.1.5 \
    requests==2.31.0

WORKDIR /app
COPY . .

CMD ["python", "ai_engine.py"]

# ./ai-engine/ai_engine.py
import os
import json
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
from sklearn.ensemble import IsolationForest
from prophet import Prophet
import tensorflow as tf

class TrafficAIEngine:
    def __init__(self):
        self.model_path = os.getenv('MODEL_PATH', '/data/models')
        self.prediction_horizon = int(os.getenv('PREDICTION_HORIZON', '24'))
        self.anomaly_threshold = float(os.getenv('ANOMALY_THRESHOLD', '0.85'))
        self.isolation_forest = None
        self.lstm_model = None
        
    def load_or_train_models(self):
        """Load or train AI models"""
        # Anomaly detection model
        model_file = os.path.join(self.model_path, 'anomaly_detector.pkl')
        if os.path.exists(model_file):
            import joblib
            self.isolation_forest = joblib.load(model_file)
        else:
            self.isolation_forest = IsolationForest(
                contamination=0.05, random_state=42
            )
            
        # LSTM prediction model
        lstm_file = os.path.join(self.model_path, 'lstm_model.h5')
        if os.path.exists(lstm_file):
            self.lstm_model = tf.keras.models.load_model(lstm_file)
            
    def detect_patterns(self, traffic_data: dict) -> dict:
        """Identify traffic patterns"""
        features = self._extract_features(traffic_data)
        
        # Pattern classification
        hour = datetime.now().hour
        day_of_week = datetime.now().weekday()
        
        if hour >= 9 and hour <= 18 and day_of_week < 5:
            pattern = "business_hours"
        elif hour >= 0 and hour <= 6:
            pattern = "low_traffic"
        elif day_of_week >= 5:
            pattern = "weekend"
        else:
            pattern = "peak_hours"
            
        return {
            'pattern': pattern,
            'features': features,
            'timestamp': datetime.now().isoformat()
        }
    
    def detect_anomalies(self, traffic_data: dict) -> list:
        """Detect anomalous traffic"""
        features = self._extract_features(traffic_data)
        
        if self.isolation_forest is None:
            return []
            
        prediction = self.isolation_forest.predict([features])
        scores = self.isolation_forest.score_samples([features])
        
        anomalies = []
        if prediction[0] == -1:  # Anomaly detected
            anomalies.append({
                'type': 'bandwidth_anomaly',
                'confidence': abs(scores[0]),
                'details': "Anomalous traffic pattern detected"
            })
            
        return anomalies
    
    def predict_bandwidth(self, history: pd.DataFrame) -> dict:
        """Predict future bandwidth needs"""
        # Use Prophet for time series forecasting
        forecast = Prophet(
            yearly_seasonality=True,
            weekly_seasonality=True,
            daily_seasonality=True
        ).fit(history)
        
        future = forecast.make_future_dataframe(periods=self.prediction_horizon)
        predict = forecast.predict(future)
        
        # Calculate statistics
        p95 = predict['yhat_upper'].quantile(0.95)
        p50 = predict['yhat'].median()
        max_pred = predict['yhat_upper'].max()
        
        return {
            'p95_peak_mbps': float(p95),
            'average_mbps': float(p50),
            'max_predicted_mbps': float(max_pred),
            'confidence': 0.9
        }
    
    def _extract_features(self, traffic_data: dict) -> list:
        """Extract features from raw traffic data"""
        return [
            traffic_data.get('total_mbps', 0),
            traffic_data.get('api_mbps', 0),
            traffic_data.get('static_mbps', 0),
            traffic_data.get('backup_mbps', 0),
            datetime.now().hour,
            datetime.now().weekday(),
            1 if datetime.now().month in [11, 12, 1] else 0  # Year-end promo season
        ]

if __name__ == '__main__':
    engine = TrafficAIEngine()
    engine.load_or_train_models()
    print("AI Engine initialized successfully")

# ./policy-manager/policy_manager.py
import subprocess
import json
import os
from datetime import datetime

class TrafficPolicyManager:
    def __init__(self):
        self.interface = os.getenv('INTERFACE', 'eth0')
        self.base_bandwidth = int(os.getenv('BASE_BANDWIDTH', '50'))
        self.api_priority = int(os.getenv('API_PRIORITY', '1'))
        self.static_priority = int(os.getenv('STATIC_PRIORITY', '2'))
        self.backup_priority = int(os.getenv('BACKUP_PRIORITY', '3'))
        
    def apply_qos_rules(self, policy: dict):
        """Apply QoS shaping rules"""
        # Flush existing rules
        self._flush_qdisc()
        
        # Create HTB root qdisc
        cmd = f'tc qdisc add dev {self.interface} root handle 1: htb default 30'
        subprocess.run(cmd, shell=True, check=True)
        
        # Dynamically allocate bandwidth based on policy
        total = policy.get('total_bandwidth', self.base_bandwidth)
        api_rate = int(total * 0.4)     # API gets 40%
        static_rate = int(total * 0.35) # Static gets 35%
        backup_rate = total - api_rate - static_rate  # Backup gets remainder
        
        # High priority: API traffic
        subprocess.run([
            'tc', 'class', 'add', 'dev', self.interface,
            'parent', '1:', 'classid', '1:1',
            'htb', 'rate', f'{api_rate}mbit',
            'ceil', f'{int(api_rate*1.5)}mbit',
            'prio', str(self.api_priority)
        ])
        
        # Medium priority: Static resources
        subprocess.run([
            'tc', 'class', 'add', 'dev', self.interface,
            'parent', '1:', 'classid', '1:2',
            'htb', 'rate', f'{static_rate}mbit',
            'ceil', f'{int(static_rate*1.5)}mbit',
            'prio', str(self.static_priority)
        ])
        
        # Low priority: Backup/logs
        subprocess.run([
            'tc', 'class', 'add', 'dev', self.interface,
            'parent', '1:', 'classid', '1:3',
            'htb', 'rate', f'{backup_rate}mbit',
            'ceil', f'{total}mbit',
            'prio', str(self.backup_priority)
        ])
        
        print(f"[{datetime.now()}] QoS rules applied: API={api_rate}M, "
              f"Static={static_rate}M, Backup={backup_rate}M")
    
    def _flush_qdisc(self):
        """Flush existing QoS rules"""
        subprocess.run(
            f'tc qdisc del dev {self.interface} root 2>/dev/null || true',
            shell=True
        )
    
    def auto_scale(self, prediction: dict):
        """Auto scale based on AI prediction"""
        p95 = prediction.get('p95_peak_mbps', self.base_bandwidth)
        current = self.base_bandwidth
        
        # Scale-up threshold: predicted peak exceeds 80% of current capacity
        if p95 > current * 0.8:
            new_capacity = int(p95 * 1.2)  # 20% headroom
            if new_capacity > current:
                self.base_bandwidth = new_capacity
                print(f"[AUTO-SCALE UP] Bandwidth: {current}M → {new_capacity}M")
                return True
                
        # Scale-down threshold: predicted peak below 30% of current capacity
        elif p95 < current * 0.3 and current > 10:
            new_capacity = int(p95 * 1.5)
            if new_capacity < current:
                self.base_bandwidth = new_capacity
                print(f"[AUTO-SCALE DOWN] Bandwidth: {current}M → {new_capacity}M")
                return True
                
        return False

if __name__ == '__main__':
    manager = TrafficPolicyManager()
    print("Policy Manager ready")