mm_ip 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,173 @@
+# mm_ip
+
+[English](README_EN.md) | [中文](README.md)
+
+一个功能强大的IP管理模块，支持白名单、黑名单管理、IP请求频率监控、违规记录和持久化存储。
+
+## 功能特性
+
+- ✅ **白名单管理** - 支持添加、删除、查询白名单IP
+- ✅ **黑名单管理** - 支持添加、删除、查询黑名单IP，支持自动过期
+- ✅ **IP请求频率监控** - 实时监控IP请求频率，防止高频访问
+- ✅ **自动拉黑机制** - 支持高频访问自动拉黑和违规次数超限自动拉黑
+- ✅ **违规记录系统** - 记录IP违规行为，支持违规次数统计和重置
+- ✅ **持久化存储** - 支持数据分文件存储（白名单、黑名单、违规记录独立存储）
+- ✅ **自动保存机制** - 支持定时自动保存和操作触发保存
+- ✅ **重启数据恢复** - 支持重启后自动加载持久化数据
+- ✅ **灵活配置** - 支持自定义各种阈值和参数
+
+## 安装
+
+```bash
+npm install mm_ip
+```
+
+## 快速开始
+
+### 基本使用
+
+```javascript
+const { Ip } = require('mm_ip');
+
+// 创建IP管理实例
+const ip_manager = new Ip();
+
+// 设置日志器（可选）
+ip_manager.setup(console);
+
+// 添加白名单IP
+ip_manager.addWhite('192.168.1.100');
+
+// 添加黑名单IP
+ip_manager.addBlack('10.0.0.100');
+
+// 检查IP状态
+console.log('192.168.1.100 在白名单:', ip_manager.isWhite('192.168.1.100'));
+console.log('10.0.0.100 在黑名单:', ip_manager.isBlack('10.0.0.100'));
+
+// 记录IP请求
+console.log('192.168.1.100 请求结果:', ip_manager.record('192.168.1.100'));
+```
+
+### 持久化存储配置
+
+```javascript
+// 创建带持久化配置的实例
+const persistent_ip = new Ip({
+    dir: './cache/ip', // 存储目录
+    max_white: 1000,   // 最大白名单数量
+    max_black: 1000    // 最大黑名单数量
+});
+
+// 添加数据后会自动保存到文件
+persistent_ip.addWhite('192.168.1.101');
+persistent_ip.addBlack('10.0.0.101');
+
+// 重启后自动加载数据
+const new_ip = new Ip({ dir: './cache/ip' });
+console.log('重启后白名单数量:', new_ip.getAllWhite().length);
+```
+
+## API文档
+
+### 构造函数
+
+```javascript
+new Ip(config)
+```
+
+**配置参数 (config):**
+
+| 参数 | 类型 | 默认值 | 描述 |
+|------|------|--------|------|
+| `max_white` | number | 1000 | 最大白名单数量 |
+| `max_black` | number | 1000 | 最大黑名单数量 |
+| `check_interval` | number | 60000 | 检查间隔（毫秒） |
+| `max_req_per_min` | number | 100 | 每分钟最大请求数 |
+| `auto_black_enable` | boolean | true | 启用自动高频拉黑 |
+| `auto_black_threshold` | number | 50 | 自动拉黑阈值 |
+| `auto_black_duration` | number | 3600000 | 自动拉黑持续时间（毫秒） |
+| `violation_enable` | boolean | true | 启用违规记录 |
+| `violation_max_count` | number | 10 | 最大违规次数 |
+| `violation_reset_time` | number | 86400000 | 违规记录重置时间（毫秒） |
+| `violation_auto_black` | boolean | true | 违规次数超限自动拉黑 |
+| `dir` | string | './cache/ip' | 持久化存储目录 |
+
+### 主要方法
+
+#### 白名单操作
+- `addWhite(ip)` - 添加白名单IP
+- `delWhite(ip)` - 删除白名单IP
+- `isWhite(ip)` - 检查是否在白名单
+- `getAllWhite()` - 获取所有白名单IP
+- `clearWhite()` - 清空白名单
+
+#### 黑名单操作
+- `addBlack(ip)` - 添加黑名单IP
+- `delBlack(ip)` - 删除黑名单IP
+- `isBlack(ip)` - 检查是否在黑名单
+- `getAllBlack()` - 获取所有黑名单IP
+- `clearBlack()` - 清空黑名单
+- `getBlackExpireTime(ip)` - 获取黑名单过期时间
+
+#### IP请求记录
+- `record(ip)` - 记录IP请求，返回是否允许访问
+- `getReqCount(ip)` - 获取IP请求次数
+- `getReqFreq(ip)` - 获取IP请求频率
+
+#### 违规记录
+- `recordViolation(ip, reason)` - 记录IP违规
+- `getViolationCount(ip)` - 获取违规次数
+- `resetViolation(ip)` - 重置违规记录
+- `clearViolations()` - 清空所有违规记录
+- `getAllViolations()` - 获取所有违规记录
+
+#### 持久化存储
+- `save()` - 手动保存数据
+- `load()` - 手动加载数据
+- `autoSave(interval)` - 开启自动保存
+- `stopAutoSave()` - 停止自动保存
+
+#### 综合操作
+- `del(ip)` - 删除IP的所有记录
+- `setup(logger)` - 设置日志器
+
+## 存储文件结构
+
+当启用持久化存储时，数据会分三个文件存储：
+
+```
+cache/ip/
+├── white.json      # 白名单数据
+├── black.json      # 黑名单数据
+└── violation.json  # 违规记录数据
+```
+
+每个文件包含对应的数据数组和时间戳信息。
+
+## 测试
+
+运行测试用例：
+
+```bash
+npm test
+```
+
+或直接运行：
+
+```bash
+node test.js
+```
+
+## 许可证
+
+ISC License
+
+## 作者
+
+qww
+
+## 仓库地址
+
+- Gitee: https://gitee.com/qiuwenwu91/mm_ip.git
+- npm: https://www.npmjs.com/package/mm_ip

