KRBL/n9m
13
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor and simplify package structure and interfaces.

Browse Source 
Reorganize code by removing unused files, restructuring package organization, and updating import references to new paths. This simplifies handling of smart and protocol-related operations, improves maintainability, and eliminates redundancy.
This commit is contained in:
Александр Лазаренко
2025-04-27 17:05:45 +03:00
parent 51308a2395
commit eaaa634558
24 changed files with 565 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
cmd/dev-client/main.go
View File

@ -3,15 +3,17 @@ package main
import (
"errors"
"fmt"
"gitea.unprism.ru/KRBL/n9m/v2"
"gitea.unprism.ru/KRBL/n9m/v2/pkg/models"
"gitea.unprism.ru/KRBL/n9m/v2/pkg/protocol"
"gitea.unprism.ru/KRBL/n9m/v2/pkg/smart"
"gitea.unprism.ru/KRBL/n9m/v2/pkg/utils"
"io"
"net"
"os"
"syscall"
)
var mainPack *n9m.SmartPackage
var videoPack *n9m.SmartPackage
var videoPack *smart.SmartChannelPackage
func main() {
conn, err := net.Dial("tcp", "10.100.100.99:9006")
@ -20,19 +22,19 @@ func main() {
panic(err)
}
var pack = n9m.Package{}
var pack = protocol.Package{}
pack.Payload.Module = "CERTIFICATE"
pack.Payload.Operation = "CONNECT"
pack.SetParameters(n9m.CertificateConnectClientRequest{})
pack.SetParameters(models.CertificateConnectClientRequest{})
conn.Write(pack.PackPackage())
handle(conn, &mainPack)
handle(conn)
}
func handleSpecialPackages(_ *n9m.SmartPackage, pack n9m.Package) error {
func handleSpecialPackages(_ *smart.SmartPackage, pack protocol.Package) error {
switch pack.SSRC {
case n9m.SpecialPayloadTypeGPS:
case protocol.SpecialPayloadTypeGPS:
fmt.Printf("%+v\n", pack.GPS)
return nil
default:
@ -40,15 +42,21 @@ func handleSpecialPackages(_ *n9m.SmartPackage, pack n9m.Package) error {
}
}
func handleCertificateConnect(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.CertificateConnectClientResponse
func handleLivePackages(_ *smart.SmartPackage, pack protocol.Package) error {
fmt.Printf("%+v\n", pack)
return nil
}
func handleCertificateConnect(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
var params models.CertificateConnectClientResponse
if err = pack.GetResponseAs(&params); err != nil {
return fmt.Errorf("failed to get response: %w", err)
}
var response = n9m.CertificateVerificationRequest{
S0: GenerateVerifyKey(params.S0),
var response = models.CertificateVerificationRequest{
S0: utils.GenerateVerifyKey(params.S0),
}
pack.Payload.Operation = "VERIFY"
@ -59,8 +67,8 @@ func handleCertificateConnect(sPack *n9m.SmartPackage, pack n9m.Package) (err er
return
}
func handleVerify(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.CertificateVerificationResponse
func handleVerify(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
var params models.CertificateVerificationResponse
if err = pack.GetResponseAs(&params); err != nil {
return fmt.Errorf("failed to get response: %w", err)
@ -72,7 +80,7 @@ func handleVerify(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
fmt.Println("шалость НЕ удалась(((")
}
var request = n9m.CertificateLoginRequest{
var request = models.CertificateLoginRequest{
ClientID: 0,
MAC: "",
User: "admin",
@ -87,8 +95,8 @@ func handleVerify(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
return
}
func handleLogin(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.CertificateLoginResponse
func handleLogin(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
var params models.CertificateLoginResponse
if err = pack.GetResponseAs(&params); err != nil {
return fmt.Errorf("failed to get response: %w", err)
@ -96,37 +104,36 @@ func handleLogin(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
conn, err := net.Dial("tcp", "10.100.100.99:9006")
var request = n9m.CertificateCreateStreamRequest{
StreamName: "KRBL",
if err != nil {
panic(err)
}
pack.Payload.Operation = "CREATESTREAM"
pack.SetParameters(request)
videoPack, err = smart.NewSmartChannelPackage(conn, sPack)
conn.Write(pack.PackPackage())
go handle(conn, &videoPack)
return
}
func handleCreateStream(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.CertificateCreateStreamResponse
if err = pack.GetResponseAs(&params); err != nil {
return fmt.Errorf("failed to get response: %w", err)
if err != nil {
panic(err)
}
if params.ErrorCode != 0 {
fmt.Println("Create stream error:", params.ErrorCode, params.ErrorCause)
return
}
go videoPack.Run()
var request = n9m.MediaStreamModelRequestLiveVideoRequest{
StreamName: "KRBL",
StreamType: 2,
Channel: 1,
AudioValid: 1,
i := 0
videoPack.AddLiveSource(2, func(data []byte) error {
fmt.Println("Есть контакт!")
i++
if i > 10 {
return errors.New("я устал")
}
return nil
})
var request = models.MediaStreamModelRequestLiveVideoRequest{
StreamName: videoPack.GetChannelName(),
StreamType: models.StreamTypeMain,
Channel: 4,
AudioValid: 4,
FrameMode: 0,
}
@ -134,13 +141,13 @@ func handleCreateStream(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
pack.Payload.Operation = "REQUESTALIVEVIDEO"
pack.SetParameters(request)
mainPack.Write(pack.PackPackage())
sPack.Write(pack.PackPackage())
return
}
func handleRequestLiveVideo(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.MediaStreamModelRequestLiveVideoResponse
func handleRequestLiveVideo(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
var params models.MediaStreamModelRequestLiveVideoResponse
if err = pack.GetResponseAs(&params); err != nil {
return fmt.Errorf("failed to get response: %w", err)
@ -151,10 +158,12 @@ func handleRequestLiveVideo(sPack *n9m.SmartPackage, pack n9m.Package) (err erro
return
}
fmt.Printf("%+v\n", params)
return
}
func handleKeepAlive(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
func handleKeepAlive(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
serial := sPack.Storage["serial"]
fmt.Println(serial, "still alive!")
@ -164,12 +173,12 @@ func handleKeepAlive(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
return
}
func handleGetConfig(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
func handleGetConfig(sPack *smart.SmartPackage, pack protocol.Package) (err error) {
serial := sPack.Storage["serial"]
os.WriteFile(fmt.Sprintf("./%s.json", serial), pack.RawPayload, 0644)
var request n9m.ConfigModelSetRequest
var request models.ConfigModelSetRequest
if err = pack.GetParametersAs(&request); err != nil {
fmt.Println(err)
@ -179,22 +188,22 @@ func handleGetConfig(sPack *n9m.SmartPackage, pack n9m.Package) (err error) {
return
}
func handleUselessAlarms(sPack *n9m.SmartPackage, pack n9m.Package, response n9m.SendAlarmInfoResponse) (err error) {
func handleUselessAlarms(sPack *smart.SmartPackage, pack protocol.Package, response models.SendAlarmInfoResponse) (err error) {
return nil
}
func handleVideoLossAlarm(sPack *n9m.SmartPackage, pack n9m.Package, response n9m.SendAlarmInfoResponse) (err error) {
func handleVideoLossAlarm(sPack *smart.SmartPackage, pack protocol.Package, response models.SendAlarmInfoResponse) (err error) {
fmt.Println("Video loss alarm!")
return nil
}
func handleCameraCoveredAlarm(sPack *n9m.SmartPackage, pack n9m.Package, response n9m.SendAlarmInfoResponse) (err error) {
func handleCameraCoveredAlarm(sPack *smart.SmartPackage, pack protocol.Package, response models.SendAlarmInfoResponse) (err error) {
fmt.Println("Camera covered alarm!")
return nil
}
func handleSPI(_ *n9m.SmartPackage, pack n9m.Package) (err error) {
var params n9m.SpiParameters
func handleSPI(_ *smart.SmartPackage, pack protocol.Package) (err error) {
var params models.SpiParameters
if err = pack.GetParametersAs(&params); err != nil {
return
@ -205,47 +214,28 @@ func handleSPI(_ *n9m.SmartPackage, pack n9m.Package) (err error) {
return
}
func createSmartPackage(conn net.Conn) (pack *n9m.SmartPackage) {
pack = n9m.NewSmartPackage(conn)
func createSmartPackage(conn net.Conn) (pack *smart.SmartPackage) {
pack = smart.NewSmartPackage(conn)
pack.AddPayloadHandler(n9m.PayloadTypeSpecial, handleSpecialPackages)
pack.AddPayloadHandler(protocol.PayloadTypeLive, handleLivePackages)
pack.AddPayloadHandler(protocol.PayloadTypeSpecial, handleSpecialPackages)
pack.AddJSONHandler("CERTIFICATE", "CONNECT", handleCertificateConnect)
pack.AddJSONHandler("CERTIFICATE", "VERIFY", handleVerify)
pack.AddJSONHandler("CERTIFICATE", "LOGIN", handleLogin)
pack.AddJSONHandler("CERTIFICATE", "CREATESTREAM", handleCreateStream)
pack.AddJSONHandler("CERTIFICATE", "KEEPALIVE", handleKeepAlive)
pack.AddJSONHandler("MEDIASTREAMMODEL", "REQUESTALIVEVIDEO", handleRequestLiveVideo)
pack.AddJSONHandler("CONFIGMODEL", "GET", handleGetConfig)
pack.AddJSONHandler("DEVEMM", "SPI", handleSPI)
pack.AddAlarmHandler(n9m.AlarmTypeMotionDetection, handleUselessAlarms)
pack.AddAlarmHandler(protocol.AlarmTypeMotionDetection, handleUselessAlarms)
pack.AddAlarmHandler(n9m.AlarmTypeVideoLoss, handleVideoLossAlarm)
pack.AddAlarmHandler(n9m.AlarmTypeCameraCovered, handleCameraCoveredAlarm)
pack.AddAlarmHandler(protocol.AlarmTypeVideoLoss, handleVideoLossAlarm)
pack.AddAlarmHandler(protocol.AlarmTypeCameraCovered, handleCameraCoveredAlarm)
return
}
/*
go func() {
pack := packS
pack.Payload.Module = "EVEM"
pack.Payload.Operation = "GALARMING"
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for range ticker.C {
fmt.Println("Sent!")
if _, err := conn.Write(pack.PackPackage()); err != nil {
fmt.Println("Failed to send GALARMING:", err)
return
}
}
}()
*/
func isNetConnClosedErr(err error) bool {
switch {
case
@ -258,17 +248,12 @@ func isNetConnClosedErr(err error) bool {
}
}
func handle(conn net.Conn, pack **n9m.SmartPackage) {
if pack != nil {
*pack = createSmartPackage(conn)
} else {
tmp := createSmartPackage(conn)
pack = &tmp
}
func handle(conn net.Conn) {
pack := createSmartPackage(conn)
var err error
for {
if err = (*pack).Handle(); err != nil {
if err = pack.Handle(); err != nil {
fmt.Println("Error:", err)
if isNetConnClosedErr(err) {

15
cmd/dev-client/utils.go
View File

@ -1,15 +0,0 @@
package main
import (
"crypto/hmac"
"crypto/md5"
"encoding/hex"
)
func GenerateVerifyKey(key string) string {
mac := hmac.New(md5.New, []byte(key))
mac.Write([]byte(key))
return hex.EncodeToString(mac.Sum(nil))
}

9
cmd/dev-client/utils_test.go
View File

@ -1,9 +0,0 @@
package main
import "testing"
func TestGenerateVerifyKey(t *testing.T) {
if GenerateVerifyKey("45792d55-0844-4053-848a-64fd0685fb32") != "fae5f19b8452c7bd03dc4f3471966c42" {
t.Error()
}
}