-
-
STOPPED!
-
The forwarding has been stopped successfully
+
-
-
+ });
+
{{end}}
\ No newline at end of file
diff --git a/server/templates/save.tmpl b/server/templates/save.tmpl
index 07644b4..8a0ee8b 100644
--- a/server/templates/save.tmpl
+++ b/server/templates/save.tmpl
@@ -1,132 +1,297 @@
{{define "content"}}
-
-
-
-
STREAMING!
-
The stream has been forwarded, the unique code of this forward is below
-
-
-
This window can be closed as long as you have the code to stop the streamhttps://streamer.dev.ystv.co.uk/resume
-
-
Enable the stop button
-
-
-
-
-
-
-
STOPPED!
-
The forwarding has been stopped successfully
-
-
-
-{{end}}
\ No newline at end of file
+
+ let websiteStreamEndpoint = $('#website_stream_endpoint');
+
+ if (document.getElementById('website_stream').checked) {
+ if (websiteStreamEndpoint.val().length === 0 || !websiteStreamEndpoint.val().includes("?pwd=")) {
+ console.log("PWD");
+ error.html("The website stream must contain \"?pwd=\"")
+ return;
+ }
+ }
+
+ let streamServer0 = $('#stream_server_0');
+
+ if (streamServer0.val().length === 0 || streamServer0.val().length === 0) {
+ console.log("ADDITIONAL");
+ error.html("The stream server and stream key cannot be empty")
+ return;
+ }
+ if (!validURL(streamServer0.val())) {
+ console.log("STREAM SERVER");
+ error.html("The stream server must contain \"rtmp://\" or \"rtmps://\" and needs to be a valid url")
+ return;
+ }
+ let j = 1;
+ while (true) {
+ let streamServerJ = $('#stream_server_' + j);
+ if (streamServerJ.length === 0) {
+ if (j < i) {
+ j++
+ } else {
+ break;
+ }
+ continue;
+ }
+ if (streamServerJ.val().length === 0 || $('#stream_key_' + j).val().length === 0) {
+ console.log("ADDITIONAL - " + j);
+ error.html("The stream server and stream key cannot be empty")
+ return;
+ }
+ if (!validURL(streamServerJ.val())) {
+ console.log("STREAM SERVER - " + j);
+ error.html("The stream server must contain \"rtmp://\" or \"rtmps://\" and needs to be a valid url")
+ return;
+ }
+ if (j < i) {
+ j++
+ } else {
+ break;
+ }
+ }
+
+ $.ajax({
+ url: 'save',
+ type: 'post',
+ dataType: 'text',
+ contentType: 'application/x-www-form-urlencoded',
+ data: $('#save_form').serialize(),
+ success: function (data) {
+ if (data.includes("An error has occurred...\n")) {
+ error.html(data)
+ return;
+ }
+ $('#unique_code').html(data);
+ document.getElementById('save_window').hidden = true;
+ document.getElementById('save_window').style.visibility = "hidden";
+ document.getElementById('saved').hidden = false;
+ document.getElementById('saved').style.visibility = "visible";
+ unique = data;
+ },
+ });
+ saveButton.disabled = false;
+ });
+
+ function validURL(str) {
+ let pattern = new RegExp('^(rtmps?:\\/\\/)?' + // protocol
+ '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+ '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+ '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+ '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+ '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+ return !!pattern.test(str);
+ }
+
+{{end}}
diff --git a/server/templates/templates.go b/server/templates/templates.go
index 936a8ed..fa326ed 100644
--- a/server/templates/templates.go
+++ b/server/templates/templates.go
@@ -4,79 +4,70 @@ import (
"embed"
"html/template"
"io"
+ "log"
"time"
)
//go:embed *.tmpl
-var tpls embed.FS
+var tmpls embed.FS
-type (
- Templater struct {
- dashboard *template.Template
- }
- BaseParams struct {
- SystemTime time.Time
- }
- PageParams struct {
- Base BaseParams
- }
-)
+type Templater struct{}
-var funcs = template.FuncMap{
- "cleantime": cleanTime,
-}
+type Template string
-func cleanTime(t time.Time) string {
- return t.Format(time.RFC1123Z)
-}
+const (
+ FacebookHelpTemplate Template = "facebookHelp.tmpl"
+ ListTemplate Template = "list.tmpl"
+ MainTemplate Template = "main.tmpl"
+ RecallTemplate Template = "recall.tmpl"
+ ResumeTemplate Template = "resume.tmpl"
+ SaveTemplate Template = "save.tmpl"
+ YouTubeHelpTemplate Template = "youtubeHelp.tmpl"
+ ErrorTemplate Template = "error.tmpl"
+ NotFound404Template Template = "404NotFound.tmpl"
+)
-func parse(file string) *template.Template {
- return template.Must(
- template.New("base.tmpl").Funcs(funcs).ParseFS(tpls, "base.tmpl", file))
+func (t Template) String() string {
+ return string(t)
}
-func NewMain() *Templater {
- return &Templater{
- dashboard: parse("main.tmpl"),
- }
+func NewTemplate() *Templater {
+ return &Templater{}
}
-func NewList() *Templater {
- return &Templater{
- dashboard: parse("list.tmpl"),
- }
-}
+func (t *Templater) RenderTemplate(w io.Writer, data interface{}, mainTmpl Template) error {
+ var err error
-func NewRecall() *Templater {
- return &Templater{
- dashboard: parse("recall.tmpl"),
- }
-}
+ t1 := template.New("_base.tmpl")
-func NewResume() *Templater {
- return &Templater{
- dashboard: parse("resume.tmpl"),
- }
-}
+ t1.Funcs(t.getFuncMaps())
-func NewSave() *Templater {
- return &Templater{
- dashboard: parse("save.tmpl"),
- }
-}
+ t1, err = t1.ParseFS(tmpls, "_base.tmpl", mainTmpl.String())
-func NewFacebookHelp() *Templater {
- return &Templater{
- dashboard: parse("facebookHelp.tmpl"),
+ if err != nil {
+ log.Printf("failed to get templates for template(RenderTemplate): %+v", err)
+ return err
}
-}
-func NewYouTubeHelp() *Templater {
- return &Templater{
- dashboard: parse("youtubeHelp.tmpl"),
- }
+ return t1.Execute(w, data)
}
-func (t *Templater) Page(w io.Writer, p PageParams) error {
- return t.dashboard.Execute(w, p)
+func (t *Templater) getFuncMaps() template.FuncMap {
+ return template.FuncMap{
+ "thisYear": func() int {
+ return time.Now().Year()
+ },
+ "add": func(a, b int) int {
+ return a + b
+ },
+ "inc": func(a int) int {
+ return a + 1
+ },
+ "dec": func(a int) int {
+ return a - 1
+ },
+ "even": func(a int) bool {
+ return a%2 == 0
+ },
+ }
}
diff --git a/server/templates/youtubeHelp.tmpl b/server/templates/youtubeHelp.tmpl
index eb4bf3c..1cea8e5 100644
--- a/server/templates/youtubeHelp.tmpl
+++ b/server/templates/youtubeHelp.tmpl
@@ -5,25 +5,25 @@
Switch accounts
Once you're on YouTube then you need to switch to the YSTV YouTube account you do this by clicking on your
icon which shows this dropdown menu
-
+
This page will show up once you select "Switch Account", you need to then go to your @york.ac.uk email
address which will have the YSTV YouTube shown
-
+
Schedule livestream
-
When the YSTV acocunt is selected then you will click the icon again but press on "YouTube Studio"
-
+
When the YSTV account is selected then you will click the icon again but press on "YouTube Studio"
+
In the top right-hand corner you'll see the three round buttons under the YSTV logo and Create button, press
on the middle button
-
+
You'll then want to schedule a stream to happen
-
+
You have the choice to reuse the settings from a previous stream or start from scratch
-
+
Getting the stream server and key
After creating the live video then you'll be shown the page with the stream key and server, copy the stream
key and the normal stream server, not the backup server unless you know what you're doing.
-
+
Return
diff --git a/server/views/activeStreamCheck.go b/server/views/activeStreamCheck.go
new file mode 100644
index 0000000..36fd666
--- /dev/null
+++ b/server/views/activeStreamCheck.go
@@ -0,0 +1,50 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "net/http"
+)
+
+// ActiveStreamCheck checks if there are any existing streams still registered in the database
+func (v *Views) ActiveStreamCheck() bool {
+ if v.conf.Verbose {
+ fmt.Println("Active Stream Check called")
+ }
+
+ streams, err := v.store.GetStreams()
+ if err != nil {
+ fmt.Println(err)
+ return false
+ }
+
+ return len(streams) > 0
+}
+
+func (v *Views) ActiveStreamsFunc(c echo.Context) error {
+ streams, err := v.store.GetStreams()
+ if err != nil {
+ return &echo.HTTPError{
+ Code: http.StatusInternalServerError,
+ Message: fmt.Errorf("failed to get active streams: %w", err),
+ Internal: fmt.Errorf("failed to get active streams: %w", err),
+ }
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ return &echo.HTTPError{
+ Code: http.StatusInternalServerError,
+ Message: fmt.Errorf("failed to get stored streams: %w", err),
+ Internal: fmt.Errorf("failed to get stored streams: %w", err),
+ }
+ }
+
+ data := struct {
+ Streams int `json:"streams"`
+ }{
+ Streams: len(streams) + len(stored),
+ }
+
+ return c.JSON(http.StatusOK, data)
+}
diff --git a/server/views/delete.go b/server/views/delete.go
new file mode 100644
index 0000000..47b64b1
--- /dev/null
+++ b/server/views/delete.go
@@ -0,0 +1,31 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "net/http"
+)
+
+// DeleteFunc will delete the saved stream before it can start
+func (v *Views) DeleteFunc(c echo.Context) error {
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Delete POST called")
+ }
+
+ stored, err := v.store.FindStored(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ if stored == nil {
+ fmt.Println("no data in stored")
+ fmt.Println("REJECTED!")
+ return c.String(http.StatusOK, "REJECTED!")
+ }
+
+ fmt.Println("DELETED!")
+ return c.String(http.StatusOK, "DELETED!")
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/endpoints.go b/server/views/endpoints.go
similarity index 60%
rename from server/endpoints.go
rename to server/views/endpoints.go
index c7c3a43..d120d7a 100644
--- a/server/endpoints.go
+++ b/server/views/endpoints.go
@@ -1,16 +1,17 @@
-package main
+package views
import (
"encoding/xml"
"fmt"
"github.com/joho/godotenv"
- "io"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper"
"net/http"
"strings"
)
-// endpoints presents the endpoints to the user
-func (web *Web) endpoints(w http.ResponseWriter, r *http.Request) {
+// EndpointsFunc presents the endpoints to the user
+func (v *Views) EndpointsFunc(c echo.Context) error {
/*if !authenticate(w, r) {
err := godotenv.Load()
if err != nil {
@@ -22,11 +23,11 @@ func (web *Web) endpoints(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, jwtAuthentication, http.StatusTemporaryRedirect)
return
}*/
- if verbose {
+ if v.conf.Verbose {
fmt.Println("Endpoints called")
}
- if r.Method == "POST" {
- if verbose {
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
fmt.Println("Endpoints POST")
}
err := godotenv.Load()
@@ -34,24 +35,10 @@ func (web *Web) endpoints(w http.ResponseWriter, r *http.Request) {
fmt.Printf("error loading .env file: %s", err)
}
- response, err := http.Get(web.cfg.StreamChecker)
+ streamPageContent, err := helper.GetBody("http://" + v.conf.StreamServer + "stat")
if err != nil {
fmt.Println(err)
}
- defer func(Body io.ReadCloser) {
- err := Body.Close()
- if err != nil {
- fmt.Println(err)
- }
- }(response.Body)
-
- buf := new(strings.Builder)
- _, err = io.Copy(buf, response.Body)
- if err != nil {
- fmt.Println(err)
- }
-
- streamPageContent := buf.String()
var rtmp RTMP
@@ -67,9 +54,8 @@ func (web *Web) endpoints(w http.ResponseWriter, r *http.Request) {
}
stringByte := strings.Join(endpoints, "\x20")
- _, err = w.Write([]byte(stringByte))
- if err != nil {
- fmt.Println(err)
- }
+
+ return c.String(http.StatusOK, stringByte)
}
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
}
diff --git a/server/views/errors.go b/server/views/errors.go
new file mode 100644
index 0000000..08d204d
--- /dev/null
+++ b/server/views/errors.go
@@ -0,0 +1,36 @@
+package views
+
+import (
+ "errors"
+ "github.com/ystv/streamer/server/templates"
+
+ "github.com/labstack/echo/v4"
+ "github.com/labstack/gommon/log"
+)
+
+func (v *Views) CustomHTTPErrorHandler(err error, c echo.Context) {
+ log.Print(err)
+ var he *echo.HTTPError
+ var status int
+ if errors.As(err, &he) {
+ status = he.Code
+ } else {
+ status = 500
+ }
+ c.Response().WriteHeader(status)
+ data := struct {
+ Code int
+ Error any
+ }{
+ Code: status,
+ Error: he.Message,
+ }
+ err1 := v.template.RenderTemplate(c.Response().Writer, data, templates.ErrorTemplate)
+ if err1 != nil {
+ log.Printf("failed to render error page: %+v", err1)
+ }
+}
+
+func (v *Views) Error404(c echo.Context) error {
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.NotFound404Template)
+}
diff --git a/server/views/existingStreamCheck.go b/server/views/existingStreamCheck.go
new file mode 100644
index 0000000..b99dfda
--- /dev/null
+++ b/server/views/existingStreamCheck.go
@@ -0,0 +1,26 @@
+package views
+
+import (
+ "fmt"
+)
+
+// ExistingStreamCheck checks if there are any existing streams still registered in the database
+func (v *Views) ExistingStreamCheck() bool {
+ if v.conf.Verbose {
+ fmt.Println("Existing Stream Check called")
+ }
+
+ streams, err := v.store.GetStreams()
+ if err != nil {
+ fmt.Println(err)
+ return false
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ fmt.Println(err)
+ return false
+ }
+
+ return len(streams) > 0 || len(stored) > 0
+}
diff --git a/server/views/facebookHelp.go b/server/views/facebookHelp.go
new file mode 100644
index 0000000..60ed86c
--- /dev/null
+++ b/server/views/facebookHelp.go
@@ -0,0 +1,28 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+)
+
+// FacebookHelpFunc is the handler for the Facebook help page
+func (v *Views) FacebookHelpFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication+"facebookhelp", http.StatusTemporaryRedirect)
+ return
+ }*/
+
+ if v.conf.Verbose {
+ fmt.Println("facebook called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.FacebookHelpTemplate)
+}
diff --git a/server/views/handleTXLight.go b/server/views/handleTXLight.go
new file mode 100644
index 0000000..e53cccb
--- /dev/null
+++ b/server/views/handleTXLight.go
@@ -0,0 +1,43 @@
+package views
+
+import (
+ "fmt"
+ "github.com/ystv/streamer/server/helper/tx"
+ "net/http"
+ "strings"
+)
+
+func (v *Views) HandleTXLight(url string, function tx.FunctionTX) (err error) {
+ switch function {
+ case tx.TransmissionOn:
+ _, err = http.Get(url + tx.TransmissionOn.String())
+ if err != nil && !strings.Contains(err.Error(), "unexpected EOF") {
+ return
+ }
+ return
+ case tx.AllOff:
+ if !v.ExistingStreamCheck() {
+ _, err = http.Get(url + tx.AllOff.String()) // Output is ignored as it returns a 204 status and there's a weird bug with no content
+ if err != nil && !strings.Contains(err.Error(), "unexpected EOF") {
+ return
+ }
+ } else if !v.SavedStreamCheck() {
+ _, err = http.Get(url + tx.RehearsalOn.String())
+ if err != nil && !strings.Contains(err.Error(), "unexpected EOF") {
+ return
+ }
+ }
+ return
+ case tx.RehearsalOn:
+ if !v.ActiveStreamCheck() {
+ _, err = http.Get(url + tx.RehearsalOn.String())
+ if err != nil && !strings.Contains(err.Error(), "unexpected EOF") {
+ return
+ }
+ }
+ return
+ default:
+ err = fmt.Errorf("unexpected function string: \"%s\"", function)
+ return
+ }
+}
diff --git a/server/views/home.go b/server/views/home.go
new file mode 100644
index 0000000..edc9ee8
--- /dev/null
+++ b/server/views/home.go
@@ -0,0 +1,46 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+)
+
+// HomeFunc is the basic html writer that provides the main page for Streamer
+func (v *Views) HomeFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication+"authenticate1", http.StatusTemporaryRedirect)
+ return
+ }*/
+ if v.conf.Verbose {
+ fmt.Println("Home called")
+ }
+
+ _, rec := v.cache.Get("recorder")
+ _, fow := v.cache.Get("forwarder")
+
+ var err error
+
+ if !rec && !fow {
+ err = fmt.Errorf("no recorder or forwarder available")
+ } else if !rec {
+ err = fmt.Errorf("no recorder available")
+ } else if !fow {
+ err = fmt.Errorf("no forwarder available")
+ }
+
+ data := struct {
+ Error error
+ }{
+ Error: err,
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, data, templates.MainTemplate)
+}
diff --git a/server/views/list.go b/server/views/list.go
new file mode 100644
index 0000000..08b94b1
--- /dev/null
+++ b/server/views/list.go
@@ -0,0 +1,69 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+ "net/http"
+ "strings"
+)
+
+// ListFunc lists all current streams that are registered in the database
+func (v *Views) ListFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication+"list", http.StatusTemporaryRedirect)
+ return
+ }*/
+ if c.Request().Method == "GET" {
+ if v.conf.Verbose {
+ fmt.Println("Stop GET called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.ListTemplate)
+ } else if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Stop POST called")
+ }
+
+ streams, err := v.store.GetStreams()
+ if err != nil {
+ return err
+ }
+
+ var streamsSlice []string
+
+ data := false
+
+ for _, s := range streams {
+ data = true
+ streamsSlice = append(streamsSlice, "Active", "-", s.Stream, "-", s.Input)
+ streamsSlice = append(streamsSlice, "
")
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ return err
+ }
+
+ for _, s := range stored {
+ data = true
+ streamsSlice = append(streamsSlice, "Saved", "-", s.Stream, "-", s.Input)
+ streamsSlice = append(streamsSlice, "
")
+ }
+
+ if !data {
+ return c.String(http.StatusOK, "No current streams")
+ } else {
+ stringByte := strings.Join(streamsSlice, "\x20")
+ return c.String(http.StatusOK, stringByte)
+ }
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/recall.go b/server/views/recall.go
new file mode 100644
index 0000000..727e00a
--- /dev/null
+++ b/server/views/recall.go
@@ -0,0 +1,38 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+ "net/http"
+)
+
+// RecallFunc can pull back up stream details from the save function and allows you to start a stored stream
+func (v *Views) RecallFunc(c echo.Context) error {
+ if c.Request().Method == "GET" {
+ if v.conf.Verbose {
+ fmt.Println("Recall GET called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.RecallTemplate)
+ } else if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Recall POST called")
+ }
+
+ stored, err := v.store.FindStored(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ if stored == nil {
+ fmt.Println("No data")
+ fmt.Println("REJECTED!")
+ return c.String(http.StatusOK, "REJECTED!")
+ }
+
+ fmt.Println("ACCEPTED!")
+ return c.String(http.StatusOK, "ACCEPTED!")
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/resume.go b/server/views/resume.go
new file mode 100644
index 0000000..b489871
--- /dev/null
+++ b/server/views/resume.go
@@ -0,0 +1,49 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+ "net/http"
+)
+
+// ResumeFunc is used if the user decides to return at a later date then they can, by inputting the unique code that they were given then they can go to the resume page and enter the code
+func (v *Views) ResumeFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication, http.StatusTemporaryRedirect)
+ return
+ }*/
+ if c.Request().Method == "GET" {
+ if v.conf.Verbose {
+ fmt.Println("Resume GET called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.ResumeTemplate)
+ } else if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Resume POST called")
+ }
+
+ stream, err := v.store.FindStream(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ if stream == nil {
+ fmt.Println("No data")
+ fmt.Println("REJECTED!")
+ return c.String(http.StatusOK, "REJECTED!")
+ }
+
+ fmt.Println("ACCEPTED!")
+ return c.String(http.StatusOK, "ACCEPTED!")
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/save.go b/server/views/save.go
new file mode 100644
index 0000000..7e3158f
--- /dev/null
+++ b/server/views/save.go
@@ -0,0 +1,135 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper/tx"
+ "github.com/ystv/streamer/server/storage"
+ "github.com/ystv/streamer/server/templates"
+ "math"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+// SaveFunc allows for the functionality of saving a stream's details for later in order to make things easier for massive operations where you have multiple streams at once
+func (v *Views) SaveFunc(c echo.Context) error {
+ if c.Request().Method == "GET" {
+ if v.conf.Verbose {
+ fmt.Println("Save GET called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.SaveTemplate)
+ } else if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Save POST called")
+ }
+
+ endpoint := strings.Split(c.FormValue("endpointsTable"), "~")[1]
+
+ largest := 0
+ var numbers []int
+ for s := range c.Request().PostForm {
+ if strings.Contains(s, "stream_server_") {
+ split := strings.Split(s, "_")
+ conv, _ := strconv.ParseInt(split[2], 10, 64)
+ largest = int(math.Max(float64(largest), float64(conv)))
+ numbers = append(numbers, int(conv))
+ }
+ }
+ sort.Ints(numbers)
+
+ var b []byte
+
+ loop := true
+
+ for loop {
+ b = make([]byte, 10)
+ for i := range b {
+ b[i] = charset[seededRand.Intn(len(charset))]
+ }
+
+ streams1, err := v.store.GetStreams()
+ if err != nil {
+ return err
+ }
+
+ if len(streams1) == 0 {
+ break
+ }
+
+ for _, s := range streams1 {
+ if s.Stream == string(b) {
+ loop = true
+ break
+ }
+ loop = false
+ }
+
+ if loop {
+ continue
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ return err
+ }
+
+ if len(stored) == 0 {
+ break
+ }
+
+ for _, s := range stored {
+ if s.Stream == string(b) {
+ loop = true
+ break
+ }
+ loop = false
+ }
+ }
+
+ recording := "§"
+ website := "§"
+
+ if c.FormValue("record") == "on" {
+ recording = c.FormValue("save_path")
+ }
+
+ if c.FormValue("website_stream") == "on" {
+ website = c.FormValue("website_stream_endpoint")
+ }
+
+ var streams []string
+ for _, index := range numbers {
+ server := c.FormValue("stream_server_" + strconv.Itoa(index))
+ server += "|"
+ streams = append(streams, server+c.FormValue("stream_key_"+strconv.Itoa(index)))
+ }
+
+ stored := &storage.Stored{
+ Stream: string(b),
+ Input: endpoint + "/" + c.FormValue("stream_input"),
+ Recording: recording,
+ Website: website,
+ Streams: streams,
+ }
+
+ s, err := v.store.AddStored(stored)
+ if err != nil {
+ return err
+ }
+
+ if s == nil {
+ return fmt.Errorf("failed to add stored, stored is nil")
+ }
+
+ err = v.HandleTXLight(v.conf.TransmissionLight, tx.RehearsalOn)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ return c.String(http.StatusOK, string(b))
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/savedStreamCheck.go b/server/views/savedStreamCheck.go
new file mode 100644
index 0000000..7a69803
--- /dev/null
+++ b/server/views/savedStreamCheck.go
@@ -0,0 +1,20 @@
+package views
+
+import (
+ "fmt"
+)
+
+// SavedStreamCheck checks if there are any existing streams still registered in the database
+func (v *Views) SavedStreamCheck() bool {
+ if v.conf.Verbose {
+ fmt.Println("Saved Stream Check called")
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ fmt.Println(err)
+ return false
+ }
+
+ return len(stored) > 0
+}
diff --git a/server/views/start.go b/server/views/start.go
new file mode 100644
index 0000000..4fe2ac0
--- /dev/null
+++ b/server/views/start.go
@@ -0,0 +1,196 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper/tx"
+ "github.com/ystv/streamer/server/storage"
+ "log"
+ "math"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+// StartFunc is the core of the program, where it takes the values set by the user in the webpage and processes the data and sends it to the recorder and the forwarder
+func (v *Views) StartFunc(c echo.Context) error {
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Start POST called")
+ }
+
+ transporter := Transporter{
+ Action: "start",
+ }
+
+ fStart := ForwarderStart{
+ StreamIn: c.FormValue("stream_selector"),
+ }
+
+ rStart := RecorderStart{
+ StreamIn: c.FormValue("stream_selector"),
+ PathOut: c.FormValue("save_path"),
+ }
+
+ recording := false
+ websiteStream := false
+ if c.FormValue("website_stream") == "on" {
+ websiteStream = true
+ if v.websiteCheck(c.FormValue("website_stream_endpoint")) {
+ fStart.WebsiteOut = c.FormValue("website_stream_endpoint")
+ } else {
+ return fmt.Errorf("website key check has failed")
+ }
+ }
+
+ // This section finds the number of the stream from the form
+ // You can miss values out and some rearranging will have to be done
+ largest := 0
+ var numbers []int
+ for s := range c.Request().PostForm {
+ if strings.Contains(s, "stream_server_") {
+ split := strings.Split(s, "_")
+ conv, _ := strconv.ParseInt(split[2], 10, 64)
+ largest = int(math.Max(float64(largest), float64(conv)))
+ numbers = append(numbers, int(conv))
+ }
+ }
+ sort.Ints(numbers)
+
+ var b []byte
+
+ loop := true
+
+ for loop {
+ b = make([]byte, 10)
+ for i := range b {
+ b[i] = charset[seededRand.Intn(len(charset))]
+ }
+
+ streams1, err := v.store.GetStreams()
+ if err != nil {
+ return err
+ }
+
+ if len(streams1) == 0 {
+ break
+ }
+
+ for _, s := range streams1 {
+ if s.Stream == string(b) {
+ loop = true
+ break
+ }
+ loop = false
+ }
+
+ stored, err := v.store.GetStored()
+ if err != nil {
+ return err
+ }
+
+ if len(stored) == 0 {
+ break
+ }
+
+ for _, s := range stored {
+ if s.Stream == string(b) {
+ loop = true
+ break
+ }
+ loop = false
+ }
+ }
+
+ transporter.Unique = string(b)
+
+ var streams []string
+ for _, index := range numbers {
+ server := c.FormValue("stream_server_" + strconv.Itoa(index))
+ if server[len(server)-1] != '/' {
+ server += "/"
+ }
+ server += c.FormValue("stream_key_" + strconv.Itoa(index))
+ streams = append(streams, server)
+ }
+
+ fStart.Streams = streams
+
+ var wg sync.WaitGroup
+ wg.Add(2)
+ errors := false
+ go func() {
+ defer wg.Done()
+ if c.FormValue("record") == "on" {
+ recording = true
+ recorderTransporter := transporter
+ recorderTransporter.Payload = rStart
+ response, err := v.wsHelper("recorder", recorderTransporter)
+ if err != nil {
+ log.Println(err, "Error sending to Recorder for start")
+ errors = true
+ return
+ }
+ if strings.Contains(response, "ERROR") {
+ log.Printf("Error sending to Recorder for start: %s", response)
+ errors = true
+ return
+ }
+ if !strings.Contains(response, "OKAY") {
+ log.Printf("invalid response from Recorder for start: %s", response)
+ errors = true
+ return
+ }
+ }
+ }()
+ go func() {
+ defer wg.Done()
+ forwarderTransporter := transporter
+ forwarderTransporter.Payload = fStart
+ response, err := v.wsHelper("recorder", forwarderTransporter)
+ if err != nil {
+ log.Println(err, "Error sending to Forwarder for start")
+ errors = true
+ return
+ }
+ if strings.Contains(response, "ERROR") {
+ log.Printf("Error sending to Forwarder for start: %s", response)
+ errors = true
+ return
+ }
+ if !strings.Contains(response, "OKAY") {
+ log.Printf("invalid response from Forwarder for start: %s", response)
+ errors = true
+ return
+ }
+ }()
+ wg.Wait()
+
+ if !errors {
+ err := v.HandleTXLight(v.conf.TransmissionLight, tx.TransmissionOn)
+ if err != nil {
+ log.Println(err)
+ }
+
+ s, err := v.store.AddStream(&storage.Stream{
+ Stream: string(b),
+ Input: c.FormValue("stream_selector"),
+ Recording: recording,
+ Website: websiteStream,
+ Streams: uint64(len(streams)),
+ })
+ if err != nil {
+ return err
+ }
+
+ if s == nil {
+ return fmt.Errorf("failed to add stream, data is empty")
+ }
+
+ return c.String(http.StatusOK, string(b))
+ }
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/startUnique.go b/server/views/startUnique.go
new file mode 100644
index 0000000..4c476c9
--- /dev/null
+++ b/server/views/startUnique.go
@@ -0,0 +1,176 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper"
+ "github.com/ystv/streamer/server/helper/tx"
+ "github.com/ystv/streamer/server/storage"
+ "golang.org/x/crypto/ssh"
+ "math"
+ "net/http"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+// StartUniqueFunc is the core of the program, where it takes the values set by the user in the webpage and processes the data and sends it to the recorder and the forwarder with a specified unique key
+func (v *Views) StartUniqueFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication, http.StatusTemporaryRedirect)
+ return
+ }*/
+ //errors := false
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("StartUnique POST called")
+ }
+
+ unique := c.FormValue("unique_code")
+ if len(unique) != 10 {
+ return fmt.Errorf("unique key invalid")
+ }
+
+ recording := false
+ websiteStream := false
+ var streams uint64
+ var forwarderStart string
+ if c.FormValue("website_stream") == "on" {
+ websiteStream = true
+ if v.websiteCheck(c.FormValue("website_stream_endpoint")) {
+ forwarderStart = "./forwarder_start " + c.FormValue("stream_selector") + " " + c.FormValue("website_stream_endpoint") + " "
+ } else {
+ return fmt.Errorf("eebsite key check has failed")
+ }
+ } else {
+ forwarderStart = "./forwarder_start \"" + c.FormValue("stream_selector") + "\" no "
+ }
+ largest := 0
+ var numbers []int
+ for s := range c.Request().PostForm {
+ if strings.Contains(s, "stream_server_") {
+ split := strings.Split(s, "_")
+ conv, _ := strconv.ParseInt(split[2], 10, 64)
+ largest = int(math.Max(float64(largest), float64(conv)))
+ numbers = append(numbers, int(conv))
+ }
+ }
+ sort.Ints(numbers)
+
+ stored, err := v.store.FindStored(unique)
+ if err != nil {
+ return err
+ }
+
+ if stored == nil {
+ return fmt.Errorf("failed to get stored as data is empty")
+ }
+
+ forwarderStart += unique + " "
+ for _, index := range numbers {
+ server := c.FormValue("stream_server_" + strconv.Itoa(index))
+ if server[len(server)-1] != '/' {
+ server += "/"
+ }
+ forwarderStart += "\"" + server + "\" \"" + c.FormValue("stream_key_"+strconv.Itoa(index)) + "\" "
+ streams++
+ }
+ forwarderStart += "| bash"
+
+ recorderStart := "./recorder_start \"" + c.FormValue("stream_selector") + "\" \"" + c.FormValue("save_path") + "\" " + unique + " | bash"
+
+ var wg sync.WaitGroup
+ wg.Add(2)
+ errors := false
+ go func() {
+ defer wg.Done()
+ if c.FormValue("record") == "on" {
+ recording = true
+ var client *ssh.Client
+ var session *ssh.Session
+ //if recorderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(recorder, recorderUsername, recorderPrivateKey, recorderPassphrase)
+ //} else if recorderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Recorder, v.conf.RecorderUsername, v.conf.RecorderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println(err, "Error connecting to Recorder for start")
+ return
+ }
+ _, err = session.CombinedOutput(recorderStart)
+ if err != nil {
+ fmt.Println(err, "Error executing on Recorder for start")
+ return
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ }
+ }()
+ go func() {
+ defer wg.Done()
+ var client *ssh.Client
+ var session *ssh.Session
+ //if forwarderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(forwarder, forwarderUsername, forwarderPrivateKey, forwarderPassphrase)
+ //} else if forwarderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Forwarder, v.conf.ForwarderUsername, v.conf.ForwarderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println(err, "Error connecting to Forwarder for start")
+ errors = true
+ return
+ }
+ _, err = session.CombinedOutput(forwarderStart)
+ if err != nil {
+ fmt.Println(err, "Error executing on Forwarder for start")
+ errors = true
+ return
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ errors = true
+ return
+ }
+ }()
+ wg.Wait()
+
+ if !errors {
+ err = v.HandleTXLight(v.conf.TransmissionLight, tx.TransmissionOn)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ var s *storage.Stream
+
+ s, err = v.store.AddStream(&storage.Stream{
+ Stream: unique,
+ Input: c.FormValue("stream_selector"),
+ Recording: recording,
+ Website: websiteStream,
+ Streams: streams,
+ })
+ if err != nil {
+ return err
+ }
+
+ if s == nil {
+ return fmt.Errorf("failed to add stream as data is empty")
+ }
+
+ return c.String(http.StatusOK, unique)
+ }
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/status.go b/server/views/status.go
new file mode 100644
index 0000000..64c1c2e
--- /dev/null
+++ b/server/views/status.go
@@ -0,0 +1,142 @@
+package views
+
+import (
+ "encoding/json"
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper"
+ "golang.org/x/crypto/ssh"
+ "net/http"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+// StatusFunc is used to check the status of the streams and does this by tail command of the output logs
+func (v *Views) StatusFunc(c echo.Context) error {
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Status POST called")
+ }
+
+ stream, err := v.store.FindStream(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ m := make(map[string]string)
+ var wg sync.WaitGroup
+ if stream != nil {
+ if stream.Recording {
+ wg.Add(2)
+ go func() {
+ defer wg.Done()
+ var client *ssh.Client
+ var session *ssh.Session
+ var err error
+ //if recorderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(recorder, recorderUsername, recorderPrivateKey, recorderPassphrase)
+ //} else if recorderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Recorder, v.conf.RecorderUsername, v.conf.RecorderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println("Error connecting to Recorder for status")
+ fmt.Println(err)
+ }
+ dataOut, err := session.CombinedOutput("./recorder_status.sh " + c.FormValue("unique"))
+ if err != nil {
+ fmt.Println("Error executing on Recorder for status")
+ fmt.Println(err)
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ dataOut1 := string(dataOut)[:len(dataOut)-2]
+
+ if len(dataOut1) > 0 {
+ if strings.Contains(dataOut1, "frame=") {
+ first := strings.Index(dataOut1, "frame=") - 1
+ last := strings.LastIndex(dataOut1, "\r")
+ dataOut1 = dataOut1[:last]
+ last = strings.LastIndex(dataOut1, "\r") + 1
+ m["recording"] = dataOut1[:first] + "\n" + dataOut1[last:]
+ } else {
+ m["recording"] = dataOut1
+ }
+ }
+
+ fmt.Println("Recorder status success")
+ }()
+ } else {
+ wg.Add(1)
+ }
+ go func() {
+ defer wg.Done()
+ var client *ssh.Client
+ var session *ssh.Session
+ var err error
+ //if forwarderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(forwarder, forwarderUsername, forwarderPrivateKey, forwarderPassphrase)
+ //} else if forwarderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Forwarder, v.conf.ForwarderUsername, v.conf.ForwarderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println("Error connecting to Forwarder for status")
+ fmt.Println(err)
+ }
+ dataOut, err := session.CombinedOutput("./forwarder_status " + strconv.FormatBool(stream.Website) + " " + strconv.FormatUint(stream.Streams, 10) + " " + c.FormValue("unique"))
+ if err != nil {
+ fmt.Println("Error executing on Forwarder for status")
+ fmt.Println(err)
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ dataOut1 := string(dataOut)[4 : len(dataOut)-2]
+
+ dataOut2 := strings.Split(dataOut1, "\u0000")
+
+ for _, dataOut3 := range dataOut2 {
+ if len(dataOut3) > 0 {
+ if strings.Contains(dataOut3, "frame=") {
+ dataOut4 := strings.Split(dataOut3, "~:~")
+ first := strings.Index(dataOut4[1], "frame=") - 1
+ last := strings.LastIndex(dataOut4[1], "\r")
+ dataOut4[1] = dataOut4[1][:last]
+ last = strings.LastIndex(dataOut4[1], "\r") + 1
+ if len(dataOut4) > 1 {
+ m[strings.Trim(dataOut4[0], " ")] = dataOut4[1][:first] + "\n" + dataOut4[1][last:]
+ } else {
+ fmt.Println(dataOut4)
+ m[strings.Trim(dataOut4[0], " ")] = ""
+ }
+ } else {
+ dataOut4 := strings.Split(dataOut3, "~:~")
+ if len(dataOut4) > 1 {
+ m[strings.Trim(dataOut4[0], " ")] = dataOut4[1]
+ } else {
+ fmt.Println(dataOut4)
+ m[strings.Trim(dataOut4[0], " ")] = ""
+ }
+ }
+ }
+ }
+
+ fmt.Println("Forwarder status success")
+ }()
+ wg.Wait()
+ jsonStr, err := json.Marshal(m)
+ if err != nil {
+ return err
+ }
+ output := strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(string(jsonStr[1:len(jsonStr)-1]), "\\n", "
"), "\"", ""), " , ", "
"), " ,", "
"), "
,", "
")
+ return c.String(http.StatusOK, output)
+ }
+ return fmt.Errorf("ERROR DATA STATUS")
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/stop.go b/server/views/stop.go
new file mode 100644
index 0000000..daa1b03
--- /dev/null
+++ b/server/views/stop.go
@@ -0,0 +1,120 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper"
+ "github.com/ystv/streamer/server/helper/tx"
+ "golang.org/x/crypto/ssh"
+ "net/http"
+ "sync"
+)
+
+// StopFunc is used when the stream is finished then you can stop the stream by pressing the stop button and that would kill all the ffmpeg commands
+func (v *Views) StopFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication+"list", http.StatusTemporaryRedirect)
+ return
+ }*/
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Stop POST called")
+ }
+
+ stream, err := v.store.FindStream(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ if stream == nil {
+ return fmt.Errorf("no data in stream stop")
+ }
+
+ var wg sync.WaitGroup
+ _, rec := v.cache.Get("recorder")
+ _, fow := v.cache.Get("forwarder")
+
+ if (!rec && stream.Recording) && !fow {
+ err = fmt.Errorf("no recorder or forwarder available")
+ } else if !rec && stream.Recording {
+ err = fmt.Errorf("no recorder available")
+ } else if !fow {
+ err = fmt.Errorf("no forwarder available")
+ }
+ if stream.Recording {
+ wg.Add(2)
+ go func() {
+ defer wg.Done()
+ var client *ssh.Client
+ var session *ssh.Session
+ //if recorderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(recorder, recorderUsername, recorderPrivateKey, recorderPassphrase)
+ //} else if recorderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Recorder, v.conf.RecorderUsername, v.conf.RecorderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println("Error connecting to Recorder for stop")
+ fmt.Println(err)
+ }
+ _, err = session.CombinedOutput("./recorder_stop " + c.FormValue("unique") + " | bash")
+ if err != nil {
+ fmt.Println("Error executing on Recorder for stop")
+ fmt.Println(err)
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ }
+ }()
+ } else {
+ wg.Add(1)
+ }
+ go func() {
+ defer wg.Done()
+ var client *ssh.Client
+ var session *ssh.Session
+ //if forwarderAuth == "PEM" {
+ // client, session, err = connectToHostPEM(forwarder, forwarderUsername, forwarderPrivateKey, forwarderPassphrase)
+ //} else if forwarderAuth == "PASS" {
+ client, session, err = helper.ConnectToHostPassword(v.conf.Forwarder, v.conf.ForwarderUsername, v.conf.ForwarderPassword, v.conf.Verbose)
+ //}
+ if err != nil {
+ fmt.Println("Error connecting to Forwarder for stop")
+ fmt.Println(err)
+ }
+ _, err = session.CombinedOutput("./forwarder_stop " + c.FormValue("unique") + " | bash")
+ if err != nil {
+ fmt.Println("Error executing on Forwarder for stop")
+ fmt.Println(err)
+ }
+ err = client.Close()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ fmt.Println("Forwarder stop success")
+ }()
+ wg.Wait()
+ fmt.Println("STOPPED!")
+
+ err = v.store.DeleteStream(c.FormValue("unique"))
+ if err != nil {
+ return err
+ }
+
+ err = v.HandleTXLight(v.conf.TransmissionLight, tx.AllOff)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ return c.String(http.StatusOK, "STOPPED!")
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/streams.go b/server/views/streams.go
new file mode 100644
index 0000000..1c9c46e
--- /dev/null
+++ b/server/views/streams.go
@@ -0,0 +1,71 @@
+package views
+
+import (
+ "encoding/xml"
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/helper"
+ "net/http"
+ "strings"
+)
+
+// StreamsFunc collects the data from the rtmp stat page of nginx and produces a list of active streaming endpoints from given endpoints
+func (v *Views) StreamsFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication, http.StatusTemporaryRedirect)
+ return
+ }*/
+ if c.Request().Method == "POST" {
+ if v.conf.Verbose {
+ fmt.Println("Streams POST called")
+ }
+
+ err := c.Request().ParseForm()
+ if err != nil {
+ c.Logger().Error(err)
+ return err
+ }
+
+ streamPageContent, err := helper.GetBody("http://" + v.conf.StreamServer + "stat")
+ if err != nil {
+ c.Logger().Error(err)
+ return err
+ }
+
+ var rtmp RTMP
+
+ err = xml.Unmarshal([]byte(streamPageContent), &rtmp)
+ if err != nil {
+ c.Logger().Error(err)
+ return err
+ }
+
+ var endpoints []string
+
+ for key := range c.Request().Form {
+ endpoint := strings.Split(key, "~")
+ for i := 0; i < len(rtmp.Server.Applications); i++ {
+ if rtmp.Server.Applications[i].Name == endpoint[1] {
+ for j := 0; j < len(rtmp.Server.Applications[i].Live.Streams); j++ {
+ endpoints = append(endpoints, endpoint[1]+"/"+rtmp.Server.Applications[i].Live.Streams[j].Name)
+ }
+ }
+ }
+ }
+
+ if len(endpoints) != 0 {
+ stringByte := strings.Join(endpoints, "\x20")
+ return c.String(http.StatusOK, stringByte)
+ } else {
+ return c.String(http.StatusOK, "No active streams with the current selection")
+ }
+ }
+ return echo.NewHTTPError(http.StatusMethodNotAllowed, "invalid method")
+}
diff --git a/server/views/views.go b/server/views/views.go
new file mode 100644
index 0000000..2fc6980
--- /dev/null
+++ b/server/views/views.go
@@ -0,0 +1,105 @@
+package views
+
+import (
+ "encoding/xml"
+ "github.com/patrickmn/go-cache"
+ "github.com/ystv/streamer/server/store"
+ "github.com/ystv/streamer/server/templates"
+ "math/rand"
+ "time"
+)
+
+type (
+ // Config the global web-auth configuration
+ Config struct {
+ Verbose bool
+ Forwarder string `envconfig:"FORWARDER"`
+ Recorder string `envconfig:"RECORDER"`
+ ForwarderUsername string `envconfig:"FORWARDER_USERNAME"`
+ RecorderUsername string `envconfig:"RECORDER_USERNAME"`
+ ForwarderPassword string `envconfig:"FORWARDER_PASSWORD"`
+ RecorderPassword string `envconfig:"RECORDER_PASSWORD"`
+ StreamServer string `envconfig:"STREAM_SERVER"`
+ TransmissionLight string `envconfig:"TRANSMISSION_LIGHT"`
+ KeyChecker string `envconfig:"KEY_CHECKER"`
+ ServerPort int `envconfig:"SERVER_PORT"`
+ ServerAddress string `envconfig:"SERVER_ADDRESS"`
+ RecordingLocation string `envconfig:"RECORDING_LOCATION"`
+ StreamerWebsocketPath string `envconfig:"STREAMER_WEBSOCKET_PATH"`
+ }
+
+ // Views encapsulates our view dependencies
+ Views struct {
+ cache *cache.Cache
+ conf Config
+ store *store.Store
+ template *templates.Templater
+ }
+
+ RTMP struct {
+ XMLName xml.Name `xml:"rtmp"`
+ Server Server `xml:"server"`
+ }
+
+ Server struct {
+ XMLName xml.Name `xml:"server"`
+ Applications []Application `xml:"application"`
+ }
+
+ Application struct {
+ XMLName xml.Name `xml:"application"`
+ Name string `xml:"name"`
+ Live Live `xml:"live"`
+ }
+
+ Live struct {
+ XMLName xml.Name `xml:"live"`
+ Streams []Stream `xml:"stream"`
+ }
+
+ Stream struct {
+ XMLName xml.Name `xml:"stream"`
+ Name string `xml:"name"`
+ }
+
+ Transporter struct {
+ Action string `json:"action"`
+ Unique string `json:"unique"`
+ Payload interface{} `json:"payload"`
+ }
+
+ ForwarderStart struct {
+ StreamIn string `json:"streamIn"`
+ WebsiteOut string `json:"websiteOut"`
+ Streams []string `json:"streams"`
+ }
+
+ ForwarderStatus struct {
+ Website bool `json:"website"`
+ Streams int `json:"streams"`
+ }
+
+ ForwarderStatusResponse struct {
+ Website string `json:"website"`
+ Streams map[uint64]string `json:"streams"`
+ }
+
+ RecorderStart struct {
+ StreamIn string `json:"streamIn"`
+ PathOut string `json:"pathOut"`
+ }
+)
+
+const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+var seededRand = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// New initialises connections, templates, and cookies
+func New(conf Config, store *store.Store) *Views {
+ return &Views{
+ cache: cache.New(cache.NoExpiration, 1*time.Hour),
+ conf: conf,
+ store: store,
+ template: templates.NewTemplate(),
+ }
+}
diff --git a/server/websiteCheck.go b/server/views/websiteCheck.go
similarity index 73%
rename from server/websiteCheck.go
rename to server/views/websiteCheck.go
index 154df1b..aeb10c7 100644
--- a/server/websiteCheck.go
+++ b/server/views/websiteCheck.go
@@ -1,9 +1,8 @@
-package main
+package views
import (
"fmt"
"io"
- "io/ioutil"
"net/http"
"net/url"
"strconv"
@@ -11,8 +10,8 @@ import (
)
// websiteCheck checks if the website stream key is valid using software called COBRA
-func (web *Web) websiteCheck(endpoint string) bool {
- if verbose {
+func (v *Views) websiteCheck(endpoint string) bool {
+ if v.conf.Verbose {
fmt.Println("Website Check called")
}
@@ -25,7 +24,7 @@ func (web *Web) websiteCheck(endpoint string) bool {
data.Set("pwd", splitting[1])
client := &http.Client{}
- r, err := http.NewRequest("POST", web.cfg.KeyChecker, strings.NewReader(data.Encode()))
+ r, err := http.NewRequest("POST", v.conf.KeyChecker, strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
}
@@ -37,17 +36,14 @@ func (web *Web) websiteCheck(endpoint string) bool {
fmt.Println(err)
}
defer func(Body io.ReadCloser) {
- err := Body.Close()
- if err != nil {
- }
+ _ = Body.Close()
}(res.Body)
- body, err := ioutil.ReadAll(res.Body)
+ body, err := io.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
}
if string(body) == "Accepted" {
return true
- } else {
- return false
}
+ return false
}
diff --git a/server/views/websocket.go b/server/views/websocket.go
new file mode 100644
index 0000000..2d6f224
--- /dev/null
+++ b/server/views/websocket.go
@@ -0,0 +1,113 @@
+package views
+
+import (
+ "fmt"
+ "github.com/gorilla/websocket"
+ "github.com/labstack/echo/v4"
+ "github.com/patrickmn/go-cache"
+ "log"
+ "time"
+)
+
+var wsUpgrade = websocket.Upgrader{}
+
+func (v *Views) Websocket(c echo.Context) error {
+ ws, err := wsUpgrade.Upgrade(c.Response(), c.Request(), nil)
+ if err != nil {
+ return err
+ }
+ defer func(ws *websocket.Conn) {
+ _ = ws.Close()
+ }(ws)
+
+ _, msg, err := ws.ReadMessage()
+ if err != nil {
+ c.Logger().Error(err)
+ _ = ws.Close()
+ return nil
+ }
+
+ name := string(msg)
+
+ log.Println("connecting", name)
+
+ clientChannel := make(chan []byte)
+ internalChannel := make(chan []byte)
+
+ err = v.cache.Add(name, clientChannel, cache.NoExpiration)
+ if err != nil {
+ c.Logger().Error(err)
+ _ = ws.Close()
+ return nil
+ }
+
+ err = v.cache.Add(name+"Internal", internalChannel, cache.NoExpiration)
+ if err != nil {
+ c.Logger().Error(err)
+ _ = ws.Close()
+ return nil
+ }
+
+ err = ws.WriteMessage(websocket.TextMessage, []byte("ACKNOWLEDGED"))
+ if err != nil {
+ c.Logger().Error(err)
+ _ = ws.Close()
+ return nil
+ }
+
+ log.Println("connected", name)
+
+ loop := true
+
+ ticker := time.NewTicker(5 * time.Second)
+ defer func() {
+ ticker.Stop()
+ _ = ws.Close()
+ }()
+
+ for loop {
+ select {
+ case res := <-clientChannel:
+ err = ws.WriteMessage(websocket.TextMessage, res)
+ if err != nil {
+ c.Logger().Error(err)
+ close(internalChannel)
+ close(clientChannel)
+ v.cache.Delete(name)
+ v.cache.Delete(name + "Internal")
+ loop = false
+ }
+
+ _, msg, err = ws.ReadMessage()
+ if err != nil {
+ c.Logger().Error(err)
+ internalChannel <- []byte(fmt.Sprintf("ERROR: failed to read message from %s: %+v", name, err))
+ close(internalChannel)
+ close(clientChannel)
+ v.cache.Delete(name)
+ v.cache.Delete(name + "Internal")
+ loop = false
+ }
+ internalChannel <- msg
+ log.Printf("Message received from \"%s\": %s", name, msg)
+ case <-ticker.C:
+ err = ws.WriteMessage(websocket.TextMessage, []byte("ping"))
+ if err != nil {
+ log.Printf("failed to write ping for %s: %+v", name, err)
+ close(clientChannel)
+ v.cache.Delete(name)
+ v.cache.Delete(name + "Internal")
+ loop = false
+ }
+ msgType, msg, err := ws.ReadMessage()
+ if err != nil || msgType != websocket.TextMessage || string(msg) != "pong" {
+ log.Printf("failed to read pong for %s: %+v", name, err)
+ close(clientChannel)
+ v.cache.Delete(name)
+ v.cache.Delete(name + "Internal")
+ loop = false
+ }
+ }
+ }
+ return nil
+}
diff --git a/server/views/wsHelper.go b/server/views/wsHelper.go
new file mode 100644
index 0000000..735f5ef
--- /dev/null
+++ b/server/views/wsHelper.go
@@ -0,0 +1,29 @@
+package views
+
+import (
+ "encoding/json"
+ "fmt"
+)
+
+func (v *Views) wsHelper(name string, transporter Transporter) (string, error) {
+ out, valid := v.cache.Get(name)
+ if !valid {
+ return "", fmt.Errorf("channel %s is not valid", name)
+ }
+
+ b, err := json.Marshal(transporter)
+ if err != nil {
+ return "", fmt.Errorf("failed marshaling transporter: %w", err)
+ }
+
+ out.(chan []byte) <- b
+
+ in, valid := v.cache.Get(name + "Internal")
+ if !valid {
+ return "", fmt.Errorf("channel %sInternal is not valid", name)
+ }
+
+ received := <-in.(chan []byte)
+
+ return string(received), nil
+}
diff --git a/server/views/youtubeHelp.go b/server/views/youtubeHelp.go
new file mode 100644
index 0000000..e277019
--- /dev/null
+++ b/server/views/youtubeHelp.go
@@ -0,0 +1,28 @@
+package views
+
+import (
+ "fmt"
+ "github.com/labstack/echo/v4"
+ "github.com/ystv/streamer/server/templates"
+)
+
+// YoutubeHelpFunc is the handler for the YouTube help page
+func (v *Views) YoutubeHelpFunc(c echo.Context) error {
+ /*if !authenticate(w, r) {
+ err := godotenv.Load()
+ if err != nil {
+ fmt.Printf("error loading .env file: %s", err)
+ }
+
+ jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
+
+ http.Redirect(w, r, jwtAuthentication+"youtubehelp", http.StatusTemporaryRedirect)
+ return
+ }*/
+
+ if v.conf.Verbose {
+ fmt.Println("YouTube called")
+ }
+
+ return v.template.RenderTemplate(c.Response().Writer, nil, templates.YouTubeHelpTemplate)
+}
diff --git a/server/youtubeHelp.go b/server/youtubeHelp.go
deleted file mode 100644
index 3fb1bc7..0000000
--- a/server/youtubeHelp.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package main
-
-import (
- "fmt"
- "github.com/ystv/streamer/server/templates"
- "net/http"
- "time"
-)
-
-// youtubeHelp is the handler for the YouTube help page
-func (web *Web) youtubeHelp(w http.ResponseWriter, _ *http.Request) {
- /*if !authenticate(w, r) {
- err := godotenv.Load()
- if err != nil {
- fmt.Printf("error loading .env file: %s", err)
- }
-
- jwtAuthentication := os.Getenv("JWT_AUTHENTICATION")
-
- http.Redirect(w, r, jwtAuthentication+"youtubehelp", http.StatusTemporaryRedirect)
- return
- }*/
-
- if verbose {
- fmt.Println("YouTube called")
- }
-
- web.t = templates.NewYouTubeHelp()
-
- params := templates.PageParams{
- Base: templates.BaseParams{
- SystemTime: time.Now(),
- },
- }
-
- err := web.t.Page(w, params)
- if err != nil {
- err = fmt.Errorf("failed to render dashboard: %w", err)
- http.Error(w, err.Error(), http.StatusInternalServerError)
- }
-}