package/README_EN.md

@@ -0,0 +1,173 @@
+# mm_ip
+
+[English](README_EN.md) | [中文](README.md)
+
+A powerful IP management module that supports whitelist, blacklist management, IP request frequency monitoring, violation records, and persistent storage.
+
+## Features
+
+- ✅ **Whitelist Management** - Add, remove, and query whitelist IPs
+- ✅ **Blacklist Management** - Add, remove, and query blacklist IPs with auto-expiration
+- ✅ **IP Request Frequency Monitoring** - Real-time IP request frequency monitoring to prevent high-frequency access
+- ✅ **Auto-Blacklist Mechanism** - Automatic blacklisting for high-frequency access and violation limit exceeding
+- ✅ **Violation Record System** - Record IP violation behaviors with violation count statistics and reset
+- ✅ **Persistent Storage** - Support for separate file storage (whitelist, blacklist, violation records stored independently)
+- ✅ **Auto-Save Mechanism** - Support for timed auto-save and operation-triggered save
+- ✅ **Data Recovery on Restart** - Automatic loading of persistent data after restart
+- ✅ **Flexible Configuration** - Support for custom thresholds and parameters
+
+## Installation
+
+```bash
+npm install mm_ip
+```
+
+## Quick Start
+
+### Basic Usage
+
+```javascript
+const { Ip } = require('mm_ip');
+
+// Create IP management instance
+const ip_manager = new Ip();
+
+// Setup logger (optional)
+ip_manager.setup(console);
+
+// Add whitelist IP
+ip_manager.addWhite('192.168.1.100');
+
+// Add blacklist IP
+ip_manager.addBlack('10.0.0.100');
+
+// Check IP status
+console.log('192.168.1.100 in whitelist:', ip_manager.isWhite('192.168.1.100'));
+console.log('10.0.0.100 in blacklist:', ip_manager.isBlack('10.0.0.100'));
+
+// Record IP request
+console.log('192.168.1.100 request result:', ip_manager.record('192.168.1.100'));
+```
+
+### Persistent Storage Configuration
+
+```javascript
+// Create instance with persistent storage configuration
+const persistent_ip = new Ip({
+    dir: './cache/ip', // Storage directory
+    max_white: 1000,   // Maximum whitelist count
+    max_black: 1000    // Maximum blacklist count
+});
+
+// Data will be automatically saved after adding
+persistent_ip.addWhite('192.168.1.101');
+persistent_ip.addBlack('10.0.0.101');
+
+// Auto-load data after restart
+const new_ip = new Ip({ dir: './cache/ip' });
+console.log('Whitelist count after restart:', new_ip.getAllWhite().length);
+```
+
+## API Documentation
+
+### Constructor
+
+```javascript
+new Ip(config)
+```
+
+**Configuration Parameters (config):**
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `max_white` | number | 1000 | Maximum whitelist count |
+| `max_black` | number | 1000 | Maximum blacklist count |
+| `check_interval` | number | 60000 | Check interval (milliseconds) |
+| `max_req_per_min` | number | 100 | Maximum requests per minute |
+| `auto_black_enable` | boolean | true | Enable auto-blacklist for high frequency |
+| `auto_black_threshold` | number | 50 | Auto-blacklist threshold |
+| `auto_black_duration` | number | 3600000 | Auto-blacklist duration (milliseconds) |
+| `violation_enable` | boolean | true | Enable violation records |
+| `violation_max_count` | number | 10 | Maximum violation count |
+| `violation_reset_time` | number | 86400000 | Violation record reset time (milliseconds) |
+| `violation_auto_black` | boolean | true | Auto-blacklist when violation count exceeds limit |
+| `dir` | string | './cache/ip' | Persistent storage directory |
+
+### Main Methods
+
+#### Whitelist Operations
+- `addWhite(ip)` - Add IP to whitelist
+- `delWhite(ip)` - Remove IP from whitelist
+- `isWhite(ip)` - Check if IP is in whitelist
+- `getAllWhite()` - Get all whitelist IPs
+- `clearWhite()` - Clear all whitelist IPs
+
+#### Blacklist Operations
+- `addBlack(ip)` - Add IP to blacklist
+- `delBlack(ip)` - Remove IP from blacklist
+- `isBlack(ip)` - Check if IP is in blacklist
+- `getAllBlack()` - Get all blacklist IPs
+- `clearBlack()` - Clear all blacklist IPs
+- `getBlackExpireTime(ip)` - Get blacklist expiration time
+
+#### IP Request Recording
+- `record(ip)` - Record IP request, return whether access is allowed
+- `getReqCount(ip)` - Get IP request count
+- `getReqFreq(ip)` - Get IP request frequency
+
+#### Violation Records
+- `recordViolation(ip, reason)` - Record IP violation
+- `getViolationCount(ip)` - Get violation count
+- `resetViolation(ip)` - Reset violation record
+- `clearViolations()` - Clear all violation records
+- `getAllViolations()` - Get all violation records
+
+#### Persistent Storage
+- `save()` - Manually save data
+- `load()` - Manually load data
+- `autoSave(interval)` - Enable auto-save
+- `stopAutoSave()` - Stop auto-save
+
+#### Comprehensive Operations
+- `del(ip)` - Delete all records for an IP
+- `setup(logger)` - Setup logger
+
+## Storage File Structure
+
+When persistent storage is enabled, data is stored in three separate files:
+
+```
+cache/ip/
+├── white.json      # Whitelist data
+├── black.json      # Blacklist data
+└── violation.json  # Violation record data
+```
+
+Each file contains corresponding data arrays and timestamp information.
+
+## Testing
+
+Run test cases:
+
+```bash
+npm test
+```
+
+Or run directly:
+
+```bash
+node test.js
+```
+
+## License
+
+ISC License
+
+## Author
+
+qww
+
+## Repository
+
+- Gitee: https://gitee.com/qiuwenwu91/mm_ip.git
+- npm: https://www.npmjs.com/package/mm_ip

