feat: add phone frequency controls and modularize codebase
This commit is contained in:
hectorzhao
@@ -0,0 +1,187 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The Submit barrier is intentionally colocated with ACK tracking: a queued
|
||||
// receipt must never overtake the SubmitResp that establishes its Msg_Id.
|
||||
|
||||
const defaultDownstreamAckTimeout = 30 * time.Second
|
||||
|
||||
type downstreamAckTracker struct {
|
||||
deliveryID string
|
||||
connectionID string
|
||||
sequenceID uint32
|
||||
messageID uint64
|
||||
session *downstreamSession
|
||||
timer *time.Timer
|
||||
}
|
||||
|
||||
var downstreamAckRegistry = struct {
|
||||
sync.Mutex
|
||||
items map[string]*downstreamAckTracker
|
||||
}{items: make(map[string]*downstreamAckTracker)}
|
||||
|
||||
var downstreamSubmitBarrier = struct {
|
||||
sync.RWMutex
|
||||
byConn map[*cmpp.Conn]int
|
||||
}{byConn: make(map[*cmpp.Conn]int)}
|
||||
|
||||
func beginDownstreamSubmitBarrier(conn *cmpp.Conn) func() {
|
||||
if conn == nil {
|
||||
return func() {}
|
||||
}
|
||||
downstreamSubmitBarrier.Lock()
|
||||
downstreamSubmitBarrier.byConn[conn]++
|
||||
downstreamSubmitBarrier.Unlock()
|
||||
var once sync.Once
|
||||
return func() {
|
||||
once.Do(func() {
|
||||
downstreamSubmitBarrier.Lock()
|
||||
if downstreamSubmitBarrier.byConn[conn] <= 1 {
|
||||
delete(downstreamSubmitBarrier.byConn, conn)
|
||||
} else {
|
||||
downstreamSubmitBarrier.byConn[conn]--
|
||||
}
|
||||
downstreamSubmitBarrier.Unlock()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func downstreamSubmitResponsePending(conn *cmpp.Conn) bool {
|
||||
if conn == nil {
|
||||
return false
|
||||
}
|
||||
downstreamSubmitBarrier.RLock()
|
||||
defer downstreamSubmitBarrier.RUnlock()
|
||||
return downstreamSubmitBarrier.byConn[conn] > 0
|
||||
}
|
||||
|
||||
func downstreamAckKey(conn *cmpp.Conn, sequenceID uint32) string {
|
||||
return fmt.Sprintf("%p:%d", conn, sequenceID)
|
||||
}
|
||||
|
||||
func registerDownstreamAck(session *downstreamSession, deliveryID string, sequenceID uint32, messageID uint64, deadline time.Time) *downstreamAckTracker {
|
||||
if session == nil || session.conn == nil || strings.TrimSpace(deliveryID) == "" {
|
||||
return nil
|
||||
}
|
||||
tracker := &downstreamAckTracker{
|
||||
deliveryID: deliveryID, connectionID: session.connectionID,
|
||||
sequenceID: sequenceID, messageID: messageID, session: session,
|
||||
}
|
||||
key := downstreamAckKey(session.conn, sequenceID)
|
||||
downstreamAckRegistry.Lock()
|
||||
downstreamAckRegistry.items[key] = tracker
|
||||
downstreamAckRegistry.Unlock()
|
||||
tracker.timer = time.AfterFunc(time.Until(deadline), func() {
|
||||
timedOut := takeDownstreamAck(session.conn, sequenceID)
|
||||
if timedOut == nil || timedOut.session == nil || timedOut.session.deliveryReport == nil {
|
||||
return
|
||||
}
|
||||
timedOut.session.deliveryReport(downstreamDeliveryLifecycleEvent{
|
||||
Kind: "failed", DeliveryID: timedOut.deliveryID, ConnectionID: timedOut.connectionID,
|
||||
SequenceID: timedOut.sequenceID, MessageID: timedOut.messageID, ObservedAt: time.Now().UTC(),
|
||||
FailureType: "ack_timeout", ErrorMessage: "CMPP_DELIVER_RESP timeout",
|
||||
})
|
||||
})
|
||||
return tracker
|
||||
}
|
||||
|
||||
func takeDownstreamAck(conn *cmpp.Conn, sequenceID uint32) *downstreamAckTracker {
|
||||
key := downstreamAckKey(conn, sequenceID)
|
||||
downstreamAckRegistry.Lock()
|
||||
tracker := downstreamAckRegistry.items[key]
|
||||
delete(downstreamAckRegistry.items, key)
|
||||
downstreamAckRegistry.Unlock()
|
||||
if tracker != nil && tracker.timer != nil {
|
||||
tracker.timer.Stop()
|
||||
}
|
||||
return tracker
|
||||
}
|
||||
|
||||
func removeDownstreamAck(tracker *downstreamAckTracker) {
|
||||
if tracker == nil || tracker.session == nil {
|
||||
return
|
||||
}
|
||||
_ = takeDownstreamAck(tracker.session.conn, tracker.sequenceID)
|
||||
}
|
||||
|
||||
func handleDownstreamAcknowledgement(conn *cmpp.Conn, sequenceID uint32, messageID uint64, result uint32, logger *log.Logger) {
|
||||
tracker := takeDownstreamAck(conn, sequenceID)
|
||||
if tracker == nil {
|
||||
if logger != nil {
|
||||
logger.Printf("cmpp inbound event=deliver_ack_unmatched seq=%d message_id=%d result=%d", sequenceID, messageID, result)
|
||||
}
|
||||
if session := findSessionByConn(conn); session != nil && session.protocolLog != nil {
|
||||
session.protocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "client_to_platform",
|
||||
EventType: "deliver_resp",
|
||||
Status: "failed",
|
||||
TenantID: session.tenantID,
|
||||
ApplicationID: session.applicationID,
|
||||
Account: session.account,
|
||||
MessageID: session.messageID,
|
||||
GatewayMessageID: strconv.FormatUint(messageID, 10),
|
||||
Phone: session.phoneNumber,
|
||||
ResultCode: strconv.FormatUint(uint64(result), 10),
|
||||
Detail: map[string]any{"sequenceId": sequenceID, "unmatched": true},
|
||||
})
|
||||
}
|
||||
return
|
||||
}
|
||||
if tracker.messageID != messageID {
|
||||
if logger != nil {
|
||||
logger.Printf("cmpp inbound event=deliver_ack_message_mismatch delivery_id=%s seq=%d expected_message_id=%d actual_message_id=%d", tracker.deliveryID, sequenceID, tracker.messageID, messageID)
|
||||
}
|
||||
result = 1
|
||||
}
|
||||
if logger != nil {
|
||||
logger.Printf("cmpp inbound event=deliver_acknowledged delivery_id=%s connection_id=%s seq=%d message_id=%d result=%d", tracker.deliveryID, tracker.connectionID, sequenceID, messageID, result)
|
||||
}
|
||||
if tracker.session != nil && tracker.session.deliveryReport != nil {
|
||||
go tracker.session.deliveryReport(downstreamDeliveryLifecycleEvent{
|
||||
Kind: "acknowledged", DeliveryID: tracker.deliveryID, ConnectionID: tracker.connectionID,
|
||||
SequenceID: sequenceID, MessageID: messageID, Result: result, ObservedAt: time.Now().UTC(),
|
||||
})
|
||||
}
|
||||
if tracker.session != nil && tracker.session.protocolLog != nil {
|
||||
status := "success"
|
||||
if result != 0 {
|
||||
status = "failed"
|
||||
}
|
||||
tracker.session.protocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "client_to_platform",
|
||||
EventType: "deliver_resp",
|
||||
Status: status,
|
||||
TenantID: tracker.session.tenantID,
|
||||
ApplicationID: tracker.session.applicationID,
|
||||
Account: tracker.session.account,
|
||||
MessageID: tracker.session.messageID,
|
||||
GatewayMessageID: strconv.FormatUint(messageID, 10),
|
||||
Phone: tracker.session.phoneNumber,
|
||||
ResultCode: strconv.FormatUint(uint64(result), 10),
|
||||
Detail: map[string]any{"sequenceId": sequenceID, "deliveryId": tracker.deliveryID},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func downstreamAckTimeout() time.Duration {
|
||||
configured, err := strconv.Atoi(strings.TrimSpace(os.Getenv("CMPP_DOWNSTREAM_ACK_TIMEOUT_SECONDS")))
|
||||
if err != nil || configured <= 0 {
|
||||
return defaultDownstreamAckTimeout
|
||||
}
|
||||
if configured < 5 {
|
||||
configured = 5
|
||||
}
|
||||
return time.Duration(configured) * time.Second
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"net"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type authRequest struct {
|
||||
Account string `json:"account"`
|
||||
AuthSource string `json:"authSource"`
|
||||
Timestamp uint32 `json:"timestamp"`
|
||||
RemoteIP string `json:"remoteIp,omitempty"`
|
||||
}
|
||||
|
||||
type authResponse struct {
|
||||
PasswordCipher string `json:"passwordCipher"`
|
||||
ApplicationID string `json:"applicationId"`
|
||||
TenantID string `json:"tenantId"`
|
||||
Account string `json:"account"`
|
||||
EnterpriseCode string `json:"enterpriseCode"`
|
||||
MaxConnections int `json:"maxConnections"`
|
||||
}
|
||||
|
||||
func (s Server) handleLogin(response *cmpp.Response, packet *cmpp.Packet, logger *log.Logger) (bool, error) {
|
||||
req, ok := packet.Packer.(*cmpp.CmppConnReqPkt)
|
||||
if !ok {
|
||||
return true, nil
|
||||
}
|
||||
account := strings.TrimRight(req.SrcAddr, "\x00")
|
||||
if account == "" {
|
||||
setInboundConnectResponse(response.Packer, cmpp.ErrnoConnInvalidSrcAddr, req.AuthSrc, "", req.Version)
|
||||
return false, cmpp.ConnRspStatusErrMap[cmpp.ErrnoConnInvalidSrcAddr]
|
||||
}
|
||||
if req.Version != cmpp.V20 && req.Version != cmpp.V21 && req.Version != cmpp.V30 {
|
||||
setInboundConnectResponse(response.Packer, cmpp.ErrnoConnVerTooHigh, req.AuthSrc, "", cmpp.V30)
|
||||
return false, cmpp.ConnRspStatusErrMap[cmpp.ErrnoConnVerTooHigh]
|
||||
}
|
||||
auth, err := s.authenticate(packet.Conn.Conn.RemoteAddr(), account, req.AuthSrc, req.Timestamp)
|
||||
if err != nil {
|
||||
logger.Printf("cmpp inbound auth failed account=%s remote=%s err=%v", account, packet.Conn.Conn.RemoteAddr(), err)
|
||||
setInboundConnectResponse(response.Packer, cmpp.ErrnoConnAuthFailed, req.AuthSrc, "", req.Version)
|
||||
return false, cmpp.ConnRspStatusErrMap[cmpp.ErrnoConnAuthFailed]
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
session := &downstreamSession{
|
||||
account: strings.TrimSpace(defaultString(auth.Account, account)),
|
||||
tenantID: strings.TrimSpace(auth.TenantID),
|
||||
applicationID: strings.TrimSpace(auth.ApplicationID),
|
||||
enterpriseCode: strings.TrimSpace(auth.EnterpriseCode),
|
||||
protocol: cmppVersionName(req.Version),
|
||||
srcID: strings.TrimSpace(auth.Account),
|
||||
remoteIP: remoteIP(packet.Conn.Conn.RemoteAddr()),
|
||||
connectedAt: now,
|
||||
connectionID: fmt.Sprintf("%s-%d", s.gatewayInstanceID(), now.UnixNano()),
|
||||
conn: packet.Conn,
|
||||
mu: &sync.Mutex{},
|
||||
presence: s.PresenceStore,
|
||||
instanceID: s.gatewayInstanceID(),
|
||||
report: s.reportConnection,
|
||||
deliveryReport: s.reportDownstreamDelivery,
|
||||
protocolLog: s.emitProtocolLog,
|
||||
}
|
||||
if !rememberAccount(session, auth.MaxConnections) {
|
||||
logger.Printf("cmpp inbound auth failed account=%s remote=%s err=connection limit exceeded max=%d", account, packet.Conn.Conn.RemoteAddr(), auth.MaxConnections)
|
||||
setInboundConnectResponse(response.Packer, cmpp.ErrnoConnOthers, req.AuthSrc, "", req.Version)
|
||||
return false, cmpp.ConnRspStatusErrMap[cmpp.ErrnoConnOthers]
|
||||
}
|
||||
setInboundConnectResponse(response.Packer, 0, req.AuthSrc, auth.PasswordCipher, req.Version)
|
||||
go s.reportConnectionOrDisconnect(session, "connected", "")
|
||||
response.AfterSend = func(sendErr error) {
|
||||
if sendErr == nil {
|
||||
go s.flushPending(defaultString(auth.Account, account), logger)
|
||||
}
|
||||
}
|
||||
logger.Printf(
|
||||
"cmpp inbound event=login_accepted protocol=%s requested_version=0x%02x response_version=0x%02x account=%s remote=%s",
|
||||
cmppVersionName(req.Version), uint8(req.Version), uint8(req.Version), account, packet.Conn.Conn.RemoteAddr(),
|
||||
)
|
||||
return false, nil
|
||||
}
|
||||
|
||||
func setInboundConnectResponse(packet any, status uint8, authSource string, secret string, version cmpp.Type) {
|
||||
switch resp := packet.(type) {
|
||||
case *cmpp.Cmpp2ConnRspPkt:
|
||||
resp.Status = status
|
||||
resp.AuthSrc = authSource
|
||||
resp.Secret = secret
|
||||
resp.Version = version
|
||||
case *cmpp.Cmpp3ConnRspPkt:
|
||||
resp.Status = uint32(status)
|
||||
resp.AuthSrc = authSource
|
||||
resp.Secret = secret
|
||||
resp.Version = version
|
||||
}
|
||||
}
|
||||
|
||||
func cmppVersionName(version cmpp.Type) string {
|
||||
switch version {
|
||||
case cmpp.V20:
|
||||
return "cmpp20"
|
||||
case cmpp.V21:
|
||||
return "cmpp21"
|
||||
case cmpp.V30:
|
||||
return "cmpp30"
|
||||
default:
|
||||
return fmt.Sprintf("unknown_0x%02x", uint8(version))
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) authenticate(remote net.Addr, account string, authSource string, timestamp uint32) (authResponse, error) {
|
||||
payload := authRequest{
|
||||
Account: account,
|
||||
AuthSource: base64.StdEncoding.EncodeToString([]byte(authSource)),
|
||||
Timestamp: timestamp,
|
||||
RemoteIP: remoteIP(remote),
|
||||
}
|
||||
var result authResponse
|
||||
err := s.post(context.Background(), "/gateway/events/inbound/authenticate", payload, &result)
|
||||
return result, err
|
||||
}
|
||||
@@ -0,0 +1,342 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
cmpputils "github.com/bigwhite/gocmpp/utils"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Receipt delivery requires the original Submit mapping. Falling back to an
|
||||
// arbitrary account session would acknowledge a message with the wrong Msg_Id.
|
||||
|
||||
type DownstreamReceipt struct {
|
||||
DeliveryID string `json:"deliveryId,omitempty"`
|
||||
Account string `json:"account,omitempty"`
|
||||
ApplicationID string `json:"applicationId,omitempty"`
|
||||
MessageID string `json:"messageId"`
|
||||
GatewayMessageID string `json:"gatewayMessageId,omitempty"`
|
||||
PhoneNumber string `json:"phoneNumber,omitempty"`
|
||||
ReceiptStatus string `json:"receiptStatus"`
|
||||
RawStatus string `json:"rawStatus,omitempty"`
|
||||
ErrorCode string `json:"errorCode,omitempty"`
|
||||
SubmitSequenceID uint32 `json:"submitSequenceId,omitempty"`
|
||||
SubmitGroupMessageID string `json:"submitGroupMessageId,omitempty"`
|
||||
DeliveredAt string `json:"deliveredAt,omitempty"`
|
||||
}
|
||||
|
||||
type DownstreamUplink struct {
|
||||
DeliveryID string `json:"deliveryId,omitempty"`
|
||||
Account string `json:"account,omitempty"`
|
||||
ApplicationID string `json:"applicationId,omitempty"`
|
||||
MessageID string `json:"messageId,omitempty"`
|
||||
PhoneNumber string `json:"phoneNumber"`
|
||||
DestID string `json:"destId"`
|
||||
Content string `json:"content"`
|
||||
ReceivedAt string `json:"receivedAt,omitempty"`
|
||||
}
|
||||
|
||||
type DownstreamSendResult struct {
|
||||
Sent bool `json:"sent"`
|
||||
Retryable bool `json:"retryable"`
|
||||
ReasonCode string `json:"reasonCode,omitempty"`
|
||||
ErrorMessage string `json:"errorMessage,omitempty"`
|
||||
ConnectionID string `json:"connectionId,omitempty"`
|
||||
SequenceID string `json:"sequenceId,omitempty"`
|
||||
MessageID string `json:"messageId,omitempty"`
|
||||
SentAt string `json:"sentAt,omitempty"`
|
||||
AckDeadlineAt string `json:"ackDeadlineAt,omitempty"`
|
||||
}
|
||||
|
||||
type downstreamDeliveryLifecycleEvent struct {
|
||||
Kind string
|
||||
DeliveryID string
|
||||
ConnectionID string
|
||||
SequenceID uint32
|
||||
MessageID uint64
|
||||
Result uint32
|
||||
ObservedAt time.Time
|
||||
AckDeadlineAt time.Time
|
||||
FailureType string
|
||||
ErrorMessage string
|
||||
}
|
||||
|
||||
func (s Server) reportDownstreamDelivery(event downstreamDeliveryLifecycleEvent) {
|
||||
if strings.TrimSpace(event.DeliveryID) == "" {
|
||||
return
|
||||
}
|
||||
payload := map[string]any{
|
||||
"id": event.DeliveryID, "connectionId": event.ConnectionID,
|
||||
"sequenceId": strconv.FormatUint(uint64(event.SequenceID), 10),
|
||||
"messageId": strconv.FormatUint(event.MessageID, 10),
|
||||
}
|
||||
switch event.Kind {
|
||||
case "sent":
|
||||
payload["sentAt"] = formatRFC3339Nano(event.ObservedAt)
|
||||
payload["ackDeadlineAt"] = formatRFC3339Nano(event.AckDeadlineAt)
|
||||
_ = s.post(context.Background(), "/gateway/events/downstream/sent", payload, nil)
|
||||
case "acknowledged":
|
||||
payload["result"] = event.Result
|
||||
payload["acknowledgedAt"] = formatRFC3339Nano(event.ObservedAt)
|
||||
_ = s.post(context.Background(), "/gateway/events/downstream/acknowledged", payload, nil)
|
||||
case "failed":
|
||||
payload["failureType"] = event.FailureType
|
||||
payload["errorMessage"] = event.ErrorMessage
|
||||
_ = s.post(context.Background(), "/gateway/events/downstream/failed", payload, nil)
|
||||
}
|
||||
}
|
||||
|
||||
func PushReceipt(event DownstreamReceipt) (bool, error) {
|
||||
result, err := PushReceiptWithResult(event)
|
||||
return result.Sent, err
|
||||
}
|
||||
|
||||
func PushReceiptWithResult(event DownstreamReceipt) (DownstreamSendResult, error) {
|
||||
return pushReceiptWithResult(event, true)
|
||||
}
|
||||
|
||||
func pushReceiptWithResult(event DownstreamReceipt, allowRecovery bool) (DownstreamSendResult, error) {
|
||||
session := findReceiptSession(event.MessageID, event.Account)
|
||||
if session == nil && allowRecovery {
|
||||
session = recoverReceiptSession(event)
|
||||
}
|
||||
if session == nil {
|
||||
if event.SubmitSequenceID == 0 {
|
||||
return DownstreamSendResult{
|
||||
Retryable: false,
|
||||
ReasonCode: "MISSING_SUBMIT_SEQUENCE_ID",
|
||||
ErrorMessage: "历史回执缺少原 Submit Sequence_Id，无法重建 Msg_Id，系统已终止重投",
|
||||
}, nil
|
||||
}
|
||||
if strings.TrimSpace(event.MessageID) == "" || strings.TrimSpace(event.Account) == "" {
|
||||
return DownstreamSendResult{
|
||||
Retryable: false,
|
||||
ReasonCode: "INVALID_RECEIPT_PAYLOAD",
|
||||
ErrorMessage: "状态回执缺少平台消息 ID 或客户账号，系统已终止重投",
|
||||
}, nil
|
||||
}
|
||||
return DownstreamSendResult{
|
||||
Retryable: true,
|
||||
ReasonCode: "CLIENT_DISCONNECTED",
|
||||
ErrorMessage: "下游客户端当前未连接，等待自动重试",
|
||||
}, nil
|
||||
}
|
||||
if downstreamSubmitResponsePending(session.conn) {
|
||||
return DownstreamSendResult{
|
||||
Retryable: true,
|
||||
ReasonCode: "SUBMIT_RESPONSE_PENDING",
|
||||
ErrorMessage: "客户 SubmitResp 尚未完成写出，回执已保留并等待响应后投递",
|
||||
}, nil
|
||||
}
|
||||
stat := strings.TrimSpace(event.RawStatus)
|
||||
if stat == "" {
|
||||
stat = cmppReceiptStatus(event.ReceiptStatus)
|
||||
}
|
||||
when := time.Now()
|
||||
if event.DeliveredAt != "" {
|
||||
if parsed, err := time.Parse(time.RFC3339Nano, event.DeliveredAt); err == nil {
|
||||
when = parsed
|
||||
}
|
||||
}
|
||||
receipt := &cmpp.CmppReceiptPkt{
|
||||
MsgId: session.gatewayMsgID,
|
||||
Stat: stat,
|
||||
SubmitTime: when.Format("0601021504"),
|
||||
DoneTime: when.Format("0601021504"),
|
||||
DestTerminalId: defaultString(event.PhoneNumber, session.phoneNumber),
|
||||
SmscSequence: uint32(time.Now().UnixNano() & 0xffffffff),
|
||||
}
|
||||
receiptBytes, err := receipt.Pack()
|
||||
if err != nil {
|
||||
return DownstreamSendResult{}, err
|
||||
}
|
||||
deliver := downstreamDeliverPacket(session, session.gatewayMsgID, session.srcID, defaultString(event.PhoneNumber, session.phoneNumber), 0, 1, string(receiptBytes))
|
||||
return sendDownstream(session, deliver, event.DeliveryID)
|
||||
}
|
||||
|
||||
func findReceiptSession(messageID string, account string) *downstreamSession {
|
||||
downstreamRegistry.RLock()
|
||||
defer downstreamRegistry.RUnlock()
|
||||
if messageID != "" {
|
||||
return downstreamRegistry.byMessageID[messageID]
|
||||
}
|
||||
if account != "" {
|
||||
return downstreamRegistry.byAccount[account]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func recoverReceiptSession(event DownstreamReceipt) *downstreamSession {
|
||||
if event.MessageID == "" || event.SubmitSequenceID == 0 || event.Account == "" {
|
||||
return nil
|
||||
}
|
||||
downstreamRegistry.RLock()
|
||||
accountSession := downstreamRegistry.byAccount[event.Account]
|
||||
downstreamRegistry.RUnlock()
|
||||
if accountSession == nil || accountSession.conn == nil {
|
||||
return nil
|
||||
}
|
||||
recovered := *accountSession
|
||||
recovered.messageID = event.MessageID
|
||||
recovered.gatewayMsgID = messageIDFrom(defaultString(event.SubmitGroupMessageID, event.MessageID), event.SubmitSequenceID)
|
||||
return &recovered
|
||||
}
|
||||
|
||||
func PushUplink(event DownstreamUplink) (bool, error) {
|
||||
result, err := PushUplinkWithResult(event)
|
||||
return result.Sent, err
|
||||
}
|
||||
|
||||
func PushUplinkWithResult(event DownstreamUplink) (DownstreamSendResult, error) {
|
||||
session := findSession(event.MessageID, event.Account)
|
||||
if session == nil {
|
||||
return DownstreamSendResult{
|
||||
Retryable: true,
|
||||
ReasonCode: "CLIENT_DISCONNECTED",
|
||||
ErrorMessage: "下游客户端当前未连接，等待自动重试",
|
||||
}, nil
|
||||
}
|
||||
content, err := cmpputils.Utf8ToUcs2(event.Content)
|
||||
if err != nil {
|
||||
return DownstreamSendResult{}, err
|
||||
}
|
||||
deliver := downstreamDeliverPacket(
|
||||
session,
|
||||
messageIDFrom(defaultString(event.MessageID, event.Account), uint32(time.Now().UnixNano())),
|
||||
defaultString(event.DestID, session.srcID),
|
||||
event.PhoneNumber,
|
||||
8,
|
||||
0,
|
||||
content,
|
||||
)
|
||||
return sendDownstream(session, deliver, event.DeliveryID)
|
||||
}
|
||||
|
||||
func errorMessageWithCode(message string, code string) string {
|
||||
message = strings.TrimSpace(message)
|
||||
code = strings.TrimSpace(code)
|
||||
if message == "" {
|
||||
message = "gateway did not complete downstream delivery"
|
||||
}
|
||||
if code == "" {
|
||||
return message
|
||||
}
|
||||
return fmt.Sprintf("%s (%s)", message, code)
|
||||
}
|
||||
|
||||
func downstreamDeliverPacket(session *downstreamSession, messageID uint64, destID string, sourceTerminalID string, msgFmt uint8, registerDelivery uint8, content string) cmpp.Packer {
|
||||
if session != nil && (session.protocol == "cmpp20" || session.protocol == "cmpp21") {
|
||||
return &cmpp.Cmpp2DeliverReqPkt{
|
||||
MsgId: messageID, DestId: destID, ServiceId: "cmpp", MsgFmt: msgFmt,
|
||||
SrcTerminalId: sourceTerminalID, RegisterDelivery: registerDelivery,
|
||||
MsgLength: uint8(len(content)), MsgContent: content,
|
||||
}
|
||||
}
|
||||
return &cmpp.Cmpp3DeliverReqPkt{
|
||||
MsgId: messageID, DestId: destID, ServiceId: "cmpp", MsgFmt: msgFmt,
|
||||
SrcTerminalId: sourceTerminalID, RegisterDelivery: registerDelivery,
|
||||
MsgLength: uint8(len(content)), MsgContent: content,
|
||||
}
|
||||
}
|
||||
|
||||
func findSession(messageID string, account string) *downstreamSession {
|
||||
downstreamRegistry.RLock()
|
||||
defer downstreamRegistry.RUnlock()
|
||||
if messageID != "" {
|
||||
if session := downstreamRegistry.byMessageID[messageID]; session != nil {
|
||||
return session
|
||||
}
|
||||
}
|
||||
if account != "" {
|
||||
return downstreamRegistry.byAccount[account]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func sendDownstream(session *downstreamSession, deliver cmpp.Packer, deliveryID string) (DownstreamSendResult, error) {
|
||||
session.mu.Lock()
|
||||
defer session.mu.Unlock()
|
||||
messageID := downstreamDeliverMessageID(deliver)
|
||||
if messageID == 0 {
|
||||
return DownstreamSendResult{}, errors.New("refusing downstream CMPP_DELIVER with Msg_Id=0")
|
||||
}
|
||||
sequenceID := <-session.conn.SeqId
|
||||
sentAt := time.Now().UTC()
|
||||
ackDeadlineAt := sentAt.Add(downstreamAckTimeout())
|
||||
result := DownstreamSendResult{
|
||||
ConnectionID: session.connectionID,
|
||||
SequenceID: strconv.FormatUint(uint64(sequenceID), 10),
|
||||
MessageID: strconv.FormatUint(messageID, 10),
|
||||
SentAt: formatRFC3339Nano(sentAt),
|
||||
AckDeadlineAt: formatRFC3339Nano(ackDeadlineAt),
|
||||
}
|
||||
tracker := registerDownstreamAck(session, deliveryID, sequenceID, messageID, ackDeadlineAt)
|
||||
if err := session.conn.SendPkt(deliver, sequenceID); err != nil {
|
||||
removeDownstreamAck(tracker)
|
||||
session.recordDownstreamProtocol(deliver, deliveryID, sequenceID, messageID, "failed", "SEND_FAILED", err)
|
||||
if session.report != nil {
|
||||
go session.report(session, "disconnected", err.Error())
|
||||
}
|
||||
forgetDownstream(session)
|
||||
result.Retryable = true
|
||||
result.ReasonCode = "SEND_FAILED"
|
||||
result.ErrorMessage = err.Error()
|
||||
return result, nil
|
||||
}
|
||||
session.recordDownstreamProtocol(deliver, deliveryID, sequenceID, messageID, "success", "", nil)
|
||||
result.Sent = true
|
||||
if deliveryID != "" && session.deliveryReport != nil {
|
||||
go session.deliveryReport(downstreamDeliveryLifecycleEvent{
|
||||
Kind: "sent", DeliveryID: deliveryID, ConnectionID: session.connectionID,
|
||||
SequenceID: sequenceID, MessageID: messageID, ObservedAt: sentAt, AckDeadlineAt: ackDeadlineAt,
|
||||
})
|
||||
}
|
||||
session.touchPresence("connected", false, true)
|
||||
if session.report != nil {
|
||||
go session.report(session, "deliver", "")
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func downstreamDeliverMetadata(deliver cmpp.Packer) (string, string) {
|
||||
switch packet := deliver.(type) {
|
||||
case *cmpp.Cmpp2DeliverReqPkt:
|
||||
if packet.RegisterDelivery == 1 {
|
||||
return "deliver_receipt", packet.SrcTerminalId
|
||||
}
|
||||
return "deliver_uplink", packet.SrcTerminalId
|
||||
case *cmpp.Cmpp3DeliverReqPkt:
|
||||
if packet.RegisterDelivery == 1 {
|
||||
return "deliver_receipt", packet.SrcTerminalId
|
||||
}
|
||||
return "deliver_uplink", packet.SrcTerminalId
|
||||
default:
|
||||
return "deliver", ""
|
||||
}
|
||||
}
|
||||
|
||||
func downstreamDeliverMessageID(deliver cmpp.Packer) uint64 {
|
||||
switch packet := deliver.(type) {
|
||||
case *cmpp.Cmpp2DeliverReqPkt:
|
||||
return packet.MsgId
|
||||
case *cmpp.Cmpp3DeliverReqPkt:
|
||||
return packet.MsgId
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func cmppReceiptStatus(status string) string {
|
||||
switch strings.ToLower(strings.TrimSpace(status)) {
|
||||
case "delivered":
|
||||
return "DELIVRD"
|
||||
case "unknown":
|
||||
return "UNKNOWN"
|
||||
default:
|
||||
return "UNDELIV"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,281 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Recovery only replays API-owned pending deliveries; Redis recovery locks and
|
||||
// presence snapshots prevent multiple Gateway instances from racing the replay.
|
||||
|
||||
type pendingDeliveryRequest struct {
|
||||
Account string `json:"account"`
|
||||
Limit int `json:"limit,omitempty"`
|
||||
}
|
||||
|
||||
type pendingDelivery struct {
|
||||
ID string `json:"id"`
|
||||
DeliveryType string `json:"deliveryType"`
|
||||
Payload json.RawMessage `json:"payload"`
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
}
|
||||
|
||||
type pendingFlushResult struct {
|
||||
Account string
|
||||
Deliveries int
|
||||
DeliveredCount int
|
||||
FailedCount int
|
||||
WaitingCount int
|
||||
LastError string
|
||||
}
|
||||
|
||||
func (s Server) flushPending(account string, logger *log.Logger) (pendingFlushResult, error) {
|
||||
result := pendingFlushResult{Account: account}
|
||||
if account == "" {
|
||||
return result, nil
|
||||
}
|
||||
var deliveries []pendingDelivery
|
||||
if err := s.post(context.Background(), "/gateway/events/downstream/pending", pendingDeliveryRequest{Account: account, Limit: 100}, &deliveries); err != nil {
|
||||
logger.Printf("cmpp inbound pending delivery fetch failed account=%s err=%v", account, err)
|
||||
result.LastError = err.Error()
|
||||
return result, err
|
||||
}
|
||||
result.Deliveries = len(deliveries)
|
||||
for _, delivery := range deliveries {
|
||||
sendResult, err := s.pushPendingDelivery(account, delivery)
|
||||
if err != nil {
|
||||
result.FailedCount++
|
||||
result.LastError = err.Error()
|
||||
_ = s.post(context.Background(), "/gateway/events/downstream/failed", map[string]any{
|
||||
"id": delivery.ID, "errorMessage": err.Error(), "failureType": "send_failed",
|
||||
"connectionId": sendResult.ConnectionID, "sequenceId": sendResult.SequenceID,
|
||||
"messageId": sendResult.MessageID, "sentAt": sendResult.SentAt,
|
||||
}, nil)
|
||||
continue
|
||||
}
|
||||
if sendResult.Sent {
|
||||
result.DeliveredCount++
|
||||
continue
|
||||
}
|
||||
if sendResult.ReasonCode == "SUBMIT_RESPONSE_PENDING" {
|
||||
result.WaitingCount++
|
||||
continue
|
||||
}
|
||||
errorMessage := defaultString(sendResult.ErrorMessage, "gateway did not complete downstream delivery")
|
||||
failureType := "unrecoverable"
|
||||
if sendResult.Retryable {
|
||||
failureType = "send_failed"
|
||||
result.WaitingCount++
|
||||
} else {
|
||||
result.FailedCount++
|
||||
}
|
||||
result.LastError = errorMessage
|
||||
_ = s.post(context.Background(), "/gateway/events/downstream/failed", map[string]any{
|
||||
"id": delivery.ID, "errorMessage": errorMessageWithCode(errorMessage, sendResult.ReasonCode),
|
||||
"failureType": failureType, "connectionId": sendResult.ConnectionID,
|
||||
"sequenceId": sendResult.SequenceID, "messageId": sendResult.MessageID, "sentAt": sendResult.SentAt,
|
||||
}, nil)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (s Server) pushPendingDelivery(account string, delivery pendingDelivery) (DownstreamSendResult, error) {
|
||||
switch delivery.DeliveryType {
|
||||
case "receipt":
|
||||
var event DownstreamReceipt
|
||||
if err := json.Unmarshal(delivery.Payload, &event); err != nil {
|
||||
return DownstreamSendResult{}, err
|
||||
}
|
||||
event.DeliveryID = delivery.ID
|
||||
event.Account = defaultString(event.Account, account)
|
||||
allowRecovery := !delivery.CreatedAt.IsZero() && time.Since(delivery.CreatedAt) >= 5*time.Second
|
||||
return pushReceiptWithResult(event, allowRecovery)
|
||||
case "uplink":
|
||||
var event DownstreamUplink
|
||||
if err := json.Unmarshal(delivery.Payload, &event); err != nil {
|
||||
return DownstreamSendResult{}, err
|
||||
}
|
||||
event.DeliveryID = delivery.ID
|
||||
event.Account = defaultString(event.Account, account)
|
||||
return PushUplinkWithResult(event)
|
||||
default:
|
||||
return DownstreamSendResult{}, fmt.Errorf("unsupported downstream delivery type %q", delivery.DeliveryType)
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) runPendingFlusher(logger *log.Logger) {
|
||||
ticker := time.NewTicker(s.pendingFlushInterval())
|
||||
defer ticker.Stop()
|
||||
for range ticker.C {
|
||||
s.flushOnlineAccounts(logger)
|
||||
s.recoverPendingCandidates(logger)
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) flushOnlineAccounts(logger *log.Logger) {
|
||||
for _, account := range onlineAccounts() {
|
||||
_, _ = s.flushPending(account, logger)
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) recoverPendingCandidates(logger *log.Logger) {
|
||||
candidates, err := ListRecoveryCandidates(context.Background(), s.PresenceStore)
|
||||
if err != nil {
|
||||
logger.Printf("cmpp inbound recovery candidate refresh failed err=%v", err)
|
||||
return
|
||||
}
|
||||
for _, candidate := range candidates {
|
||||
account := strings.TrimSpace(candidate.Account)
|
||||
if account == "" {
|
||||
continue
|
||||
}
|
||||
activeRecovery := DownstreamRecoveryStatus{
|
||||
Account: account,
|
||||
GatewayInstanceID: s.gatewayInstanceID(),
|
||||
}
|
||||
if s.RecoveryStore != nil {
|
||||
decision, recoveryErr := s.RecoveryStore.StartAccountRecovery(context.Background(), account, s.gatewayInstanceID())
|
||||
if recoveryErr != nil {
|
||||
logger.Printf("cmpp inbound recovery start failed account=%s err=%v", account, recoveryErr)
|
||||
continue
|
||||
}
|
||||
if !decision.Allowed {
|
||||
logger.Printf("cmpp inbound recovery skipped account=%s reason=%s", account, decision.SkipReason)
|
||||
decision.Status.Account = account
|
||||
decision.Status.GatewayInstanceID = s.gatewayInstanceID()
|
||||
decision.Status.State = defaultString(decision.Status.State, "failed")
|
||||
decision.Status.LastSkipReason = defaultString(decision.Status.LastSkipReason, decision.SkipReason)
|
||||
if decision.Status.FailureCategory == "" {
|
||||
decision.Status.FailureCategory = recoveryFailureCategory(decision.Status.State, "", decision.Status.LastSkipReason)
|
||||
}
|
||||
s.syncRecoveryStatus(logger, account, decision.Status)
|
||||
continue
|
||||
}
|
||||
activeRecovery = decision.Status
|
||||
activeRecovery.Account = account
|
||||
activeRecovery.GatewayInstanceID = s.gatewayInstanceID()
|
||||
}
|
||||
result, flushErr := s.flushPending(account, logger)
|
||||
if s.RecoveryStore != nil {
|
||||
status := DownstreamRecoveryStatus{
|
||||
Account: account,
|
||||
GatewayInstanceID: s.gatewayInstanceID(),
|
||||
LockToken: activeRecovery.LockToken,
|
||||
LockOwner: defaultString(activeRecovery.LockOwner, s.gatewayInstanceID()),
|
||||
LockAcquiredAt: activeRecovery.LockAcquiredAt,
|
||||
LockExpiresAt: activeRecovery.LockExpiresAt,
|
||||
LastAttemptAt: activeRecovery.LastAttemptAt,
|
||||
}
|
||||
switch {
|
||||
case flushErr != nil:
|
||||
status.State = "failed"
|
||||
status.LastError = flushErr.Error()
|
||||
status.FailureCategory = recoveryFailureCategory(status.State, status.LastError, status.LastSkipReason)
|
||||
case result.WaitingCount > 0 && result.DeliveredCount == 0 && result.FailedCount == 0:
|
||||
status.State = "waiting_connection"
|
||||
status.LastError = "downstream client is not connected"
|
||||
status.FailureCategory = recoveryFailureCategory(status.State, status.LastError, status.LastSkipReason)
|
||||
case result.FailedCount > 0 && result.DeliveredCount > 0:
|
||||
status.State = "partial"
|
||||
status.LastError = result.LastError
|
||||
status.FailureCategory = recoveryFailureCategory(status.State, status.LastError, status.LastSkipReason)
|
||||
case result.FailedCount > 0:
|
||||
status.State = "failed"
|
||||
status.LastError = result.LastError
|
||||
status.FailureCategory = recoveryFailureCategory(status.State, status.LastError, status.LastSkipReason)
|
||||
default:
|
||||
status.State = "success"
|
||||
status.LastError = ""
|
||||
status.FailureCategory = ""
|
||||
}
|
||||
if err := s.RecoveryStore.CompleteAccountRecovery(context.Background(), status); err != nil {
|
||||
logger.Printf("cmpp inbound recovery completion failed account=%s err=%v", account, err)
|
||||
if err == ErrRecoveryLockLost {
|
||||
status.State = "failed"
|
||||
status.LastSkipReason = "lock_lost"
|
||||
status.FailureCategory = "lock_lost"
|
||||
s.syncRecoveryStatus(logger, account, status)
|
||||
}
|
||||
} else if persisted, err := s.RecoveryStore.GetAccountRecoveryStatus(context.Background(), account); err != nil {
|
||||
logger.Printf("cmpp inbound recovery status fetch failed account=%s err=%v", account, err)
|
||||
} else {
|
||||
s.syncRecoveryStatus(logger, account, persisted)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) syncRecoveryStatus(logger *log.Logger, account string, status DownstreamRecoveryStatus) {
|
||||
if err := s.post(context.Background(), "/gateway/events/downstream/recovery-status", map[string]any{
|
||||
"account": status.Account,
|
||||
"gatewayInstanceId": status.GatewayInstanceID,
|
||||
"state": status.State,
|
||||
"lockOwner": status.LockOwner,
|
||||
"lockExpiresAt": formatRFC3339Nano(status.LockExpiresAt),
|
||||
"lastAttemptAt": formatRFC3339Nano(status.LastAttemptAt),
|
||||
"lastSuccessAt": formatRFC3339Nano(status.LastSuccessAt),
|
||||
"lastFailureAt": formatRFC3339Nano(status.LastFailureAt),
|
||||
"nextRetryAt": formatRFC3339Nano(status.NextRetryAt),
|
||||
"attemptCount": status.AttemptCount,
|
||||
"failureCategory": status.FailureCategory,
|
||||
"lastError": status.LastError,
|
||||
"lastSkipReason": status.LastSkipReason,
|
||||
}, nil); err != nil {
|
||||
logger.Printf("cmpp inbound recovery status sync failed account=%s err=%v", account, err)
|
||||
}
|
||||
}
|
||||
|
||||
func recoveryFailureCategory(state string, lastError string, lastSkipReason string) string {
|
||||
if state == "success" || state == "running" {
|
||||
return ""
|
||||
}
|
||||
if lastSkipReason == "backoff" {
|
||||
return "backoff"
|
||||
}
|
||||
if lastSkipReason == "locked" {
|
||||
return "lock_contended"
|
||||
}
|
||||
if lastSkipReason == "lock_lost" {
|
||||
return "lock_lost"
|
||||
}
|
||||
if state == "waiting_connection" {
|
||||
return "client_disconnected"
|
||||
}
|
||||
if state == "partial" {
|
||||
return "partial_delivery_failed"
|
||||
}
|
||||
if state == "failed" && strings.TrimSpace(lastError) != "" {
|
||||
return "flush_failed"
|
||||
}
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
func (s Server) pendingFlushInterval() time.Duration {
|
||||
if s.PendingFlushInterval > 0 {
|
||||
return s.PendingFlushInterval
|
||||
}
|
||||
return time.Minute
|
||||
}
|
||||
|
||||
func (s Server) logRecoveryCandidates(logger *log.Logger) {
|
||||
candidates, err := ListRecoveryCandidates(context.Background(), s.PresenceStore)
|
||||
if err != nil {
|
||||
logger.Printf("cmpp inbound recovery candidates load failed err=%v", err)
|
||||
return
|
||||
}
|
||||
if len(candidates) == 0 {
|
||||
logger.Printf("cmpp inbound recovery candidates loaded count=0")
|
||||
return
|
||||
}
|
||||
accounts := make([]string, 0, len(candidates))
|
||||
for _, item := range candidates {
|
||||
if strings.TrimSpace(item.Account) != "" {
|
||||
accounts = append(accounts, item.Account)
|
||||
}
|
||||
}
|
||||
logger.Printf("cmpp inbound recovery candidates loaded count=%d accounts=%s", len(candidates), strings.Join(accounts, ","))
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type protocolLogEvent struct {
|
||||
Protocol string `json:"protocol"`
|
||||
Direction string `json:"direction"`
|
||||
EventType string `json:"eventType"`
|
||||
Status string `json:"status"`
|
||||
TenantID string `json:"tenantId,omitempty"`
|
||||
ApplicationID string `json:"applicationId,omitempty"`
|
||||
Account string `json:"account,omitempty"`
|
||||
MessageID string `json:"messageId,omitempty"`
|
||||
GatewayMessageID string `json:"gatewayMessageId,omitempty"`
|
||||
Phone string `json:"phone,omitempty"`
|
||||
ResultCode string `json:"resultCode,omitempty"`
|
||||
Detail map[string]any `json:"detail,omitempty"`
|
||||
}
|
||||
|
||||
func (s Server) submitResponseProtocolLogger(
|
||||
account string,
|
||||
protocol string,
|
||||
sequenceID uint32,
|
||||
phone string,
|
||||
messageID string,
|
||||
gatewayMessageID uint64,
|
||||
result uint32,
|
||||
) func(error) {
|
||||
return func(sendErr error) {
|
||||
s.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_client",
|
||||
EventType: "submit_resp",
|
||||
Status: protocolSendStatus(sendErr),
|
||||
Account: account,
|
||||
MessageID: messageID,
|
||||
GatewayMessageID: fmt.Sprint(gatewayMessageID),
|
||||
Phone: phone,
|
||||
ResultCode: protocolSendResultCode(sendErr, result),
|
||||
Detail: protocolSubmitResponseDetail(sequenceID, sendErr),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func protocolSendStatus(sendErr error) string {
|
||||
if sendErr != nil {
|
||||
return "failed"
|
||||
}
|
||||
return "success"
|
||||
}
|
||||
|
||||
func protocolSendResultCode(sendErr error, result uint32) string {
|
||||
if sendErr != nil {
|
||||
return "SEND_FAILED"
|
||||
}
|
||||
return fmt.Sprint(result)
|
||||
}
|
||||
|
||||
func protocolSubmitResponseDetail(sequenceID uint32, sendErr error) map[string]any {
|
||||
detail := map[string]any{"sequenceId": sequenceID}
|
||||
if sendErr != nil {
|
||||
detail["error"] = sendErr.Error()
|
||||
}
|
||||
return detail
|
||||
}
|
||||
|
||||
func (s Server) emitProtocolLog(event protocolLogEvent) {
|
||||
go func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), defaultHTTPTimeout)
|
||||
defer cancel()
|
||||
if err := s.post(ctx, "/gateway/events/protocol-log", event, nil); err != nil {
|
||||
log.Printf("cmpp inbound protocol_event direction=%s event=%s status=telemetry_failed account=%s message_id=%s error=%q", event.Direction, event.EventType, event.Account, event.MessageID, err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
func (session *downstreamSession) recordDownstreamProtocol(
|
||||
deliver cmpp.Packer,
|
||||
deliveryID string,
|
||||
sequenceID uint32,
|
||||
messageID uint64,
|
||||
status string,
|
||||
resultCode string,
|
||||
sendErr error,
|
||||
) {
|
||||
if session == nil || session.protocolLog == nil {
|
||||
return
|
||||
}
|
||||
eventType, phone := downstreamDeliverMetadata(deliver)
|
||||
detail := map[string]any{"sequenceId": sequenceID, "deliveryId": deliveryID}
|
||||
if sendErr != nil {
|
||||
detail["error"] = sendErr.Error()
|
||||
}
|
||||
session.protocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_client",
|
||||
EventType: eventType,
|
||||
Status: status,
|
||||
TenantID: session.tenantID,
|
||||
ApplicationID: session.applicationID,
|
||||
Account: session.account,
|
||||
MessageID: session.messageID,
|
||||
GatewayMessageID: strconv.FormatUint(messageID, 10),
|
||||
Phone: defaultString(phone, session.phoneNumber),
|
||||
ResultCode: resultCode,
|
||||
Detail: detail,
|
||||
})
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,262 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// This registry is the single in-process owner of authenticated downstream
|
||||
// sessions. Delivery and recovery code must resolve sessions through it.
|
||||
|
||||
type downstreamConnectionEvent struct {
|
||||
Account string `json:"account"`
|
||||
ConnectionID string `json:"connectionId"`
|
||||
Status string `json:"status"`
|
||||
RemoteIP string `json:"remoteIp,omitempty"`
|
||||
Protocol string `json:"protocol,omitempty"`
|
||||
ConnectedAt string `json:"connectedAt,omitempty"`
|
||||
ObservedAt string `json:"observedAt,omitempty"`
|
||||
ErrorMessage string `json:"errorMessage,omitempty"`
|
||||
}
|
||||
|
||||
type downstreamSession struct {
|
||||
messageID string
|
||||
account string
|
||||
tenantID string
|
||||
applicationID string
|
||||
enterpriseCode string
|
||||
protocol string
|
||||
srcID string
|
||||
phoneNumber string
|
||||
gatewayMsgID uint64
|
||||
remoteIP string
|
||||
connectedAt time.Time
|
||||
connectionID string
|
||||
conn *cmpp.Conn
|
||||
mu *sync.Mutex
|
||||
presence PresenceStore
|
||||
instanceID string
|
||||
report func(*downstreamSession, string, string)
|
||||
deliveryReport func(downstreamDeliveryLifecycleEvent)
|
||||
protocolLog func(protocolLogEvent)
|
||||
}
|
||||
|
||||
var downstreamRegistry = struct {
|
||||
sync.RWMutex
|
||||
byMessageID map[string]*downstreamSession
|
||||
byAccount map[string]*downstreamSession
|
||||
byConn map[*cmpp.Conn]*downstreamSession
|
||||
}{
|
||||
byMessageID: make(map[string]*downstreamSession),
|
||||
byAccount: make(map[string]*downstreamSession),
|
||||
byConn: make(map[*cmpp.Conn]*downstreamSession),
|
||||
}
|
||||
|
||||
func (s Server) handleActivity(_ *cmpp.Response, packet *cmpp.Packet, logger *log.Logger) (bool, error) {
|
||||
session := findSessionByConn(packet.Conn)
|
||||
if session == nil {
|
||||
return true, nil
|
||||
}
|
||||
switch response := packet.Packer.(type) {
|
||||
case *cmpp.CmppActiveTestReqPkt, *cmpp.CmppActiveTestRspPkt:
|
||||
if session.report != nil {
|
||||
go s.reportConnectionOrDisconnect(session, "heartbeat", "")
|
||||
}
|
||||
case *cmpp.Cmpp2DeliverRspPkt:
|
||||
handleDownstreamAcknowledgement(packet.Conn, response.SeqId, response.MsgId, uint32(response.Result), logger)
|
||||
case *cmpp.Cmpp3DeliverRspPkt:
|
||||
handleDownstreamAcknowledgement(packet.Conn, response.SeqId, response.MsgId, response.Result, logger)
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (s Server) reportConnection(session *downstreamSession, status string, errorMessage string) {
|
||||
_ = s.reportConnectionChecked(session, status, errorMessage)
|
||||
}
|
||||
|
||||
func (s Server) reportConnectionChecked(session *downstreamSession, status string, errorMessage string) error {
|
||||
if session == nil || strings.TrimSpace(session.account) == "" || strings.TrimSpace(session.connectionID) == "" {
|
||||
return nil
|
||||
}
|
||||
event := downstreamConnectionEvent{
|
||||
Account: session.account, ConnectionID: session.connectionID, Status: status,
|
||||
RemoteIP: session.remoteIP, Protocol: session.protocol,
|
||||
ConnectedAt: formatRFC3339Nano(session.connectedAt), ObservedAt: formatRFC3339Nano(time.Now()),
|
||||
ErrorMessage: errorMessage,
|
||||
}
|
||||
if err := s.post(context.Background(), "/gateway/events/inbound/connection", event, nil); err != nil {
|
||||
log.Printf("cmpp inbound connection state callback failed account=%s connection_id=%s status=%s err=%v", session.account, session.connectionID, status, err)
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s Server) reportConnectionOrDisconnect(session *downstreamSession, status string, errorMessage string) {
|
||||
if err := s.reportConnectionChecked(session, status, errorMessage); err != nil && status != "disconnected" {
|
||||
_ = s.reportConnectionChecked(session, "disconnected", err.Error())
|
||||
forgetDownstream(session)
|
||||
if session.conn != nil {
|
||||
session.conn.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) handleConnectionClosed(conn *cmpp.Conn) {
|
||||
downstreamSubmitBarrier.Lock()
|
||||
delete(downstreamSubmitBarrier.byConn, conn)
|
||||
downstreamSubmitBarrier.Unlock()
|
||||
session := findSessionByConn(conn)
|
||||
if session == nil {
|
||||
return
|
||||
}
|
||||
forgetDownstream(session)
|
||||
_ = s.reportConnectionChecked(session, "disconnected", "CMPP client connection closed")
|
||||
}
|
||||
|
||||
func findSessionByConn(conn *cmpp.Conn) *downstreamSession {
|
||||
downstreamRegistry.RLock()
|
||||
defer downstreamRegistry.RUnlock()
|
||||
return downstreamRegistry.byConn[conn]
|
||||
}
|
||||
|
||||
func rememberDownstream(session downstreamSession) {
|
||||
if session.messageID == "" || session.conn == nil {
|
||||
return
|
||||
}
|
||||
session.touchPresence("connected", true, false)
|
||||
downstreamRegistry.Lock()
|
||||
if existing := downstreamRegistry.byMessageID[session.messageID]; existing != nil && existing.conn == session.conn {
|
||||
// A downstream long message returns one SUBMIT_RESP per fragment but is
|
||||
// persisted as one platform message. Keep the first fragment Msg_Id so
|
||||
// online delivery and restart recovery (which persists the first
|
||||
// Sequence_Id) address the same client-side message.
|
||||
session.gatewayMsgID = existing.gatewayMsgID
|
||||
}
|
||||
downstreamRegistry.byMessageID[session.messageID] = &session
|
||||
downstreamRegistry.byConn[session.conn] = &session
|
||||
if session.account != "" {
|
||||
downstreamRegistry.byAccount[session.account] = &session
|
||||
}
|
||||
downstreamRegistry.Unlock()
|
||||
}
|
||||
|
||||
func rememberAccount(session *downstreamSession, maxConnections int) bool {
|
||||
if session == nil || session.account == "" || session.conn == nil {
|
||||
return false
|
||||
}
|
||||
if maxConnections <= 0 {
|
||||
maxConnections = 1
|
||||
}
|
||||
session.touchPresence("connected", false, false)
|
||||
downstreamRegistry.Lock()
|
||||
defer downstreamRegistry.Unlock()
|
||||
active := 0
|
||||
for _, current := range downstreamRegistry.byConn {
|
||||
if current != nil && current.account == session.account {
|
||||
active++
|
||||
}
|
||||
}
|
||||
if active >= maxConnections {
|
||||
return false
|
||||
}
|
||||
downstreamRegistry.byAccount[session.account] = session
|
||||
downstreamRegistry.byConn[session.conn] = session
|
||||
return true
|
||||
}
|
||||
|
||||
func forgetDownstream(session *downstreamSession) {
|
||||
if session == nil {
|
||||
return
|
||||
}
|
||||
downstreamRegistry.Lock()
|
||||
for messageID, current := range downstreamRegistry.byMessageID {
|
||||
if current != nil && current.conn == session.conn {
|
||||
delete(downstreamRegistry.byMessageID, messageID)
|
||||
}
|
||||
}
|
||||
if session.account != "" {
|
||||
if current := downstreamRegistry.byAccount[session.account]; current == session {
|
||||
delete(downstreamRegistry.byAccount, session.account)
|
||||
}
|
||||
}
|
||||
if current := downstreamRegistry.byConn[session.conn]; current == session {
|
||||
delete(downstreamRegistry.byConn, session.conn)
|
||||
}
|
||||
downstreamRegistry.Unlock()
|
||||
_ = session.removePresence()
|
||||
}
|
||||
|
||||
func onlineAccounts() []string {
|
||||
downstreamRegistry.RLock()
|
||||
defer downstreamRegistry.RUnlock()
|
||||
accounts := make([]string, 0, len(downstreamRegistry.byAccount))
|
||||
for account := range downstreamRegistry.byAccount {
|
||||
if strings.TrimSpace(account) != "" {
|
||||
accounts = append(accounts, account)
|
||||
}
|
||||
}
|
||||
return accounts
|
||||
}
|
||||
|
||||
// DisconnectAccount closes every live downstream CMPP session for an
|
||||
// application account. The normal connection-close callback removes registry
|
||||
// and presence state and reports the disconnect to the API.
|
||||
func DisconnectAccount(account string) int {
|
||||
account = strings.TrimSpace(account)
|
||||
if account == "" {
|
||||
return 0
|
||||
}
|
||||
downstreamRegistry.RLock()
|
||||
sessions := make([]*downstreamSession, 0)
|
||||
for _, session := range downstreamRegistry.byConn {
|
||||
if session != nil && session.account == account && session.conn != nil {
|
||||
sessions = append(sessions, session)
|
||||
}
|
||||
}
|
||||
downstreamRegistry.RUnlock()
|
||||
for _, session := range sessions {
|
||||
session.conn.Close()
|
||||
}
|
||||
return len(sessions)
|
||||
}
|
||||
|
||||
func (s Server) gatewayInstanceID() string {
|
||||
if strings.TrimSpace(s.GatewayInstanceID) != "" {
|
||||
return strings.TrimSpace(s.GatewayInstanceID)
|
||||
}
|
||||
return "gateway-1"
|
||||
}
|
||||
|
||||
func (session downstreamSession) touchPresence(state string, includeSubmit bool, includeDeliver bool) {
|
||||
if session.presence == nil || strings.TrimSpace(session.account) == "" {
|
||||
return
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
snapshot := DownstreamPresence{
|
||||
Account: strings.TrimSpace(session.account),
|
||||
SrcID: strings.TrimSpace(session.srcID),
|
||||
RemoteIP: strings.TrimSpace(session.remoteIP),
|
||||
GatewayInstanceID: strings.TrimSpace(session.instanceID),
|
||||
State: defaultString(strings.TrimSpace(state), "connected"),
|
||||
ConnectedAt: session.connectedAt,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
if includeSubmit {
|
||||
snapshot.LastSubmitAt = now
|
||||
}
|
||||
if includeDeliver {
|
||||
snapshot.LastDeliverAt = now
|
||||
}
|
||||
_ = session.presence.TouchAccount(context.Background(), snapshot)
|
||||
}
|
||||
|
||||
func (session downstreamSession) removePresence() error {
|
||||
if session.presence == nil || strings.TrimSpace(session.account) == "" {
|
||||
return nil
|
||||
}
|
||||
return session.presence.RemoveAccount(context.Background(), strings.TrimSpace(session.account))
|
||||
}
|
||||
@@ -0,0 +1,333 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/md5"
|
||||
"errors"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
cmpputils "github.com/bigwhite/gocmpp/utils"
|
||||
"log"
|
||||
"net"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// One client Submit may contain multiple destinations. The API result retains
|
||||
// one internal message mapping per destination while CMPP receives one response.
|
||||
|
||||
type submitRequest struct {
|
||||
Account string `json:"account"`
|
||||
PhoneNumber string `json:"phoneNumber,omitempty"`
|
||||
PhoneNumbers []string `json:"phoneNumbers,omitempty"`
|
||||
Content string `json:"content"`
|
||||
SrcID string `json:"srcId,omitempty"`
|
||||
DestID string `json:"destId,omitempty"`
|
||||
SequenceID uint32 `json:"sequenceId,omitempty"`
|
||||
RemoteIP string `json:"remoteIp,omitempty"`
|
||||
LongMessage *inboundLongMessageFragment `json:"longMessage,omitempty"`
|
||||
}
|
||||
|
||||
type inboundLongMessageFragment struct {
|
||||
Reference int `json:"reference"`
|
||||
Total int `json:"total"`
|
||||
Index int `json:"index"`
|
||||
Format int `json:"format"`
|
||||
}
|
||||
|
||||
type submitResponseMessage struct {
|
||||
PhoneNumber string `json:"phoneNumber"`
|
||||
MessageID string `json:"messageId"`
|
||||
}
|
||||
|
||||
type submitResponse struct {
|
||||
Accepted bool `json:"accepted"`
|
||||
Result uint32 `json:"result,omitempty"`
|
||||
TenantID string `json:"tenantId,omitempty"`
|
||||
ApplicationID string `json:"applicationId,omitempty"`
|
||||
MessageID string `json:"messageId"`
|
||||
Messages []submitResponseMessage `json:"messages,omitempty"`
|
||||
}
|
||||
|
||||
func (s Server) handleSubmit(response *cmpp.Response, packet *cmpp.Packet, logger *log.Logger) (bool, error) {
|
||||
req, ok := normalizeInboundSubmit(packet.Packer)
|
||||
if !ok {
|
||||
return true, nil
|
||||
}
|
||||
session := findSessionByConn(packet.Conn)
|
||||
if session == nil || strings.TrimSpace(session.account) == "" {
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_rejected protocol=%s packet_type=%s remote=%s seq=%d result=9 stage=session reason=%q",
|
||||
req.protocol, req.protocol, packet.Conn.Conn.RemoteAddr(), req.sequenceID, "authenticated connection session not found",
|
||||
)
|
||||
setInboundSubmitResponse(response.Packer, 0, 9)
|
||||
response.AfterSend = s.submitResponseProtocolLogger("", req.protocol, req.sequenceID, "", "", 0, 9)
|
||||
return false, nil
|
||||
}
|
||||
account := session.account
|
||||
enterpriseCode := strings.TrimRight(req.msgSrc, "\x00")
|
||||
if session.enterpriseCode != "" && enterpriseCode != session.enterpriseCode {
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_rejected protocol=%s packet_type=%s account=%s enterprise_code=%s remote=%s seq=%d result=9 stage=protocol reason=%q",
|
||||
defaultString(session.protocol, req.protocol), req.protocol, account, enterpriseCode, packet.Conn.Conn.RemoteAddr(), req.sequenceID,
|
||||
fmt.Sprintf("enterprise code mismatch: expected %s", session.enterpriseCode),
|
||||
)
|
||||
setInboundSubmitResponse(response.Packer, 0, 9)
|
||||
response.AfterSend = s.submitResponseProtocolLogger(account, defaultString(session.protocol, req.protocol), req.sequenceID, "", "", 0, 9)
|
||||
return false, nil
|
||||
}
|
||||
phones := make([]string, len(req.destTerminalIDs))
|
||||
for index, destination := range req.destTerminalIDs {
|
||||
phones[index] = strings.TrimSpace(strings.TrimRight(destination, "\x00"))
|
||||
}
|
||||
phone := ""
|
||||
if len(phones) > 0 {
|
||||
phone = phones[0]
|
||||
}
|
||||
remote := packet.Conn.Conn.RemoteAddr()
|
||||
clientProtocol := defaultString(session.protocol, req.protocol)
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_received protocol=%s packet_type=%s account=%s enterprise_code=%s remote=%s seq=%d phone=%s src_id=%s msg_fmt=%d pk=%d/%d dest_count=%d content_bytes=%d",
|
||||
clientProtocol, req.protocol, account, enterpriseCode, remote, req.sequenceID, phone, strings.TrimSpace(req.srcID), req.msgFmt,
|
||||
req.pkNumber, req.pkTotal, len(req.destTerminalIDs), len(req.msgContent),
|
||||
)
|
||||
content, longMessage, err := decodeInboundSubmitContent(req)
|
||||
if err != nil {
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_rejected protocol=%s packet_type=%s account=%s remote=%s seq=%d phone=%s result=9 stage=decode reason=%q",
|
||||
clientProtocol, req.protocol, account, remote, req.sequenceID, phone, err,
|
||||
)
|
||||
setInboundSubmitResponse(response.Packer, 0, 9)
|
||||
response.AfterSend = s.submitResponseProtocolLogger(account, clientProtocol, req.sequenceID, phone, "", 0, 9)
|
||||
return false, nil
|
||||
}
|
||||
contentHash := fmt.Sprintf("%x", md5.Sum([]byte(content)))
|
||||
startedAt := time.Now()
|
||||
releaseSubmitBarrier := beginDownstreamSubmitBarrier(packet.Conn)
|
||||
result, err := s.submit(remote, submitRequest{
|
||||
Account: account,
|
||||
PhoneNumber: phone,
|
||||
PhoneNumbers: phones,
|
||||
Content: content,
|
||||
SrcID: req.srcID,
|
||||
DestID: phone,
|
||||
SequenceID: req.sequenceID,
|
||||
RemoteIP: remoteIP(remote),
|
||||
LongMessage: longMessage,
|
||||
})
|
||||
if err != nil || !result.Accepted {
|
||||
reason := "api returned accepted=false"
|
||||
if err != nil {
|
||||
reason = err.Error()
|
||||
}
|
||||
responseResult := result.Result
|
||||
if responseResult == 0 {
|
||||
responseResult = 9
|
||||
}
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_rejected protocol=%s packet_type=%s account=%s remote=%s seq=%d phone=%s result=%d stage=business duration_ms=%d content_chars=%d content_hash=%s reason=%q",
|
||||
clientProtocol, req.protocol, account, remote, req.sequenceID, phone, responseResult, time.Since(startedAt).Milliseconds(), len([]rune(content)), contentHash, reason,
|
||||
)
|
||||
setInboundSubmitResponse(response.Packer, 0, responseResult)
|
||||
protocolLogger := s.submitResponseProtocolLogger(account, clientProtocol, req.sequenceID, phone, result.MessageID, 0, responseResult)
|
||||
response.AfterSend = func(sendErr error) {
|
||||
releaseSubmitBarrier()
|
||||
protocolLogger(sendErr)
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
gatewayMsgID := messageIDFrom(result.MessageID, req.sequenceID)
|
||||
setInboundSubmitResponse(response.Packer, gatewayMsgID, 0)
|
||||
responseMessages := result.Messages
|
||||
if len(responseMessages) == 0 {
|
||||
responseMessages = []submitResponseMessage{{PhoneNumber: phone, MessageID: result.MessageID}}
|
||||
}
|
||||
for index, acceptedMessage := range responseMessages {
|
||||
acceptedPhone := strings.TrimSpace(acceptedMessage.PhoneNumber)
|
||||
if acceptedPhone == "" && index < len(phones) {
|
||||
acceptedPhone = phones[index]
|
||||
}
|
||||
rememberDownstream(downstreamSession{
|
||||
messageID: acceptedMessage.MessageID,
|
||||
account: account,
|
||||
tenantID: result.TenantID,
|
||||
applicationID: result.ApplicationID,
|
||||
enterpriseCode: session.enterpriseCode,
|
||||
protocol: clientProtocol,
|
||||
srcID: strings.TrimSpace(req.srcID),
|
||||
phoneNumber: acceptedPhone,
|
||||
gatewayMsgID: gatewayMsgID,
|
||||
remoteIP: remoteIP(remote),
|
||||
connectedAt: time.Now().UTC(),
|
||||
connectionID: session.connectionID,
|
||||
conn: packet.Conn,
|
||||
mu: &sync.Mutex{},
|
||||
presence: s.PresenceStore,
|
||||
instanceID: s.gatewayInstanceID(),
|
||||
report: session.report,
|
||||
deliveryReport: session.deliveryReport,
|
||||
protocolLog: session.protocolLog,
|
||||
})
|
||||
}
|
||||
if current := findSessionByConn(packet.Conn); current != nil && current.report != nil {
|
||||
go current.report(current, "submit", "")
|
||||
}
|
||||
response.AfterSend = func(sendErr error) {
|
||||
releaseSubmitBarrier()
|
||||
s.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_client",
|
||||
EventType: "submit_resp",
|
||||
Status: protocolSendStatus(sendErr),
|
||||
TenantID: result.TenantID,
|
||||
ApplicationID: result.ApplicationID,
|
||||
Account: account,
|
||||
MessageID: result.MessageID,
|
||||
GatewayMessageID: fmt.Sprint(gatewayMsgID),
|
||||
Phone: phone,
|
||||
ResultCode: protocolSendResultCode(sendErr, 0),
|
||||
Detail: protocolSubmitResponseDetail(req.sequenceID, sendErr),
|
||||
})
|
||||
if sendErr != nil {
|
||||
return
|
||||
}
|
||||
go func() {
|
||||
if _, err := s.flushPending(account, logger); err != nil {
|
||||
logger.Printf("cmpp inbound event=post_submit_pending_flush_failed account=%s message_id=%s error=%q", account, result.MessageID, err.Error())
|
||||
}
|
||||
}()
|
||||
}
|
||||
logger.Printf(
|
||||
"cmpp inbound event=submit_accepted protocol=%s packet_type=%s account=%s remote=%s seq=%d phone=%s dest_count=%d accepted_count=%d result=0 message_id=%s gateway_message_id=%d duration_ms=%d content_chars=%d content_hash=%s",
|
||||
clientProtocol, req.protocol, account, remote, req.sequenceID, phone, len(phones), len(responseMessages), result.MessageID, gatewayMsgID, time.Since(startedAt).Milliseconds(), len([]rune(content)), contentHash,
|
||||
)
|
||||
return false, nil
|
||||
}
|
||||
|
||||
type inboundSubmitPacket struct {
|
||||
protocol string
|
||||
pkTotal uint8
|
||||
pkNumber uint8
|
||||
tpUdhi uint8
|
||||
msgFmt uint8
|
||||
msgSrc string
|
||||
srcID string
|
||||
destTerminalIDs []string
|
||||
msgContent string
|
||||
sequenceID uint32
|
||||
}
|
||||
|
||||
func normalizeInboundSubmit(packet any) (inboundSubmitPacket, bool) {
|
||||
switch req := packet.(type) {
|
||||
case *cmpp.Cmpp2SubmitReqPkt:
|
||||
return inboundSubmitPacket{
|
||||
protocol: "cmpp20", pkTotal: req.PkTotal, pkNumber: req.PkNumber, tpUdhi: req.TpUdhi, msgFmt: req.MsgFmt,
|
||||
msgSrc: req.MsgSrc, srcID: req.SrcId, destTerminalIDs: req.DestTerminalId,
|
||||
msgContent: req.MsgContent, sequenceID: req.SeqId,
|
||||
}, true
|
||||
case *cmpp.Cmpp3SubmitReqPkt:
|
||||
return inboundSubmitPacket{
|
||||
protocol: "cmpp30", pkTotal: req.PkTotal, pkNumber: req.PkNumber, tpUdhi: req.TpUdhi, msgFmt: req.MsgFmt,
|
||||
msgSrc: req.MsgSrc, srcID: req.SrcId, destTerminalIDs: req.DestTerminalId,
|
||||
msgContent: req.MsgContent, sequenceID: req.SeqId,
|
||||
}, true
|
||||
default:
|
||||
return inboundSubmitPacket{}, false
|
||||
}
|
||||
}
|
||||
|
||||
func setInboundSubmitResponse(packet any, messageID uint64, result uint32) {
|
||||
switch resp := packet.(type) {
|
||||
case *cmpp.Cmpp2SubmitRspPkt:
|
||||
resp.MsgId = messageID
|
||||
resp.Result = uint8(result)
|
||||
case *cmpp.Cmpp3SubmitRspPkt:
|
||||
resp.MsgId = messageID
|
||||
resp.Result = result
|
||||
}
|
||||
}
|
||||
|
||||
func (s Server) submit(remote net.Addr, payload submitRequest) (submitResponse, error) {
|
||||
payload.RemoteIP = remoteIP(remote)
|
||||
var result submitResponse
|
||||
err := s.post(context.Background(), "/gateway/events/inbound/submit", payload, &result)
|
||||
return result, err
|
||||
}
|
||||
|
||||
func decodeContent(format uint8, content string) (string, error) {
|
||||
switch format {
|
||||
case 8:
|
||||
return cmpputils.Ucs2ToUtf8(content)
|
||||
case 15:
|
||||
return cmpputils.GB18030ToUtf8(content)
|
||||
default:
|
||||
return content, nil
|
||||
}
|
||||
}
|
||||
|
||||
func decodeInboundSubmitContent(req inboundSubmitPacket) (string, *inboundLongMessageFragment, error) {
|
||||
raw := []byte(req.msgContent)
|
||||
if req.tpUdhi == 0 && req.pkTotal <= 1 {
|
||||
content, err := decodeContent(req.msgFmt, req.msgContent)
|
||||
return content, nil, err
|
||||
}
|
||||
if len(raw) == 0 {
|
||||
return "", nil, errors.New("UDH message content is empty")
|
||||
}
|
||||
|
||||
headerLength := int(raw[0]) + 1
|
||||
if headerLength > len(raw) {
|
||||
return "", nil, fmt.Errorf("UDH length %d exceeds message content length %d", headerLength, len(raw))
|
||||
}
|
||||
|
||||
var reference, total, index int
|
||||
switch {
|
||||
case len(raw) >= 6 && raw[0] == 0x05 && raw[1] == 0x00 && raw[2] == 0x03:
|
||||
reference = int(raw[3])
|
||||
total = int(raw[4])
|
||||
index = int(raw[5])
|
||||
case len(raw) >= 7 && raw[0] == 0x06 && raw[1] == 0x08 && raw[2] == 0x04:
|
||||
reference = int(raw[3])<<8 | int(raw[4])
|
||||
total = int(raw[5])
|
||||
index = int(raw[6])
|
||||
default:
|
||||
if req.pkTotal > 1 {
|
||||
return "", nil, errors.New("concatenated CMPP submit is missing a supported 8-bit or 16-bit UDH")
|
||||
}
|
||||
content, err := decodeContent(req.msgFmt, string(raw[headerLength:]))
|
||||
return content, nil, err
|
||||
}
|
||||
if total < 2 || index < 1 || index > total {
|
||||
return "", nil, fmt.Errorf("invalid concatenated UDH total/index %d/%d", index, total)
|
||||
}
|
||||
if req.pkTotal > 0 && int(req.pkTotal) != total {
|
||||
return "", nil, fmt.Errorf("PkTotal %d does not match UDH total %d", req.pkTotal, total)
|
||||
}
|
||||
if req.pkNumber > 0 && int(req.pkNumber) != index {
|
||||
return "", nil, fmt.Errorf("PkNumber %d does not match UDH index %d", req.pkNumber, index)
|
||||
}
|
||||
|
||||
content, err := decodeContent(req.msgFmt, string(raw[headerLength:]))
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
return content, &inboundLongMessageFragment{
|
||||
Reference: reference,
|
||||
Total: total,
|
||||
Index: index,
|
||||
Format: int(req.msgFmt),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func messageIDFrom(value string, seq uint32) uint64 {
|
||||
hash := md5.Sum([]byte(value))
|
||||
result := uint64(seq)
|
||||
for _, item := range hash[:6] {
|
||||
result = (result << 8) + uint64(item)
|
||||
}
|
||||
if result == 0 {
|
||||
return uint64(time.Now().UnixNano())
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package inbound
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func (s Server) post(ctx context.Context, path string, payload any, result any) error {
|
||||
client := s.HTTPClient
|
||||
if client == nil {
|
||||
client = &http.Client{Timeout: defaultHTTPTimeout}
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(apiBaseURL(s.APIBaseURL), "/")+path, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
responseBody, err := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
|
||||
if err != nil {
|
||||
return fmt.Errorf("read api response: %w", err)
|
||||
}
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
detail := strings.TrimSpace(string(responseBody))
|
||||
if detail == "" {
|
||||
return fmt.Errorf("api returned %s", resp.Status)
|
||||
}
|
||||
return fmt.Errorf("api returned %s: %s", resp.Status, detail)
|
||||
}
|
||||
if result != nil {
|
||||
if len(responseBody) == 0 {
|
||||
return io.EOF
|
||||
}
|
||||
return json.Unmarshal(responseBody, result)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func apiBaseURL(value string) string {
|
||||
if value == "" {
|
||||
return "http://127.0.0.1:3000/api"
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
func remoteIP(addr net.Addr) string {
|
||||
if tcp, ok := addr.(*net.TCPAddr); ok {
|
||||
return tcp.IP.String()
|
||||
}
|
||||
host, _, err := net.SplitHostPort(addr.String())
|
||||
if err == nil {
|
||||
return host
|
||||
}
|
||||
return addr.String()
|
||||
}
|
||||
|
||||
func defaultString(value string, fallback string) string {
|
||||
if value == "" {
|
||||
return fallback
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
func formatRFC3339Nano(value time.Time) string {
|
||||
if value.IsZero() {
|
||||
return ""
|
||||
}
|
||||
return value.UTC().Format(time.RFC3339Nano)
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"cmpp-platform/gateway/internal/queue"
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// The reader and heartbeat goroutines share one connection lifecycle. Closing
|
||||
// the connection must wake pending submitters before scheduling pool recovery.
|
||||
|
||||
type connection struct {
|
||||
channelID string
|
||||
config queue.UpstreamConfig
|
||||
index int
|
||||
pool *connectionPool
|
||||
apiBaseURL string
|
||||
httpClient *http.Client
|
||||
|
||||
mu sync.Mutex
|
||||
sendMu sync.Mutex
|
||||
client *cmpp.Client
|
||||
window chan struct{}
|
||||
pending map[uint32]chan submitPartResponse
|
||||
tracker map[uint64]queue.SubmitCommand
|
||||
longUplink map[string]*longUplinkAssembly
|
||||
readOnce sync.Once
|
||||
closed bool
|
||||
heartbeatCancel context.CancelFunc
|
||||
heartbeatPending map[uint32]time.Time
|
||||
}
|
||||
|
||||
type submitPartResponse struct {
|
||||
seqID uint32
|
||||
msgID uint64
|
||||
result uint32
|
||||
err error
|
||||
}
|
||||
|
||||
func (c *connection) matches(config queue.UpstreamConfig) bool {
|
||||
return c.config == normalizeUpstreamConfig(config)
|
||||
}
|
||||
|
||||
func (c *connection) ensureConnected() (bool, error) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
if c.client != nil && !c.closed {
|
||||
return false, nil
|
||||
}
|
||||
client := cmpp.NewClient(protocolVersion(c.config.CMPPVersion))
|
||||
addr := fmt.Sprintf("%s:%d", c.config.GatewayHost, c.config.GatewayPort)
|
||||
if err := client.Connect(addr, c.config.Account, c.config.PasswordCipher, defaultConnectTimeout); err != nil {
|
||||
client.Disconnect()
|
||||
return false, err
|
||||
}
|
||||
c.client = client
|
||||
c.closed = false
|
||||
c.heartbeatPending = make(map[uint32]time.Time)
|
||||
heartbeatCtx, cancelHeartbeat := context.WithCancel(context.Background())
|
||||
c.heartbeatCancel = cancelHeartbeat
|
||||
go c.readLoop()
|
||||
go c.heartbeatLoop(heartbeatCtx)
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (c *connection) readLoop() {
|
||||
for {
|
||||
c.mu.Lock()
|
||||
client := c.client
|
||||
closed := c.closed
|
||||
c.mu.Unlock()
|
||||
if closed || client == nil {
|
||||
return
|
||||
}
|
||||
pkt, err := client.RecvAndUnpackPkt(time.Second)
|
||||
if err != nil {
|
||||
c.mu.Lock()
|
||||
closed = c.closed
|
||||
c.mu.Unlock()
|
||||
if closed {
|
||||
return
|
||||
}
|
||||
if isTemporaryReadTimeout(err) {
|
||||
continue
|
||||
}
|
||||
c.handleConnectionLoss(err)
|
||||
return
|
||||
}
|
||||
switch p := pkt.(type) {
|
||||
case *cmpp.Cmpp2SubmitRspPkt:
|
||||
c.mu.Lock()
|
||||
ch := c.pending[p.SeqId]
|
||||
c.mu.Unlock()
|
||||
if ch != nil {
|
||||
ch <- submitPartResponse{seqID: p.SeqId, msgID: p.MsgId, result: uint32(p.Result)}
|
||||
}
|
||||
case *cmpp.Cmpp3SubmitRspPkt:
|
||||
c.mu.Lock()
|
||||
ch := c.pending[p.SeqId]
|
||||
c.mu.Unlock()
|
||||
if ch != nil {
|
||||
ch <- submitPartResponse{seqID: p.SeqId, msgID: p.MsgId, result: p.Result}
|
||||
}
|
||||
case *cmpp.Cmpp2DeliverReqPkt:
|
||||
deliver := deliverPacketFromCMPP2(p)
|
||||
if deliver.registerDelivery == 1 {
|
||||
if err := c.handleDeliver(deliver); err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_receipt status=intake_failed channel_id=%s sequence_id=%d error=%q", c.channelID, deliver.seqID, err)
|
||||
c.handleConnectionLoss(fmt.Errorf("persist upstream receipt before DELIVER_RESP: %w", err))
|
||||
return
|
||||
}
|
||||
responseErr := c.sendResponse(client, &cmpp.Cmpp2DeliverRspPkt{MsgId: p.MsgId, Result: 0}, p.SeqId)
|
||||
c.emitDeliverResponse(deliver, responseErr)
|
||||
} else {
|
||||
responseErr := c.sendResponse(client, &cmpp.Cmpp2DeliverRspPkt{MsgId: p.MsgId, Result: 0}, p.SeqId)
|
||||
c.emitDeliverResponse(deliver, responseErr)
|
||||
_ = c.handleDeliver(deliver)
|
||||
}
|
||||
case *cmpp.Cmpp3DeliverReqPkt:
|
||||
deliver := deliverPacketFromCMPP3(p)
|
||||
if deliver.registerDelivery == 1 {
|
||||
if err := c.handleDeliver(deliver); err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_receipt status=intake_failed channel_id=%s sequence_id=%d error=%q", c.channelID, deliver.seqID, err)
|
||||
c.handleConnectionLoss(fmt.Errorf("persist upstream receipt before DELIVER_RESP: %w", err))
|
||||
return
|
||||
}
|
||||
responseErr := c.sendResponse(client, &cmpp.Cmpp3DeliverRspPkt{MsgId: p.MsgId, Result: 0}, p.SeqId)
|
||||
c.emitDeliverResponse(deliver, responseErr)
|
||||
} else {
|
||||
responseErr := c.sendResponse(client, &cmpp.Cmpp3DeliverRspPkt{MsgId: p.MsgId, Result: 0}, p.SeqId)
|
||||
c.emitDeliverResponse(deliver, responseErr)
|
||||
_ = c.handleDeliver(deliver)
|
||||
}
|
||||
case *cmpp.CmppActiveTestReqPkt:
|
||||
_ = c.sendResponse(client, &cmpp.CmppActiveTestRspPkt{}, p.SeqId)
|
||||
_ = c.pool.reportState(context.Background(), "heartbeat", nil)
|
||||
case *cmpp.CmppActiveTestRspPkt:
|
||||
c.handleHeartbeatResponse(p.SeqId)
|
||||
_ = c.pool.reportState(context.Background(), "heartbeat", nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) sendResponse(client *cmpp.Client, packet cmpp.Packer, sequenceID uint32) error {
|
||||
c.sendMu.Lock()
|
||||
defer c.sendMu.Unlock()
|
||||
return client.SendRspPkt(packet, sequenceID)
|
||||
}
|
||||
|
||||
func (c *connection) identity() string {
|
||||
if c.pool != nil && strings.TrimSpace(c.pool.connectionID) != "" {
|
||||
return fmt.Sprintf("%s-%d", c.pool.connectionID, c.index)
|
||||
}
|
||||
return fmt.Sprintf("%s-%d", c.channelID, c.index)
|
||||
}
|
||||
|
||||
func (c *connection) close() {
|
||||
c.handleConnectionLoss(fmt.Errorf("connection closed"))
|
||||
}
|
||||
|
||||
func (c *connection) handleConnectionLoss(err error) {
|
||||
c.mu.Lock()
|
||||
if c.closed && c.client == nil {
|
||||
c.mu.Unlock()
|
||||
return
|
||||
}
|
||||
c.closed = true
|
||||
if c.heartbeatCancel != nil {
|
||||
c.heartbeatCancel()
|
||||
c.heartbeatCancel = nil
|
||||
}
|
||||
pending := c.pending
|
||||
c.pending = make(map[uint32]chan submitPartResponse)
|
||||
c.heartbeatPending = make(map[uint32]time.Time)
|
||||
if c.client != nil {
|
||||
c.client.Disconnect()
|
||||
c.client = nil
|
||||
}
|
||||
c.mu.Unlock()
|
||||
|
||||
for _, ch := range pending {
|
||||
select {
|
||||
case ch <- submitPartResponse{err: err}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
if c.pool != nil {
|
||||
status := "disconnected"
|
||||
if c.pool.countActiveConnections() > 0 {
|
||||
status = "reconnecting"
|
||||
}
|
||||
c.pool.scheduleReconnect(err)
|
||||
_ = c.pool.reportState(context.Background(), status, err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"cmpp-platform/gateway/internal/queue"
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
cmpputils "github.com/bigwhite/gocmpp/utils"
|
||||
"log"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Receipt packets are correlated through the per-connection Submit tracker;
|
||||
// mobile-originated content uses a separate long-message assembly path.
|
||||
|
||||
type deliverPacket struct {
|
||||
seqID uint32
|
||||
msgID uint64
|
||||
destID string
|
||||
tpUdhi uint8
|
||||
msgFmt uint8
|
||||
srcTerminalID string
|
||||
registerDelivery uint8
|
||||
msgContent string
|
||||
}
|
||||
|
||||
func deliverPacketFromCMPP2(pkt *cmpp.Cmpp2DeliverReqPkt) deliverPacket {
|
||||
return deliverPacket{
|
||||
seqID: pkt.SeqId,
|
||||
msgID: pkt.MsgId,
|
||||
destID: pkt.DestId,
|
||||
tpUdhi: pkt.TpUdhi,
|
||||
msgFmt: pkt.MsgFmt,
|
||||
srcTerminalID: pkt.SrcTerminalId,
|
||||
registerDelivery: pkt.RegisterDelivery,
|
||||
msgContent: pkt.MsgContent,
|
||||
}
|
||||
}
|
||||
|
||||
func deliverPacketFromCMPP3(pkt *cmpp.Cmpp3DeliverReqPkt) deliverPacket {
|
||||
return deliverPacket{
|
||||
seqID: pkt.SeqId,
|
||||
msgID: pkt.MsgId,
|
||||
destID: pkt.DestId,
|
||||
tpUdhi: pkt.TpUdhi,
|
||||
msgFmt: pkt.MsgFmt,
|
||||
srcTerminalID: pkt.SrcTerminalId,
|
||||
registerDelivery: pkt.RegisterDelivery,
|
||||
msgContent: pkt.MsgContent,
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) handleDeliver(pkt deliverPacket) error {
|
||||
if pkt.registerDelivery == 1 {
|
||||
var receipt cmpp.CmppReceiptPkt
|
||||
if err := receipt.Unpack([]byte(pkt.msgContent)); err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=channel_to_platform event=deliver_receipt status=parse_failed channel_id=%s sequence_id=%d packet_msg_id=%d error=%q", c.channelID, pkt.seqID, pkt.msgID, err)
|
||||
return err
|
||||
}
|
||||
log.Printf("protocol_event protocol=cmpp direction=channel_to_platform event=deliver_receipt status=received channel_id=%s sequence_id=%d gateway_message_id=%d raw_status=%s", c.channelID, pkt.seqID, receipt.MsgId, strings.TrimSpace(receipt.Stat))
|
||||
cmd, ok := c.commandFor(receipt.MsgId)
|
||||
if !ok {
|
||||
cmd, ok = c.commandFor(pkt.msgID)
|
||||
}
|
||||
traceID := fmt.Sprintf("receipt-%d", receipt.MsgId)
|
||||
messageID := fmt.Sprintf("receipt-%d", receipt.MsgId)
|
||||
channelID := c.channelID
|
||||
if ok {
|
||||
traceID = cmd.TraceID
|
||||
messageID = cmd.MessageID
|
||||
channelID = cmd.ChannelID
|
||||
}
|
||||
event := queue.ReceiptEvent{
|
||||
Envelope: queue.Envelope{
|
||||
SchemaVersion: queue.SchemaVersion,
|
||||
MessageType: queue.MessageTypeReceiptEvent,
|
||||
TraceID: traceID,
|
||||
MessageID: messageID,
|
||||
ChannelID: channelID,
|
||||
CreatedAt: time.Now().UTC(),
|
||||
},
|
||||
SequenceID: pkt.seqID,
|
||||
GatewayMessageID: fmt.Sprint(receipt.MsgId),
|
||||
PhoneNumber: strings.TrimSpace(receipt.DestTerminalId),
|
||||
ReceiptStatus: receiptStatus(receipt.Stat),
|
||||
RawStatus: strings.TrimSpace(receipt.Stat),
|
||||
DeliveredAt: time.Now().UTC(),
|
||||
ConnectionID: c.identity(),
|
||||
}
|
||||
if err := postJSON(context.Background(), c.httpClient, c.apiBaseURL, "/gateway/events/receipt/intake", event); err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_receipt status=forward_failed channel_id=%s sequence_id=%d gateway_message_id=%d error=%q", c.channelID, pkt.seqID, receipt.MsgId, err)
|
||||
return err
|
||||
} else {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_receipt status=forwarded channel_id=%s sequence_id=%d gateway_message_id=%d", c.channelID, pkt.seqID, receipt.MsgId)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
content, complete, err := c.decodeUplinkContent(pkt)
|
||||
if err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=channel_to_platform event=deliver_uplink status=decode_failed channel_id=%s sequence_id=%d packet_msg_id=%d error=%q", c.channelID, pkt.seqID, pkt.msgID, err)
|
||||
return err
|
||||
}
|
||||
if !complete {
|
||||
return nil
|
||||
}
|
||||
cmd, _ := c.commandFor(pkt.msgID)
|
||||
event := queue.UplinkEvent{
|
||||
Envelope: queue.Envelope{
|
||||
SchemaVersion: queue.SchemaVersion,
|
||||
MessageType: queue.MessageTypeUplinkEvent,
|
||||
TraceID: cmd.TraceID,
|
||||
MessageID: cmd.MessageID,
|
||||
ChannelID: c.channelID,
|
||||
CreatedAt: time.Now().UTC(),
|
||||
},
|
||||
SequenceID: pkt.seqID,
|
||||
PhoneNumber: strings.TrimSpace(pkt.srcTerminalID),
|
||||
DestID: strings.TrimSpace(pkt.destID),
|
||||
Content: content,
|
||||
ReceivedAt: time.Now().UTC(),
|
||||
}
|
||||
if err := postJSON(context.Background(), c.httpClient, c.apiBaseURL, "/gateway/events/uplink", event); err != nil {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_uplink status=forward_failed channel_id=%s sequence_id=%d packet_msg_id=%d error=%q", c.channelID, pkt.seqID, pkt.msgID, err)
|
||||
} else {
|
||||
log.Printf("protocol_event protocol=cmpp direction=gateway_to_api event=deliver_uplink status=forwarded channel_id=%s sequence_id=%d packet_msg_id=%d", c.channelID, pkt.seqID, pkt.msgID)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *connection) decodeUplinkContent(pkt deliverPacket) (string, bool, error) {
|
||||
if pkt.tpUdhi != 1 {
|
||||
content, err := decodeContent(pkt.msgFmt, pkt.msgContent)
|
||||
return content, true, err
|
||||
}
|
||||
ref, total, number, payload, ok := parseConcatSegment(pkt.msgContent)
|
||||
if !ok {
|
||||
content, err := decodeContent(pkt.msgFmt, pkt.msgContent)
|
||||
return content, true, err
|
||||
}
|
||||
key := fmt.Sprintf("%s:%s:%s:%d:%d", c.channelID, strings.TrimSpace(pkt.srcTerminalID), strings.TrimSpace(pkt.destID), ref, total)
|
||||
c.mu.Lock()
|
||||
if c.longUplink == nil {
|
||||
c.longUplink = make(map[string]*longUplinkAssembly)
|
||||
}
|
||||
pruneLongUplinkAssemblies(c.longUplink, time.Now(), 10*time.Minute)
|
||||
content, complete, err := assembleLongUplink(c.longUplink, key, pkt.msgFmt, total, number, payload)
|
||||
c.mu.Unlock()
|
||||
return content, complete, err
|
||||
}
|
||||
|
||||
func (c *connection) commandFor(gatewayMsgID uint64) (queue.SubmitCommand, bool) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
cmd, ok := c.tracker[gatewayMsgID]
|
||||
return cmd, ok
|
||||
}
|
||||
|
||||
func decodeContent(format uint8, content string) (string, error) {
|
||||
switch format {
|
||||
case 8:
|
||||
return cmpputils.Ucs2ToUtf8(content)
|
||||
case 15:
|
||||
return cmpputils.GB18030ToUtf8(content)
|
||||
default:
|
||||
return content, nil
|
||||
}
|
||||
}
|
||||
|
||||
func receiptStatus(stat string) string {
|
||||
switch strings.ToUpper(strings.TrimSpace(stat)) {
|
||||
case "DELIVRD":
|
||||
return "delivered"
|
||||
case "":
|
||||
return "unknown"
|
||||
default:
|
||||
return "undelivered"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"time"
|
||||
)
|
||||
|
||||
// A window token belongs to one physical connection and must be released only
|
||||
// after its Submit attempt completes, preserving per-connection CMPP flow control.
|
||||
|
||||
func (p *connectionPool) acquireConnection(ctx context.Context) (*connection, func(), error) {
|
||||
waitCtx, cancel := context.WithTimeout(ctx, defaultSubmitTimeout)
|
||||
defer cancel()
|
||||
ticker := time.NewTicker(10 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
if conn, release := p.tryAcquireConnection(); conn != nil {
|
||||
if connected, err := conn.ensureConnected(); err != nil {
|
||||
release()
|
||||
select {
|
||||
case <-waitCtx.Done():
|
||||
return nil, nil, waitCtx.Err()
|
||||
case <-ticker.C:
|
||||
continue
|
||||
}
|
||||
} else if connected {
|
||||
_ = p.reportState(context.Background(), "connected", nil)
|
||||
}
|
||||
return conn, release, nil
|
||||
}
|
||||
select {
|
||||
case <-waitCtx.Done():
|
||||
return nil, nil, waitCtx.Err()
|
||||
case <-ticker.C:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (p *connectionPool) tryAcquireConnection() (*connection, func()) {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
if len(p.conns) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
for i := 0; i < len(p.conns); i++ {
|
||||
index := (p.next + i) % len(p.conns)
|
||||
conn := p.conns[index]
|
||||
if conn.tryAcquireWindow() {
|
||||
p.next = (index + 1) % len(p.conns)
|
||||
return conn, conn.releaseWindow
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (c *connection) tryAcquireWindow() bool {
|
||||
if c.window == nil {
|
||||
c.window = make(chan struct{}, defaultWindowSize)
|
||||
}
|
||||
select {
|
||||
case c.window <- struct{}{}:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) releaseWindow() {
|
||||
if c.window == nil {
|
||||
return
|
||||
}
|
||||
select {
|
||||
case <-c.window:
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) heartbeatLoop(ctx context.Context) {
|
||||
interval := time.Duration(c.config.HeartbeatIntervalSeconds) * time.Second
|
||||
if interval <= 0 {
|
||||
interval = defaultHeartbeatInterval
|
||||
}
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
if !c.sendHeartbeat() {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) sendHeartbeat() bool {
|
||||
threshold := c.config.HeartbeatMissThreshold
|
||||
if threshold <= 0 {
|
||||
threshold = defaultHeartbeatMissThreshold
|
||||
}
|
||||
c.mu.Lock()
|
||||
if c.closed {
|
||||
c.mu.Unlock()
|
||||
return false
|
||||
}
|
||||
if len(c.heartbeatPending) >= threshold {
|
||||
c.mu.Unlock()
|
||||
c.handleConnectionLoss(fmt.Errorf("heartbeat timeout after %d unanswered ACTIVE_TEST requests", threshold))
|
||||
return false
|
||||
}
|
||||
if c.client == nil {
|
||||
c.mu.Unlock()
|
||||
return false
|
||||
}
|
||||
c.sendMu.Lock()
|
||||
seq, err := c.client.SendReqPkt(&cmpp.CmppActiveTestReqPkt{})
|
||||
c.sendMu.Unlock()
|
||||
if err != nil {
|
||||
c.mu.Unlock()
|
||||
c.handleConnectionLoss(fmt.Errorf("send ACTIVE_TEST: %w", err))
|
||||
return false
|
||||
}
|
||||
if !c.closed {
|
||||
c.heartbeatPending[seq] = time.Now().UTC()
|
||||
}
|
||||
c.mu.Unlock()
|
||||
return true
|
||||
}
|
||||
|
||||
func (c *connection) handleHeartbeatResponse(sequenceID uint32) {
|
||||
c.mu.Lock()
|
||||
delete(c.heartbeatPending, sequenceID)
|
||||
c.mu.Unlock()
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,121 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"cmpp-platform/gateway/internal/queue"
|
||||
"context"
|
||||
"net/http"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type connectionPool struct {
|
||||
channelID string
|
||||
connectionID string
|
||||
config queue.UpstreamConfig
|
||||
apiBaseURL string
|
||||
httpClient *http.Client
|
||||
reporter func(context.Context, ConnectionState) error
|
||||
|
||||
mu sync.Mutex
|
||||
connectMu sync.Mutex
|
||||
conns []*connection
|
||||
next int
|
||||
reconnectSignal chan struct{}
|
||||
stopCh chan struct{}
|
||||
stopOnce sync.Once
|
||||
supervisorOnce sync.Once
|
||||
reconnectCount int
|
||||
lastReconnectAttemptAt time.Time
|
||||
nextReconnectAt time.Time
|
||||
lastErrorCategory string
|
||||
}
|
||||
|
||||
func (p *connectionPool) matches(config queue.UpstreamConfig) bool {
|
||||
return p.config == normalizeUpstreamConfig(config)
|
||||
}
|
||||
|
||||
func (p *connectionPool) ensureConnected() error {
|
||||
p.connectMu.Lock()
|
||||
defer p.connectMu.Unlock()
|
||||
desired := p.config.DesiredConnections
|
||||
if desired <= 0 {
|
||||
desired = 1
|
||||
}
|
||||
connectedAny := false
|
||||
for {
|
||||
p.mu.Lock()
|
||||
active := p.conns[:0]
|
||||
for _, existing := range p.conns {
|
||||
existing.mu.Lock()
|
||||
usable := existing.client != nil && !existing.closed
|
||||
existing.mu.Unlock()
|
||||
if usable {
|
||||
active = append(active, existing)
|
||||
}
|
||||
}
|
||||
p.conns = active
|
||||
if len(p.conns) >= desired {
|
||||
p.mu.Unlock()
|
||||
break
|
||||
}
|
||||
index := len(p.conns)
|
||||
conn := &connection{
|
||||
channelID: p.channelID,
|
||||
config: p.config,
|
||||
index: index,
|
||||
pool: p,
|
||||
apiBaseURL: p.apiBaseURL,
|
||||
httpClient: p.httpClient,
|
||||
window: make(chan struct{}, p.config.WindowSize),
|
||||
pending: make(map[uint32]chan submitPartResponse),
|
||||
tracker: make(map[uint64]queue.SubmitCommand),
|
||||
longUplink: make(map[string]*longUplinkAssembly),
|
||||
heartbeatPending: make(map[uint32]time.Time),
|
||||
}
|
||||
p.mu.Unlock()
|
||||
|
||||
connected, err := conn.ensureConnected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
p.mu.Lock()
|
||||
p.conns = append(p.conns, conn)
|
||||
p.mu.Unlock()
|
||||
connectedAny = connectedAny || connected
|
||||
}
|
||||
if connectedAny {
|
||||
_ = p.reportState(context.Background(), "connected", nil)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *connectionPool) close() {
|
||||
p.connectMu.Lock()
|
||||
defer p.connectMu.Unlock()
|
||||
p.stopOnce.Do(func() {
|
||||
close(p.stopCh)
|
||||
})
|
||||
p.mu.Lock()
|
||||
conns := p.conns
|
||||
p.conns = nil
|
||||
p.mu.Unlock()
|
||||
for _, conn := range conns {
|
||||
conn.close()
|
||||
}
|
||||
}
|
||||
|
||||
func (p *connectionPool) countActiveConnections() int {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
count := 0
|
||||
for _, conn := range p.conns {
|
||||
conn.mu.Lock()
|
||||
active := conn.client != nil && !conn.closed
|
||||
conn.mu.Unlock()
|
||||
if active {
|
||||
count += 1
|
||||
}
|
||||
}
|
||||
return count
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
"log"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type protocolLogEvent struct {
|
||||
Protocol string `json:"protocol"`
|
||||
Direction string `json:"direction"`
|
||||
EventType string `json:"eventType"`
|
||||
Status string `json:"status"`
|
||||
TenantID string `json:"tenantId,omitempty"`
|
||||
ApplicationID string `json:"applicationId,omitempty"`
|
||||
ChannelID string `json:"channelId,omitempty"`
|
||||
Account string `json:"account,omitempty"`
|
||||
MessageID string `json:"messageId,omitempty"`
|
||||
GatewayMessageID string `json:"gatewayMessageId,omitempty"`
|
||||
Phone string `json:"phone,omitempty"`
|
||||
ResultCode string `json:"resultCode,omitempty"`
|
||||
PayloadBytes int `json:"payloadBytes,omitempty"`
|
||||
Detail map[string]any `json:"detail,omitempty"`
|
||||
}
|
||||
|
||||
func (c *connection) emitDeliverResponse(pkt deliverPacket, responseErr error) {
|
||||
status := "success"
|
||||
resultCode := "0"
|
||||
detail := map[string]any{"sequenceId": pkt.seqID}
|
||||
gatewayMessageID := fmt.Sprint(pkt.msgID)
|
||||
messageID := ""
|
||||
phone := ""
|
||||
tenantID := ""
|
||||
applicationID := ""
|
||||
channelID := c.channelID
|
||||
if pkt.registerDelivery == 1 {
|
||||
var receipt cmpp.CmppReceiptPkt
|
||||
if err := receipt.Unpack([]byte(pkt.msgContent)); err == nil {
|
||||
gatewayMessageID = fmt.Sprint(receipt.MsgId)
|
||||
phone = strings.TrimSpace(receipt.DestTerminalId)
|
||||
if cmd, ok := c.commandFor(receipt.MsgId); ok {
|
||||
messageID = cmd.MessageID
|
||||
tenantID = cmd.TenantID
|
||||
applicationID = cmd.ApplicationID
|
||||
channelID = cmd.ChannelID
|
||||
}
|
||||
}
|
||||
}
|
||||
if responseErr != nil {
|
||||
status = "failed"
|
||||
resultCode = "SEND_FAILED"
|
||||
detail["error"] = responseErr.Error()
|
||||
}
|
||||
c.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_channel",
|
||||
EventType: "deliver_resp",
|
||||
Status: status,
|
||||
TenantID: tenantID,
|
||||
ApplicationID: applicationID,
|
||||
ChannelID: channelID,
|
||||
Account: c.config.Account,
|
||||
MessageID: messageID,
|
||||
GatewayMessageID: gatewayMessageID,
|
||||
Phone: phone,
|
||||
ResultCode: resultCode,
|
||||
Detail: detail,
|
||||
})
|
||||
}
|
||||
|
||||
func (c *connection) emitProtocolLog(event protocolLogEvent) {
|
||||
go func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), defaultHTTPTimeout)
|
||||
defer cancel()
|
||||
if err := postJSON(ctx, c.httpClient, c.apiBaseURL, "/gateway/events/protocol-log", event); err != nil {
|
||||
log.Printf("protocol_event protocol=%s direction=%s event=%s status=telemetry_failed channel_id=%s message_id=%s error=%q", event.Protocol, event.Direction, event.EventType, event.ChannelID, event.MessageID, err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Authentication failures intentionally use the slow retry class while
|
||||
// transient network failures use capped backoff; manual disconnect closes stopCh.
|
||||
|
||||
func (p *connectionPool) startSupervisor() {
|
||||
p.supervisorOnce.Do(func() {
|
||||
go p.superviseReconnects()
|
||||
})
|
||||
}
|
||||
|
||||
func (p *connectionPool) stopped() bool {
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (p *connectionPool) signalReconnect() {
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
select {
|
||||
case p.reconnectSignal <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (p *connectionPool) scheduleReconnect(stateErr error) {
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
p.mu.Lock()
|
||||
now := time.Now().UTC()
|
||||
if !p.nextReconnectAt.IsZero() && p.nextReconnectAt.After(now) {
|
||||
p.mu.Unlock()
|
||||
return
|
||||
}
|
||||
p.reconnectCount++
|
||||
p.lastReconnectAttemptAt = now
|
||||
p.lastErrorCategory = connectionErrorCategory(stateErr)
|
||||
delay := reconnectDelay(p.reconnectCount, p.lastErrorCategory)
|
||||
p.nextReconnectAt = p.lastReconnectAttemptAt.Add(delay)
|
||||
p.mu.Unlock()
|
||||
p.signalReconnect()
|
||||
}
|
||||
|
||||
func (p *connectionPool) resetReconnectState() {
|
||||
p.mu.Lock()
|
||||
p.reconnectCount = 0
|
||||
p.lastReconnectAttemptAt = time.Time{}
|
||||
p.nextReconnectAt = time.Time{}
|
||||
p.lastErrorCategory = ""
|
||||
p.mu.Unlock()
|
||||
p.signalReconnect()
|
||||
}
|
||||
|
||||
func (p *connectionPool) superviseReconnects() {
|
||||
for {
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return
|
||||
case <-p.reconnectSignal:
|
||||
}
|
||||
for {
|
||||
p.mu.Lock()
|
||||
next := p.nextReconnectAt
|
||||
p.mu.Unlock()
|
||||
if next.IsZero() {
|
||||
break
|
||||
}
|
||||
timer := time.NewTimer(time.Until(next))
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
if !timer.Stop() {
|
||||
<-timer.C
|
||||
}
|
||||
return
|
||||
case <-p.reconnectSignal:
|
||||
if !timer.Stop() {
|
||||
<-timer.C
|
||||
}
|
||||
continue
|
||||
case <-timer.C:
|
||||
}
|
||||
_ = p.reportState(context.Background(), "reconnecting", nil)
|
||||
p.mu.Lock()
|
||||
p.lastReconnectAttemptAt = time.Now().UTC()
|
||||
p.mu.Unlock()
|
||||
if err := p.ensureConnected(); err != nil {
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
p.scheduleReconnect(err)
|
||||
_ = p.reportState(context.Background(), "failed", err)
|
||||
continue
|
||||
}
|
||||
select {
|
||||
case <-p.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
p.resetReconnectState()
|
||||
_ = p.reportState(context.Background(), "connected", nil)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func connectionErrorCategory(err error) string {
|
||||
if err == nil {
|
||||
return ""
|
||||
}
|
||||
message := strings.ToLower(err.Error())
|
||||
switch {
|
||||
case strings.Contains(message, "auth"), strings.Contains(message, "password"), strings.Contains(message, "credential"):
|
||||
return "authentication"
|
||||
case strings.Contains(message, "heartbeat"):
|
||||
return "heartbeat_timeout"
|
||||
case strings.Contains(message, "timeout"):
|
||||
return "timeout"
|
||||
default:
|
||||
return "network"
|
||||
}
|
||||
}
|
||||
|
||||
func reconnectDelay(attempt int, category string) time.Duration {
|
||||
if category == "authentication" {
|
||||
return defaultAuthReconnectDelay
|
||||
}
|
||||
if attempt < 1 {
|
||||
attempt = 1
|
||||
}
|
||||
delays := []time.Duration{
|
||||
defaultReconnectInitialDelay,
|
||||
15 * time.Second,
|
||||
30 * time.Second,
|
||||
time.Minute,
|
||||
2 * time.Minute,
|
||||
defaultReconnectMaximumDelay,
|
||||
}
|
||||
delay := delays[min(attempt-1, len(delays)-1)]
|
||||
// Deterministic ±10% jitter prevents a large set of channels from retrying together.
|
||||
offsetPercent := (attempt*37)%21 - 10
|
||||
delay += time.Duration(int64(delay) * int64(offsetPercent) / 100)
|
||||
if delay < time.Second {
|
||||
return time.Second
|
||||
}
|
||||
return delay
|
||||
}
|
||||
|
||||
func isTemporaryReadTimeout(err error) bool {
|
||||
var netErr net.Error
|
||||
return errors.As(err, &netErr) && netErr.Timeout()
|
||||
}
|
||||
@@ -0,0 +1,387 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"cmpp-platform/gateway/internal/queue"
|
||||
"context"
|
||||
"fmt"
|
||||
cmpp "github.com/bigwhite/gocmpp"
|
||||
cmpputils "github.com/bigwhite/gocmpp/utils"
|
||||
"log"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Segment callbacks are emitted in submission order. The aggregate result keeps
|
||||
// the first sequence and Msg_Id while retaining every segment result for billing.
|
||||
|
||||
func (m *Manager) Submit(ctx context.Context, cmd queue.SubmitCommand) (queue.SubmitResult, error) {
|
||||
if err := validateSubmitCommand(cmd); err != nil {
|
||||
result := submitResult(cmd, 0, "", "rejected", "INVALID_COMMAND", err.Error())
|
||||
if postErr := m.post(ctx, "/gateway/events/submit-result", result); postErr != nil {
|
||||
return result, postErr
|
||||
}
|
||||
return result, err
|
||||
}
|
||||
|
||||
pool, err := m.connectionFor(cmd)
|
||||
if err != nil {
|
||||
result := submitResult(cmd, 0, "", "rejected", "CONNECT_FAILED", err.Error())
|
||||
if postErr := m.post(ctx, "/gateway/events/submit-result", result); postErr != nil {
|
||||
return result, postErr
|
||||
}
|
||||
return result, err
|
||||
}
|
||||
|
||||
result, err := pool.submit(ctx, cmd, func(segment queue.SubmitSegmentResult) {
|
||||
payload := struct {
|
||||
queue.Envelope
|
||||
SubmitID string `json:"submitId,omitempty"`
|
||||
queue.SubmitSegmentResult
|
||||
}{
|
||||
Envelope: cmd.Envelope,
|
||||
SubmitID: cmd.SubmitID,
|
||||
SubmitSegmentResult: segment,
|
||||
}
|
||||
callbackCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
postErr := m.post(callbackCtx, "/gateway/events/submit-segment-result", payload)
|
||||
cancel()
|
||||
if postErr != nil {
|
||||
log.Printf(
|
||||
"protocol_event protocol=cmpp direction=gateway_to_api event=submit_segment_result status=forward_failed channel_id=%s message_id=%s segment=%d/%d error=%q",
|
||||
cmd.ChannelID, cmd.MessageID, segment.SegmentIndex, segment.SegmentTotal, postErr,
|
||||
)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
if postErr := m.post(ctx, "/gateway/events/submit-result", result); postErr != nil {
|
||||
return result, postErr
|
||||
}
|
||||
return result, err
|
||||
}
|
||||
if err := m.post(ctx, "/gateway/events/submit-result", result); err != nil {
|
||||
return result, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (p *connectionPool) submit(
|
||||
ctx context.Context,
|
||||
cmd queue.SubmitCommand,
|
||||
onSegment func(queue.SubmitSegmentResult),
|
||||
) (queue.SubmitResult, error) {
|
||||
parts, err := splitSubmitContent(cmd.CMPP.MsgFmt, cmd.Content)
|
||||
if err != nil {
|
||||
result := submitResult(cmd, 0, "", "rejected", "ENCODE_FAILED", err.Error())
|
||||
return result, err
|
||||
}
|
||||
|
||||
var firstSequence uint32
|
||||
var firstGatewayMessageID string
|
||||
segments := make([]queue.SubmitSegmentResult, 0, len(parts))
|
||||
for _, part := range parts {
|
||||
conn, release, err := p.acquireConnection(ctx)
|
||||
if err != nil {
|
||||
result := submitResult(cmd, 0, "", "timeout", "WINDOW_TIMEOUT", err.Error())
|
||||
result.Segments = segments
|
||||
return result, err
|
||||
}
|
||||
seq, gatewayMessageID, result, err := conn.submitPart(ctx, cmd, part)
|
||||
release()
|
||||
segment := submitSegmentResult(part, seq, gatewayMessageID, result)
|
||||
segments = append(segments, segment)
|
||||
if onSegment != nil {
|
||||
onSegment(segment)
|
||||
}
|
||||
if firstSequence == 0 {
|
||||
firstSequence = seq
|
||||
}
|
||||
if firstGatewayMessageID == "" {
|
||||
firstGatewayMessageID = gatewayMessageID
|
||||
}
|
||||
if err != nil {
|
||||
result.Segments = segments
|
||||
return result, err
|
||||
}
|
||||
if result.SubmitStatus != "accepted" {
|
||||
result.Segments = segments
|
||||
return result, nil
|
||||
}
|
||||
}
|
||||
|
||||
result := submitResult(cmd, firstSequence, firstGatewayMessageID, "accepted", "", "")
|
||||
result.Segments = segments
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (c *connection) submitPart(ctx context.Context, cmd queue.SubmitCommand, part submitPart) (uint32, string, queue.SubmitResult, error) {
|
||||
rspCh := make(chan submitPartResponse, 1)
|
||||
pkt := c.submitRequestPacket(cmd, part)
|
||||
|
||||
c.mu.Lock()
|
||||
client := c.client
|
||||
closed := c.closed
|
||||
c.mu.Unlock()
|
||||
if closed || client == nil {
|
||||
err := fmt.Errorf("supplier connection is not available")
|
||||
result := submitResult(cmd, 0, "", "timeout", "CONNECTION_LOST", err.Error())
|
||||
return 0, "", result, err
|
||||
}
|
||||
c.sendMu.Lock()
|
||||
seq, err := client.SendReqPkt(pkt)
|
||||
c.sendMu.Unlock()
|
||||
if err != nil {
|
||||
c.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_channel",
|
||||
EventType: "submit",
|
||||
Status: "failed",
|
||||
TenantID: cmd.TenantID,
|
||||
ApplicationID: cmd.ApplicationID,
|
||||
ChannelID: cmd.ChannelID,
|
||||
Account: c.config.Account,
|
||||
MessageID: cmd.MessageID,
|
||||
Phone: cmd.PhoneNumber,
|
||||
ResultCode: "SEND_FAILED",
|
||||
PayloadBytes: len(part.MsgContent),
|
||||
Detail: map[string]any{
|
||||
"segmentTotal": part.PkTotal,
|
||||
"segmentIndex": part.PkNumber,
|
||||
},
|
||||
})
|
||||
c.close()
|
||||
result := submitResult(cmd, 0, "", "timeout", "SEND_FAILED", err.Error())
|
||||
return 0, "", result, err
|
||||
}
|
||||
c.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "platform_to_channel",
|
||||
EventType: "submit",
|
||||
Status: "success",
|
||||
TenantID: cmd.TenantID,
|
||||
ApplicationID: cmd.ApplicationID,
|
||||
ChannelID: cmd.ChannelID,
|
||||
Account: c.config.Account,
|
||||
MessageID: cmd.MessageID,
|
||||
Phone: cmd.PhoneNumber,
|
||||
PayloadBytes: len(part.MsgContent),
|
||||
Detail: map[string]any{
|
||||
"sequenceId": seq,
|
||||
"segmentTotal": part.PkTotal,
|
||||
"segmentIndex": part.PkNumber,
|
||||
},
|
||||
})
|
||||
|
||||
c.mu.Lock()
|
||||
c.pending[seq] = rspCh
|
||||
c.mu.Unlock()
|
||||
defer func() {
|
||||
c.mu.Lock()
|
||||
delete(c.pending, seq)
|
||||
c.mu.Unlock()
|
||||
}()
|
||||
|
||||
waitCtx, cancel := context.WithTimeout(ctx, defaultSubmitTimeout)
|
||||
defer cancel()
|
||||
select {
|
||||
case <-waitCtx.Done():
|
||||
result := submitResult(cmd, seq, "", "timeout", "SUBMIT_TIMEOUT", waitCtx.Err().Error())
|
||||
return seq, "", result, waitCtx.Err()
|
||||
case rsp := <-rspCh:
|
||||
if rsp.err != nil {
|
||||
result := submitResult(cmd, seq, "", "timeout", "CONNECTION_LOST", rsp.err.Error())
|
||||
return seq, "", result, rsp.err
|
||||
}
|
||||
gatewayMessageID := fmt.Sprint(rsp.msgID)
|
||||
status := "accepted"
|
||||
errorCode := ""
|
||||
errorMessage := ""
|
||||
if rsp.result != 0 {
|
||||
status = "rejected"
|
||||
errorCode = fmt.Sprint(rsp.result)
|
||||
errorMessage = fmt.Sprintf("upstream submit rejected with result %d", rsp.result)
|
||||
}
|
||||
c.emitProtocolLog(protocolLogEvent{
|
||||
Protocol: "cmpp",
|
||||
Direction: "channel_to_platform",
|
||||
EventType: "submit_resp",
|
||||
Status: "success",
|
||||
TenantID: cmd.TenantID,
|
||||
ApplicationID: cmd.ApplicationID,
|
||||
ChannelID: cmd.ChannelID,
|
||||
Account: c.config.Account,
|
||||
MessageID: cmd.MessageID,
|
||||
GatewayMessageID: gatewayMessageID,
|
||||
Phone: cmd.PhoneNumber,
|
||||
ResultCode: fmt.Sprint(rsp.result),
|
||||
Detail: map[string]any{
|
||||
"sequenceId": rsp.seqID,
|
||||
"segmentTotal": part.PkTotal,
|
||||
"segmentIndex": part.PkNumber,
|
||||
},
|
||||
})
|
||||
if rsp.result == 0 {
|
||||
c.mu.Lock()
|
||||
c.tracker[rsp.msgID] = cmd
|
||||
c.mu.Unlock()
|
||||
}
|
||||
return seq, gatewayMessageID, submitResult(cmd, seq, gatewayMessageID, status, errorCode, errorMessage), nil
|
||||
}
|
||||
}
|
||||
|
||||
func (c *connection) submitRequestPacket(cmd queue.SubmitCommand, part submitPart) cmpp.Packer {
|
||||
base := submitRequestFields{
|
||||
PkTotal: part.PkTotal,
|
||||
PkNumber: part.PkNumber,
|
||||
TpUdhi: part.TpUdhi,
|
||||
RegisteredDelivery: uint8(cmd.CMPP.RegisteredDelivery),
|
||||
MsgLevel: 1,
|
||||
ServiceId: cmd.CMPP.ServiceID,
|
||||
FeeUserType: uint8(defaultInt(cmd.CMPP.FeeUserType, 2)),
|
||||
FeeTerminalId: cmd.PhoneNumber,
|
||||
MsgFmt: uint8(cmd.CMPP.MsgFmt),
|
||||
MsgSrc: c.config.Account,
|
||||
FeeType: defaultString(cmd.CMPP.FeeType, "02"),
|
||||
FeeCode: defaultString(cmd.CMPP.FeeCode, "0"),
|
||||
SrcId: cmd.CMPP.SrcID,
|
||||
DestUsrTl: 1,
|
||||
DestTerminalId: []string{cmd.PhoneNumber},
|
||||
MsgLength: uint8(len(part.MsgContent)),
|
||||
MsgContent: part.MsgContent,
|
||||
}
|
||||
if protocolVersion(c.config.CMPPVersion) == cmpp.V20 {
|
||||
return &cmpp.Cmpp2SubmitReqPkt{
|
||||
PkTotal: base.PkTotal,
|
||||
PkNumber: base.PkNumber,
|
||||
RegisteredDelivery: base.RegisteredDelivery,
|
||||
MsgLevel: base.MsgLevel,
|
||||
ServiceId: base.ServiceId,
|
||||
FeeUserType: base.FeeUserType,
|
||||
FeeTerminalId: base.FeeTerminalId,
|
||||
TpUdhi: base.TpUdhi,
|
||||
MsgFmt: base.MsgFmt,
|
||||
MsgSrc: base.MsgSrc,
|
||||
FeeType: base.FeeType,
|
||||
FeeCode: base.FeeCode,
|
||||
SrcId: base.SrcId,
|
||||
DestUsrTl: base.DestUsrTl,
|
||||
DestTerminalId: base.DestTerminalId,
|
||||
MsgLength: base.MsgLength,
|
||||
MsgContent: base.MsgContent,
|
||||
}
|
||||
}
|
||||
return &cmpp.Cmpp3SubmitReqPkt{
|
||||
PkTotal: base.PkTotal,
|
||||
PkNumber: base.PkNumber,
|
||||
RegisteredDelivery: base.RegisteredDelivery,
|
||||
MsgLevel: base.MsgLevel,
|
||||
ServiceId: base.ServiceId,
|
||||
FeeUserType: base.FeeUserType,
|
||||
FeeTerminalId: base.FeeTerminalId,
|
||||
TpUdhi: base.TpUdhi,
|
||||
MsgFmt: base.MsgFmt,
|
||||
MsgSrc: base.MsgSrc,
|
||||
FeeType: base.FeeType,
|
||||
FeeCode: base.FeeCode,
|
||||
SrcId: base.SrcId,
|
||||
DestUsrTl: base.DestUsrTl,
|
||||
DestTerminalId: base.DestTerminalId,
|
||||
MsgLength: base.MsgLength,
|
||||
MsgContent: base.MsgContent,
|
||||
}
|
||||
}
|
||||
|
||||
type submitRequestFields struct {
|
||||
PkTotal uint8
|
||||
PkNumber uint8
|
||||
RegisteredDelivery uint8
|
||||
MsgLevel uint8
|
||||
ServiceId string
|
||||
FeeUserType uint8
|
||||
FeeTerminalId string
|
||||
TpUdhi uint8
|
||||
MsgFmt uint8
|
||||
MsgSrc string
|
||||
FeeType string
|
||||
FeeCode string
|
||||
SrcId string
|
||||
DestUsrTl uint8
|
||||
DestTerminalId []string
|
||||
MsgLength uint8
|
||||
MsgContent string
|
||||
}
|
||||
|
||||
func submitResult(cmd queue.SubmitCommand, sequenceID uint32, gatewayMessageID string, status string, code string, message string) queue.SubmitResult {
|
||||
if gatewayMessageID == "" {
|
||||
gatewayMessageID = fmt.Sprintf("GW-%s-%d", cmd.SubmitID, time.Now().UnixNano())
|
||||
}
|
||||
return queue.SubmitResult{
|
||||
Envelope: queue.Envelope{
|
||||
SchemaVersion: queue.SchemaVersion,
|
||||
MessageType: queue.MessageTypeSubmitResult,
|
||||
TraceID: cmd.TraceID,
|
||||
MessageID: cmd.MessageID,
|
||||
ChannelID: cmd.ChannelID,
|
||||
CreatedAt: time.Now().UTC(),
|
||||
},
|
||||
SubmitID: cmd.SubmitID,
|
||||
SequenceID: sequenceID,
|
||||
GatewayMessageID: gatewayMessageID,
|
||||
SubmitStatus: status,
|
||||
ErrorCode: code,
|
||||
ErrorMessage: message,
|
||||
SubmittedAt: time.Now().UTC(),
|
||||
}
|
||||
}
|
||||
|
||||
func submitSegmentResult(part submitPart, sequenceID uint32, gatewayMessageID string, result queue.SubmitResult) queue.SubmitSegmentResult {
|
||||
if gatewayMessageID == "" {
|
||||
gatewayMessageID = result.GatewayMessageID
|
||||
}
|
||||
return queue.SubmitSegmentResult{
|
||||
SegmentTotal: int(part.PkTotal),
|
||||
SegmentIndex: int(part.PkNumber),
|
||||
SequenceID: sequenceID,
|
||||
GatewayMessageID: gatewayMessageID,
|
||||
SubmitStatus: result.SubmitStatus,
|
||||
ErrorCode: result.ErrorCode,
|
||||
ErrorMessage: result.ErrorMessage,
|
||||
SubmittedAt: result.SubmittedAt,
|
||||
}
|
||||
}
|
||||
|
||||
func validateSubmitCommand(cmd queue.SubmitCommand) error {
|
||||
if cmd.MessageType != queue.MessageTypeSubmitCommand {
|
||||
return fmt.Errorf("unsupported messageType %q", cmd.MessageType)
|
||||
}
|
||||
if cmd.MessageID == "" || cmd.ChannelID == "" || cmd.SubmitID == "" {
|
||||
return fmt.Errorf("messageId, channelId and submitId are required")
|
||||
}
|
||||
if cmd.Upstream.GatewayHost == "" || cmd.Upstream.GatewayPort <= 0 {
|
||||
return fmt.Errorf("upstream gatewayHost and gatewayPort are required")
|
||||
}
|
||||
if cmd.Upstream.Account == "" || cmd.Upstream.PasswordCipher == "" {
|
||||
return fmt.Errorf("upstream account and passwordCipher are required")
|
||||
}
|
||||
if len(cmd.PhoneNumber) == 0 || len(cmd.Content) == 0 {
|
||||
return fmt.Errorf("phoneNumber and content are required")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func encodeContent(format int, content string) (string, error) {
|
||||
switch format {
|
||||
case 8:
|
||||
return cmpputils.Utf8ToUcs2(content)
|
||||
case 15:
|
||||
return cmpputils.Utf8ToGB18030(content)
|
||||
default:
|
||||
return content, nil
|
||||
}
|
||||
}
|
||||
|
||||
func protocolVersion(version string) cmpp.Type {
|
||||
if strings.HasPrefix(version, "2") {
|
||||
return cmpp.V20
|
||||
}
|
||||
return cmpp.V30
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
package upstream
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func (m *Manager) post(ctx context.Context, path string, payload any) error {
|
||||
client := m.HTTPClient
|
||||
if client == nil {
|
||||
client = &http.Client{Timeout: defaultHTTPTimeout}
|
||||
}
|
||||
return postJSON(ctx, client, m.APIBaseURL, path, payload)
|
||||
}
|
||||
|
||||
func (p *connectionPool) reportState(ctx context.Context, status string, stateErr error) error {
|
||||
if p.reporter == nil {
|
||||
return nil
|
||||
}
|
||||
return p.reporter(ctx, p.snapshotState(status, stateErr))
|
||||
}
|
||||
|
||||
func (p *connectionPool) snapshotState(status string, stateErr error) ConnectionState {
|
||||
now := time.Now().UTC().Format(time.RFC3339Nano)
|
||||
state := ConnectionState{
|
||||
ChannelID: p.channelID,
|
||||
ConnectionID: p.connectionID,
|
||||
Status: status,
|
||||
DesiredConnections: p.config.DesiredConnections,
|
||||
CurrentConnections: p.countActiveConnections(),
|
||||
}
|
||||
p.mu.Lock()
|
||||
state.ReconnectCount = p.reconnectCount
|
||||
state.LastErrorCategory = p.lastErrorCategory
|
||||
if !p.lastReconnectAttemptAt.IsZero() {
|
||||
state.LastReconnectAttemptAt = p.lastReconnectAttemptAt.Format(time.RFC3339Nano)
|
||||
}
|
||||
if !p.nextReconnectAt.IsZero() {
|
||||
state.NextReconnectAt = p.nextReconnectAt.Format(time.RFC3339Nano)
|
||||
}
|
||||
p.mu.Unlock()
|
||||
if state.DesiredConnections <= 0 {
|
||||
state.DesiredConnections = 1
|
||||
}
|
||||
switch status {
|
||||
case "connected":
|
||||
state.LastConnectedAt = now
|
||||
state.LastHeartbeatAt = now
|
||||
case "heartbeat":
|
||||
state.LastHeartbeatAt = now
|
||||
case "disconnected", "failed":
|
||||
state.LastDisconnectedAt = now
|
||||
}
|
||||
if stateErr != nil {
|
||||
state.LastError = stateErr.Error()
|
||||
}
|
||||
return state
|
||||
}
|
||||
|
||||
func postJSON(ctx context.Context, client *http.Client, apiBaseURL string, path string, payload any) error {
|
||||
if client == nil {
|
||||
client = &http.Client{Timeout: defaultHTTPTimeout}
|
||||
}
|
||||
body, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
base := strings.TrimRight(apiBaseURL, "/")
|
||||
if base == "" {
|
||||
base = "http://127.0.0.1:3000/api"
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, base+path, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return fmt.Errorf("api returned %s", resp.Status)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func defaultString(value string, fallback string) string {
|
||||
if value == "" {
|
||||
return fallback
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
func defaultInt(value int, fallback int) int {
|
||||
if value == 0 {
|
||||
return fallback
|
||||
}
|
||||
return value
|
||||
}
|
||||
Reference in New Issue
Block a user