fix build

.devcontainer/Dockerfile

@@ -1,2 +1,2 @@
-FROM kerberos/devcontainer:9da0ee3
+FROM kerberos/devcontainer:b2bc659
 LABEL AUTHOR=Kerberos.io

README.md

@@ -210,6 +210,43 @@ After a few minutes, you will see a beautiful `Visual Studio Code` shown in your
 
 ![Kerberos Agent VSCode](assets/img/codespace-vscode.png)
 
+On opening of the GitHub Codespace, some dependencies will be installed. Once this is done go ahead to the `ui/src/config.json` file, and (un)comment following section. Make sure to replace the `externalHost` variable with the DNS name you will retrieve from the next step.
+
+    // Uncomment this when using codespaces or other special DNS names (which you can't control)
+    // replace this with the DNS name of the kerberos agent server (the codespace url)
+    const externalHost = 'cedricve-automatic-computing-machine-v647rxvj4whx9qp-80.preview.app.github.dev';
+
+    const dev = {
+      ENV: 'dev',
+      HOSTNAME: externalHost,
+      //API_URL: `${protocol}//${hostname}:8080/api`,
+      //URL: `${protocol}//${hostname}:8080`,
+      //WS_URL: `${websocketprotocol}//${hostname}:8080/ws`,
+
+      // Uncomment, and comment the above lines, when using codespaces or other special DNS names (which you can't control)
+      API_URL: `${protocol}//${externalHost}/api`,
+      URL: `${protocol}//${externalHost}`,
+      WS_URL: `${websocketprotocol}//${externalHost}/ws`,
+    };
+
+Go and open two terminals one for the `ui` project and one for the `machinery` project.
+
+1.  Terminal A:
+
+        cd machinery/
+        go run main.go run camera 80
+
+2.  Terminal B:
+
+        cd ui/
+        yarn start
+
+Once executed, a popup will show up mentioning `portforwarding`. You should see two ports being opened, one for the ui `3000` and one for the machinery `80`. `Right-click` on the port `80` and change visibility from `private` to `public`, this is required to avoid `CORS` errors.
+
+![Codespace make public](./assets/img/codespace-make-public.png)
+
+As mentioned above, copy the hostname of the `machinery` DNS name, and past it in the `ui/src/config.json` file. Once done reload, the `ui` page in your browser, and you should be able to access the login page with the default credentials `root` and `root`.
+
 ## Develop and build
 
 Kerberos Agent is divided in two parts a `machinery` and `web`. Both parts live in this repository in their relative folders. For development or running the application on your local machine, you have to run both the `machinery` and the `web` as described below. When running in production everything is shipped as only one artifact, read more about this at [Building for production](#building-for-production).

machinery/data/config/config.json

@@ -1,3 +1,4 @@
+
 {
 	"type": "",
 	"key": "",

machinery/go.mod

@@ -2,7 +2,8 @@ module github.com/kerberos-io/agent/machinery
 
 go 1.19
 
-//replace github.com/kerberos-io/joy4 v1.0.51 => ../../../../github.com/kerberos-io/joy4
+//replace github.com/kerberos-io/joy4 v1.0.54 => ../../../../github.com/kerberos-io/joy4
+
 //replace github.com/kerberos-io/onvif v0.0.5 => ../../../../github.com/kerberos-io/onvif
 
 require (
@@ -20,7 +21,7 @@ require (
 	github.com/golang-module/carbon/v2 v2.2.3
 	github.com/gorilla/websocket v1.5.0
 	github.com/kellydunn/golang-geo v0.7.0
-	github.com/kerberos-io/joy4 v1.0.53
+	github.com/kerberos-io/joy4 v1.0.55
 	github.com/kerberos-io/onvif v0.0.5
 	github.com/minio/minio-go/v6 v6.0.57
 	github.com/nsmith5/mjpeg v0.0.0-20200913181537-54b8ada0e53e

machinery/go.sum

@@ -175,8 +175,8 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/kellydunn/golang-geo v0.7.0 h1:A5j0/BvNgGwY6Yb6inXQxzYwlPHc6WVZR+MrarZYNNg=
 github.com/kellydunn/golang-geo v0.7.0/go.mod h1:YYlQPJ+DPEzrHx8kT3oPHC/NjyvCCXE+IuKGKdrjrcU=
-github.com/kerberos-io/joy4 v1.0.53 h1:DfVptCUzo/77xLUIwnp1/dbcVffmT0DKPDduQBcu26Y=
-github.com/kerberos-io/joy4 v1.0.53/go.mod h1:nZp4AjvKvTOXRrmDyAIOw+Da+JA5OcSo/JundGfOlFU=
+github.com/kerberos-io/joy4 v1.0.55 h1:P5RISBp8kUowgb/bvqLPVKPJL9n9jI/wXBCLs+XFMWg=
+github.com/kerberos-io/joy4 v1.0.55/go.mod h1:nZp4AjvKvTOXRrmDyAIOw+Da+JA5OcSo/JundGfOlFU=
 github.com/kerberos-io/onvif v0.0.5 h1:kq9mnHZkih9Jl4DyIJ4Rzt++Y3DDKy3nI8S2ESEfZ5w=
 github.com/kerberos-io/onvif v0.0.5/go.mod h1:Hr2dJOH2LM5SpYKk17gYZ1CMjhGhUl+QlT5kwYogrW0=
 github.com/klauspost/cpuid v1.2.3 h1:CCtW0xUnWGVINKvE/WWOYKdsPV6mawAtvQuSl8guwQs=

machinery/src/capture/IPCamera.go

@@ -25,7 +25,19 @@ func OpenRTSP(url string) (av.DemuxCloser, []av.CodecData, error) {
 	return nil, []av.CodecData{}, err
 }
 
-func GetVideoDecoder(streams []av.CodecData) *ffmpeg.VideoDecoder {
+func GetVideoStream(streams []av.CodecData) (av.CodecData, error) {
+	var videoStream av.CodecData
+	for _, stream := range streams {
+		if stream.Type().IsAudio() {
+			//astream := stream.(av.AudioCodecData)
+		} else if stream.Type().IsVideo() {
+			videoStream = stream
+		}
+	}
+	return videoStream, nil
+}
+
+func GetVideoDecoder(decoder *ffmpeg.VideoDecoder, streams []av.CodecData) {
 	// Load video codec
 	var vstream av.VideoCodecData
 	for _, stream := range streams {
@@ -35,8 +47,10 @@ func GetVideoDecoder(streams []av.CodecData) *ffmpeg.VideoDecoder {
 			vstream = stream.(av.VideoCodecData)
 		}
 	}
-	dec, _ := ffmpeg.NewVideoDecoder(vstream)
-	return dec
+	err := ffmpeg.NewVideoDecoder(decoder, vstream)
+	if err != nil {
+		log.Log.Error("GetVideoDecoder: " + err.Error())
+	}
 }
 
 func DecodeImage(frame *ffmpeg.VideoFrame, pkt av.Packet, decoder *ffmpeg.VideoDecoder, decoderMutex *sync.Mutex) (*ffmpeg.VideoFrame, error) {

machinery/src/cloud/Cloud.go

@@ -95,6 +95,9 @@ func GetSystemInfo() (models.System, error) {
 	var usedMem uint64 = 0
 	var totalMem uint64 = 0
 	var freeMem uint64 = 0
+
+	var processUsedMem uint64 = 0
+
 	architecture := ""
 	cpuId := ""
 	KernelVersion := ""
@@ -133,18 +136,27 @@ func GetSystemInfo() (models.System, error) {
 		}
 	}
 
+	process, err := sysinfo.Self()
+	if err == nil {
+		memInfo, err := process.Memory()
+		if err == nil {
+			processUsedMem = memInfo.Resident
+		}
+	}
+
 	system := models.System{
-		Hostname:      hostname,
-		CPUId:         cpuId,
-		KernelVersion: KernelVersion,
-		Version:       agentVersion,
-		MACs:          MACs,
-		IPs:           IPs,
-		BootTime:      uint64(bootTime.Unix()),
-		Architecture:  architecture,
-		UsedMemory:    usedMem,
-		TotalMemory:   totalMem,
-		FreeMemory:    freeMem,
+		Hostname:          hostname,
+		CPUId:             cpuId,
+		KernelVersion:     KernelVersion,
+		Version:           agentVersion,
+		MACs:              MACs,
+		IPs:               IPs,
+		BootTime:          uint64(bootTime.Unix()),
+		Architecture:      architecture,
+		UsedMemory:        usedMem,
+		TotalMemory:       totalMem,
+		FreeMemory:        freeMem,
+		ProcessUsedMemory: processUsedMem,
 	}
 
 	return system, nil
@@ -200,6 +212,11 @@ func HandleHeartBeat(configuration *models.Configuration, communication *models.
 			uptimeString := carbon.Parse(uptimeFormatted).DiffForHumans()
 			uptimeString = strings.ReplaceAll(uptimeString, "ago", "")
 
+			// Do the same for boottime
+			bootTimeFormatted := time.Unix(int64(system.BootTime), 0).Format("2006-01-02 15:04:05")
+			boottimeString := carbon.Parse(bootTimeFormatted).DiffForHumans()
+			boottimeString = strings.ReplaceAll(boottimeString, "ago", "")
+
 			// We'll check which mode is enabled for the camera.
 			onvifEnabled := "false"
 			if config.Capture.IPCamera.ONVIFXAddr != "" {
@@ -239,13 +256,15 @@ func HandleHeartBeat(configuration *models.Configuration, communication *models.
 				"totalMemory" : "%d",
 				"usedMemory" : "%d",
 				"freeMemory" : "%d",
-				"macs" : %s,
-				"ips" : %s,
+				"processMemory" : "%d",
+				"mac_list" : %s,
+				"ip_list" : %s,
 				"board" : "",
 				"disk1size" : "%s",
 				"disk3size" : "%s",
 				"diskvdasize" :  "%s",
 				"uptime" : "%s",
+				"boot_time" : "%s",
 				"siteID" : "%s",
 				"onvif" : "%s",
 				"numberoffiles" : "33",
@@ -254,7 +273,7 @@ func HandleHeartBeat(configuration *models.Configuration, communication *models.
 				"docker" : true,
 				"kios" : false,
 				"raspberrypi" : false
-			}`, config.Key, system.Version, system.CPUId, username, key, name, isEnterprise, system.Hostname, system.Architecture, system.TotalMemory, system.UsedMemory, system.FreeMemory, macs, ips, "0", "0", "0", uptimeString, config.HubSite, onvifEnabled)
+			}`, config.Key, system.Version, system.CPUId, username, key, name, isEnterprise, system.Hostname, system.Architecture, system.TotalMemory, system.UsedMemory, system.FreeMemory, system.ProcessUsedMemory, macs, ips, "0", "0", "0", uptimeString, boottimeString, config.HubSite, onvifEnabled)
 
 			var jsonStr = []byte(object)
 			buffy := bytes.NewBuffer(jsonStr)

machinery/src/components/Config.go

@@ -1,8 +1,6 @@
 package components
 
 import (
-	"bufio"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -42,24 +40,6 @@ func GetImageFromFilePath() (image.Image, error) {
 	return nil, errors.New("Could not find a snapshot in " + snapshotDirectory)
 }
 
-func GetSnapshot() string {
-	var snapshot string
-	files, err := ioutil.ReadDir("./data/snapshots")
-	if err == nil && len(files) > 1 {
-		sort.Slice(files, func(i, j int) bool {
-			return files[i].ModTime().Before(files[j].ModTime())
-		})
-		f, _ := os.Open("./data/snapshots/" + files[1].Name())
-		defer f.Close()
-		// Read entire JPG into byte slice.
-		reader := bufio.NewReader(f)
-		content, _ := ioutil.ReadAll(reader)
-		// Encode as base64.
-		snapshot = base64.StdEncoding.EncodeToString(content)
-	}
-	return snapshot
-}
-
 // ReadUserConfig Reads the user configuration of the Kerberos Open Source instance.
 // This will return a models.User struct including the username, password,
 // selected language, and if the installation was completed or not.
@@ -146,6 +126,9 @@ func OpenConfig(configuration *models.Configuration) {
 		conjungo.Merge(&s3, configuration.CustomConfig.S3, opts)
 		configuration.Config.S3 = &s3
 
+		// Cleanup
+		opts = nil
+
 	} else if os.Getenv("DEPLOYMENT") == "" || os.Getenv("DEPLOYMENT") == "agent" {
 
 		// Local deployment means we do a stand-alone installation

machinery/src/components/Kerberos.go

@@ -1,11 +1,14 @@
 package components
 
 import (
+	"runtime"
 	"strconv"
 	"sync"
 	"sync/atomic"
 	"time"
 
+	"github.com/kerberos-io/joy4/cgo/ffmpeg"
+
 	"github.com/kerberos-io/agent/machinery/src/capture"
 	"github.com/kerberos-io/agent/machinery/src/cloud"
 	"github.com/kerberos-io/agent/machinery/src/computervision"
@@ -15,7 +18,6 @@ import (
 	routers "github.com/kerberos-io/agent/machinery/src/routers/mqtt"
 	"github.com/kerberos-io/joy4/av"
 	"github.com/kerberos-io/joy4/av/pubsub"
-	"github.com/kerberos-io/joy4/cgo/ffmpeg"
 	"github.com/tevino/abool"
 )
 
@@ -57,12 +59,17 @@ func Bootstrap(configuration *models.Configuration, communication *models.Commun
 	// do several checks to see if the agent is still operational.
 	go ControlAgent(communication)
 
+	// Create some global variables
+	decoder := &ffmpeg.VideoDecoder{}
+	subDecoder := &ffmpeg.VideoDecoder{}
+	cameraSettings := &models.Camera{}
+
 	// Run the agent and fire up all the other
 	// goroutines which do image capture, motion detection, onvif, etc.
 
 	for {
 		// This will blocking until receiving a signal to be restarted, reconfigured, stopped, etc.
-		status := RunAgent(configuration, communication, uptimeStart)
+		status := RunAgent(configuration, communication, uptimeStart, cameraSettings, decoder, subDecoder)
 		if status == "stop" {
 			break
 		}
@@ -72,7 +79,7 @@ func Bootstrap(configuration *models.Configuration, communication *models.Commun
 	log.Log.Debug("Bootstrap: finished")
 }
 
-func RunAgent(configuration *models.Configuration, communication *models.Communication, uptimeStart time.Time) string {
+func RunAgent(configuration *models.Configuration, communication *models.Communication, uptimeStart time.Time, cameraSettings *models.Camera, decoder *ffmpeg.VideoDecoder, subDecoder *ffmpeg.VideoDecoder) string {
 	log.Log.Debug("RunAgent: started")
 
 	config := configuration.Config
@@ -84,6 +91,10 @@ func RunAgent(configuration *models.Configuration, communication *models.Communi
 	infile, streams, err := capture.OpenRTSP(rtspUrl)
 
 	var queue *pubsub.Queue
+	var subQueue *pubsub.Queue
+
+	var decoderMutex sync.Mutex
+	var subDecoderMutex sync.Mutex
 
 	status := "not started"
 
@@ -104,15 +115,42 @@ func RunAgent(configuration *models.Configuration, communication *models.Communi
 			}
 		}
 
-		// At some routines we will need to decode the image.
-		// Make sure its properly locked as we only have a single decoder.
-		var decoderMutex sync.Mutex
-		var subDecoderMutex sync.Mutex
-		decoder := capture.GetVideoDecoder(streams)
+		// We will initialise the camera settings object
+		// so we can check if the camera settings have changed, and we need
+		// to reload the decoders.
+		videoStream, _ := capture.GetVideoStream(streams)
+		num, denum := videoStream.(av.VideoCodecData).Framerate()
+		width := videoStream.(av.VideoCodecData).Width()
+		height := videoStream.(av.VideoCodecData).Height()
 
-		var subDecoder *ffmpeg.VideoDecoder
-		if subStreamEnabled {
-			subDecoder = capture.GetVideoDecoder(subStreams)
+		if cameraSettings.RTSP != rtspUrl || cameraSettings.SubRTSP != subRtspUrl || cameraSettings.Width != width || cameraSettings.Height != height || cameraSettings.Num != num || cameraSettings.Denum != denum || cameraSettings.Codec != videoStream.(av.VideoCodecData).Type() {
+
+			if cameraSettings.Initialized {
+				decoder.Close()
+				if subStreamEnabled {
+					subDecoder.Close()
+				}
+			}
+
+			// At some routines we will need to decode the image.
+			// Make sure its properly locked as we only have a single decoder.
+			log.Log.Info("RunAgent: camera settings changed, reloading decoder")
+			capture.GetVideoDecoder(decoder, streams)
+			if subStreamEnabled {
+				capture.GetVideoDecoder(subDecoder, subStreams)
+			}
+
+			cameraSettings.RTSP = rtspUrl
+			cameraSettings.SubRTSP = subRtspUrl
+			cameraSettings.Width = width
+			cameraSettings.Height = height
+			cameraSettings.Framerate = float64(num) / float64(denum)
+			cameraSettings.Num = num
+			cameraSettings.Denum = denum
+			cameraSettings.Codec = videoStream.(av.VideoCodecData).Type()
+			cameraSettings.Initialized = true
+		} else {
+			log.Log.Info("RunAgent: camera settings did not change, keeping decoder")
 		}
 
 		communication.Decoder = decoder
@@ -136,10 +174,10 @@ func RunAgent(configuration *models.Configuration, communication *models.Communi
 		queue.WriteHeader(streams)
 
 		// We might have a substream, if so we'll create a seperate queue.
-		var subQueue *pubsub.Queue
 		if subStreamEnabled {
 			log.Log.Info("RunAgent: Creating sub stream queue with SetMaxGopCount set to " + strconv.Itoa(int(1)))
 			subQueue = pubsub.NewQueue()
+			communication.SubQueue = subQueue
 			subQueue.SetMaxGopCount(1)
 			subQueue.WriteHeader(subStreams)
 		}
@@ -214,22 +252,30 @@ func RunAgent(configuration *models.Configuration, communication *models.Communi
 		time.Sleep(time.Second * 1)
 
 		infile.Close()
+		infile = nil
 		queue.Close()
+		queue = nil
+		communication.Queue = nil
 		if subStreamEnabled {
 			subInfile.Close()
+			subInfile = nil
 			subQueue.Close()
+			subQueue = nil
+			communication.SubQueue = nil
 		}
 		close(communication.HandleONVIF)
+		communication.HandleONVIF = nil
 		close(communication.HandleLiveHDHandshake)
+		communication.HandleLiveHDHandshake = nil
 		close(communication.HandleMotion)
-		routers.DisconnectMQTT(mqttClient)
+		communication.HandleMotion = nil
+
+		// Disconnect MQTT
+		routers.DisconnectMQTT(mqttClient, &configuration.Config)
 
 		// Wait a few seconds to stop the decoder.
 		time.Sleep(time.Second * 3)
-		decoder.Close()
-		if subStreamEnabled {
-			subDecoder.Close()
-		}
+
 		// Waiting for some seconds to make sure everything is properly closed.
 		log.Log.Info("RunAgent: waiting 3 seconds to make sure everything is properly closed.")
 		time.Sleep(time.Second * 3)
@@ -240,6 +286,9 @@ func RunAgent(configuration *models.Configuration, communication *models.Communi
 
 	log.Log.Debug("RunAgent: finished")
 
+	// Clean up, force garbage collection
+	runtime.GC()
+
 	return status
 }
 

machinery/src/computervision/main.go

@@ -3,12 +3,9 @@ package computervision
 import (
 	"bufio"
 	"bytes"
+	"encoding/base64"
 	"image"
 	"image/jpeg"
-	"io/ioutil"
-	"os"
-	"sort"
-	"strconv"
 	"sync"
 	"time"
 
@@ -130,26 +127,7 @@ func ProcessMotion(motionCursor *pubsub.QueueCursor, configuration *models.Confi
 
 				// Store snapshots (jpg) for hull.
 				if config.Capture.Snapshots != "false" {
-					files, err := ioutil.ReadDir("./data/snapshots")
-					if err == nil {
-						rgbImage, err := GetRawImage(frame, pkt, decoder, decoderMutex)
-						if err == nil {
-							sort.Slice(files, func(i, j int) bool {
-								return files[i].ModTime().Before(files[j].ModTime())
-							})
-							if len(files) > 3 {
-								os.Remove("./data/snapshots/" + files[0].Name())
-							}
-
-							// Save image
-							t := strconv.FormatInt(time.Now().Unix(), 10)
-							f, err := os.Create("./data/snapshots/" + t + ".jpg")
-							if err == nil {
-								jpeg.Encode(f, &rgbImage.Image, &jpeg.Options{Quality: 15})
-								f.Close()
-							}
-						}
-					}
+					StoreSnapshot(communication, frame, pkt, decoder, decoderMutex)
 				}
 
 				// Check if within time interval
@@ -255,3 +233,16 @@ func AbsDiffBitwiseAndThreshold(img1 *image.Gray, img2 *image.Gray, img3 *image.
 	}
 	return changes
 }
+
+func StoreSnapshot(communication *models.Communication, frame *ffmpeg.VideoFrame, pkt av.Packet, decoder *ffmpeg.VideoDecoder, decoderMutex *sync.Mutex) {
+	rgbImage, err := GetRawImage(frame, pkt, decoder, decoderMutex)
+	if err == nil {
+		buffer := new(bytes.Buffer)
+		w := bufio.NewWriter(buffer)
+		err := jpeg.Encode(w, &rgbImage.Image, &jpeg.Options{Quality: 15})
+		if err == nil {
+			snapshot := base64.StdEncoding.EncodeToString(buffer.Bytes())
+			communication.Image = snapshot
+		}
+	}
+}

machinery/src/models/Camera.go

@@ -0,0 +1,15 @@
+package models
+
+import "github.com/kerberos-io/joy4/av"
+
+type Camera struct {
+	Width       int
+	Height      int
+	Num         int
+	Denum       int
+	Framerate   float64
+	RTSP        string
+	SubRTSP     string
+	Codec       av.CodecType
+	Initialized bool
+}

machinery/src/models/Communication.go

@@ -28,8 +28,10 @@ type Communication struct {
 	HandleONVIF           chan OnvifAction
 	IsConfiguring         *abool.AtomicBool
 	Queue                 *pubsub.Queue
+	SubQueue              *pubsub.Queue
 	DecoderMutex          *sync.Mutex
 	SubDecoderMutex       *sync.Mutex
 	Decoder               *ffmpeg.VideoDecoder
 	SubDecoder            *ffmpeg.VideoDecoder
+	Image                 string
 }

machinery/src/models/System.go

@@ -1,16 +1,17 @@
 package models
 
 type System struct {
-	CPUId         string   `json:"cpu_idle" bson:"cpu_idle"`
-	Hostname      string   `json:"hostname" bson:"hostname"`
-	Version       string   `json:"version" bson:"version"`
-	Release       string   `json:"release" bson:"release"`
-	BootTime      uint64   `json:"boot_time" bson:"boot_time"`
-	KernelVersion string   `json:"kernel_version" bson:"kernel_version"`
-	MACs          []string `json:"macs" bson:"macs"`
-	IPs           []string `json:"ips" bson:"ips"`
-	Architecture  string   `json:"architecture" bson:"architecture"`
-	UsedMemory    uint64   `json:"used_memory" bson:"used_memory"`
-	TotalMemory   uint64   `json:"total_memory" bson:"total_memory"`
-	FreeMemory    uint64   `json:"free_memory" bson:"free_memory"`
+	CPUId             string   `json:"cpu_idle" bson:"cpu_idle"`
+	Hostname          string   `json:"hostname" bson:"hostname"`
+	Version           string   `json:"version" bson:"version"`
+	Release           string   `json:"release" bson:"release"`
+	BootTime          uint64   `json:"boot_time" bson:"boot_time"`
+	KernelVersion     string   `json:"kernel_version" bson:"kernel_version"`
+	MACs              []string `json:"macs" bson:"macs"`
+	IPs               []string `json:"ips" bson:"ips"`
+	Architecture      string   `json:"architecture" bson:"architecture"`
+	UsedMemory        uint64   `json:"used_memory" bson:"used_memory"`
+	TotalMemory       uint64   `json:"total_memory" bson:"total_memory"`
+	FreeMemory        uint64   `json:"free_memory" bson:"free_memory"`
+	ProcessUsedMemory uint64   `json:"process_used_memory" bson:"process_used_memory"`
 }

machinery/src/routers/http/Routes.go

@@ -29,7 +29,7 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configuratio
 			"config":   configuration.Config,
 			"custom":   configuration.CustomConfig,
 			"global":   configuration.GlobalConfig,
-			"snapshot": components.GetSnapshot(),
+			"snapshot": communication.Image,
 		})
 	})
 
@@ -157,7 +157,7 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configuratio
 				"config":   configuration.Config,
 				"custom":   configuration.CustomConfig,
 				"global":   configuration.GlobalConfig,
-				"snapshot": components.GetSnapshot(),
+				"snapshot": communication.Image,
 			})
 		})
 

machinery/src/routers/mqtt/main.go

@@ -193,8 +193,16 @@ func MQTTListenerHandleONVIF(mqttClient mqtt.Client, hubKey string, configuratio
 	})
 }
 
-func DisconnectMQTT(mqttClient mqtt.Client) {
+func DisconnectMQTT(mqttClient mqtt.Client, config *models.Config) {
 	if mqttClient != nil {
+		// Cleanup all subscriptions.
+		mqttClient.Unsubscribe("kerberos/" + config.HubKey + "/device/" + config.Key + "/request-live")
+		mqttClient.Unsubscribe(config.Key + "/register")
+		mqttClient.Unsubscribe("kerberos/webrtc/keepalivehub/" + config.Key)
+		mqttClient.Unsubscribe("kerberos/webrtc/peers/" + config.Key)
+		mqttClient.Unsubscribe("candidate/cloud")
+		mqttClient.Unsubscribe("kerberos/onvif/" + config.Key)
 		mqttClient.Disconnect(1000)
+		mqttClient = nil
 	}
 }

machinery/src/routers/websocket/main.go

@@ -136,7 +136,7 @@ func ForwardSDStream(ctx context.Context, clientID string, connection *Connectio
 logreader:
 	for {
 		var encodedImage string
-		if cursor != nil && decoder != nil {
+		if queue != nil && cursor != nil && decoder != nil {
 			pkt, err := cursor.ReadPacket()
 			if err == nil {
 				if !pkt.IsKeyFrame {

machinery/src/utils/main.go

@@ -271,108 +271,3 @@ func CreateFragmentedMP4(fullName string, fragmentedDuration int64) {
 	os.Remove(fullName)
 	os.Rename(fullName+"f.mp4", fullName)
 }
-
-/*func FloatToString(input_num float64) string {
-	// to convert a float number to a string
-	return strconv.FormatFloat(input_num, 'f', 6, 64)
-}
-
-func ParseFMP4(file *bytes.Reader) (error, uint64, uint64, []*mp4.MediaSegment, uint64) {
-	var ftypSize, moovSize uint64
-	var segments []*mp4.MediaSegment
-	var duration uint64
-	parsedMp4, err := mp4.DecodeFile(file, mp4.WithDecodeMode(mp4.DecModeLazyMdat))
-	if parsedMp4 != nil && parsedMp4.Init != nil && err == nil {
-		ftypSize = parsedMp4.Init.Ftyp.Size()
-		moovSize = parsedMp4.Init.Moov.Size()
-		duration = parsedMp4.Moov.Trak.Tkhd.Duration
-		segments = parsedMp4.Segments
-	}
-	return err, ftypSize, moovSize, segments, duration
-}
-
-func ParseFMP4Detail(fullName string) {
-
-	// open fullName
-	file, err := os.Open(fullName)
-	if err != nil {
-		log.Log.Error("Error opening file: " + err.Error())
-	}
-	defer file.Close()
-
-	fileBytes, err := ioutil.ReadAll(file)
-	if err != nil {
-		log.Log.Error("Error reading file: " + err.Error())
-	}
-	fileReader := bytes.NewReader(fileBytes)
-
-	err, ftypSize, moovSize, segments, dur := ParseFMP4(fileReader)
-	fmt.Println("========== Fragmented details =================")
-	fmt.Println(dur)
-	fmt.Println(ftypSize)
-	fmt.Println(moovSize)
-	fmt.Println(len(segments))
-
-	// Calculate duration of segments
-	var totalDuration uint64
-	for _, segment := range segments {
-		fragments := segment.Fragments
-
-		for _, fragment := range fragments {
-			var sampleDuration uint32
-			samples := fragment.Moof.Traf.Trun.Samples
-			for _, sample := range samples {
-				sampleDuration += sample.Dur
-			}
-			fmt.Println(sampleDuration)
-			totalDuration += uint64(sampleDuration)
-		}
-	}
-
-	misingDuration := dur - totalDuration/100
-	fmt.Println(misingDuration)
-	fmt.Println(totalDuration/100 + misingDuration)
-}
-
-func CreateFragmentByteRanges(log log.Logging, fileName string, ftypSize uint64, moovSize uint64, segments []*mp4.MediaSegment) (string, []models.BytesRangeOnTime) {
-	size := strconv.FormatInt(int64(ftypSize+moovSize), 10)
-
-	var fileFragments strings.Builder
-	fileFragments.WriteString("#EXT-X-MAP:URI=\"" + fileName + "\",BYTERANGE=\"" + size + "@0\"\n")
-
-	var bytesRangeOnTime []models.BytesRangeOnTime
-	var currentTime uint32
-	for _, segment := range segments {
-		fragments := segment.Fragments
-		for _, fragment := range fragments {
-			var sampleDuration uint32
-			samples := fragment.Moof.Traf.Trun.Samples
-			for _, sample := range samples {
-				sampleDuration += sample.Dur
-			}
-			currentTime = currentTime + sampleDuration
-			duration := FloatToString(float64(sampleDuration / 100000))
-
-			startPos := fragment.Moof.StartPos
-			start := strconv.FormatInt(int64(startPos), 10)
-
-			totalSize := fragment.Mdat.Size() + fragment.Moof.Size()
-			size := strconv.FormatInt(int64(totalSize), 10)
-
-			fileFragments.WriteString("#EXTINF:" + duration + ",\n") // @TODO calculate the duration
-			fileFragments.WriteString("#EXT-X-BYTERANGE:" + size + "@" + start + "\n")
-			fileFragments.WriteString(fileName + "\n")
-
-			byteRange := models.BytesRangeOnTime{
-				Duration: duration,
-				Time:     FloatToString(float64(currentTime) / 100000),
-				Range:    size + "@" + start,
-			}
-			bytesRangeOnTime = append(bytesRangeOnTime, byteRange)
-		}
-	}
-
-	bytesRanges := fileFragments.String()
-	log.Info("Fragments calculate from " + fileName + ": " + bytesRanges)
-	return bytesRanges, bytesRangeOnTime
-}*/

ui/src/config.js

@@ -7,14 +7,16 @@ const websocketprotocol = protocol === 'http:' ? 'ws:' : 'wss:';
 
 const dev = {
   ENV: 'dev',
+  // Comment the below lines, when using codespaces or other special DNS names (which you can't control)
   HOSTNAME: hostname,
   API_URL: `${protocol}//${hostname}:8080/api`,
   URL: `${protocol}//${hostname}:8080`,
   WS_URL: `${websocketprotocol}//${hostname}:8080/ws`,
-
   // Uncomment, and comment the above lines, when using codespaces or other special DNS names (which you can't control)
+  // HOSTNAME: externalHost,
   // API_URL: `${protocol}//${externalHost}/api`,
   // URL: `${protocol}//${externalHost}`,
+  // WS_URL: `${websocketprotocol}//${externalHost}/ws`,
 };
 
 const prod = {