feat: 实现 Sense 批量开通与失败重试 (#72)
This commit is contained in:
@@ -0,0 +1,24 @@
|
||||
package router
|
||||
|
||||
import (
|
||||
"github.com/gin-gonic/gin"
|
||||
jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
|
||||
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/app/sense/provisioning"
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/common/actions"
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/common/middleware"
|
||||
)
|
||||
|
||||
func init() { routerCheckRole = append(routerCheckRole, registerSenseProvisioningRouter) }
|
||||
|
||||
func registerSenseProvisioningRouter(v1 *gin.RouterGroup, auth *jwt.GinJWTMiddleware) {
|
||||
api := &provisioning.API{}
|
||||
r := v1.Group("/provisioning/batches").Use(auth.MiddlewareFunc()).Use(middleware.AuthCheckRole()).Use(actions.PermissionAction())
|
||||
r.GET("", api.List)
|
||||
r.POST("", api.Create)
|
||||
r.GET("/:id", api.Get)
|
||||
r.POST("/:id/execute", api.Execute)
|
||||
r.POST("/:id/retry-failed", api.RetryFailed)
|
||||
r.POST("/:id/items/:itemId/retry", api.RetryItem)
|
||||
r.GET("/:id/export", api.Export)
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"encoding/csv"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/go-admin-team/go-admin-core/sdk/api"
|
||||
"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth/user"
|
||||
)
|
||||
|
||||
type API struct{ api.Api }
|
||||
|
||||
func (e *API) service(c *gin.Context) (*Service, error) {
|
||||
service := &Service{}
|
||||
if err := e.MakeContext(c).MakeOrm().MakeService(&service.Service).Errors; err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return service, nil
|
||||
}
|
||||
|
||||
func (e *API) List(c *gin.Context) {
|
||||
service, err := e.service(c)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
request := BatchPageRequest{}
|
||||
if err = e.MakeContext(c).Bind(&request).Errors; err != nil {
|
||||
e.Error(http.StatusBadRequest, err, "查询条件格式不正确")
|
||||
return
|
||||
}
|
||||
list, count, err := service.ListBatches(&request)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
e.PageOK(list, int(count), request.GetPageIndex(), request.GetPageSize(), "查询成功")
|
||||
}
|
||||
|
||||
func (e *API) Get(c *gin.Context) {
|
||||
service, err := e.service(c)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
response, err := service.GetBatch(c.Param("id"))
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
e.OK(response, "查询成功")
|
||||
}
|
||||
|
||||
func (e *API) Create(c *gin.Context) {
|
||||
service, err := e.service(c)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
request := CreateBatchRequest{CreateBy: user.GetUserId(c)}
|
||||
if err = bindStrictJSON(c, &request); err != nil {
|
||||
e.Error(http.StatusBadRequest, err, "导入内容格式不正确")
|
||||
return
|
||||
}
|
||||
response, err := service.CreateBatch(request)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
e.OK(response, "批次已导入并完成预校验")
|
||||
}
|
||||
|
||||
func (e *API) Execute(c *gin.Context) { e.execute(c, false, "") }
|
||||
func (e *API) RetryFailed(c *gin.Context) { e.execute(c, true, "") }
|
||||
func (e *API) RetryItem(c *gin.Context) { e.execute(c, true, c.Param("itemId")) }
|
||||
|
||||
func (e *API) execute(c *gin.Context, retryFailed bool, itemID string) {
|
||||
service, err := e.service(c)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
request := ExecuteRequest{UpdateBy: user.GetUserId(c)}
|
||||
defer func() { clearCredentials(request.Credentials) }()
|
||||
if err = bindStrictJSON(c, &request); err != nil {
|
||||
e.Error(http.StatusBadRequest, err, "执行内容格式不正确")
|
||||
return
|
||||
}
|
||||
response, err := service.Execute(c.Request.Context(), c.Param("id"), itemID, retryFailed, request)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
e.OK(response, "批量开通处理完成")
|
||||
}
|
||||
|
||||
func (e *API) Export(c *gin.Context) {
|
||||
service, err := e.service(c)
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
batch, err := service.GetBatch(c.Param("id"))
|
||||
if err != nil {
|
||||
e.writeError(err)
|
||||
return
|
||||
}
|
||||
c.Header("Content-Type", "text/csv; charset=utf-8")
|
||||
c.Header("Content-Disposition", "attachment; filename=provisioning-"+batch.ID+".csv")
|
||||
c.Status(http.StatusOK)
|
||||
writer := csv.NewWriter(c.Writer)
|
||||
if err = writer.Write([]string{"line_number", "name", "location", "address", "status", "failure_code", "detail", "device_id"}); err != nil {
|
||||
e.Logger.Error(err)
|
||||
return
|
||||
}
|
||||
for _, item := range batch.Items {
|
||||
if err = writer.Write([]string{strconv.Itoa(item.LineNumber), item.Name, item.Location, item.Address, item.Status, item.FailureCode, item.Detail, item.DeviceID}); err != nil {
|
||||
e.Logger.Error(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
writer.Flush()
|
||||
if err = writer.Error(); err != nil {
|
||||
e.Logger.Error(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *API) writeError(err error) {
|
||||
switch {
|
||||
case errors.Is(err, ErrInvalidRequest):
|
||||
e.Error(http.StatusBadRequest, err, err.Error())
|
||||
case errors.Is(err, ErrBatchNotFound), errors.Is(err, ErrItemNotFound):
|
||||
e.Error(http.StatusNotFound, err, err.Error())
|
||||
default:
|
||||
e.Error(http.StatusInternalServerError, err, "批量开通操作失败")
|
||||
}
|
||||
}
|
||||
|
||||
func bindStrictJSON(c *gin.Context, target any) error {
|
||||
if !strings.HasPrefix(strings.ToLower(strings.TrimSpace(c.GetHeader("Content-Type"))), "application/json") {
|
||||
return errors.New("content type must be application/json")
|
||||
}
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(c.Writer, c.Request.Body, 2<<20))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(target); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
|
||||
if err == nil {
|
||||
return errors.New("request body must contain one JSON object")
|
||||
}
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func clearCredentials(values []CredentialInput) {
|
||||
for index := range values {
|
||||
values[index].ONVIFUsername = ""
|
||||
values[index].ONVIFPassword = ""
|
||||
values[index].RTSPUsername = ""
|
||||
values[index].RTSPPassword = ""
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
func TestCreateRequestRejectsCredentialColumns(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
recorder := httptest.NewRecorder()
|
||||
context, _ := gin.CreateTestContext(recorder)
|
||||
context.Request = httptest.NewRequest("POST", "/api/v1/provisioning/batches", strings.NewReader(`{
|
||||
"idempotencyKey":"import-1",
|
||||
"rows":[{"lineNumber":1,"name":"东门摄像机","location":"东门","address":"http://192.0.2.10/onvif","password":"must-not-be-accepted"}]
|
||||
}`))
|
||||
context.Request.Header.Set("Content-Type", "application/json")
|
||||
var request CreateBatchRequest
|
||||
if err := bindStrictJSON(context, &request); err == nil || !strings.Contains(err.Error(), "unknown field") {
|
||||
t.Fatalf("expected unknown credential field to be rejected, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClearCredentialsOverwritesTransientValues(t *testing.T) {
|
||||
values := []CredentialInput{{ONVIFUsername: "installer", ONVIFPassword: "temporary-secret", RTSPUsername: "stream", RTSPPassword: "stream-secret"}}
|
||||
clearCredentials(values)
|
||||
if values[0].ONVIFUsername != "" || values[0].ONVIFPassword != "" || values[0].RTSPUsername != "" || values[0].RTSPPassword != "" {
|
||||
t.Fatalf("credentials were not cleared: %#v", values[0])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
commonDTO "git.ilapage.cn/ila/yovision/Sense/server/common/dto"
|
||||
)
|
||||
|
||||
type BatchPageRequest struct {
|
||||
commonDTO.Pagination `search:"-"`
|
||||
Status string `form:"status"`
|
||||
}
|
||||
|
||||
type ImportRow struct {
|
||||
LineNumber int `json:"lineNumber"`
|
||||
Name string `json:"name"`
|
||||
Location string `json:"location"`
|
||||
Address string `json:"address"`
|
||||
}
|
||||
|
||||
type CreateBatchRequest struct {
|
||||
IdempotencyKey string `json:"idempotencyKey"`
|
||||
Rows []ImportRow `json:"rows"`
|
||||
CreateBy int `json:"-"`
|
||||
}
|
||||
|
||||
type CredentialInput struct {
|
||||
ItemID string `json:"itemId"`
|
||||
ONVIFUsername string `json:"onvifUsername"`
|
||||
ONVIFPassword string `json:"onvifPassword"`
|
||||
RTSPSameAsONVIF bool `json:"rtspSameAsOnvif"`
|
||||
RTSPUsername string `json:"rtspUsername"`
|
||||
RTSPPassword string `json:"rtspPassword"`
|
||||
}
|
||||
|
||||
type ExecuteRequest struct {
|
||||
Credentials []CredentialInput `json:"credentials"`
|
||||
UpdateBy int `json:"-"`
|
||||
}
|
||||
|
||||
type ItemResponse struct {
|
||||
ID string `json:"id"`
|
||||
LineNumber int `json:"lineNumber"`
|
||||
Name string `json:"name"`
|
||||
Location string `json:"location"`
|
||||
Address string `json:"address"`
|
||||
Status string `json:"status"`
|
||||
FailureCode string `json:"failureCode,omitempty"`
|
||||
Detail string `json:"detail,omitempty"`
|
||||
DeviceID string `json:"deviceId,omitempty"`
|
||||
Attempts int `json:"attempts"`
|
||||
LastTriedAt *time.Time `json:"lastTriedAt,omitempty"`
|
||||
}
|
||||
|
||||
type BatchResponse struct {
|
||||
ID string `json:"id"`
|
||||
IdempotencyKey string `json:"idempotencyKey"`
|
||||
Status string `json:"status"`
|
||||
QuotaLimit int `json:"quotaLimit"`
|
||||
ExistingCount int `json:"existingCount"`
|
||||
TotalCount int `json:"totalCount"`
|
||||
ReadyCount int `json:"readyCount"`
|
||||
SuccessCount int `json:"successCount"`
|
||||
FailureCount int `json:"failureCount"`
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
UpdatedAt time.Time `json:"updatedAt"`
|
||||
Items []ItemResponse `json:"items,omitempty"`
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
common "git.ilapage.cn/ila/yovision/Sense/server/common/models"
|
||||
)
|
||||
|
||||
const (
|
||||
BatchReady = "ready"
|
||||
BatchRunning = "running"
|
||||
BatchSucceeded = "succeeded"
|
||||
BatchPartial = "partial"
|
||||
BatchFailed = "failed"
|
||||
|
||||
ItemInvalid = "invalid"
|
||||
ItemReady = "ready"
|
||||
ItemQuotaExceeded = "quota_exceeded"
|
||||
ItemRunning = "running"
|
||||
ItemSucceeded = "succeeded"
|
||||
ItemFailed = "failed"
|
||||
)
|
||||
|
||||
type Batch struct {
|
||||
ID string `gorm:"size:36;primaryKey" json:"id"`
|
||||
IdempotencyKey string `gorm:"size:128;not null;uniqueIndex" json:"idempotencyKey"`
|
||||
Status string `gorm:"size:32;not null;index" json:"status"`
|
||||
QuotaLimit int `gorm:"not null" json:"quotaLimit"`
|
||||
ExistingCount int `gorm:"not null" json:"existingCount"`
|
||||
TotalCount int `gorm:"not null" json:"totalCount"`
|
||||
ReadyCount int `gorm:"not null" json:"readyCount"`
|
||||
SuccessCount int `gorm:"not null" json:"successCount"`
|
||||
FailureCount int `gorm:"not null" json:"failureCount"`
|
||||
common.ControlBy
|
||||
common.ModelTime
|
||||
Items []Item `gorm:"foreignKey:BatchID" json:"items,omitempty"`
|
||||
}
|
||||
|
||||
func (Batch) TableName() string { return "sense_provisioning_batches" }
|
||||
|
||||
type Item struct {
|
||||
ID string `gorm:"size:36;primaryKey" json:"id"`
|
||||
BatchID string `gorm:"size:36;not null;uniqueIndex:batch_line;index" json:"batchId"`
|
||||
LineNumber int `gorm:"not null;uniqueIndex:batch_line" json:"lineNumber"`
|
||||
Name string `gorm:"size:128;not null" json:"name"`
|
||||
Location string `gorm:"size:255;not null;default:''" json:"location"`
|
||||
Address string `gorm:"size:1024;not null" json:"address"`
|
||||
Status string `gorm:"size:32;not null;index" json:"status"`
|
||||
FailureCode string `gorm:"size:64;not null;default:''" json:"failureCode,omitempty"`
|
||||
Detail string `gorm:"size:512;not null;default:''" json:"detail,omitempty"`
|
||||
DeviceID string `gorm:"size:36;not null;default:'';index" json:"deviceId,omitempty"`
|
||||
Attempts int `gorm:"not null;default:0" json:"attempts"`
|
||||
LastTriedAt *time.Time `json:"lastTriedAt,omitempty"`
|
||||
common.ControlBy
|
||||
common.ModelTime
|
||||
}
|
||||
|
||||
func (Item) TableName() string { return "sense_provisioning_items" }
|
||||
@@ -0,0 +1,366 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"os"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
coreService "github.com/go-admin-team/go-admin-core/sdk/service"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"gorm.io/gorm"
|
||||
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/app/sense/admission"
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/app/sense/credential"
|
||||
deviceService "git.ilapage.cn/ila/yovision/Sense/server/app/sense/device/service"
|
||||
deviceDTO "git.ilapage.cn/ila/yovision/Sense/server/app/sense/device/service/dto"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrInvalidRequest = errors.New("批量开通请求不符合要求")
|
||||
ErrBatchNotFound = errors.New("批量开通批次不存在")
|
||||
ErrItemNotFound = errors.New("批量开通条目不存在")
|
||||
)
|
||||
|
||||
type Activator func(context.Context, *Service, *Item, CredentialInput, int) (string, string, string, error)
|
||||
|
||||
type Service struct {
|
||||
coreService.Service
|
||||
Quota int
|
||||
Activator Activator
|
||||
}
|
||||
|
||||
func QuotaFromEnvironment() int {
|
||||
value := strings.TrimSpace(os.Getenv("SENSE_PROVISIONING_QUOTA"))
|
||||
if value == "" {
|
||||
return 16
|
||||
}
|
||||
parsed, err := strconv.Atoi(value)
|
||||
if err != nil || parsed < 1 || parsed > 100000 {
|
||||
return 16
|
||||
}
|
||||
return parsed
|
||||
}
|
||||
|
||||
func (s *Service) quota() int {
|
||||
if s.Quota > 0 {
|
||||
return s.Quota
|
||||
}
|
||||
return QuotaFromEnvironment()
|
||||
}
|
||||
|
||||
func (s *Service) CreateBatch(request CreateBatchRequest) (BatchResponse, error) {
|
||||
request.IdempotencyKey = strings.TrimSpace(request.IdempotencyKey)
|
||||
if request.IdempotencyKey == "" || len(request.IdempotencyKey) > 128 || len(request.Rows) == 0 || len(request.Rows) > 1000 {
|
||||
return BatchResponse{}, ErrInvalidRequest
|
||||
}
|
||||
var existing Batch
|
||||
if err := s.Orm.Preload("Items", func(db *gorm.DB) *gorm.DB { return db.Order("line_number") }).First(&existing, "idempotency_key = ?", request.IdempotencyKey).Error; err == nil {
|
||||
return batchResponse(existing), nil
|
||||
} else if !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return BatchResponse{}, fmt.Errorf("read provisioning idempotency key: %w", err)
|
||||
}
|
||||
|
||||
var existingDevices int64
|
||||
if err := s.Orm.Table("sense_devices").Where("status <> ?", "disabled").Count(&existingDevices).Error; err != nil {
|
||||
return BatchResponse{}, fmt.Errorf("count provisioned devices: %w", err)
|
||||
}
|
||||
quota := s.quota()
|
||||
available := quota - int(existingDevices)
|
||||
if available < 0 {
|
||||
available = 0
|
||||
}
|
||||
batch := Batch{ID: uuid.NewString(), IdempotencyKey: request.IdempotencyKey, Status: BatchReady, QuotaLimit: quota, ExistingCount: int(existingDevices), TotalCount: len(request.Rows)}
|
||||
batch.CreateBy, batch.UpdateBy = request.CreateBy, request.CreateBy
|
||||
seenLines := map[int]bool{}
|
||||
seenAddresses := map[string]bool{}
|
||||
ready := 0
|
||||
for _, row := range request.Rows {
|
||||
item := Item{ID: uuid.NewString(), BatchID: batch.ID, LineNumber: row.LineNumber, Name: strings.TrimSpace(row.Name), Location: strings.TrimSpace(row.Location), Address: strings.TrimSpace(row.Address), Status: ItemReady}
|
||||
item.CreateBy, item.UpdateBy = request.CreateBy, request.CreateBy
|
||||
code, detail := validateImportRow(item, seenLines, seenAddresses)
|
||||
if code != "" {
|
||||
item.Status, item.FailureCode, item.Detail = ItemInvalid, code, detail
|
||||
} else if ready >= available {
|
||||
item.Status, item.FailureCode, item.Detail = ItemQuotaExceeded, "quota_exceeded", "超出当前可用配额,请调整配额或批次后重试"
|
||||
} else {
|
||||
ready++
|
||||
}
|
||||
batch.Items = append(batch.Items, item)
|
||||
}
|
||||
batch.ReadyCount = ready
|
||||
if ready == 0 {
|
||||
batch.Status = BatchFailed
|
||||
}
|
||||
if err := s.Orm.Transaction(func(tx *gorm.DB) error {
|
||||
if err := tx.Omit("Items").Create(&batch).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Create(&batch.Items).Error
|
||||
}); err != nil {
|
||||
if isDuplicateKey(err) {
|
||||
return s.GetBatchByKey(request.IdempotencyKey)
|
||||
}
|
||||
return BatchResponse{}, fmt.Errorf("create provisioning batch: %w", err)
|
||||
}
|
||||
return s.GetBatch(batch.ID)
|
||||
}
|
||||
|
||||
func validateImportRow(item Item, seenLines map[int]bool, seenAddresses map[string]bool) (string, string) {
|
||||
if item.LineNumber < 1 || seenLines[item.LineNumber] {
|
||||
return "invalid_line_number", "行号必须为正整数且批次内唯一"
|
||||
}
|
||||
seenLines[item.LineNumber] = true
|
||||
if item.Name == "" || len([]rune(item.Name)) > 128 || len([]rune(item.Location)) > 255 {
|
||||
return "invalid_device", "设备名称不能为空,名称或安装位置长度不能超过限制"
|
||||
}
|
||||
parsed, err := url.Parse(item.Address)
|
||||
if err != nil || (parsed.Scheme != "http" && parsed.Scheme != "https") || parsed.Hostname() == "" || parsed.User != nil || parsed.RawQuery != "" || parsed.Fragment != "" {
|
||||
return "invalid_address", "设备地址必须是无账号、查询参数和片段的 HTTP(S) 地址"
|
||||
}
|
||||
key := strings.ToLower(parsed.String())
|
||||
if seenAddresses[key] {
|
||||
return "duplicate_address", "同一批次中设备地址不能重复"
|
||||
}
|
||||
seenAddresses[key] = true
|
||||
return "", ""
|
||||
}
|
||||
|
||||
func (s *Service) ListBatches(request *BatchPageRequest) ([]BatchResponse, int64, error) {
|
||||
query := s.Orm.Model(&Batch{})
|
||||
if request.Status != "" {
|
||||
query = query.Where("status = ?", request.Status)
|
||||
}
|
||||
var count int64
|
||||
if err := query.Count(&count).Error; err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
pageSize := request.GetPageSize()
|
||||
if pageSize > 100 {
|
||||
pageSize = 100
|
||||
}
|
||||
var batches []Batch
|
||||
if err := query.Order("created_at DESC").Limit(pageSize).Offset((request.GetPageIndex() - 1) * pageSize).Find(&batches).Error; err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
result := make([]BatchResponse, 0, len(batches))
|
||||
for _, batch := range batches {
|
||||
result = append(result, batchResponse(batch))
|
||||
}
|
||||
return result, count, nil
|
||||
}
|
||||
|
||||
func (s *Service) GetBatch(id string) (BatchResponse, error) {
|
||||
var batch Batch
|
||||
if err := s.Orm.Preload("Items", func(db *gorm.DB) *gorm.DB { return db.Order("line_number") }).First(&batch, "id = ?", id).Error; err != nil {
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return BatchResponse{}, ErrBatchNotFound
|
||||
}
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
return batchResponse(batch), nil
|
||||
}
|
||||
|
||||
func (s *Service) GetBatchByKey(key string) (BatchResponse, error) {
|
||||
var batch Batch
|
||||
if err := s.Orm.Preload("Items", func(db *gorm.DB) *gorm.DB { return db.Order("line_number") }).First(&batch, "idempotency_key = ?", key).Error; err != nil {
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
return batchResponse(batch), nil
|
||||
}
|
||||
|
||||
func (s *Service) Execute(ctx context.Context, batchID string, itemID string, retryFailed bool, request ExecuteRequest) (BatchResponse, error) {
|
||||
credentialByItem := make(map[string]CredentialInput, len(request.Credentials))
|
||||
for _, input := range request.Credentials {
|
||||
if input.ItemID == "" || credentialByItem[input.ItemID].ItemID != "" {
|
||||
return BatchResponse{}, ErrInvalidRequest
|
||||
}
|
||||
credentialByItem[input.ItemID] = input
|
||||
}
|
||||
var batch Batch
|
||||
if err := s.Orm.First(&batch, "id = ?", batchID).Error; err != nil {
|
||||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return BatchResponse{}, ErrBatchNotFound
|
||||
}
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
query := s.Orm.Where("batch_id = ?", batchID)
|
||||
if itemID != "" {
|
||||
query = query.Where("id = ?", itemID)
|
||||
}
|
||||
if retryFailed {
|
||||
query = query.Where("status = ?", ItemFailed)
|
||||
} else {
|
||||
query = query.Where("status = ?", ItemReady)
|
||||
}
|
||||
var items []Item
|
||||
if err := query.Order("line_number").Find(&items).Error; err != nil {
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
if itemID != "" && len(items) == 0 {
|
||||
return BatchResponse{}, ErrItemNotFound
|
||||
}
|
||||
if len(items) == 0 {
|
||||
return s.GetBatch(batchID)
|
||||
}
|
||||
if err := s.Orm.Model(&Batch{}).Where("id = ?", batchID).Updates(map[string]any{"status": BatchRunning, "update_by": request.UpdateBy}).Error; err != nil {
|
||||
return BatchResponse{}, fmt.Errorf("mark provisioning batch running: %w", err)
|
||||
}
|
||||
activate := s.Activator
|
||||
if activate == nil {
|
||||
activate = defaultActivate
|
||||
}
|
||||
for index := range items {
|
||||
item := &items[index]
|
||||
now := time.Now().UTC()
|
||||
expectedStatus := ItemReady
|
||||
if retryFailed {
|
||||
expectedStatus = ItemFailed
|
||||
}
|
||||
claim := s.Orm.Model(&Item{}).Where("id = ? AND status = ?", item.ID, expectedStatus).Updates(map[string]any{"status": ItemRunning, "attempts": gorm.Expr("attempts + 1"), "last_tried_at": now, "update_by": request.UpdateBy})
|
||||
if claim.Error != nil {
|
||||
return BatchResponse{}, fmt.Errorf("mark provisioning item running: %w", claim.Error)
|
||||
}
|
||||
if claim.RowsAffected == 0 {
|
||||
continue
|
||||
}
|
||||
input, ok := credentialByItem[item.ID]
|
||||
if !ok || strings.TrimSpace(input.ONVIFUsername) == "" || input.ONVIFPassword == "" {
|
||||
if err := s.failItem(item.ID, request.UpdateBy, "credentials_required", "请安全填写该设备的账号密码后重试"); err != nil {
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
continue
|
||||
}
|
||||
deviceID, status, detail, err := activate(ctx, s, item, input, request.UpdateBy)
|
||||
if deviceID != "" && deviceID != item.DeviceID {
|
||||
item.DeviceID = deviceID
|
||||
if err := s.Orm.Model(&Item{}).Where("id = ?", item.ID).Update("device_id", deviceID).Error; err != nil {
|
||||
return BatchResponse{}, fmt.Errorf("link provisioning item to device: %w", err)
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
code, safeDetail := safeFailure(err)
|
||||
if updateErr := s.failItem(item.ID, request.UpdateBy, code, safeDetail); updateErr != nil {
|
||||
return BatchResponse{}, updateErr
|
||||
}
|
||||
continue
|
||||
}
|
||||
if status != "ready" {
|
||||
if detail == "" {
|
||||
detail = "设备或视频流尚未通过验证"
|
||||
}
|
||||
if err := s.failItem(item.ID, request.UpdateBy, status, detail); err != nil {
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err := s.Orm.Model(&Item{}).Where("id = ?", item.ID).Updates(map[string]any{"status": ItemSucceeded, "failure_code": "", "detail": "设备已开通并通过视频验证", "update_by": request.UpdateBy}).Error; err != nil {
|
||||
return BatchResponse{}, fmt.Errorf("mark provisioning item succeeded: %w", err)
|
||||
}
|
||||
}
|
||||
if err := s.refreshBatch(batchID, request.UpdateBy); err != nil {
|
||||
return BatchResponse{}, err
|
||||
}
|
||||
return s.GetBatch(batchID)
|
||||
}
|
||||
|
||||
func isDuplicateKey(err error) bool {
|
||||
if errors.Is(err, gorm.ErrDuplicatedKey) {
|
||||
return true
|
||||
}
|
||||
var postgresError *pgconn.PgError
|
||||
return errors.As(err, &postgresError) && postgresError.Code == "23505"
|
||||
}
|
||||
|
||||
func (s *Service) failItem(id string, updateBy int, code, detail string) error {
|
||||
if err := s.Orm.Model(&Item{}).Where("id = ?", id).Updates(map[string]any{"status": ItemFailed, "failure_code": code, "detail": detail, "update_by": updateBy}).Error; err != nil {
|
||||
return fmt.Errorf("mark provisioning item failed: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) refreshBatch(batchID string, updateBy int) error {
|
||||
var items []Item
|
||||
if err := s.Orm.Where("batch_id = ?", batchID).Find(&items).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
ready, success, failure := 0, 0, 0
|
||||
for _, item := range items {
|
||||
switch item.Status {
|
||||
case ItemReady, ItemRunning:
|
||||
ready++
|
||||
case ItemSucceeded:
|
||||
success++
|
||||
case ItemFailed:
|
||||
failure++
|
||||
}
|
||||
}
|
||||
status := BatchFailed
|
||||
if success == len(items) {
|
||||
status = BatchSucceeded
|
||||
} else if success > 0 {
|
||||
status = BatchPartial
|
||||
} else if ready > 0 {
|
||||
status = BatchReady
|
||||
}
|
||||
return s.Orm.Model(&Batch{}).Where("id = ?", batchID).Updates(map[string]any{"status": status, "ready_count": ready, "success_count": success, "failure_count": failure, "update_by": updateBy}).Error
|
||||
}
|
||||
|
||||
func defaultActivate(ctx context.Context, service *Service, item *Item, input CredentialInput, updateBy int) (string, string, string, error) {
|
||||
device := deviceService.Device{Service: service.Service}
|
||||
deviceID := item.DeviceID
|
||||
var response deviceDTO.DeviceResponse
|
||||
if deviceID == "" {
|
||||
if err := device.Insert(&deviceDTO.CreateReq{Name: item.Name, Location: item.Location, Modality: "video", Capabilities: []string{"video"}, CreateBy: updateBy}, &response); err != nil {
|
||||
return "", "", "", err
|
||||
}
|
||||
deviceID = response.ID
|
||||
if err := service.Orm.Model(&Item{}).Where("id = ?", item.ID).Update("device_id", deviceID).Error; err != nil {
|
||||
return deviceID, "", "", err
|
||||
}
|
||||
} else if err := device.Get(deviceID, &response); err != nil {
|
||||
return deviceID, "", "", err
|
||||
}
|
||||
if err := device.UpdateCredentials(&deviceDTO.CredentialUpdateReq{ID: deviceID, ONVIFUsername: input.ONVIFUsername, ONVIFPassword: input.ONVIFPassword, RTSPSameAsONVIF: input.RTSPSameAsONVIF, RTSPUsername: input.RTSPUsername, RTSPPassword: input.RTSPPassword, Version: response.Version, UpdateBy: updateBy}, &response); err != nil {
|
||||
return deviceID, "", "", err
|
||||
}
|
||||
probeService, err := admission.NewRuntime(service.Service)
|
||||
if err != nil {
|
||||
return deviceID, "", "", err
|
||||
}
|
||||
result, err := probeService.Probe(ctx, admission.ProbeRequest{DeviceID: deviceID, Address: item.Address, Version: response.Version, UpdateBy: updateBy})
|
||||
if err != nil {
|
||||
return deviceID, "", "", err
|
||||
}
|
||||
return deviceID, result.Status, result.Detail, nil
|
||||
}
|
||||
|
||||
func safeFailure(err error) (string, string) {
|
||||
switch {
|
||||
case errors.Is(err, credential.ErrKeyUnavailable):
|
||||
return "credential_key_unavailable", "摄像头凭据安全配置不可用"
|
||||
case errors.Is(err, credential.ErrCredentialNotConfigured):
|
||||
return "credentials_required", "请安全填写摄像头账号密码后重试"
|
||||
case errors.Is(err, deviceService.ErrInvalidDevice), errors.Is(err, admission.ErrInvalid):
|
||||
return "invalid_device", "设备信息或凭据不符合要求"
|
||||
case errors.Is(err, deviceService.ErrVersionConflict), errors.Is(err, admission.ErrConflict):
|
||||
return "version_conflict", "设备已被其他操作更新,请重试"
|
||||
default:
|
||||
return "activation_failed", "设备开通失败,请检查网络、地址和凭据后重试"
|
||||
}
|
||||
}
|
||||
|
||||
func batchResponse(batch Batch) BatchResponse {
|
||||
response := BatchResponse{ID: batch.ID, IdempotencyKey: batch.IdempotencyKey, Status: batch.Status, QuotaLimit: batch.QuotaLimit, ExistingCount: batch.ExistingCount, TotalCount: batch.TotalCount, ReadyCount: batch.ReadyCount, SuccessCount: batch.SuccessCount, FailureCount: batch.FailureCount, CreatedAt: batch.CreatedAt, UpdatedAt: batch.UpdatedAt, Items: make([]ItemResponse, 0, len(batch.Items))}
|
||||
sort.Slice(batch.Items, func(i, j int) bool { return batch.Items[i].LineNumber < batch.Items[j].LineNumber })
|
||||
for _, item := range batch.Items {
|
||||
response.Items = append(response.Items, ItemResponse{ID: item.ID, LineNumber: item.LineNumber, Name: item.Name, Location: item.Location, Address: item.Address, Status: item.Status, FailureCode: item.FailureCode, Detail: item.Detail, DeviceID: item.DeviceID, Attempts: item.Attempts, LastTriedAt: item.LastTriedAt})
|
||||
}
|
||||
return response
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
package provisioning
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
|
||||
coreService "github.com/go-admin-team/go-admin-core/sdk/service"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"gorm.io/driver/sqlite"
|
||||
"gorm.io/gorm"
|
||||
|
||||
deviceModels "git.ilapage.cn/ila/yovision/Sense/server/app/sense/device/models"
|
||||
)
|
||||
|
||||
func provisioningService(t *testing.T, quota int) *Service {
|
||||
t.Helper()
|
||||
db, err := gorm.Open(sqlite.Open("file:"+uuid.NewString()+"?mode=memory&cache=shared"), &gorm.Config{TranslateError: true})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sqlDB, err := db.DB()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sqlDB.SetMaxOpenConns(1)
|
||||
if err = db.AutoMigrate(&deviceModels.Device{}, &Batch{}, &Item{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &Service{Service: coreService.Service{Orm: db}, Quota: quota}
|
||||
}
|
||||
|
||||
func TestCreateBatchValidatesQuotaAndIsIdempotent(t *testing.T) {
|
||||
service := provisioningService(t, 2)
|
||||
if err := service.Orm.Create(&deviceModels.Device{ID: "existing", Name: "已接入摄像机", Modality: "video", Status: "active", AdapterStatus: "ready", Version: 1}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
request := CreateBatchRequest{
|
||||
IdempotencyKey: "import-001",
|
||||
CreateBy: 7,
|
||||
Rows: []ImportRow{
|
||||
{LineNumber: 1, Name: "东门摄像机", Location: "东门", Address: "http://192.0.2.10/onvif"},
|
||||
{LineNumber: 2, Name: "重复地址", Location: "东门", Address: "http://192.0.2.10/onvif"},
|
||||
{LineNumber: 3, Name: "西门摄像机", Location: "西门", Address: "https://192.0.2.11/onvif"},
|
||||
},
|
||||
}
|
||||
created, err := service.CreateBatch(request)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if created.QuotaLimit != 2 || created.ExistingCount != 1 || created.ReadyCount != 1 || len(created.Items) != 3 {
|
||||
t.Fatalf("unexpected batch: %#v", created)
|
||||
}
|
||||
if created.Items[0].Status != ItemReady || created.Items[1].Status != ItemInvalid || created.Items[2].Status != ItemQuotaExceeded {
|
||||
t.Fatalf("unexpected item statuses: %#v", created.Items)
|
||||
}
|
||||
|
||||
request.Rows = []ImportRow{{LineNumber: 1, Name: "不应覆盖", Address: "http://192.0.2.99/onvif"}}
|
||||
repeated, err := service.CreateBatch(request)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if repeated.ID != created.ID || repeated.TotalCount != 3 || repeated.Items[0].Name != "东门摄像机" {
|
||||
t.Fatalf("idempotent replay changed the batch: %#v", repeated)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecuteSupportsPartialSuccessAndFailedOnlyRetry(t *testing.T) {
|
||||
service := provisioningService(t, 16)
|
||||
created, err := service.CreateBatch(CreateBatchRequest{
|
||||
IdempotencyKey: "execute-001",
|
||||
Rows: []ImportRow{
|
||||
{LineNumber: 1, Name: "东门摄像机", Address: "http://192.0.2.10/onvif"},
|
||||
{LineNumber: 2, Name: "西门摄像机", Address: "http://192.0.2.11/onvif"},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
calls := map[int]int{}
|
||||
service.Activator = func(_ context.Context, _ *Service, item *Item, input CredentialInput, _ int) (string, string, string, error) {
|
||||
calls[item.LineNumber]++
|
||||
if input.ONVIFPassword != "temporary-secret" {
|
||||
t.Fatalf("activator did not receive the transient credential")
|
||||
}
|
||||
if item.LineNumber == 2 && calls[item.LineNumber] == 1 {
|
||||
return "device-2", "", "", errors.New("synthetic network failure containing temporary-secret")
|
||||
}
|
||||
return "device-" + string(rune('0'+item.LineNumber)), "ready", "验证通过", nil
|
||||
}
|
||||
credentials := make([]CredentialInput, 0, len(created.Items))
|
||||
for _, item := range created.Items {
|
||||
credentials = append(credentials, CredentialInput{ItemID: item.ID, ONVIFUsername: "installer", ONVIFPassword: "temporary-secret", RTSPSameAsONVIF: true})
|
||||
}
|
||||
partial, err := service.Execute(context.Background(), created.ID, "", false, ExecuteRequest{Credentials: credentials, UpdateBy: 8})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if partial.Status != BatchPartial || partial.SuccessCount != 1 || partial.FailureCount != 1 {
|
||||
t.Fatalf("expected partial success, got %#v", partial)
|
||||
}
|
||||
if partial.Items[1].Detail == "" || strings.Contains(partial.Items[1].Detail, "temporary-secret") {
|
||||
t.Fatalf("unsafe failure detail: %q", partial.Items[1].Detail)
|
||||
}
|
||||
|
||||
retried, err := service.Execute(context.Background(), created.ID, "", true, ExecuteRequest{Credentials: []CredentialInput{{ItemID: created.Items[1].ID, ONVIFUsername: "installer", ONVIFPassword: "temporary-secret", RTSPSameAsONVIF: true}}, UpdateBy: 8})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if retried.Status != BatchSucceeded || retried.SuccessCount != 2 || calls[1] != 1 || calls[2] != 2 {
|
||||
t.Fatalf("failed-only retry was not idempotent: response=%#v calls=%#v", retried, calls)
|
||||
}
|
||||
encoded, err := json.Marshal(retried)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(string(encoded), "temporary-secret") || strings.Contains(string(encoded), "installer") {
|
||||
t.Fatalf("response contains credentials: %s", encoded)
|
||||
}
|
||||
var stored []Item
|
||||
if err = service.Orm.Find(&stored).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
storedJSON, _ := json.Marshal(stored)
|
||||
if strings.Contains(string(storedJSON), "temporary-secret") || strings.Contains(string(storedJSON), "installer") {
|
||||
t.Fatalf("provisioning rows contain credentials: %s", storedJSON)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecuteRequiresCredentialsWithoutCallingActivator(t *testing.T) {
|
||||
service := provisioningService(t, 16)
|
||||
created, err := service.CreateBatch(CreateBatchRequest{IdempotencyKey: "missing-credentials", Rows: []ImportRow{{LineNumber: 1, Name: "东门摄像机", Address: "http://192.0.2.10/onvif"}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
called := false
|
||||
service.Activator = func(context.Context, *Service, *Item, CredentialInput, int) (string, string, string, error) {
|
||||
called = true
|
||||
return "", "", "", nil
|
||||
}
|
||||
result, err := service.Execute(context.Background(), created.ID, "", false, ExecuteRequest{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if called || result.Status != BatchFailed || result.Items[0].FailureCode != "credentials_required" {
|
||||
t.Fatalf("missing credentials were not handled safely: %#v called=%v", result, called)
|
||||
}
|
||||
}
|
||||
|
||||
func TestQuotaFromEnvironment(t *testing.T) {
|
||||
t.Setenv("SENSE_PROVISIONING_QUOTA", "24")
|
||||
if got := QuotaFromEnvironment(); got != 24 {
|
||||
t.Fatalf("quota=%d", got)
|
||||
}
|
||||
t.Setenv("SENSE_PROVISIONING_QUOTA", "invalid")
|
||||
if got := QuotaFromEnvironment(); got != 16 {
|
||||
t.Fatalf("fallback quota=%d", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentCreateUsesOneIdempotentBatch(t *testing.T) {
|
||||
service := provisioningService(t, 16)
|
||||
sqlDB, err := service.Orm.DB()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sqlDB.SetMaxOpenConns(1)
|
||||
request := CreateBatchRequest{IdempotencyKey: "concurrent-import", Rows: []ImportRow{{LineNumber: 1, Name: "东门摄像机", Address: "http://192.0.2.10/onvif"}}}
|
||||
const workers = 8
|
||||
ids := make(chan string, workers)
|
||||
errs := make(chan error, workers)
|
||||
var wait sync.WaitGroup
|
||||
for index := 0; index < workers; index++ {
|
||||
wait.Add(1)
|
||||
go func() {
|
||||
defer wait.Done()
|
||||
batch, createErr := service.CreateBatch(request)
|
||||
if createErr != nil {
|
||||
errs <- createErr
|
||||
return
|
||||
}
|
||||
ids <- batch.ID
|
||||
}()
|
||||
}
|
||||
wait.Wait()
|
||||
close(ids)
|
||||
close(errs)
|
||||
for createErr := range errs {
|
||||
t.Fatalf("concurrent create failed: %v", createErr)
|
||||
}
|
||||
var first string
|
||||
for id := range ids {
|
||||
if first == "" {
|
||||
first = id
|
||||
} else if id != first {
|
||||
t.Fatalf("idempotent creates returned different batches: %q and %q", first, id)
|
||||
}
|
||||
}
|
||||
var count int64
|
||||
if err = service.Orm.Model(&Batch{}).Count(&count).Error; err != nil || count != 1 {
|
||||
t.Fatalf("batch count=%d err=%v", count, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSixteenDeviceBaselineSmoke(t *testing.T) {
|
||||
service := provisioningService(t, 16)
|
||||
rows := make([]ImportRow, 0, 16)
|
||||
for index := 1; index <= 16; index++ {
|
||||
rows = append(rows, ImportRow{LineNumber: index, Name: fmt.Sprintf("摄像机-%02d", index), Address: fmt.Sprintf("http://192.0.2.%d/onvif", index)})
|
||||
}
|
||||
created, err := service.CreateBatch(CreateBatchRequest{IdempotencyKey: "sixteen-device-smoke", Rows: rows})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if created.ReadyCount != 16 {
|
||||
t.Fatalf("ready count=%d", created.ReadyCount)
|
||||
}
|
||||
service.Activator = func(_ context.Context, _ *Service, item *Item, _ CredentialInput, _ int) (string, string, string, error) {
|
||||
return "device-" + item.ID, "ready", "验证通过", nil
|
||||
}
|
||||
credentials := make([]CredentialInput, 0, 16)
|
||||
for _, item := range created.Items {
|
||||
credentials = append(credentials, CredentialInput{ItemID: item.ID, ONVIFUsername: "installer", ONVIFPassword: "temporary-secret", RTSPSameAsONVIF: true})
|
||||
}
|
||||
completed, err := service.Execute(context.Background(), created.ID, "", false, ExecuteRequest{Credentials: credentials})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if completed.Status != BatchSucceeded || completed.SuccessCount != 16 || completed.FailureCount != 0 {
|
||||
t.Fatalf("unexpected 16-device result: %#v", completed)
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentExecuteClaimsAnItemOnce(t *testing.T) {
|
||||
service := provisioningService(t, 16)
|
||||
created, err := service.CreateBatch(CreateBatchRequest{IdempotencyKey: "concurrent-execute", Rows: []ImportRow{{LineNumber: 1, Name: "东门摄像机", Address: "http://192.0.2.10/onvif"}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var calls atomic.Int32
|
||||
service.Activator = func(_ context.Context, _ *Service, item *Item, _ CredentialInput, _ int) (string, string, string, error) {
|
||||
calls.Add(1)
|
||||
return "device-" + item.ID, "ready", "验证通过", nil
|
||||
}
|
||||
request := ExecuteRequest{Credentials: []CredentialInput{{ItemID: created.Items[0].ID, ONVIFUsername: "installer", ONVIFPassword: "temporary-secret", RTSPSameAsONVIF: true}}}
|
||||
var wait sync.WaitGroup
|
||||
errs := make(chan error, 2)
|
||||
for index := 0; index < 2; index++ {
|
||||
wait.Add(1)
|
||||
go func() {
|
||||
defer wait.Done()
|
||||
_, executeErr := service.Execute(context.Background(), created.ID, "", false, request)
|
||||
errs <- executeErr
|
||||
}()
|
||||
}
|
||||
wait.Wait()
|
||||
close(errs)
|
||||
for executeErr := range errs {
|
||||
if executeErr != nil {
|
||||
t.Fatal(executeErr)
|
||||
}
|
||||
}
|
||||
if calls.Load() != 1 {
|
||||
t.Fatalf("activator calls=%d", calls.Load())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostgresDuplicateKeyDetection(t *testing.T) {
|
||||
if !isDuplicateKey(&pgconn.PgError{Code: "23505"}) || isDuplicateKey(&pgconn.PgError{Code: "23503"}) {
|
||||
t.Fatal("PostgreSQL duplicate-key detection is incorrect")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package version
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"runtime"
|
||||
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/app/sense/provisioning"
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/cmd/migrate/migration"
|
||||
migrationModels "git.ilapage.cn/ila/yovision/Sense/server/cmd/migrate/migration/models"
|
||||
common "git.ilapage.cn/ila/yovision/Sense/server/common/models"
|
||||
)
|
||||
|
||||
func init() {
|
||||
_, fileName, _, _ := runtime.Caller(0)
|
||||
migration.Migrate.SetVersion(migration.GetFilename(fileName), migrateSenseProvisioning)
|
||||
}
|
||||
|
||||
func migrateSenseProvisioning(db *gorm.DB, version string) error {
|
||||
return db.Transaction(func(tx *gorm.DB) error {
|
||||
if err := tx.AutoMigrate(&provisioning.Batch{}, &provisioning.Item{}, &deviceCasbinRule{}); err != nil {
|
||||
return err
|
||||
}
|
||||
root, err := ensureDeviceMenu(tx, migrationModels.SysMenu{MenuName: senseLayoutMenuName, Title: "视频感知", Icon: "video-camera", Path: "/sense", MenuType: "M", Component: "Layout", Sort: 5, Visible: "0", IsFrame: "1"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
page, err := ensureDeviceMenu(tx, migrationModels.SysMenu{MenuName: "SenseProvisioning", Title: "批量开通", Icon: "upload", Path: "provisioning", Paths: fmt.Sprintf("/0/%d", root.MenuId), MenuType: "C", Permission: "sense:provisioning:list", ParentId: root.MenuId, Component: "/sense/provisioning/index", Sort: 2, Visible: "0", IsFrame: "1"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
definitions := []struct{ name, title, action, permission string }{
|
||||
{"SenseProvisioningImport", "导入批次", "POST", "sense:provisioning:import"},
|
||||
{"SenseProvisioningExecute", "执行开通", "POST", "sense:provisioning:execute"},
|
||||
{"SenseProvisioningRetry", "重试失败项", "POST", "sense:provisioning:retry"},
|
||||
{"SenseProvisioningExport", "导出结果", "GET", "sense:provisioning:export"},
|
||||
}
|
||||
buttons := make([]migrationModels.SysMenu, 0, len(definitions))
|
||||
for index, definition := range definitions {
|
||||
button, err := ensureDeviceMenu(tx, migrationModels.SysMenu{MenuName: definition.name, Title: definition.title, MenuType: "F", Action: definition.action, Permission: definition.permission, ParentId: page.MenuId, Paths: fmt.Sprintf("/0/%d/%d", root.MenuId, page.MenuId), Sort: index + 1, Visible: "1", IsFrame: "1"})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
buttons = append(buttons, button)
|
||||
}
|
||||
allMenus := append([]migrationModels.SysMenu{page}, buttons...)
|
||||
for _, role := range []string{"implementation_operator", "site_admin"} {
|
||||
if err = attachDeviceRole(tx, role, allMenus); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err = attachDeviceRole(tx, "viewer", []migrationModels.SysMenu{page, buttons[3]}); err != nil {
|
||||
return err
|
||||
}
|
||||
read := [][2]string{{"/api/v1/provisioning/batches", "GET"}, {"/api/v1/provisioning/batches/:id", "GET"}, {"/api/v1/provisioning/batches/:id/export", "GET"}}
|
||||
write := [][2]string{{"/api/v1/provisioning/batches", "POST"}, {"/api/v1/provisioning/batches/:id/execute", "POST"}, {"/api/v1/provisioning/batches/:id/retry-failed", "POST"}, {"/api/v1/provisioning/batches/:id/items/:itemId/retry", "POST"}}
|
||||
for _, role := range []string{"implementation_operator", "site_admin", "viewer"} {
|
||||
policies := append([][2]string{}, read...)
|
||||
if role != "viewer" {
|
||||
policies = append(policies, write...)
|
||||
}
|
||||
for _, policy := range policies {
|
||||
if err = tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&deviceCasbinRule{Ptype: "p", V0: role, V1: policy[0], V2: policy[1]}).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
if err = rebuildSenseMenuPaths(tx, root.MenuId, "/0"); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Create(&common.Migration{Version: version}).Error
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package version
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"gorm.io/driver/postgres"
|
||||
"gorm.io/gorm"
|
||||
|
||||
"git.ilapage.cn/ila/yovision/Sense/server/app/sense/provisioning"
|
||||
migrationModels "git.ilapage.cn/ila/yovision/Sense/server/cmd/migrate/migration/models"
|
||||
common "git.ilapage.cn/ila/yovision/Sense/server/common/models"
|
||||
)
|
||||
|
||||
func TestProvisioningMigrationOnPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("SENSE_PROVISIONING_MIGRATION_TEST_DATABASE_URL")
|
||||
if dsn == "" {
|
||||
t.Skip("set SENSE_PROVISIONING_MIGRATION_TEST_DATABASE_URL to run the PostgreSQL migration test")
|
||||
}
|
||||
db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const schema = "sense_provisioning_72_test"
|
||||
if err = db.Exec("DROP SCHEMA IF EXISTS " + schema + " CASCADE").Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = db.Exec("CREATE SCHEMA " + schema).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Exec("DROP SCHEMA IF EXISTS " + schema + " CASCADE").Error })
|
||||
sqlDB, err := db.DB()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
sqlDB.SetMaxOpenConns(1)
|
||||
if err = db.Exec("SET search_path TO " + schema).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = db.AutoMigrate(&migrationModels.SysRole{}, &migrationModels.SysMenu{}, &deviceCasbinRule{}, &common.Migration{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, role := range []string{"implementation_operator", "site_admin", "viewer"} {
|
||||
if err = db.Create(&migrationModels.SysRole{RoleName: role, RoleKey: role, Status: "2"}).Error; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
const version = "2026082809000_provisioning.go"
|
||||
if err = migrateSenseProvisioning(db, version); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var menus, policies, batches, items, applied int64
|
||||
db.Model(&migrationModels.SysMenu{}).Where("menu_name LIKE ?", "SenseProvisioning%").Count(&menus)
|
||||
db.Model(&deviceCasbinRule{}).Where("v1 LIKE ?", "/api/v1/provisioning/%").Count(&policies)
|
||||
db.Model(&provisioning.Batch{}).Count(&batches)
|
||||
db.Model(&provisioning.Item{}).Count(&items)
|
||||
db.Model(&common.Migration{}).Where("version = ?", version).Count(&applied)
|
||||
if menus != 5 || policies != 17 || batches != 0 || items != 0 || applied != 1 {
|
||||
t.Fatalf("menus=%d policies=%d batches=%d items=%d applied=%d", menus, policies, batches, items, applied)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user