关于TDengine 其实时序性服务器，安装TDengin.Connector。这个里面有一些服务的处理。
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using MqttServerApi.Models;
using TDengine.Driver;
using TDengine.Driver.Client;
namespace MqttServerApi.Services
{
public class TDengineService : ITDengineService, IDisposable
{
private readonly ILogger<TDengineService> _logger;
private readonly string _host;
private readonly int _port;
private readonly string _username;
private readonly string _password;
private readonly string _database;
private readonly bool _useSSL;
private object _client;
private bool _disposed;
private readonly object _lock = new object();
public TDengineService(IConfiguration configuration, ILogger<TDengineService> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_host = configuration["TDengine:Host"] ?? "localhost";
var portStr = configuration["TDengine:Port"] ?? "6041";
_port = int.TryParse(portStr, out var port) ? port : 6041;
_username = configuration["TDengine:Username"] ?? "root";
_password = configuration["TDengine:Password"] ?? "taosdata";
_database = configuration["TDengine:Database"] ?? "edge_data";
_useSSL = bool.TryParse(configuration["TDengine:UseSSL"], out var ssl) && ssl;
_logger.LogInformation("TDengineService initialized - Host: {Host}, Port: {Port}, Database: {Database}",
_host, _port, _database);
}
private string BuildConnectionString()
{
var connStr = new StringBuilder();
connStr.Append($"protocol=WebSocket;host={_host};port={_port};useSSL={_useSSL.ToString().ToLower()};database={_database}");
connStr.Append($";username={_username};password={_password}");
return connStr.ToString();
}
private object GetClient()
{
lock (_lock)
{
if (_client != null)
{
return _client;
}
try
{
var connectionString = BuildConnectionString();
_logger.LogDebug("Connecting to TDengine with: {ConnectionString}", connectionString.Replace(_password, "***"));
var builder = new ConnectionStringBuilder(connectionString);
_client = DbDriver.Open(builder);
if (_client == null)
{
throw new TDengineException("Failed to connect to TDengine: client is null");
}
_logger.LogInformation("Successfully connected to TDengine");
return _client;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error connecting to TDengine");
throw new TDengineException("Failed to connect to TDengine", ex);
}
}
}
public async Task<bool> TestConnectionAsync()
{
return await Task.Run(() =>
{
try
{
var client = GetClient();
((dynamic)client).Exec("SHOW DATABASES");
return true;
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to test TDengine connection");
return false;
}
});
}
private string GetStringValue(object value)
{
if (value == null)
{
return null;
}
if (value is byte[] byteArray)
{
return Encoding.UTF8.GetString(byteArray);
}
return value.ToString();
}
private bool DatabaseExists(object client, string database)
{
try
{
using (var rows = ((dynamic)client).Query("SHOW DATABASES"))
{
while (rows.Read())
{
var dbName = GetStringValue(rows.GetValue(0));
if (dbName != null && dbName.Equals(database, StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
}
return false;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error checking database existence");
return false;
}
}
public async Task<TableStructureResponse> GetTableStructureAsync(string database)
{
if (string.IsNullOrWhiteSpace(database))
{
throw new ArgumentException("Database name cannot be null or empty", nameof(database));
}
_logger.LogInformation("Getting table structure for database: {Database}", database);
return await Task.Run(() =>
{
var response = new TableStructureResponse();
try
{
var client = GetClient();
// 切换到指定数据库
((dynamic)client).Exec($"USE `{database}`");
var superTables = GetSuperTables(client);
foreach (var superTable in superTables)
{
var superTableInfo = BuildSuperTableInfo(client, superTable);
response.SuperTables.Add(superTableInfo);
}
_logger.LogInformation("Successfully retrieved table structure. Found {Count} tables", response.SuperTables.Count);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting table structure for database: {Database}", database);
throw;
}
});
}
private List<string> GetSuperTables(object client)
{
var superTables = new List<string>();
try
{
using (var rows = ((dynamic)client).Query("SHOW STABLES"))
{
while (rows.Read())
{
var tableName = GetStringValue(rows.GetValue(0));
if (!string.IsNullOrEmpty(tableName))
{
superTables.Add(tableName);
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting super tables");
}
return superTables;
}
private SuperTableInfo BuildSuperTableInfo(object client, string superTableName)
{
var superTableInfo = new SuperTableInfo
{
TableName = superTableName,
TableType = "SUPER_TABLE",
Columns = new List<ColumnInfo>(),
Tags = new List<ColumnInfo>(),
ChildTables = new List<ChildTableInfo>()
};
try
{
var childTables = GetChildTables(client, superTableName);
foreach (var childTable in childTables)
{
var childTableInfo = new ChildTableInfo
{
TableName = childTable,
SuperTableName = superTableName,
TagValues = new Dictionary<string, object>()
};
superTableInfo.ChildTables.Add(childTableInfo);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error building super table info for: {TableName}", superTableName);
}
return superTableInfo;
}
private List<string> GetChildTables(object client, string superTableName)
{
var childTables = new List<string>();
try
{
using (var rows = ((dynamic)client).Query($"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.INS_TABLES WHERE STABLE_NAME = '{superTableName}'"))
{
while (rows.Read())
{
var tableName = GetStringValue(rows.GetValue(0));
if (!string.IsNullOrEmpty(tableName))
{
childTables.Add(tableName);
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting child tables for: {SuperTableName}", superTableName);
}
return childTables;
}
private List<string> GetStandaloneTables(object client, List<string> superTables)
{
var tables = new List<string>();
try
{
using (var rows = ((dynamic)client).Query("SHOW TABLES"))
{
while (rows.Read())
{
var tableName = GetStringValue(rows.GetValue(0));
string superTable = null;
if (rows.FieldCount > 3)
{
superTable = GetStringValue(rows.GetValue(3));
}
if (string.IsNullOrEmpty(superTable) && !superTables.Contains(tableName))
{
tables.Add(tableName);
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting standalone tables");
}
return tables;
}
public async Task<List<Dictionary<string, object>>> QueryDataAsync(string tableName, DateTime startTime, DateTime endTime, string database = "edge_data", int limit = 1000)
{
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentException("Table name cannot be null or empty", nameof(tableName));
}
if (limit <= 0)
{
limit = 1000; // 默认值
}
//_logger.LogInformation("Querying data for table: {TableName}, from {StartTime} to {EndTime}, limit: {Limit}, offset: {Offset}", tableName, startTime, endTime, limit);
return await Task.Run(() =>
{
var result = new List<Dictionary<string, object>>();
try
{
var client = GetClient();
// 切换到指定数据库
((dynamic)client).Exec($"USE `{database}`");
// 构建查询SQL
string sql = $"SELECT * FROM `{tableName}` WHERE ts >= '{startTime:yyyy-MM-dd HH:mm:ss.fff}' AND ts <= '{endTime:yyyy-MM-dd HH:mm:ss.fff}' ORDER BY ts LIMIT {limit}";
_logger.LogDebug("Executing query: {Sql}", sql);
using (var rows = ((dynamic)client).Query(sql))
{
while (rows.Read())
{
var rowData = new Dictionary<string, object>();
// 获取列数
int fieldCount = rows.FieldCount;
for (int i = 0; i < fieldCount; i++)
{
// 获取列名和值
string columnName = GetStringValue(rows.GetName(i));
object value = rows.GetValue(i);
// 处理字节数组
if (value is byte[] byteArray)
{
rowData[columnName] = Encoding.UTF8.GetString(byteArray);
}
else
{
rowData[columnName] = value;
}
}
result.Add(rowData);
}
}
_logger.LogInformation("Successfully retrieved {Count} records from table: {TableName}", result.Count, tableName);
return result;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error querying data for table: {TableName}", tableName);
throw;
}
});
}
public void Dispose()
{
if (!_disposed)
{
if (_client != null)
{
try
{
((dynamic)_client).Close();
_logger.LogInformation("TDengine connection closed");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error closing TDengine connection");
}
_client = null;
}
_disposed = true;
}
}
}
public class TDengineException : Exception
{
public TDengineException(string message) : base(message) { }
public TDengineException(string message, Exception innerException) : base(message, innerException) { }
}
}还有一些服务器授权的代码。
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Cors;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
using System.Text.Json.Serialization;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using System.Security.Cryptography;
using System.Text;
using System;
namespace MqttServerApi.Controllers
{
[ApiController]
[Route("api/[controller]")]
[EnableCors("OpenCors")]
public class AuthorizationController : ControllerBase
{
private const int AuthCodeLength = 16;
private readonly string _authFilePath = "auth.json";
private readonly string _authLogPath = "auth.log";
/// <summary>
/// 获取设备码，用于用户向公司申请授权码
/// </summary>
[HttpGet("machine-code")]
public IActionResult GetMachineCodeApi()
{
try
{
var machineCode = GetMachineCode();
if (string.IsNullOrEmpty(machineCode))
{
return StatusCode(500, new { success = false, message = "无法获取机器码" });
}
return Ok(new { success = true, machineCode = machineCode });
}
catch (System.Exception ex)
{
return StatusCode(500, new { success = false, message = "获取机器码过程发生错误", error = ex.Message });
}
}
/// <summary>
/// 获取授权状态
/// </summary>
/// <returns>
/// 授权状态信息
/// 未授权时返回: {"success": true, "status": null}
/// 已授权时返回: {"success": true, "status": {"authCode": "授权码", "isAuth": true}}
/// </returns>
[HttpGet("status")]
public async Task<IActionResult> GetAuthorizationStatus()
{
try
{
var authData = await ReadAuthFileAsync();
if (authData == null || !authData.IsAuth)
{
return Ok(new { success = true, status = (object)null });
}
return Ok(new { success = true, status = authData });
}
catch (System.Exception ex)
{
return StatusCode(500, new { success = false, message = "获取授权状态过程发生错误", error = ex.Message });
}
}
/// <summary>
/// 用戶在網頁提交授權碼，API 用本機機器碼經 AES 加密後取 16 位比對，無論成功與否都寫入 auth.json，並將用戶碼與正確碼寫入日誌。
/// </summary>
[HttpPost]
public async Task<IActionResult> SubmitAuthorization([FromBody] AuthorizationRequest request)
{
try
{
var userSubmittedCode = request?.Code?.Trim() ?? string.Empty;
var machineCode = GetMachineCode();
if (string.IsNullOrEmpty(machineCode))
{
await SaveUserAuthToFileAsync(userSubmittedCode, false);
WriteAuthLog(userSubmittedCode, "", false);
return StatusCode(500, new { success = false, message = "无法获取机器码" });
}
var correctCode = EncryptMachineCode(machineCode); // 已改為 16 位
bool isAuth = userSubmittedCode.Length == AuthCodeLength && userSubmittedCode == correctCode;
await SaveUserAuthToFileAsync(userSubmittedCode, isAuth);
WriteAuthLog(userSubmittedCode, correctCode, isAuth);
if (isAuth)
return Ok(new { success = true, message = "授权验证成功" });
return Ok(new { success = false, message = "授权码不匹配，验证失败，请重新录入" });
}
catch (System.Exception ex)
{
var userCode = request?.Code?.Trim() ?? string.Empty;
try { await SaveUserAuthToFileAsync(userCode, false); } catch { }
try { WriteAuthLog(userCode, "", false); } catch { }
return StatusCode(500, new { success = false, message = "验证过程发生错误", error = ex.Message });
}
}
/// <summary>
/// 將用戶提交的授權碼與正確授權碼寫入日誌文件。
/// </summary>
private void WriteAuthLog(string userSubmittedCode, string correctCode, bool isAuth)
{
try
{
var line = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} | UserCode: {userSubmittedCode} | CorrectCode: {correctCode} | Result: {(isAuth ? "Success" : "Fail")}{Environment.NewLine}";
System.IO.File.AppendAllText(_authLogPath, line);
}
catch { /* 日誌寫入失敗不影響主流程 */ }
}
/// <summary>
/// 將用戶提交的授權碼寫入 auth.json(僅用於記錄，不存明文機器碼)。
/// </summary>
private async Task SaveUserAuthToFileAsync(string userSubmittedAuthCode, bool isAuth)
{
var authData = new AuthorizationFileData
{
AuthCode = userSubmittedAuthCode,
IsAuth = isAuth
};
await WriteAuthFileAsync(authData);
}
private async Task WriteAuthFileAsync(AuthorizationFileData authData)
{
var json = JsonSerializer.Serialize(authData, new JsonSerializerOptions { WriteIndented = true });
await System.IO.File.WriteAllTextAsync(_authFilePath, json);
}
private async Task<AuthorizationFileData> ReadAuthFileAsync()
{
if (!System.IO.File.Exists(_authFilePath))
{
return null;
}
try
{
var json = await System.IO.File.ReadAllTextAsync(_authFilePath);
return JsonSerializer.Deserialize<AuthorizationFileData>(json);
}
catch
{
return null;
}
}
/// <summary>
/// 使用 AES 加密機器碼，返回前 16 位作為授權碼(仍為 Base64 字元集，便於比對與顯示)。
/// </summary>
private string EncryptMachineCode(string machineCode)
{
using var aes = CreateAesFromPassword("xwdsoft@2019");
using var encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
var plainBytes = Encoding.UTF8.GetBytes(machineCode);
var cipherBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);
var fullBase64 = System.Convert.ToBase64String(cipherBytes);
return fullBase64.Length >= AuthCodeLength ? fullBase64.Substring(0, AuthCodeLength) : fullBase64;
}
/// <summary>
/// 使用 AES 解密(僅適用完整密文 Base64，不適用 16 位授權碼；16 位為截斷結果無法還原)。
/// </summary>
private string DecryptMachineCode(string encryptedMachineCode)
{
using var aes = CreateAesFromPassword("xwdsoft@2019");
using var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
var cipherBytes = System.Convert.FromBase64String(encryptedMachineCode);
var plainBytes = decryptor.TransformFinalBlock(cipherBytes, 0, cipherBytes.Length);
return Encoding.UTF8.GetString(plainBytes);
}
private Aes CreateAesFromPassword(string password)
{
// 使用 SHA256(password) 作為 32 位元組金鑰，前 16 位元組作為 IV
using var sha256 = SHA256.Create();
var pwdBytes = Encoding.UTF8.GetBytes(password);
var hash = sha256.ComputeHash(pwdBytes); // 32 bytes
var key = hash; // 32 bytes
var iv = new byte[16];
System.Array.Copy(hash, iv, 16);
var aes = Aes.Create();
aes.Key = key;
aes.IV = iv;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
return aes;
}
private string GetMachineCode()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return GetWindowsMachineCode();
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
return GetLinuxMachineCode();
}
return System.Environment.MachineName;
}
private string GetWindowsMachineCode()
{
try
{
using var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Cryptography");
var machineGuid = key?.GetValue("MachineGuid")?.ToString();
if (!string.IsNullOrEmpty(machineGuid))
{
return machineGuid;
}
}
catch
{
// ignore and fallback
}
return System.Environment.MachineName;
}
private string GetLinuxMachineCode()
{
try
{
const string machineIdPath1 = "/etc/machine-id";
const string machineIdPath2 = "/var/lib/dbus/machine-id";
if (System.IO.File.Exists(machineIdPath1))
{
return System.IO.File.ReadAllText(machineIdPath1).Trim();
}
if (System.IO.File.Exists(machineIdPath2))
{
return System.IO.File.ReadAllText(machineIdPath2).Trim();
}
}
catch
{
// ignore and fallback
}
return System.Environment.MachineName;
}
}
public class AuthorizationRequest
{
public string Code { get; set; }
public bool Authorized { get; set; }
}
public class AuthorizationFileData
{
[JsonPropertyName("authCode")]
public string AuthCode { get; set; }
[JsonPropertyName("isAuth")]
public bool IsAuth { get; set; }
}
}
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Cors;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using MqttServerApi.Services;
namespace MqttServerApi.Controllers
{
[ApiController]
[Route("api/[controller]")]
[EnableCors("OpenCors")]
public class DataManagementController : ControllerBase
{
private readonly ITDengineService _tdengineService;
private readonly ILogger<DataManagementController> _logger;
public DataManagementController(
ITDengineService tdengineService,
ILogger<DataManagementController> logger)
{
_tdengineService = tdengineService ?? throw new ArgumentNullException(nameof(tdengineService));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
[HttpGet("table-structure")]
public async Task<IActionResult> GetTableStructure([FromQuery] string database = "edge_data")
{
if (string.IsNullOrWhiteSpace(database))
{
_logger.LogWarning("GetTableStructure called with empty database name");
return BadRequest(new
{
success = false,
message = "数据库名称不能为空"
});
}
if (!IsValidDatabaseName(database))
{
_logger.LogWarning("GetTableStructure called with invalid database name: {Database}", database);
return BadRequest(new
{
success = false,
message = "数据库名称包含无效字符"
});
}
try
{
_logger.LogInformation("Getting table structure for database: {Database}", database);
var result = await _tdengineService.GetTableStructureAsync(database);
if (result == null || result.SuperTables == null || result.SuperTables.Count == 0)
{
_logger.LogInformation("No tables found in database: {Database}", database);
return NotFound(new
{
success = false,
message = $"数据库 '{database}' 中未找到任何表",
data = (object)null
});
}
_logger.LogInformation("Successfully retrieved {Count} tables from database: {Database}",
result.SuperTables.Count, database);
return Ok(new
{
success = true,
message = "获取表结构成功",
data = result
});
}
catch (TDengineException ex)
{
_logger.LogError(ex, "TDengine error while getting table structure for database: {Database}", database);
return StatusCode(503, new
{
success = false,
message = "数据库连接失败，请检查TDengine服务是否正常运行",
error = ex.Message
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Unexpected error while getting table structure for database: {Database}", database);
return StatusCode(500, new
{
success = false,
message = "获取表结构时发生内部错误",
error = ex.Message
});
}
}
[HttpGet("test-connection")]
public async Task<IActionResult> TestConnection()
{
try
{
_logger.LogInformation("Testing TDengine connection");
var isConnected = await _tdengineService.TestConnectionAsync();
if (isConnected)
{
_logger.LogInformation("TDengine connection test successful");
return Ok(new
{
success = true,
message = "数据库连接成功"
});
}
_logger.LogWarning("TDengine connection test failed");
return StatusCode(503, new
{
success = false,
message = "数据库连接失败"
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Error testing TDengine connection");
return StatusCode(500, new
{
success = false,
message = "测试连接时发生错误",
error = ex.Message
});
}
}
private bool IsValidDatabaseName(string database)
{
if (string.IsNullOrWhiteSpace(database))
{
return false;
}
foreach (var c in database)
{
if (!char.IsLetterOrDigit(c) && c != '_')
{
return false;
}
}
return true;
}
[HttpGet("query-data")]
public async Task<IActionResult> QueryData(
[FromQuery] string tableName,
[FromQuery] DateTime startTime,
[FromQuery] DateTime endTime,
[FromQuery] string database = "edge_data",
[FromQuery] int limit = 1000)
{
if (string.IsNullOrWhiteSpace(tableName))
{
_logger.LogWarning("QueryData called with empty table name");
return BadRequest(new
{
success = false,
message = "表名不能为空"
});
}
if (string.IsNullOrWhiteSpace(database))
{
_logger.LogWarning("QueryData called with empty database name");
return BadRequest(new
{
success = false,
message = "数据库名称不能为空"
});
}
if (!IsValidDatabaseName(database))
{
_logger.LogWarning("QueryData called with invalid database name: {Database}", database);
return BadRequest(new
{
success = false,
message = "数据库名称包含无效字符"
});
}
if (startTime >= endTime)
{
_logger.LogWarning("QueryData called with startTime >= endTime");
return BadRequest(new
{
success = false,
message = "开始时间必须小于结束时间"
});
}
if (limit <= 0)
{
limit = 1000; // 默认值
}
try
{
_logger.LogInformation("Querying data for table: {TableName}, database: {Database}, from {StartTime} to {EndTime}, limit: {Limit}",
tableName, database, startTime, endTime, limit);
var result = await _tdengineService.QueryDataAsync(tableName, startTime, endTime, database, limit);
_logger.LogInformation("Successfully retrieved {Count} records from table: {TableName}", result.Count, tableName);
return Ok(new
{
success = true,
message = "查询数据成功",
data = result,
total = result.Count,
limit = limit
});
}
catch (TDengineException ex)
{
_logger.LogError(ex, "TDengine error while querying data for table: {TableName}", tableName);
return StatusCode(503, new
{
success = false,
message = "数据库连接失败，请检查TDengine服务是否正常运行",
error = ex.Message
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Unexpected error while querying data for table: {TableName}", tableName);
return StatusCode(500, new
{
success = false,
message = "查询数据时发生内部错误",
error = ex.Message
});
}
}
}
}最后需要你写个配置。用于监听服务监听。auth.json
{
"authCode": "string",
"isAuth": false
}
#!/bin/bash
JSON_FILE="/home/mqttauth/auth.json"
PROCESS_NAME="XWDTechnology.EdgeServer"
EXEC_CMD="sudo /home/linux64/XWDTechnology.EdgeServer"
STATE_FILE="/tmp/hsl_edge_server_state"
LOG_FILE="/tmp/monitor_debug.log"
# 服务名(用于 systemctl)
SERVICE_NAME="mqttserverapi.service"
LED_PATH="/sys/class/leds/led1/brightness"
# EdgeServer HTTP 关闭接口配置
EDGE_SERVER_IP="192.168.0.15"
EDGE_SERVER_PORT="522"
EDGE_SERVER_USER="admin"
EDGE_SERVER_PASS="123456"
# 新接口：关闭并重启，用户名密码同时放在 URL 参数和 Basic 认证中
EDGE_SERVER_CLOSE_URL="http://${EDGE_SERVER_IP}:${EDGE_SERVER_PORT}/Admin/ServerClose?name=${EDGE_SERVER_USER}&password=${EDGE_SERVER_PASS}"
echo "$(date): 监控脚本启动(仅HTTP关闭，禁用pkill)" >> "$LOG_FILE"
# 检查必要工具
if ! command -v jq &>/dev/null; then
echo "$(date): 警告: jq 未安装，将使用 grep 备用解析" >> "$LOG_FILE"
fi
if ! command -v curl &>/dev/null; then
echo "$(date): 错误: curl 未安装，无法发送 HTTP 关闭请求，脚本退出" >> "$LOG_FILE"
exit 1
fi
# 读取上次 isAuth 状态
if [ -f "$STATE_FILE" ]; then
last_isAuth=$(cat "$STATE_FILE")
else
last_isAuth=""
fi
echo "$(date): 初始 last_isAuth = $last_isAuth" >> "$LOG_FILE"
# --- 初始化 LED 状态(根据 systemd 服务状态)---
if sudo systemctl is-active --quiet "$SERVICE_NAME"; then
sudo sh -c "echo 1 > $LED_PATH" 2>>"$LOG_FILE"
last_service_active=true
echo "$(date): 服务 $SERVICE_NAME 为 active，LED 设置为 1" >> "$LOG_FILE"
else
sudo sh -c "echo 0 > $LED_PATH" 2>>"$LOG_FILE"
last_service_active=false
echo "$(date): 服务 $SERVICE_NAME 未运行，LED 设置为 0" >> "$LOG_FILE"
fi
# 函数：通过 HTTP 请求关闭/重启 EdgeServer(新接口)
stop_edge_server_via_http() {
echo "$(date): 尝试通过 HTTP 请求关闭 EdgeServer(新接口)" >> "$LOG_FILE"
# 发送 POST 请求，同时使用 Basic 认证和 URL 参数，无请求体
response=$(curl --location --request POST "$EDGE_SERVER_CLOSE_URL" \
--user "${EDGE_SERVER_USER}:${EDGE_SERVER_PASS}" \
--header "User-Agent: Apifox/1.0.0 (https://apifox.com)" \
--header "Accept: */*" \
--header "Host: ${EDGE_SERVER_IP}:${EDGE_SERVER_PORT}" \
--header "Connection: keep-alive" \
--header "Content-Length: 0" \
-s -w "\n%{http_code}")
curl_exit=$?
http_code=$(echo "$response" | tail -n1)
content=$(echo "$response" | sed '$d') # 去除最后一行状态码，得到响应内容
if [ $curl_exit -eq 0 ] && [ "$http_code" -ge 200 ] && [ "$http_code" -lt 300 ]; then
echo "$(date): HTTP 请求成功，状态码 $http_code，响应内容: $content" >> "$LOG_FILE"
sleep 3
else
echo "$(date): HTTP 请求失败 (curl 退出码 $curl_exit, HTTP 状态 $http_code)" >> "$LOG_FILE"
fi
}
# 函数：启动 EdgeServer
start_edge_server() {
echo "$(date): 启动 EdgeServer" >> "$LOG_FILE"
nohup $EXEC_CMD > /dev/null 2>&1 &
sleep 2
if pgrep -f "$PROCESS_NAME" > /dev/null; then
echo "$(date): EdgeServer 启动成功" >> "$LOG_FILE"
else
echo "$(date): EdgeServer 启动失败" >> "$LOG_FILE"
fi
}
# 主循环
while true; do
if [ ! -f "$JSON_FILE" ]; then
echo "$(date): 错误: 文件 $JSON_FILE 不存在，退出监控" >> "$LOG_FILE"
exit 1
fi
# ---------- 解析 isAuth ----------
current_isAuth=""
if command -v jq &>/dev/null; then
current_isAuth=$(jq -r '.isAuth' "$JSON_FILE" 2>>"$LOG_FILE")
if [ $? -ne 0 ] || [ "$current_isAuth" != "true" -a "$current_isAuth" != "false" ]; then
echo "$(date): jq 解析失败或值无效: $current_isAuth" >> "$LOG_FILE"
current_isAuth=""
fi
fi
if [ -z "$current_isAuth" ]; then
# 备用 grep
if grep -q '"isAuth": *true' "$JSON_FILE"; then
current_isAuth="true"
elif grep -q '"isAuth": *false' "$JSON_FILE"; then
current_isAuth="false"
else
echo "$(date): 错误: 无法确定 isAuth 的值，跳过本次检查" >> "$LOG_FILE"
fi
if [ -n "$current_isAuth" ]; then
echo "$(date): 使用 grep 解析到 current_isAuth = $current_isAuth" >> "$LOG_FILE"
fi
else
echo "$(date): 使用 jq 解析到 current_isAuth = $current_isAuth" >> "$LOG_FILE"
fi
# 如果解析失败，跳过本轮处理
if [ -z "$current_isAuth" ]; then
sleep 10
continue
fi
# ---------- 处理 isAuth 变化 ----------
if [ "$current_isAuth" != "$last_isAuth" ]; then
echo "$(date): 检测到 isAuth 从 $last_isAuth 变为 $current_isAuth" >> "$LOG_FILE"
if [ "$current_isAuth" = "true" ]; then
# false -> true：先尝试关闭旧进程(如有)，再启动
if pgrep -f "$PROCESS_NAME" > /dev/null; then
stop_edge_server_via_http
fi
start_edge_server
else
# true -> false：尝试关闭进程
if pgrep -f "$PROCESS_NAME" > /dev/null; then
stop_edge_server_via_http
fi
fi
# 更新状态文件
echo "$current_isAuth" > "$STATE_FILE"
last_isAuth="$current_isAuth"
else
echo "$(date): isAuth 无变化 ($current_isAuth)，跳过变化处理" >> "$LOG_FILE"
fi
# ---------- 确保进程状态与 isAuth 一致(崩溃恢复/残留清理)----------
if [ "$current_isAuth" = "true" ]; then
if ! pgrep -f "$PROCESS_NAME" > /dev/null; then
echo "$(date): isAuth 为 true 但进程不存在，启动 EdgeServer" >> "$LOG_FILE"
start_edge_server
fi
else # current_isAuth = false
if pgrep -f "$PROCESS_NAME" > /dev/null; then
echo "$(date): isAuth 为 false 但进程仍在运行，尝试通过 HTTP 关闭" >> "$LOG_FILE"
stop_edge_server_via_http
fi
fi
# ---------- 检查 systemd 服务状态并控制 LED ----------
current_service_active=false
if sudo systemctl is-active --quiet "$SERVICE_NAME"; then
current_service_active=true
fi
if [ "$current_service_active" != "$last_service_active" ]; then
if [ "$current_service_active" = true ]; then
sudo sh -c "echo 1 > $LED_PATH" 2>>"$LOG_FILE"
echo "$(date): 服务 $SERVICE_NAME 变为 active，LED 设置为 1" >> "$LOG_FILE"
else
sudo sh -c "echo 0 > $LED_PATH" 2>>"$LOG_FILE"
echo "$(date): 服务 $SERVICE_NAME 变为 inactive，LED 设置为 0" >> "$LOG_FILE"
fi
last_service_active=$current_service_active
else
echo "$(date): 服务状态无变化 (active=$current_service_active)，LED 不变" >> "$LOG_FILE"
fi
sleep 10
done最后这个脚本在linux中进行监听。