package/cache/ip/black.json

@@ -0,0 +1,27 @@
+{
+  "black": [
+    "192.168.100.2",
+    "192.168.200.1",
+    "192.168.200.2",
+    "192.168.200.3"
+  ],
+  "black_time": [
+    [
+      "172.16.0.2",
+      1765261940971
+    ],
+    [
+      "192.168.100.2",
+      1765262134846
+    ],
+    [
+      "192.168.200.2",
+      1765262135900
+    ],
+    [
+      "192.168.200.3",
+      1765262135908
+    ]
+  ],
+  "timestamp": 1765262142949
+}

package/cache/ip/violation.json

@@ -0,0 +1,5 @@
+{
+  "violation_count": [],
+  "violation_time": [],
+  "timestamp": 1765262142949
+}

package/cache/ip/white.json

@@ -0,0 +1,4 @@
+{
+  "white": [],
+  "timestamp": 1765262142949
+}

package/index.js

@@ -25,7 +25,8 @@ class Ip {
             violation_enable: true, // 启用违规记录
             violation_max_count: 10, // 最大违规次数
             violation_reset_time: 86400000, // 违规记录重置时间（24小时）
-            violation_auto_black: true // 违规次数超限自动拉黑
+            violation_auto_black: true, // 违规次数超限自动拉黑
+            dir: './cache/ip' // 持久化存储目录
         }, config || {});
         
         this._white = new Set();
