748 lines
26 KiB
Go
748 lines
26 KiB
Go
// Package channel 通道领域服务(Day 35):CRUD、测试工具(单条测试短信验证连通性)、
|
|
// 拦截配置(夜发/日限/屏蔽地区)与当日计数。
|
|
package channel
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"gorm.io/gorm"
|
|
|
|
"go-sms/internal/model/entity"
|
|
errs "go-sms/internal/pkg/errors"
|
|
"go-sms/internal/protocol/httpadapter"
|
|
"go-sms/internal/protocol/sgip"
|
|
"go-sms/internal/protocol/smpp"
|
|
"go-sms/internal/repository/mysql"
|
|
"go-sms/internal/service/channel/pool"
|
|
)
|
|
|
|
// 支持的接入协议。
|
|
var validProtocols = map[string]bool{"cmpp": true, "http": true, "sgip": true, "smpp": true}
|
|
|
|
// 拦截结果码(CheckIntercept 返回)。
|
|
const (
|
|
ResultPass int8 = 0 // 放行
|
|
ResultNightBlock int8 = -1 // 夜发拦截
|
|
ResultRegionHit int8 = -2 // 屏蔽地区命中
|
|
ResultDayLimit int8 = -3 // 日限超出(计划验收:-3)
|
|
)
|
|
|
|
// Service 通道服务。
|
|
type Service struct {
|
|
db *gorm.DB
|
|
dao *mysql.BaseDAO[*entity.ChannelChannel]
|
|
|
|
mu sync.Mutex
|
|
dayCnt map[int64]*dayCounter // 通道当日计数(单实例;生产切 Redis)
|
|
|
|
links *pool.Manager // 常驻链路(Day 31+:cmpp.Pool 业务挂载;S1-B P2 拆 pool 子包)
|
|
logs *ChannelLogger // 通道日志(Day 40 · A-3.14;db nil 时为 nil=no-op)
|
|
mon *Monitor // 实时统计(Day 40 · A-3.13;WS 2s 推送源)
|
|
alerts *ChannelAlertService // 通道告警(Day 40 · A-3.12)
|
|
}
|
|
|
|
// dayCounter 当日计数(跨日自动清零)。
|
|
type dayCounter struct {
|
|
date string
|
|
n int
|
|
}
|
|
|
|
// NewService 构造(db 为 nil 时日志/告警降级 no-op,监控统计仍可用)。
|
|
func NewService(db *gorm.DB) *Service {
|
|
s := &Service{db: db, dao: mysql.NewBaseDAO[*entity.ChannelChannel](db), dayCnt: map[int64]*dayCounter{}, mon: NewMonitor()}
|
|
if db != nil {
|
|
s.logs = NewChannelLogger(db)
|
|
}
|
|
s.links = pool.NewManager(s)
|
|
s.alerts = NewChannelAlertService(db, s.mon, s.links.Status, nil)
|
|
s.alerts.SetLogHook(func(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) {
|
|
s.logs.Log(channelID, kind, level, msgID, detail, latencyMs)
|
|
})
|
|
return s
|
|
}
|
|
|
|
// SetUplinkSink 注入上行处理器(nil=维持 Day48 前仅日志/环形缓冲行为;接口定义在 pool 包)。
|
|
func (s *Service) SetUplinkSink(u pool.UplinkSink) { s.links.SetUplinkSink(u) }
|
|
|
|
// SetReportSink 注入回执出口(Day 56;nil=维持 Day55 前仅日志/环形缓冲行为)。
|
|
func (s *Service) SetReportSink(r pool.ReportSink) { s.links.SetReportSink(r) }
|
|
|
|
// ---- pool.Deps 适配(S1-B P2:pool 子包断环;口径与拆分前 linkManager 经 svc.* 直调
|
|
// 一一对应;Get 直接复用既有方法,此处补齐其余五个适配) ----
|
|
|
|
// Pool 常驻链路管理器访问器(S1-B P2;装配层/链路测试注入回执用)。
|
|
func (s *Service) Pool() *pool.Manager { return s.links }
|
|
|
|
// RestartLink 重建链路(S1-B P2 补齐包装:与 StartLink/StopLink 家族对齐)。
|
|
func (s *Service) RestartLink(ctx context.Context, id int64) (*pool.LinkStatus, error) {
|
|
return s.links.RestartLink(ctx, id)
|
|
}
|
|
|
|
// ListCMPPActive 启用中的 CMPP 通道清单(pool.Deps;原 Bootstrap 内联查询)。
|
|
func (s *Service) ListCMPPActive(ctx context.Context) ([]entity.ChannelChannel, error) {
|
|
list, _, err := s.List(ctx, &ListQuery{Page: 1, PageSize: 100, Protocol: "cmpp", Status: 1})
|
|
return list, err
|
|
}
|
|
|
|
// LogChannel 通道日志(pool.Deps;原 svc.logs.Log)。
|
|
func (s *Service) LogChannel(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) {
|
|
s.logs.Log(channelID, kind, level, msgID, detail, latencyMs)
|
|
}
|
|
|
|
// EvaluateChannel 告警评估(pool.Deps;原 svc.alerts.EvaluateChannel)。
|
|
func (s *Service) EvaluateChannel(ctx context.Context, channelID int64) {
|
|
s.alerts.EvaluateChannel(ctx, channelID)
|
|
}
|
|
|
|
// ReportSubmit 提交计数(pool.Deps;原 svc.mon.ReportSubmit)。
|
|
func (s *Service) ReportSubmit(channelID int64, ok bool, latencyMs int) {
|
|
s.mon.ReportSubmit(channelID, ok, latencyMs)
|
|
}
|
|
|
|
// ReportDeliver 回执计数(pool.Deps;原 svc.mon.ReportDeliver)。
|
|
func (s *Service) ReportDeliver(channelID int64, ok bool) { s.mon.ReportDeliver(channelID, ok) }
|
|
|
|
// DB 只读访问器(S1-B P2:pool_test 外部包断环后,链路测试直查库断言用)。
|
|
func (s *Service) DB() *gorm.DB { return s.db }
|
|
|
|
// FlushChannelLogs 立即冲刷通道日志缓冲(nil 安全;pool_test 演练断言用)。
|
|
func (s *Service) FlushChannelLogs() {
|
|
if s.logs != nil {
|
|
s.logs.FlushNow()
|
|
}
|
|
}
|
|
|
|
// LinkReceiptsPersist 持久化回执查询(Day 56):状态报告=message_report_seg
|
|
// (report_at 非空行),上行=message_uplink;按时间倒序归并截取 n 条。
|
|
// 重启后回执可查(环形缓冲 100 条/进程内,本方法为持久层真源);
|
|
// 查询失败返回 error(调用方降级内存环形)。
|
|
func (s *Service) LinkReceiptsPersist(ctx context.Context, channelID int64, n int) ([]pool.Receipt, error) {
|
|
if s.db == nil || n <= 0 {
|
|
return []pool.Receipt{}, nil
|
|
}
|
|
var segs []entity.MessageReportSeg
|
|
if err := s.db.WithContext(ctx).
|
|
Where("channel_id = ? AND report_at IS NOT NULL", channelID).
|
|
Order("report_at DESC").Limit(n).Find(&segs).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
var mos []entity.MessageUplink
|
|
if err := s.db.WithContext(ctx).
|
|
Where("channel_id = ?", channelID).
|
|
Order("recv_at DESC").Limit(n).Find(&mos).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]pool.Receipt, 0, len(segs)+len(mos))
|
|
for _, sg := range segs {
|
|
at := sg.ReportAt.Format("2006-01-02 15:04:05")
|
|
out = append(out, pool.Receipt{
|
|
ChannelID: channelID, IsReport: true, MsgID: sg.MsgID,
|
|
Stat: sg.RawCode, Dest: sg.Mobile, At: at,
|
|
})
|
|
}
|
|
for _, mo := range mos {
|
|
out = append(out, pool.Receipt{
|
|
ChannelID: channelID, IsReport: false,
|
|
Src: mo.SrcMobile, Content: mo.Content,
|
|
At: mo.RecvAt.Format("2006-01-02 15:04:05"),
|
|
})
|
|
}
|
|
// 归并倒序截 n(两路各自倒序,线性归并)。
|
|
sort.Slice(out, func(i, j int) bool { return out[i].At > out[j].At })
|
|
if len(out) > n {
|
|
out = out[:n]
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Close 优雅收尾:冲刷通道日志落库并停止 writer(进程退出/测试 Cleanup 调用)。
|
|
func (s *Service) Close() {
|
|
if s.logs != nil {
|
|
s.logs.Close()
|
|
}
|
|
}
|
|
|
|
// AlertService 暴露告警服务(gateway cron 装配扫描任务)。
|
|
func (s *Service) AlertService() *ChannelAlertService { return s.alerts }
|
|
|
|
// MonitorSnapshot 全通道实时快照(A-3.13:WS 2s 推送/HTTP 轮询共用)。
|
|
func (s *Service) MonitorSnapshot(ctx context.Context) ([]ChannelSnapshot, error) {
|
|
list, _, err := s.List(ctx, &ListQuery{Page: 1, PageSize: 100, Status: -1}) // Status=-1 全量(含停用,运维视图)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]ChannelSnapshot, 0, len(list))
|
|
now := time.Now().Format("2006-01-02 15:04:05")
|
|
for _, ch := range list {
|
|
st := s.links.Status(ch.ID)
|
|
submit, fail, deliver, _, latP50 := s.mon.Stats(ch.ID)
|
|
snap := ChannelSnapshot{
|
|
ChannelID: ch.ID, Name: ch.Name, Protocol: ch.Protocol, Status: ch.Status,
|
|
SubmitPs: float64(submit) / float64(monWindowSec),
|
|
DeliverPs: float64(deliver) / float64(monWindowSec),
|
|
LatencyP50: latP50, UpdatedAt: now,
|
|
}
|
|
if submit > 0 {
|
|
snap.FailRate = float64(fail) / float64(submit)
|
|
}
|
|
if st != nil {
|
|
snap.Running, snap.Total, snap.Healthy = st.Running, st.Total, st.Healthy
|
|
}
|
|
out = append(out, snap)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ListLogs 通道日志查询(A-3.14:连接/提交/回执完整记录;倒序分页)。
|
|
func (s *Service) ListLogs(ctx context.Context, channelID int64, kind string, page, pageSize int) ([]entity.ChannelLog, int64, error) {
|
|
if s.db == nil {
|
|
return nil, 0, pool.ErrLinkUnavailable
|
|
}
|
|
q := s.db.WithContext(ctx).Model(&entity.ChannelLog{}).Where("channel_id = ?", channelID)
|
|
if kind != "" {
|
|
q = q.Where("kind = ?", kind)
|
|
}
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
var list []entity.ChannelLog
|
|
if err := q.Order("id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Find(&list).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return list, total, nil
|
|
}
|
|
|
|
// ---- 常驻链路(Day 31+):导出包装 ----
|
|
|
|
// StartLink 为通道建立常驻长连接(幂等)。
|
|
func (s *Service) StartLink(ctx context.Context, id int64) (*pool.LinkStatus, error) {
|
|
return s.links.StartLink(ctx, id)
|
|
}
|
|
|
|
// StopLink 拆除链路(幂等)。
|
|
func (s *Service) StopLink(id int64) { s.links.StopLink(id) }
|
|
|
|
// LinkStatus 链路状态。
|
|
func (s *Service) LinkStatus(id int64) *pool.LinkStatus { return s.links.Status(id) }
|
|
|
|
// LinkReceipts 最近 n 条回执(倒序;channelID 过滤)。
|
|
func (s *Service) LinkReceipts(channelID int64, n int) []pool.Receipt {
|
|
return s.links.Receipts(channelID, n)
|
|
}
|
|
|
|
// BootstrapLinks 启动时为启用中的 cmpp 通道建链。
|
|
func (s *Service) BootstrapLinks(ctx context.Context) { go s.links.Bootstrap(ctx) }
|
|
|
|
// ShutdownLinks 拆除全部链路。
|
|
func (s *Service) ShutdownLinks() { s.links.Shutdown() }
|
|
|
|
// CreateReq 创建通道请求。
|
|
type CreateReq struct {
|
|
Name string `json:"name" binding:"required"`
|
|
Code string `json:"code" binding:"required"`
|
|
Protocol string `json:"protocol" binding:"required"`
|
|
Host string `json:"host" binding:"required"`
|
|
Port int `json:"port"`
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
Speed int `json:"speed"`
|
|
ConnCount int `json:"conn_count"` // Day 31 联调补:此前缺失导致提交值被忽略(落默认 1)
|
|
UpstreamID int64 `json:"upstream_id"`
|
|
Priority int `json:"priority"`
|
|
Weight int `json:"weight"`
|
|
IsDefault int8 `json:"is_default"`
|
|
Remark string `json:"remark"`
|
|
|
|
// 协议接入参数(Day 31)。
|
|
SpID string `json:"sp_id"` // 企业代码(cmpp/sgip;cmpp ≤6B)
|
|
ProtocolVersion int8 `json:"protocol_version"` // cmpp:20|30 sgip:12 smpp:34(缺省按协议填充)
|
|
HeartbeatInterval int `json:"heartbeat_interval"`
|
|
ReconnectMax int `json:"reconnect_max"`
|
|
ServiceID string `json:"service_id"`
|
|
|
|
// 运营属性(Day 31)。
|
|
Carrier string `json:"carrier"` // 逗号分隔 cmcc,cucc,ctcc
|
|
BillingLength int `json:"billing_length"`
|
|
PaymentType string `json:"payment_type"`
|
|
BillingMode string `json:"billing_mode"`
|
|
Price float64 `json:"price"`
|
|
Category string `json:"category"`
|
|
MOForwardChannelID int64 `json:"mo_forward_channel_id"`
|
|
NumberRule int8 `json:"number_rule"`
|
|
CodeTruncate int8 `json:"code_truncate"`
|
|
ExtParams string `json:"ext_params"`
|
|
ServiceRemark string `json:"service_remark"`
|
|
}
|
|
|
|
// 合法运营属性白名单。
|
|
var (
|
|
validCarriers = map[string]bool{"cmcc": true, "cucc": true, "ctcc": true}
|
|
validPaymentType = map[string]bool{"": true, "prepay_monthly": true, "postpaid_monthly": true, "prepay_realtime": true}
|
|
validBillingMode = map[string]bool{"": true, "success_unknown": true, "success": true, "all": true}
|
|
)
|
|
|
|
// validateExt 校验 Day 31 扩展字段(返回规范化后的值)。
|
|
func (s *Service) validateExt(req *CreateReq) error {
|
|
req.SpID = strings.TrimSpace(req.SpID)
|
|
if len(req.SpID) > 6 {
|
|
return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节")
|
|
}
|
|
// 版本:缺省按协议填充;cmpp 显式拒绝 3.0(协议栈未实现)。
|
|
switch req.Protocol {
|
|
case "cmpp":
|
|
if req.ProtocolVersion == 0 {
|
|
req.ProtocolVersion = 20
|
|
}
|
|
if req.ProtocolVersion == 30 {
|
|
return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)")
|
|
}
|
|
if req.ProtocolVersion != 20 {
|
|
return errs.InvalidParam.WithMsg("CMPP 版本仅支持 2.0")
|
|
}
|
|
case "sgip":
|
|
req.ProtocolVersion = 12
|
|
case "smpp":
|
|
req.ProtocolVersion = 34
|
|
default: // http
|
|
req.ProtocolVersion = 0
|
|
}
|
|
if req.HeartbeatInterval < 0 || req.HeartbeatInterval > 600 {
|
|
return errs.InvalidParam.WithMsg("心跳周期须在 0~600 秒(0 取默认 30)")
|
|
}
|
|
if req.HeartbeatInterval == 0 {
|
|
req.HeartbeatInterval = 30
|
|
}
|
|
if req.ReconnectMax < 0 || req.ReconnectMax > 3600 {
|
|
return errs.InvalidParam.WithMsg("重连上限须在 0~3600 秒(0 取默认 30)")
|
|
}
|
|
if req.ReconnectMax == 0 {
|
|
req.ReconnectMax = 30
|
|
}
|
|
// 运营商:每项须合法。
|
|
for _, c := range strings.Split(req.Carrier, ",") {
|
|
c = strings.TrimSpace(c)
|
|
if c != "" && !validCarriers[c] {
|
|
return errs.InvalidParam.WithMsg("运营商仅支持 cmcc/cucc/ctcc: " + c)
|
|
}
|
|
}
|
|
if !validPaymentType[req.PaymentType] {
|
|
return errs.InvalidParam.WithMsg("付款方式非法(仅 prepay_monthly/postpaid_monthly/prepay_realtime)")
|
|
}
|
|
if !validBillingMode[req.BillingMode] {
|
|
return errs.InvalidParam.WithMsg("计费方式非法(仅 success_unknown/success/all)")
|
|
}
|
|
if req.BillingLength < 0 || req.BillingLength > 1000 {
|
|
return errs.InvalidParam.WithMsg("计费长度须在 0~1000 字(0 取默认 70)")
|
|
}
|
|
if req.BillingLength == 0 {
|
|
req.BillingLength = 70
|
|
}
|
|
if req.Price < 0 {
|
|
return errs.InvalidParam.WithMsg("通道价格不能为负")
|
|
}
|
|
if req.NumberRule < 0 || req.NumberRule > 3 {
|
|
return errs.InvalidParam.WithMsg("号码组装规则仅 0~3")
|
|
}
|
|
if req.CodeTruncate < 0 || req.CodeTruncate > 20 {
|
|
return errs.InvalidParam.WithMsg("通道号截断位数须在 0~20")
|
|
}
|
|
if len(req.ExtParams) > 255 || len(req.ServiceRemark) > 255 {
|
|
return errs.InvalidParam.WithMsg("扩展参数/客服备注不得超过 255 字")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Create 创建通道(协议白名单 + code 唯一)。
|
|
func (s *Service) Create(ctx context.Context, req *CreateReq) (*entity.ChannelChannel, error) {
|
|
req.Code = strings.TrimSpace(req.Code)
|
|
req.Protocol = strings.ToLower(strings.TrimSpace(req.Protocol))
|
|
if !validProtocols[req.Protocol] {
|
|
return nil, errs.InvalidParam.WithMsg("协议仅支持 cmpp/http/sgip/smpp")
|
|
}
|
|
if err := s.validateExt(req); err != nil {
|
|
return nil, err
|
|
}
|
|
var n int64
|
|
s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("code = ?", req.Code).Count(&n)
|
|
if n > 0 {
|
|
return nil, errs.InvalidParam.WithMsg(fmt.Sprintf("通道编码 %s 已存在", req.Code))
|
|
}
|
|
if req.Weight <= 0 {
|
|
req.Weight = 1
|
|
}
|
|
ch := &entity.ChannelChannel{
|
|
Name: req.Name, Code: req.Code, Protocol: req.Protocol,
|
|
Host: req.Host, Port: req.Port, Username: req.Username, Password: req.Password,
|
|
Speed: req.Speed, ConnCount: req.ConnCount, UpstreamID: req.UpstreamID,
|
|
Priority: req.Priority, Weight: req.Weight,
|
|
IsDefault: req.IsDefault, Status: 1, Remark: req.Remark,
|
|
SpID: req.SpID, ProtocolVersion: req.ProtocolVersion,
|
|
HeartbeatInterval: req.HeartbeatInterval, ReconnectMax: req.ReconnectMax,
|
|
ServiceID: req.ServiceID, Carrier: req.Carrier, BillingLength: req.BillingLength,
|
|
PaymentType: req.PaymentType, BillingMode: req.BillingMode, Price: req.Price,
|
|
Category: req.Category, MOForwardChannelID: req.MOForwardChannelID,
|
|
NumberRule: req.NumberRule, CodeTruncate: req.CodeTruncate,
|
|
ExtParams: req.ExtParams, ServiceRemark: req.ServiceRemark,
|
|
}
|
|
if err := s.dao.Create(ctx, ch); err != nil {
|
|
return nil, err
|
|
}
|
|
return ch, nil
|
|
}
|
|
|
|
// Update 白名单字段更新(code/protocol/status 不可改;status 走独立端点)。
|
|
func (s *Service) Update(ctx context.Context, id int64, fields map[string]any) error {
|
|
allowed := map[string]bool{
|
|
"name": true, "host": true, "port": true, "username": true, "password": true,
|
|
"speed": true, "priority": true, "weight": true, "remark": true, "is_default": true,
|
|
// 连接/拦截(Day 31 补:此前缺失导致前端表单全量提交被拒)。
|
|
"conn_count": true, "upstream_id": true, "ext_length": true, "sign_mode": true,
|
|
"template_mode": true, "day_limit": true, "night_limit": true,
|
|
"black_keywords": true, "block_regions": true,
|
|
// 协议接入参数(Day 31)。
|
|
"sp_id": true, "protocol_version": true, "heartbeat_interval": true,
|
|
"reconnect_max": true, "service_id": true,
|
|
// 运营属性(Day 31)。
|
|
"carrier": true, "billing_length": true, "payment_type": true, "billing_mode": true,
|
|
"price": true, "category": true, "mo_forward_channel_id": true, "number_rule": true,
|
|
"code_truncate": true, "ext_params": true, "service_remark": true,
|
|
}
|
|
for k := range fields {
|
|
if !allowed[k] {
|
|
return errs.InvalidParam.WithMsg(fmt.Sprintf("不允许更新字段 %q", k))
|
|
}
|
|
}
|
|
if v, ok := fields["sp_id"].(string); ok && len(strings.TrimSpace(v)) > 6 {
|
|
return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节")
|
|
}
|
|
// 数值经 JSON 绑定为 float64,Go 调用方可能传 int/int64——统一归一化后校验。
|
|
if v, ok := numField(fields, "protocol_version"); ok && v == 30 {
|
|
return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)")
|
|
}
|
|
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(fields)
|
|
if res.Error != nil {
|
|
return res.Error
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return errs.NotFound.WithMsg("通道不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// numField 归一化读取数值字段(float64/int/int64;JSON 与 Go 调用方两种来源)。
|
|
func numField(fields map[string]any, key string) (float64, bool) {
|
|
switch v := fields[key].(type) {
|
|
case float64:
|
|
return v, true
|
|
case int:
|
|
return float64(v), true
|
|
case int64:
|
|
return float64(v), true
|
|
case int8:
|
|
return float64(v), true
|
|
default:
|
|
return 0, false
|
|
}
|
|
}
|
|
|
|
// SetStatus 启用/停用。
|
|
func (s *Service) SetStatus(ctx context.Context, id int64, status int8) error {
|
|
if status != 0 && status != 1 {
|
|
return errs.InvalidParam.WithMsg("状态仅 0/1")
|
|
}
|
|
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Update("status", status)
|
|
if res.Error != nil {
|
|
return res.Error
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return errs.NotFound.WithMsg("通道不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get 详情(NotFound 语义化)。
|
|
func (s *Service) Get(ctx context.Context, id int64) (*entity.ChannelChannel, error) {
|
|
ch, err := s.dao.GetByID(ctx, id)
|
|
if err != nil {
|
|
if stderrors.Is(err, mysql.ErrNotFound) {
|
|
return nil, errs.NotFound.WithMsg("通道不存在")
|
|
}
|
|
return nil, err
|
|
}
|
|
return ch, nil
|
|
}
|
|
|
|
// ListQuery 列表过滤。
|
|
type ListQuery struct {
|
|
Page, PageSize int
|
|
Name string
|
|
Protocol string
|
|
Status int8 // -1 不过滤
|
|
}
|
|
|
|
// List 分页列表(优先级倒序+id 倒序)。
|
|
func (s *Service) List(ctx context.Context, q *ListQuery) ([]entity.ChannelChannel, int64, error) {
|
|
if q.Page <= 0 {
|
|
q.Page = 1
|
|
}
|
|
if q.PageSize <= 0 || q.PageSize > 100 {
|
|
q.PageSize = 20
|
|
}
|
|
tx := s.db.WithContext(ctx).Model(&entity.ChannelChannel{})
|
|
if q.Name != "" {
|
|
tx = tx.Where("name LIKE ?", "%"+q.Name+"%")
|
|
}
|
|
if q.Protocol != "" {
|
|
tx = tx.Where("protocol = ?", q.Protocol)
|
|
}
|
|
if q.Status >= 0 {
|
|
tx = tx.Where("status = ?", q.Status)
|
|
}
|
|
var total int64
|
|
if err := tx.Count(&total).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
var out []entity.ChannelChannel
|
|
if err := tx.Order("priority DESC").Order("id DESC").
|
|
Offset((q.Page - 1) * q.PageSize).Limit(q.PageSize).Find(&out).Error; err != nil {
|
|
return nil, 0, err
|
|
}
|
|
return out, total, nil
|
|
}
|
|
|
|
// Delete 删除(需先停用且不被组引用;Day 36 扩展引用守卫)。
|
|
func (s *Service) Delete(ctx context.Context, id int64) error {
|
|
ch, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if ch.Status != 0 {
|
|
return errs.InvalidParam.WithMsg("通道启用中,须先停用再删除")
|
|
}
|
|
if n := s.channelInUse(ctx, id); n > 0 {
|
|
return errs.InvalidParam.WithMsg(fmt.Sprintf("通道被 %d 个通道组引用,须先移除组成员", n))
|
|
}
|
|
return s.dao.Delete(ctx, id)
|
|
}
|
|
|
|
// ---- 测试工具(Day 35):发送单条测试短信验证连通性 ----
|
|
|
|
// TestResult 测试工具结果。
|
|
type TestResult struct {
|
|
MessageID string `json:"message_id"`
|
|
Protocol string `json:"protocol"`
|
|
ElapsedMS int64 `json:"elapsed_ms"`
|
|
}
|
|
|
|
// TestChannel 用指定通道真实发送一条测试短信,返回上游 MsgID。
|
|
// 验收:测试工具发送通道返回正确 MsgID。
|
|
// SubmitViaLink 单号链路提交(Day56 起返回各段 msg_id;兼容旧调用取 [0])。
|
|
func (s *Service) SubmitViaLink(ctx context.Context, id int64, mobile, content string) ([]string, error) {
|
|
return s.links.SubmitViaLink(ctx, id, mobile, content)
|
|
}
|
|
|
|
func (s *Service) TestChannel(ctx context.Context, id int64, mobile, content string) (*TestResult, error) {
|
|
ch, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if ch.Status != 1 {
|
|
return nil, errs.InvalidParam.WithMsg("通道已停用,无法测试")
|
|
}
|
|
start := time.Now()
|
|
var messageID string
|
|
switch ch.Protocol {
|
|
case "http":
|
|
resp, err := httpadapter.New(httpadapter.Config{
|
|
Endpoint: ch.Host, AuthType: httpadapter.AuthNone, Timeout: 5 * time.Second,
|
|
}).Send(ctx, &httpadapter.SendReq{Mobile: mobile, Content: content})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
messageID = resp.MessageID
|
|
case "cmpp":
|
|
// Day 31+:经常驻链路提交(未建链自动建立,连接保持——网关生成下发记录的必要条件;
|
|
// 回执经 OnDeliver 进环形缓冲/结构化日志)。原短连接工具逻辑由 linkManager 承接。
|
|
mids, err := s.links.SubmitViaLink(ctx, id, mobile, content)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(mids) > 0 {
|
|
messageID = mids[0] // 测试工具视图取首段(与历史展示口径一致)
|
|
}
|
|
case "sgip":
|
|
corpID := ch.SpID // 企业代码:优先 sp_id;空回退 username(历史兼容)
|
|
if corpID == "" {
|
|
corpID = ch.Username
|
|
}
|
|
spNumber := ch.Code // SP 接入码=通道号;空回退 username
|
|
if spNumber == "" {
|
|
spNumber = ch.Username
|
|
}
|
|
c := sgip.NewClient(sgip.Config{
|
|
Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), Name: ch.Username, Password: ch.Password,
|
|
NodeID: 1, Timeout: 5 * time.Second,
|
|
})
|
|
if err := c.Connect(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = c.Close() }()
|
|
result, err := c.Submit(&sgip.SubmitReq{
|
|
SPNumber: spNumber, UserNumbers: []string{mobile}, CorpID: corpID,
|
|
ServiceType: "TEST", Content: []byte(content), ReportFlag: 1,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if result != 0 {
|
|
return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: result=%d", result))
|
|
}
|
|
messageID = "sgip-ok"
|
|
case "smpp":
|
|
// 心跳周期映射 enquire_link(0 值由 smpp.Config.withDefaults 兜底 30s)。
|
|
c := smpp.NewClient(smpp.Config{
|
|
Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), SystemID: ch.Username, Password: ch.Password,
|
|
WindowSize: 1, Timeout: 5 * time.Second,
|
|
HeartbeatInterval: time.Duration(ch.HeartbeatInterval) * time.Second,
|
|
})
|
|
if err := c.Connect(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() { _ = c.Close() }()
|
|
srcAddr := ch.Code // 源地址=接入码;空回退 system_id
|
|
if srcAddr == "" {
|
|
srcAddr = ch.Username
|
|
}
|
|
mid, st, err := c.Submit(&smpp.SubmitReq{
|
|
Source: smpp.Addr{Ton: 1, Npi: 1, Address: srcAddr},
|
|
Dest: smpp.Addr{Ton: 1, Npi: 1, Address: mobile},
|
|
ShortMessage: []byte(content), RegisteredDelivery: 1,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if st != smpp.StatusOK {
|
|
return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: status=0x%08x", uint32(st)))
|
|
}
|
|
messageID = mid
|
|
default:
|
|
return nil, errs.InvalidParam.WithMsg("未知协议 " + ch.Protocol)
|
|
}
|
|
return &TestResult{MessageID: messageID, Protocol: ch.Protocol, ElapsedMS: time.Since(start).Milliseconds()}, nil
|
|
}
|
|
|
|
// ---- 拦截配置(Day 35):夜发/日限/屏蔽地区 ----
|
|
|
|
// InterceptConfig 拦截配置视图。
|
|
type InterceptConfig struct {
|
|
NightLimit int `json:"night_limit"` // >0 开启夜发拦截(22:00-08:00 禁发)
|
|
DayLimit int `json:"day_limit"` // >0 每日上限;超出 result=-3
|
|
BlockRegions string `json:"block_regions"` // 逗号分隔地区(前缀命中)
|
|
BlackKeywords string `json:"black_keywords"` // 展示(命中逻辑在 Day 42 拦截器链)
|
|
}
|
|
|
|
// GetIntercept 查询拦截配置。
|
|
func (s *Service) GetIntercept(ctx context.Context, id int64) (*InterceptConfig, error) {
|
|
ch, err := s.Get(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterceptConfig{
|
|
NightLimit: ch.NightLimit, DayLimit: ch.DayLimit,
|
|
BlockRegions: ch.BlockRegions, BlackKeywords: ch.BlackKeywords,
|
|
}, nil
|
|
}
|
|
|
|
// SetIntercept 设置拦截配置。
|
|
func (s *Service) SetIntercept(ctx context.Context, id int64, cfg *InterceptConfig) error {
|
|
if len(cfg.BlockRegions) > 512 {
|
|
return errs.InvalidParam.WithMsg("屏蔽地区列表过长(≤512)")
|
|
}
|
|
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(map[string]any{
|
|
"night_limit": cfg.NightLimit, "day_limit": cfg.DayLimit, "block_regions": cfg.BlockRegions,
|
|
})
|
|
if res.Error != nil {
|
|
return res.Error
|
|
}
|
|
if res.RowsAffected == 0 {
|
|
return errs.NotFound.WithMsg("通道不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// InterceptVerdict 拦截判定。
|
|
type InterceptVerdict struct {
|
|
Blocked bool
|
|
Result int8 // 见 Result* 常量
|
|
Reason string
|
|
}
|
|
|
|
// CheckIntercept 判定是否拦截(顺序:夜发→地区→日限;now 注入便于测试)。
|
|
// 验收:拦截三配置生效;日限超出返回 -3。
|
|
func (s *Service) CheckIntercept(ch *entity.ChannelChannel, region string, now time.Time) InterceptVerdict {
|
|
if ch.NightLimit > 0 && isNight(now) {
|
|
return InterceptVerdict{Blocked: true, Result: ResultNightBlock,
|
|
Reason: "夜发时段禁止发送(22:00-08:00)"}
|
|
}
|
|
if region != "" && ch.BlockRegions != "" {
|
|
for _, r := range strings.Split(ch.BlockRegions, ",") {
|
|
r = strings.TrimSpace(r)
|
|
if r != "" && (r == region || strings.HasPrefix(region, r)) {
|
|
return InterceptVerdict{Blocked: true, Result: ResultRegionHit,
|
|
Reason: "命中屏蔽地区: " + region}
|
|
}
|
|
}
|
|
}
|
|
if ch.DayLimit > 0 {
|
|
if s.TodayCount(ch.ID) >= ch.DayLimit {
|
|
return InterceptVerdict{Blocked: true, Result: ResultDayLimit,
|
|
Reason: fmt.Sprintf("超出日限 %d(今日已发 %d)", ch.DayLimit, s.TodayCount(ch.ID))}
|
|
}
|
|
}
|
|
return InterceptVerdict{}
|
|
}
|
|
|
|
// IncrDayCount 放行后计数。
|
|
func (s *Service) IncrDayCount(channelID int64) int {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
today := time.Now().Format("2006-01-02")
|
|
c, ok := s.dayCnt[channelID]
|
|
if !ok || c.date != today {
|
|
c = &dayCounter{date: today}
|
|
s.dayCnt[channelID] = c
|
|
}
|
|
c.n++
|
|
return c.n
|
|
}
|
|
|
|
// TodayCount 当日已发数。
|
|
func (s *Service) TodayCount(channelID int64) int {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
today := time.Now().Format("2006-01-02")
|
|
if c, ok := s.dayCnt[channelID]; ok && c.date == today {
|
|
return c.n
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// isNight 夜间时段判定(22:00-08:00,跨越零点)。
|
|
func isNight(t time.Time) bool {
|
|
h := t.Hour()
|
|
return h >= 22 || h < 8
|
|
}
|