401 lines
13 KiB
Go
401 lines
13 KiB
Go
package handlers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.insit.tech/psa/rtsp_reader-writer/writer/pkg/storage"
|
|
"go.uber.org/zap"
|
|
"reader/internal/config"
|
|
logger "reader/internal/log"
|
|
"reader/internal/processor"
|
|
)
|
|
|
|
type VideoRequest struct {
|
|
Date string `json:"date"`
|
|
StartTime string `json:"start_time"`
|
|
EndTime string `json:"end_time"`
|
|
}
|
|
|
|
type ListVodsResponse struct {
|
|
EstimatedCount int `json:"estimated_count"` // Estimated total number of records for the query.
|
|
Vods []string `json:"vods"` // List of vods.
|
|
Files map[string][]string `json:"files"` // List files and folders of a specific VOD location.
|
|
}
|
|
|
|
type ConfigVodsResponse struct {
|
|
Prefix string `json:"prefix"` // The unique name of VOD location.
|
|
AutoMbr bool `json:"auto_mbr"` // Turns on automatic creation of a multi-bitrate HLS playlist from several files with different bitrates.
|
|
Disabled bool `json:"disabled"` // Whether this VOD location is disabled.
|
|
Protocols struct { // Configuraton of play protocols.
|
|
Hls bool `json:"hls"` // Whether to allow or deny an HLS stream playback.
|
|
Cmaf bool `json:"cmaf"` // Whether to allow or deny an LL-HLS stream playback.
|
|
Dash bool `json:"dash"` // Whether to allow or deny a DASH stream playback.
|
|
Player bool `json:"player"` // Whether to allow or deny playback in embed.html.
|
|
Mss bool `json:"mss"` // Whether to allow or deny an MSS stream playback.
|
|
Rtmp bool `json:"rtmp"` // Whether to allow or deny an RTMP stream playback.
|
|
Rtsp bool `json:"rtsp"` // Whether to allow or deny an RTSP stream playback.
|
|
M4F bool `json:"m4f"` // Whether to allow or deny an M4F stream playback.
|
|
M4S bool `json:"m4s"` // Whether to allow or deny an M4S stream playback.
|
|
Mseld bool `json:"mseld"` // Whether to allow or deny an MSE-LD stream playback.
|
|
Tshttp bool `json:"tshttp"` // Whether to allow or deny an MPEG-TS stream playback over HTTP(S).
|
|
Webrtc bool `json:"webrtc"` // Whether to allow or deny an WebRTC stream playback.
|
|
Srt bool `json:"srt"` // Whether to allow or deny an SRT stream playback.
|
|
Shoutcast bool `json:"shoutcast"` // Whether to allow or deny a SHOUTcast/Icecast stream playback.
|
|
Mp4 bool `json:"mp4"` // Whether to allow or deny an MP4 file download over HTTP(S).
|
|
Jpeg bool `json:"jpeg"` // Whether to allow or deny delivering JPEG thumbnails over HTTP(S).
|
|
Api bool `json:"api"` // Whether to allow or deny API requests.
|
|
} `json:"protocols"`
|
|
SegmentDuration int `json:"segment_duration"` // The time, in seconds, of the segment duration. Used for the protocols like HLS or DASH.
|
|
AddAudioOnly bool `json:"add_audio_only"` // Whether to add an audio-only version of an HLS stream. Used to create App Store compliant HLS streams to deliver the content to Apple iOS devices. Add audio-only HLS playlist to variant MBR playlist for iOS compliant streaming.
|
|
Provider string `json:"provider"` // Human-readable name of the content provider. Applicable to MPEG-TS.
|
|
}
|
|
|
|
type SingleVodsResponse struct {
|
|
Name string `json:"name"`
|
|
Prefix string `json:"prefix"`
|
|
Url string `json:"url"`
|
|
Folder string `json:"folder"`
|
|
Bytes int64 `json:"bytes"`
|
|
MediaInfo MediaSingleVodsResponse `json:"media_info"`
|
|
}
|
|
|
|
type MediaSingleVodsResponse struct {
|
|
Tracks map[string]string `json:"tracks"`
|
|
Duration int `json:"duration"`
|
|
Provider string `json:"provider"`
|
|
Title string `json:"title"`
|
|
}
|
|
|
|
// Inactive5Minutes checks if a folder has files that was not created or modified for last 5 minutes.
|
|
func Inactive5Minutes(entries []os.DirEntry) (bool, error) {
|
|
threshold := time.Now().Add(-5 * time.Minute)
|
|
|
|
disabled := true
|
|
|
|
for _, entry := range entries {
|
|
info, err := entry.Info()
|
|
if err != nil {
|
|
return true, errors.New("Info error: " + err.Error())
|
|
}
|
|
|
|
if info.ModTime().After(threshold) {
|
|
disabled = false
|
|
return disabled, nil
|
|
}
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// recDurationMilliseconds calculates the difference between first existing rec file and the last one in milliseconds.
|
|
func recDurationMilliseconds(entries []os.DirEntry) (int, error) {
|
|
// Find last file and first file; get timestamps.
|
|
lastFile := entries[len(entries)-1].Name()
|
|
lastTime := strings.Split(lastFile, "_")[0]
|
|
|
|
firstFile := entries[0].Name()
|
|
firstTime := strings.Split(firstFile, "_")[0]
|
|
|
|
// Convert string timestamps to int.
|
|
lastTimeInt, err := strconv.Atoi(lastTime)
|
|
if err != nil {
|
|
return 0, errors.New("convert last time error: " + err.Error())
|
|
}
|
|
|
|
firstTimeInt, err := strconv.Atoi(firstTime)
|
|
if err != nil {
|
|
return 0, errors.New("convert first time error: " + err.Error())
|
|
}
|
|
|
|
// Calculate the difference.
|
|
difference := lastTimeInt - firstTimeInt
|
|
|
|
return difference * 1000, nil
|
|
}
|
|
|
|
// Download processes Download request.
|
|
func Download(w http.ResponseWriter, r *http.Request) {
|
|
log.Printf("new download request: %+v\n", r)
|
|
|
|
downloadRequest := VideoRequest{}
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&downloadRequest)
|
|
if err != nil {
|
|
log.Printf("json decode error: %v\n", err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
pathFileNameRes, err := processor.Process(downloadRequest.Date, downloadRequest.StartTime, downloadRequest.EndTime)
|
|
if err != nil {
|
|
log.Printf("process error: %v\n", err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "video/mp4")
|
|
// Разрешаем частичную загрузку (поддержка перемотки)
|
|
w.Header().Set("Accept-Ranges", "bytes")
|
|
|
|
http.ServeFile(w, r, pathFileNameRes)
|
|
}
|
|
|
|
// HLS processes Download request.
|
|
func HLS(w http.ResponseWriter, r *http.Request) {
|
|
log.Printf("new hls request: %+v\n", r)
|
|
|
|
path := "/home/psa/GoRepository/data/1280x720/"
|
|
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
http.StripPrefix("/hls", http.FileServer(http.Dir(path))).ServeHTTP(w, r)
|
|
}
|
|
|
|
// ListVodsHandler returns the list of VOD locations.
|
|
//
|
|
// This method allows to get the list of all VOD locations. VOD location is a virtual filepath used to place files for
|
|
// VOD (Video on Demand) broadcasting.
|
|
func ListVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read directory.
|
|
entries, err := os.ReadDir(config.DirData)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("failed to read dir", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
// Filter only folders.
|
|
var dirs []string
|
|
for _, entry := range entries {
|
|
if entry.IsDir() {
|
|
dirs = append(dirs, entry.Name())
|
|
}
|
|
}
|
|
|
|
// Prepare the Response.
|
|
VodsRes := ListVodsResponse{
|
|
EstimatedCount: len(dirs),
|
|
Vods: dirs,
|
|
}
|
|
|
|
// Write header and code response.
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(VodsRes); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("failed to encode dir", zap.Error(err))
|
|
return
|
|
}
|
|
}
|
|
|
|
// ConfigVodsHandler returns configuration of the requested VOD location.
|
|
//
|
|
// This method allows to get a single VOD location.
|
|
func ConfigVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read camera id.
|
|
id := r.PathValue("id")
|
|
|
|
// Get resolutions.
|
|
resolutions, err := storage.GetResolutions(id)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
logger.Log.Error("camera does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
// Calculate response fields.
|
|
|
|
// Create path to first resolution.
|
|
resDir := fmt.Sprintf("%s/%s/%s", config.DirData, id, resolutions[0])
|
|
|
|
// Read directory.
|
|
entries, err := os.ReadDir(resDir)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("resolution does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
// Check if a folder has files that was not created or modified for last 5 minutes.
|
|
disabled, err := Inactive5Minutes(entries)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
|
|
segmentDuration, err := recDurationMilliseconds(entries)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
|
|
// Prepare the Response.
|
|
VodsRes := ConfigVodsResponse{
|
|
Prefix: id,
|
|
AutoMbr: false, // Always false. Temporary.
|
|
Disabled: disabled,
|
|
SegmentDuration: segmentDuration,
|
|
AddAudioOnly: false, // Always false. Temporary.
|
|
Provider: "Insit",
|
|
}
|
|
|
|
// Write header and code response.
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(VodsRes); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("failed to encode dir", zap.Error(err))
|
|
return
|
|
}
|
|
w.Write([]byte("Whole VOD location configuration"))
|
|
}
|
|
|
|
// DelVodsHandler delete archive of the requested VOD location.
|
|
//
|
|
// This method delete a single VOD location by its prefix.
|
|
func DelVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read camera id.
|
|
id := r.PathValue("id")
|
|
|
|
err := os.Remove(fmt.Sprintf("%s/%s", config.DirData, id))
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
logger.Log.Error("camera does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
w.Write([]byte("Deleted"))
|
|
}
|
|
|
|
// ListFilesVodsHandler returns the list of all files and folders in archive for a specific VOD location.
|
|
//
|
|
// This method allows to get the list of all files and folders for a specific VOD location.
|
|
func ListFilesVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read camera id.
|
|
id := r.PathValue("id")
|
|
|
|
// Create map for response.
|
|
files := make(map[string][]string)
|
|
|
|
// Get resolutions.
|
|
resolutions, err := storage.GetResolutions(id)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
logger.Log.Error("camera does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
for _, resolution := range resolutions {
|
|
// Create path to the resolutions.
|
|
resDir := fmt.Sprintf("%s/%s/%s", config.DirData, id, resolution)
|
|
|
|
// Read directory.
|
|
entries, err := os.ReadDir(resDir)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("resolution does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
// Create slice for files in folders.
|
|
filesInFolder := make([]string, 0)
|
|
|
|
// Add all files to the slice with files.
|
|
for _, entry := range entries {
|
|
filesInFolder = append(filesInFolder, entry.Name())
|
|
}
|
|
|
|
// Add resolution and all files to the response map.
|
|
files[resolution] = filesInFolder
|
|
}
|
|
|
|
// Prepare the Response.
|
|
vodsRes := ListVodsResponse{
|
|
EstimatedCount: len(files),
|
|
Files: files,
|
|
}
|
|
|
|
// Write header and code response.
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte("List of files in the VOD storage"))
|
|
if err := json.NewEncoder(w).Encode(vodsRes); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("failed to encode dir", zap.Error(err))
|
|
return
|
|
}
|
|
}
|
|
|
|
// SingleVodsHandler returns a specific file in archive for a specific resolution and VOD location.
|
|
//
|
|
// This method allows to get a single VOD file.
|
|
func SingleVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read camera id, res, filename.
|
|
id := r.PathValue("id")
|
|
res := r.PathValue("res")
|
|
file := r.PathValue("file")
|
|
|
|
// Calculate file size in bytes.
|
|
FileBytes, err := storage.FileBytes(id, res, file)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("file not found", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
dur, tracks, err := storage.GetDurAndTracks(id, res, file)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("file not found", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
media := MediaSingleVodsResponse{
|
|
Tracks: tracks,
|
|
Duration: dur,
|
|
Provider: "Insit",
|
|
Title: id,
|
|
}
|
|
|
|
// Prepare the Response.
|
|
vodsRes := SingleVodsResponse{
|
|
Name: file,
|
|
Prefix: id,
|
|
Url: r.URL.String(),
|
|
Folder: res,
|
|
Bytes: FileBytes,
|
|
MediaInfo: media,
|
|
}
|
|
|
|
// Write header and code response.
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte("Whole VOD file configuration"))
|
|
if err := json.NewEncoder(w).Encode(vodsRes); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
logger.Log.Error("failed to encode dir", zap.Error(err))
|
|
return
|
|
}
|
|
}
|
|
|
|
// DelSingleVodsHandler deletes a VOD file by its name.
|
|
//
|
|
// This method deletes a VOD file by its name.
|
|
func DelSingleVodsHandler(w http.ResponseWriter, r *http.Request) {
|
|
// Read camera id, res, filename.
|
|
id := r.PathValue("id")
|
|
res := r.PathValue("res")
|
|
file := r.PathValue("file")
|
|
|
|
if err := os.Remove(fmt.Sprintf("%s/%s/%s/%s", config.DirData, id, res, file)); err != nil {
|
|
http.Error(w, err.Error(), http.StatusNotFound)
|
|
logger.Log.Error("file does not exist", zap.Error(err))
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
w.Write([]byte("Deleted"))
|
|
}
|