@@ -36,6 +37,11 @@ class Ip {
         this._violation_count = new Map(); // 违规次数记录
         this._violation_time = new Map(); // 违规时间记录
         this._logger = $.log || console;
+        
+        // 自动加载持久化数据
+        if (this._config.dir) {
+            this.load();
+        }
     }
 }
 
@@ -75,6 +81,12 @@ Ip.prototype.addWhite = function (ip) {
 
     this._white.add(ip);
     this.logger('info', '添加白名单IP:', ip);
+    
+    // 自动保存到持久化存储
+    if (this._config.dir) {
+        this.save();
+    }
+    
     return true;
 };
 
@@ -94,6 +106,12 @@ Ip.prototype.addBlack = function (ip) {
 
     this._black.add(ip);
     this.logger('info', '添加黑名单IP:', ip);
+    
+    // 自动保存到持久化存储
+    if (this._config.dir) {
+        this.save();
+    }
+    
     return true;
 };
 
@@ -109,6 +127,11 @@ Ip.prototype.delWhite = function (ip) {
     const result = this._white.delete(ip);
     if (result) {
         this.logger('info', '删除白名单IP:', ip);
+        
+        // 自动保存到持久化存储
+        if (this._config.dir) {
+            this.save();
+        }
     }
     return result;
 };
@@ -125,6 +148,11 @@ Ip.prototype.delBlack = function (ip) {
     const result = this._black.delete(ip);
     if (result) {
         this.logger('info', '删除黑名单IP:', ip);
+        
+        // 自动保存到持久化存储
+        if (this._config.dir) {
+            this.save();
+        }
     }
     return result;
 };
