mirror of
https://github.com/owncast/owncast.git
synced 2024-10-25 05:56:00 +03:00
476 lines
12 KiB
Go
476 lines
12 KiB
Go
package admin
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"path/filepath"
|
|
"reflect"
|
|
|
|
"github.com/owncast/owncast/controllers"
|
|
"github.com/owncast/owncast/core"
|
|
"github.com/owncast/owncast/core/data"
|
|
"github.com/owncast/owncast/models"
|
|
"github.com/owncast/owncast/utils"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// ConfigValue is a container object that holds a value, is encoded, and saved to the database.
|
|
type ConfigValue struct {
|
|
Value interface{} `json:"value"`
|
|
}
|
|
|
|
// SetTags will handle the web config request to set tags.
|
|
func SetTags(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValues, success := getValuesFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
var tagStrings []string
|
|
for _, tag := range configValues {
|
|
tagStrings = append(tagStrings, tag.Value.(string))
|
|
}
|
|
|
|
if err := data.SetServerMetadataTags(tagStrings); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetStreamTitle will handle the web config request to set the current stream title.
|
|
func SetStreamTitle(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
value := configValue.Value.(string)
|
|
|
|
if err := data.SetStreamTitle(value); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
if value != "" {
|
|
sendSystemChatAction(fmt.Sprintf("Stream title changed to **%s**", value), true)
|
|
}
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
func sendSystemChatAction(messageText string, ephemeral bool) {
|
|
message := models.ChatEvent{}
|
|
message.Body = messageText
|
|
message.MessageType = models.ChatActionSent
|
|
message.ClientID = "internal-server"
|
|
message.Ephemeral = ephemeral
|
|
message.SetDefaults()
|
|
|
|
if err := core.SendMessageToChat(message); err != nil {
|
|
log.Errorln(err)
|
|
}
|
|
}
|
|
|
|
// SetServerName will handle the web config request to set the server's name.
|
|
func SetServerName(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetServerName(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetServerSummary will handle the web config request to set the about/summary text.
|
|
func SetServerSummary(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetServerSummary(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetExtraPageContent will handle the web config request to set the page markdown content.
|
|
func SetExtraPageContent(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetExtraPageBodyContent(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetStreamKey will handle the web config request to set the server stream key.
|
|
func SetStreamKey(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetStreamKey(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetLogoPath will handle the web config request to validate and set the logo path.
|
|
func SetLogoPath(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
imgPath := configValue.Value.(string)
|
|
fullPath := filepath.Join("data", imgPath)
|
|
if !utils.DoesFileExists(fullPath) {
|
|
controllers.WriteSimpleResponse(w, false, fmt.Sprintf("%s does not exist", fullPath))
|
|
return
|
|
}
|
|
|
|
if err := data.SetLogoPath(imgPath); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetNSFW will handle the web config request to set the NSFW flag.
|
|
func SetNSFW(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetNSFW(configValue.Value.(bool)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetFfmpegPath will handle the web config request to validate and set an updated copy of ffmpg.
|
|
func SetFfmpegPath(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
path := configValue.Value.(string)
|
|
if err := utils.VerifyFFMpegPath(path); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
if err := data.SetFfmpegPath(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "changed")
|
|
}
|
|
|
|
// SetWebServerPort will handle the web config request to set the server's HTTP port.
|
|
func SetWebServerPort(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetHTTPPortNumber(configValue.Value.(float64)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "http port set")
|
|
}
|
|
|
|
// SetRTMPServerPort will handle the web config request to set the inbound RTMP port.
|
|
func SetRTMPServerPort(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetRTMPPortNumber(configValue.Value.(float64)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "rtmp port set")
|
|
}
|
|
|
|
// SetServerURL will handle the web config request to set the full server URL.
|
|
func SetServerURL(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetServerURL(configValue.Value.(string)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "server url set")
|
|
}
|
|
|
|
// SetDirectoryEnabled will handle the web config request to enable or disable directory registration.
|
|
func SetDirectoryEnabled(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetDirectoryEnabled(configValue.Value.(bool)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, err.Error())
|
|
return
|
|
}
|
|
controllers.WriteSimpleResponse(w, true, "directory state changed")
|
|
}
|
|
|
|
// SetStreamLatencyLevel will handle the web config request to set the stream latency level.
|
|
func SetStreamLatencyLevel(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
configValue, success := getValueFromRequest(w, r)
|
|
if !success {
|
|
return
|
|
}
|
|
|
|
if err := data.SetStreamLatencyLevel(configValue.Value.(float64)); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "error setting stream latency "+err.Error())
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "set stream latency")
|
|
}
|
|
|
|
// SetS3Configuration will handle the web config request to set the storage configuration.
|
|
func SetS3Configuration(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
type s3ConfigurationRequest struct {
|
|
Value models.S3 `json:"value"`
|
|
}
|
|
|
|
decoder := json.NewDecoder(r.Body)
|
|
var newS3Config s3ConfigurationRequest
|
|
if err := decoder.Decode(&newS3Config); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to update s3 config with provided values")
|
|
return
|
|
}
|
|
|
|
if newS3Config.Value.Enabled {
|
|
if newS3Config.Value.Endpoint == "" || !utils.IsValidUrl((newS3Config.Value.Endpoint)) {
|
|
controllers.WriteSimpleResponse(w, false, "s3 support requires an endpoint")
|
|
return
|
|
|
|
}
|
|
|
|
if newS3Config.Value.AccessKey == "" || newS3Config.Value.Secret == "" {
|
|
controllers.WriteSimpleResponse(w, false, "s3 support requires an access key and secret")
|
|
return
|
|
}
|
|
|
|
if newS3Config.Value.Region == "" {
|
|
controllers.WriteSimpleResponse(w, false, "s3 support requires a region and endpoint")
|
|
return
|
|
}
|
|
|
|
if newS3Config.Value.Bucket == "" {
|
|
controllers.WriteSimpleResponse(w, false, "s3 support requires a bucket created for storing public video segments")
|
|
return
|
|
}
|
|
}
|
|
|
|
data.SetS3Config(newS3Config.Value)
|
|
controllers.WriteSimpleResponse(w, true, "storage configuration changed")
|
|
|
|
}
|
|
|
|
// SetStreamOutputVariants will handle the web config request to set the video output stream variants.
|
|
func SetStreamOutputVariants(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
type streamOutputVariantRequest struct {
|
|
Value []models.StreamOutputVariant `json:"value"`
|
|
}
|
|
|
|
decoder := json.NewDecoder(r.Body)
|
|
var videoVariants streamOutputVariantRequest
|
|
if err := decoder.Decode(&videoVariants); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to update video config with provided values")
|
|
return
|
|
}
|
|
|
|
// Temporary: Convert the cpuUsageLevel to a preset. In the future we will have
|
|
// different codec models that will handle this for us and we won't
|
|
// be keeping track of presets at all. But for now...
|
|
presetMapping := []string{
|
|
"ultrafast",
|
|
"superfast",
|
|
"veryfast",
|
|
"faster",
|
|
"fast",
|
|
}
|
|
|
|
for i, variant := range videoVariants.Value {
|
|
preset := "superfast"
|
|
if variant.CPUUsageLevel > 0 && variant.CPUUsageLevel <= len(presetMapping) {
|
|
preset = presetMapping[variant.CPUUsageLevel-1]
|
|
}
|
|
variant.EncoderPreset = preset
|
|
videoVariants.Value[i] = variant
|
|
}
|
|
|
|
if err := data.SetStreamOutputVariants(videoVariants.Value); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to update video config with provided values")
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "stream output variants updated")
|
|
}
|
|
|
|
// SetSocialHandles will handle the web config request to set the external social profile links.
|
|
func SetSocialHandles(w http.ResponseWriter, r *http.Request) {
|
|
if !requirePOST(w, r) {
|
|
return
|
|
}
|
|
|
|
type socialHandlesRequest struct {
|
|
Value []models.SocialHandle `json:"value"`
|
|
}
|
|
|
|
decoder := json.NewDecoder(r.Body)
|
|
var socialHandles socialHandlesRequest
|
|
if err := decoder.Decode(&socialHandles); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to update social handles with provided values")
|
|
return
|
|
}
|
|
|
|
if err := data.SetSocialHandles(socialHandles.Value); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to update social handles with provided values")
|
|
return
|
|
}
|
|
|
|
controllers.WriteSimpleResponse(w, true, "social handles updated")
|
|
}
|
|
|
|
func requirePOST(w http.ResponseWriter, r *http.Request) bool {
|
|
if r.Method != controllers.POST {
|
|
controllers.WriteSimpleResponse(w, false, r.Method+" not supported")
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func getValueFromRequest(w http.ResponseWriter, r *http.Request) (ConfigValue, bool) {
|
|
decoder := json.NewDecoder(r.Body)
|
|
var configValue ConfigValue
|
|
if err := decoder.Decode(&configValue); err != nil {
|
|
log.Warnln(err)
|
|
controllers.WriteSimpleResponse(w, false, "unable to parse new value")
|
|
return configValue, false
|
|
}
|
|
|
|
return configValue, true
|
|
}
|
|
|
|
func getValuesFromRequest(w http.ResponseWriter, r *http.Request) ([]ConfigValue, bool) {
|
|
var values []ConfigValue
|
|
|
|
decoder := json.NewDecoder(r.Body)
|
|
var configValue ConfigValue
|
|
if err := decoder.Decode(&configValue); err != nil {
|
|
controllers.WriteSimpleResponse(w, false, "unable to parse array of values")
|
|
return values, false
|
|
}
|
|
|
|
object := reflect.ValueOf(configValue.Value)
|
|
|
|
for i := 0; i < object.Len(); i++ {
|
|
values = append(values, ConfigValue{Value: object.Index(i).Interface()})
|
|
}
|
|
|
|
return values, true
|
|
}
|