MiFaZhan
96 lines
2.6 KiB
Go
96 lines
2.6 KiB
Go
package upstreamimpl
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"regexp"
|
|
"time"
|
|
"git.5iot.com/iotlcm-public/iotlcm-upstream-proxy/internal/logic/upstreamimpl/dx"
|
|
"git.5iot.com/iotlcm-public/iotlcm-upstream-proxy/internal/model"
|
|
"git.5iot.com/iotlcm-public/iotlcm-upstream-proxy/internal/service"
|
|
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/net/gsvc"
|
|
)
|
|
|
|
// XML命名空间正则
|
|
var xmlNamespaceRegex = regexp.MustCompile(`xmlns[^=]*="[^"]*"\s*|:web:`)
|
|
|
|
type sSimDX struct {
|
|
channelConfig *model.SimChannelConfigItemCache
|
|
client *dx.Client
|
|
}
|
|
|
|
func NewSimDX() *sSimDX {
|
|
return &sSimDX{}
|
|
}
|
|
|
|
func init() {
|
|
s := NewSimDX()
|
|
service.UpstreamAPI().RegisterTemp("sim_dx_v1", s)
|
|
service.UpstreamAPI().RegisterTemp("sim_dx_v3", s)
|
|
service.RegisterSimDX(s)
|
|
}
|
|
|
|
func (s *sSimDX) NewTemp(ctx context.Context, channelConfig *model.SimChannelConfigItemCache) model.SimCardChannelI {
|
|
client := dx.NewClient(dx.Config{
|
|
BaseURL: dx.DefaultBaseURL,
|
|
AppKey: channelConfig.Channel.AppKey,
|
|
AppSecret: channelConfig.Channel.AppSecret,
|
|
})
|
|
return &sSimDX{
|
|
channelConfig: channelConfig,
|
|
client: client,
|
|
}
|
|
}
|
|
|
|
func (s *sSimDX) getUpstreamUrl(ctx context.Context, serviceUrl string) (string, error) {
|
|
address, err := g.Cfg().Get(ctx, "gateway.address")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("http://%s%s", address, serviceUrl), nil
|
|
// return fmt.Sprintf("http://%s%s", "127.0.0.1:8110", serviceUrl), nil
|
|
|
|
}
|
|
|
|
func (s *sSimDX) getUpstreamTimeout(ctx context.Context) time.Duration {
|
|
timeout, _ := g.Cfg().Get(ctx, "gateway.timeout")
|
|
if timeout == nil {
|
|
return 10 * time.Second
|
|
}
|
|
if d := timeout.Duration(); d > 0 {
|
|
return d
|
|
}
|
|
if seconds := timeout.Int(); seconds > 0 {
|
|
return time.Duration(seconds) * time.Second
|
|
}
|
|
return 10 * time.Second
|
|
}
|
|
|
|
func (s *sSimDX) SimBase(ctx context.Context, input *model.SimBaseReqJson) (model.SimBaseResJson, error) {
|
|
r := g.RequestFromCtx(ctx)
|
|
if r.Method != "POST" {
|
|
return nil, gerror.New("method not allowed")
|
|
}
|
|
path := r.URL.Path
|
|
if path == "" {
|
|
return nil, gerror.New("path is required")
|
|
}
|
|
url, err := s.getUpstreamUrl(ctx, path)
|
|
if err != nil {
|
|
g.Log().Debugf(ctx, "SimBase getUpstreamUrl error %+v, ", err)
|
|
return nil, err
|
|
}
|
|
client := g.Client()
|
|
client.SetDiscovery(gsvc.GetRegistry())
|
|
configureGatewayTimeout(ctx, client, path, len(input.SimKeys), s.getUpstreamTimeout(ctx))
|
|
resp, err := client.Post(ctx, url, input)
|
|
if err != nil {
|
|
g.Log().Errorf(ctx, "SimBase post error %+v,url %s, params %+v, ", err, url, input)
|
|
return nil, err
|
|
}
|
|
return readGatewayResponse(resp)
|
|
}
|