@@ -294,17 +322,27 @@ Ip.prototype.getAllReqIps = function () {
 /**
  * 清空白名单
  */
-Ip.prototype.clearWhite = function () {
+Ip.prototype.clearWhite = function() {
     this._white.clear();
     this.logger('info', '清空白名单');
+    
+    // 自动保存到持久化存储
+    if (this._config.dir) {
+        this.save();
+    }
 };
 
 /**
  * 清空黑名单
  */
-Ip.prototype.clearBlack = function () {
+Ip.prototype.clearBlack = function() {
     this._black.clear();
     this.logger('info', '清空黑名单');
+    
+    // 自动保存到持久化存储
+    if (this._config.dir) {
+        this.save();
+    }
 };
 
 /**
@@ -620,6 +658,194 @@ Ip.prototype.clearViolations = function() {
     this._violation_count.clear();
     this._violation_time.clear();
     this.logger('info', '清空所有违规记录');
+    
+    // 自动保存到持久化存储
+    if (this._config.dir) {
+        this.save();
+    }
+};
+
+/**
+ * 保存IP数据到文件（持久化存储）
+ * @returns {boolean} 是否保存成功
+ */
+Ip.prototype.save = function() {
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        
+        // 确保存储目录存在
+        const dir = this._config.dir;
+        dir.addDir();
+        
+        // 分别保存不同数据到不同文件
+        const timestamp = Date.now();
+        
+        // 保存白名单数据
+        const whiteData = {
+            white: this.getAllWhite(),
+            timestamp: timestamp
+        };
+        const whitePath = path.join(dir, 'white.json');
+        fs.writeFileSync(whitePath, JSON.stringify(whiteData, null, 2), 'utf8');
+        
+        // 保存黑名单数据
+        const blackData = {
+            black: this.getAllBlack(),
+            black_time: Array.from(this._black_time.entries()),
+            timestamp: timestamp
+        };
+        const blackPath = path.join(dir, 'black.json');
+        fs.writeFileSync(blackPath, JSON.stringify(blackData, null, 2), 'utf8');
+        
+        // 保存违规记录数据
+        const violationData = {
+            violation_count: Array.from(this._violation_count.entries()),
+            violation_time: Array.from(this._violation_time.entries()),
+            timestamp: timestamp
+        };
+        const violationPath = path.join(dir, 'violation.json');
+        fs.writeFileSync(violationPath, JSON.stringify(violationData, null, 2), 'utf8');
+        
+        this.logger('info', 'IP数据已分文件保存:', {
+            white: whitePath,
+            black: blackPath,
+            violation: violationPath
+        });
+        return true;
+    } catch (err) {
+        this.logger('error', '保存IP数据失败:', err.message);
+        return false;
+    }
+};
+
+/**
+ * 从文件加载IP数据（持久化存储）
+ * @returns {boolean} 是否加载成功
+ */
+Ip.prototype.load = function() {
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        
+        const dir = this._config.dir;
+        let loadedCount = 0;
+        
+        // 加载白名单数据
+        const whitePath = path.join(dir, 'white.json');
+        if (fs.existsSync(whitePath)) {
+            const content = fs.readFileSync(whitePath, 'utf8');
+            const data = JSON.parse(content);
+            
+            if (Array.isArray(data.white)) {
+                for (const ip of data.white) {
+                    if (typeof ip === 'string') {
+                        this._white.add(ip);
+                    }
+                }
+                loadedCount++;
+                this.logger('info', '白名单数据已加载:', whitePath);
+            }
+        }
+        
+        // 加载黑名单数据
+        const blackPath = path.join(dir, 'black.json');
+        if (fs.existsSync(blackPath)) {
+            const content = fs.readFileSync(blackPath, 'utf8');
+            const data = JSON.parse(content);
+            
+            // 加载黑名单
+            if (Array.isArray(data.black)) {
+                for (const ip of data.black) {
+                    if (typeof ip === 'string') {
+                        this._black.add(ip);
+                    }
+                }
+            }
+            
+            // 加载黑名单过期时间
+            if (Array.isArray(data.black_time)) {
+                for (const [ip, time] of data.black_time) {
+                    if (typeof ip === 'string' && typeof time === 'number') {
+                        this._black_time.set(ip, time);
+                    }
+                }
+            }
+            
+            loadedCount++;
+            this.logger('info', '黑名单数据已加载:', blackPath);
+        }
+        
+        // 加载违规记录数据
+        const violationPath = path.join(dir, 'violation.json');
+        if (fs.existsSync(violationPath)) {
+            const content = fs.readFileSync(violationPath, 'utf8');
+            const data = JSON.parse(content);
+            
+            // 加载违规记录
+            if (Array.isArray(data.violation_count)) {
+                for (const [ip, count] of data.violation_count) {
+                    if (typeof ip === 'string' && typeof count === 'number') {
+                        this._violation_count.set(ip, count);
+                    }
+                }
+            }
+            
+            if (Array.isArray(data.violation_time)) {
+                for (const [ip, time] of data.violation_time) {
+                    if (typeof ip === 'string' && typeof time === 'number') {
+                        this._violation_time.set(ip, time);
+                    }
+                }
+            }
+            
+            loadedCount++;
+            this.logger('info', '违规记录数据已加载:', violationPath);
+        }
+        
+        if (loadedCount === 0) {
+            this.logger('info', '未找到任何IP数据文件，跳过加载');
+        } else {
+            this.logger('info', 'IP数据加载完成，统计:', {
+                white_count: this.getAllWhite().length,
+                black_count: this.getAllBlack().length,
+                violation_count: this.getAllViolationIps().length,
+                files_loaded: loadedCount
+            });
+        }
+        
+        return true;
+    } catch (err) {
+        this.logger('error', '加载IP数据失败:', err.message);
+        return false;
+    }
+};
+
+/**
+ * 自动保存数据（定时保存）
+ * @param {number} interval - 保存间隔（毫秒），默认5分钟
+ */
+Ip.prototype.autoSave = function(interval = 300000) {
+    if (this._autoSaveTimer) {
+        clearInterval(this._autoSaveTimer);
+    }
+    
+    this._autoSaveTimer = setInterval(() => {
+        this.save();
+    }, interval);
+    
+    this.logger('info', '自动保存已启动，间隔:', interval, 'ms');
+};
+
+/**
+ * 停止自动保存
+ */
+Ip.prototype.stopAutoSave = function() {
+    if (this._autoSaveTimer) {
+        clearInterval(this._autoSaveTimer);
+        this._autoSaveTimer = null;
+        this.logger('info', '自动保存已停止');
+    }
 };
 
 /**
@@ -669,9 +895,14 @@ Ip.prototype.del = function(ip) {
         result.black_time = true;
     }
     
-    // 如果有任何删除操作，记录日志
+    // 如果有任何删除操作，记录日志并自动保存
     if (Object.values(result).some(Boolean)) {
         this.logger('info', '删除IP记录:', { ip, result });
+        
+        // 自动保存到持久化存储
+        if (this._config.dir) {
+            this.save();
+        }
     }
     
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_ip",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "用于管理IP名单，可设置白名单、黑名单和IP检查，查询IP请求次数、频率等。",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -198,6 +198,135 @@ setTimeout(() => {
     ip_manager.clearViolations();
     console.log('清空后违规记录数量:', Object.keys(ip_manager.getAllViolations()).length);
     
+    // 测试13: 持久化存储功能（分文件存储）
+    console.log('\n13. 测试持久化存储功能（分文件存储）:');
+    
+    // 创建带持久化配置的实例
+    const persistent_ip = new Ip({
+        dir: './cache/ip',
+        max_white: 3,
+        max_black: 3
+    });
+    persistent_ip.setup(logger);
+    
+    // 添加测试数据
+    console.log('添加测试数据到持久化实例:');
+    persistent_ip.addWhite('192.168.300.1');
+    persistent_ip.addWhite('192.168.300.2');
+    persistent_ip.addBlack('10.0.300.1');
+    persistent_ip.addBlack('10.0.300.2');
+    persistent_ip.recordViolation('172.16.300.1', '测试违规');
+    
+    console.log('保存前数据统计:');
+    console.log('白名单数量:', persistent_ip.getAllWhite().length);
+    console.log('黑名单数量:', persistent_ip.getAllBlack().length);
+    console.log('违规记录数量:', persistent_ip.getAllViolationIps().length);
+    
+    // 保存数据到分文件
+    console.log('保存数据到分文件:', persistent_ip.save());
+    
+    // 验证文件是否创建
+    const fs = require('fs');
+    const path = require('path');
+    const whiteFile = path.join('./cache/ip', 'white.json');
+    const blackFile = path.join('./cache/ip', 'black.json');
+    const violationFile = path.join('./cache/ip', 'violation.json');
+    
+    console.log('检查分文件存储:');
+    console.log('白名单文件存在:', fs.existsSync(whiteFile));
+    console.log('黑名单文件存在:', fs.existsSync(blackFile));
+    console.log('违规记录文件存在:', fs.existsSync(violationFile));
+    
+    // 验证文件内容
+    if (fs.existsSync(whiteFile)) {
+        const whiteData = JSON.parse(fs.readFileSync(whiteFile, 'utf8'));
+        console.log('白名单文件数据:', whiteData.white);
+    }
+    
+    if (fs.existsSync(blackFile)) {
+        const blackData = JSON.parse(fs.readFileSync(blackFile, 'utf8'));
+        console.log('黑名单文件数据:', blackData.black);
+    }
+    
+    if (fs.existsSync(violationFile)) {
+        const violationData = JSON.parse(fs.readFileSync(violationFile, 'utf8'));
+        console.log('违规记录文件数据:', violationData.violation_count);
+    }
+    
+    // 创建新实例并加载数据
+    console.log('创建新实例并加载数据:');
+    const loaded_ip = new Ip({
+        dir: './cache/ip'
+    });
+    loaded_ip.setup(logger);
+    
+    console.log('加载后数据统计:');
+    console.log('白名单数量:', loaded_ip.getAllWhite().length);
+    console.log('黑名单数量:', loaded_ip.getAllBlack().length);
+    console.log('违规记录数量:', loaded_ip.getAllViolationIps().length);
+    
+    // 验证数据一致性
+    console.log('验证数据一致性:');
+    console.log('192.168.300.1 在白名单:', loaded_ip.isWhite('192.168.300.1'));
+    console.log('10.0.300.1 在黑名单:', loaded_ip.isBlack('10.0.300.1'));
+    console.log('172.16.300.1 违规次数:', loaded_ip.getViolationCount('172.16.300.1'));
+    
+    // 测试自动保存
+    console.log('\n测试自动保存功能:');
+    loaded_ip.autoSave(2000); // 2秒间隔便于测试
+    
+    // 添加新数据
+    setTimeout(() => {
+        console.log('添加新数据触发自动保存:');
+        loaded_ip.addWhite('192.168.300.3');
+        
+        // 停止自动保存
+        setTimeout(() => {
+            loaded_ip.stopAutoSave();
+            console.log('自动保存已停止');
+            
+            // 测试删除操作触发自动保存
+            console.log('测试删除操作触发自动保存:');
+            loaded_ip.del('192.168.300.1');
+            
+            // 测试清空操作触发自动保存
+            console.log('测试清空操作触发自动保存:');
+            loaded_ip.clearWhite();
+            
+            console.log('持久化存储功能测试完成');
+            
+            // 测试14: 删除IP记录功能
+            console.log('\n14. 测试删除IP记录功能:');
+            
+            // 准备测试数据
+            ip_manager.addBlack('192.168.300.1');
+            ip_manager.addWhite('192.168.300.1');
+            ip_manager.recordViolation('192.168.300.1', '测试违规');
+            
+            console.log('删除前状态:');
+            console.log('192.168.300.1 在黑名单:', ip_manager.isBlack('192.168.300.1'));
+            console.log('192.168.300.1 在白名单:', ip_manager.isWhite('192.168.300.1'));
+            console.log('192.168.300.1 违规次数:', ip_manager.getViolationCount('192.168.300.1'));
+            console.log('192.168.300.1 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.300.1'));
+            
+            // 删除IP记录
+            const delete_result = ip_manager.del('192.168.300.1');
+            console.log('删除结果:', delete_result);
+            
+            console.log('删除后状态:');
+            console.log('192.168.300.1 在黑名单:', ip_manager.isBlack('192.168.300.1'));
+            console.log('192.168.300.1 在白名单:', ip_manager.isWhite('192.168.300.1'));
+            console.log('192.168.300.1 违规次数:', ip_manager.getViolationCount('192.168.300.1'));
+            console.log('192.168.300.1 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.300.1'));
+            
+            // 测试删除不存在的IP
+            const delete_none_result = ip_manager.del('192.168.999.999');
+            console.log('删除不存在IP的结果:', delete_none_result);
+            
+            console.log('\n=== IP管理模块测试结束 ===');
+        }, 3000);
+    }, 1000);
+    
     // 测试违规记录过期清理
     console.log('\n测试违规记录过期清理:');
     console.log('等待12秒后检查违规记录过期清理...');