FlightSim-Streaming/Remote-Gameplay
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added barrier escape NAT support

Browse Source
This commit is contained in:
Akilan Selvacoumar
2023-03-01 17:26:14 +00:00
parent c88b4343ce
commit 2d2c083744
2 changed files with 258 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
core/escape-NAT.go
View File

@@ -1,58 +1,62 @@
package core package core
import ( import (
"github.com/Akilan1999/p2p-rendering-computation/p2p/frp" "github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
"time" "time"
) )
// EscapeNAT Func to escape NAT // EscapeNAT Func to escape NAT
// - 1 port for server // - 1 port for server
// - 2 port for barrierKVM // - 2 port for barrierKVM
func EscapeNAT(ScreenSharePort, GameplayServerPort string) (ServerPort string, ScreensharePort string, barrierKVMport string, err error) { func EscapeNAT(ScreenSharePort, GameplayServerPort string) (ServerPort string, ScreensharePort string, err error) {
// Get free port from P2PRC server node // Get free port from P2PRC server node
serverPort, err := frp.GetFRPServerPort("http://64.227.168.102:8088") serverPort, err := frp.GetFRPServerPort("http://64.227.168.102:8088")
if err != nil { if err != nil {
return return
} }
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
// port for the remote gameplay server // port for the remote gameplay server
ServerPort, err = frp.StartFRPClientForServer("64.227.168.102", serverPort, GameplayServerPort) ServerPort, err = frp.StartFRPClientForServer("64.227.168.102", serverPort, GameplayServerPort)
if err != nil { if err != nil {
return return
} }
// Get free port from P2PRC server node // Get free port from P2PRC server node
ScreensharePortFRP, err := frp.GetFRPServerPort("http://64.227.168.102:8088") ScreensharePortFRP, err := frp.GetFRPServerPort("http://64.227.168.102:8088")
if err != nil { if err != nil {
return return
} }
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
// port for the screenshare port // port for the screenshare port
ScreensharePort, err = frp.StartFRPClientForServer("64.227.168.102", ScreensharePortFRP, ScreenSharePort) ScreensharePort, err = frp.StartFRPClientForServer("64.227.168.102", ScreensharePortFRP, ScreenSharePort)
if err != nil { if err != nil {
return return
} }
// Get free port from P2PRC server node return
serverPort, err = frp.GetFRPServerPort("http://64.227.168.102:8088") }
if err != nil { func EscapeNATBarrier() (barrierKVMport string, err error) {
return // Get free port from P2PRC server node
} serverPort, err := frp.GetFRPServerPort("http://64.227.168.102:8088")
time.Sleep(1 * time.Second) if err != nil {
return
//port for the barrierKVM server }
barrierKVMport, err = frp.StartFRPClientForServer("64.227.168.102", serverPort, "24800")
if err != nil { time.Sleep(1 * time.Second)
return
} //port for the barrierKVM server
barrierKVMport, err = frp.StartFRPClientForServer("64.227.168.102", serverPort, "24800")
return if err != nil {
return
}
return
} }

409
main.go
View File

@@ -1,247 +1,264 @@
package main package main
import ( import (
"encoding/json" "encoding/json"
"flag" "flag"
"fmt" "fmt"
"github.com/Akilan1999/remotegameplay/config" "github.com/Akilan1999/remotegameplay/config"
"github.com/Akilan1999/remotegameplay/core" "github.com/Akilan1999/remotegameplay/core"
gameserver "github.com/Akilan1999/remotegameplay/server" gameserver "github.com/Akilan1999/remotegameplay/server"
"log" "log"
"math/rand" "math/rand"
"net/http" "net/http"
"os/exec" "os/exec"
"time" "time"
) )
func main() { func main() {
addr := flag.String("addr", "0.0.0.0", "Listen address") addr := flag.String("addr", "0.0.0.0", "Listen address")
//port := flag.String("port", "8888", "port for running the server") //port := flag.String("port", "8888", "port for running the server")
tls := flag.Bool("tls", false, "Use TLS") barrier := flag.Bool("barrier", false, "set external port barrier")
setconfig := flag.Bool("setconfig", false, "Generates a config file") tls := flag.Bool("tls", false, "Use TLS")
certFile := flag.String("certFile", "files/server.crt", "TLS cert file") setconfig := flag.Bool("setconfig", false, "Generates a config file")
keyFile := flag.String("keyFile", "files/server.key", "TLS key file") certFile := flag.String("certFile", "files/server.crt", "TLS cert file")
headless := flag.Bool("headless", false, "Creating screenshare using headless mode") keyFile := flag.String("keyFile", "files/server.key", "TLS key file")
roomInfo := flag.Bool("roomInfo", false, "Getting room id of headless server") headless := flag.Bool("headless", false, "Creating screenshare using headless mode")
killServer := flag.Bool("killServer", false, "Kills the laplace") roomInfo := flag.Bool("roomInfo", false, "Getting room id of headless server")
killChromium := flag.Bool("killChromium", false, "Kills all chromuim") killServer := flag.Bool("killServer", false, "Kills the laplace")
BinaryToExecute := flag.String("BinaryToExecute", "", "Providing path (i.e Absolute path) of binary to execute") killChromium := flag.Bool("killChromium", false, "Kills all chromuim")
GameServer := flag.Bool("GameServer", false, "Starts the game server by default") BinaryToExecute := flag.String("BinaryToExecute", "", "Providing path (i.e Absolute path) of binary to execute")
Migrate := flag.Bool("Migrate", false, "Sets up the tables for the Sqlite database") GameServer := flag.Bool("GameServer", false, "Starts the game server by default")
BothServers := flag.Bool("BothServers", false, "Starts the Gameserver and screenshare. Also ensures the screenshare can broadcast the availability to the game server") Migrate := flag.Bool("Migrate", false, "Sets up the tables for the Sqlite database")
BothServers := flag.Bool("BothServers", false, "Starts the Gameserver and screenshare. Also ensures the screenshare can broadcast the availability to the game server")
flag.Parse() flag.Parse()
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
server := core.GetHttp() server := core.GetHttp()
if *setconfig { if *setconfig {
err := config.SetDefaults() err := config.SetDefaults()
if err != nil { if err != nil {
return return
} }
return return
} }
// Print out room information Config, err := config.ConfigInit()
if *roomInfo { if err != nil {
room, err := core.ReadRoomsFile() log.Fatalln(err)
if err != nil { }
log.Fatalln(err)
}
PrettyPrint(room) // if barrier flag is provided
return if *barrier {
} natBarrier, err := core.EscapeNATBarrier()
if err != nil {
fmt.Println(err)
return
}
Config.NATEscapeBarrierPort = natBarrier
err = Config.WriteConfig()
if err != nil {
return
}
fmt.Println(Config.IPAddress + ":" + Config.NATEscapeBarrierPort)
return
}
// kills laplace server // Print out room information
if *killServer { if *roomInfo {
cmd := exec.Command("pkill", "remotegameplay") room, err := core.ReadRoomsFile()
if err := cmd.Run(); err != nil { if err != nil {
fmt.Println(err) log.Fatalln(err)
} }
return
}
// kills chromium server
if *killChromium {
cmd := exec.Command("pkill", "chromium")
if err := cmd.Run(); err != nil {
fmt.Println(err)
}
return
}
if *Migrate { PrettyPrint(room)
// Connect to Sqlite return
connect, err := gameserver.Connect() }
if err != nil {
fmt.Println(err)
}
// Migrate table
session, err := gameserver.CreateTables(connect)
if err != nil {
fmt.Println(err)
}
session.Scan(gameserver.GameSession{})
return // kills laplace server
} if *killServer {
cmd := exec.Command("pkill", "remotegameplay")
if err := cmd.Run(); err != nil {
fmt.Println(err)
}
return
}
// kills chromium server
if *killChromium {
cmd := exec.Command("pkill", "chromium")
if err := cmd.Run(); err != nil {
fmt.Println(err)
}
return
}
Config, err := config.ConfigInit() if *Migrate {
if err != nil { // Connect to Sqlite
log.Fatalln(err) connect, err := gameserver.Connect()
} if err != nil {
fmt.Println(err)
}
// Migrate table
session, err := gameserver.CreateTables(connect)
if err != nil {
fmt.Println(err)
}
session.Scan(gameserver.GameSession{})
// running implementation to escape NAT return
GameServerPort, ScreenSharePort, barrireKVM, err := core.EscapeNAT(Config.InternalScreenSharePort, Config.InternalGameServerPort) }
if err != nil {
log.Fatalln(err)
}
Config.IPAddress = "64.227.168.102" // running implementation to escape NAT
Config.NATEscapeGameServerPort = GameServerPort GameServerPort, ScreenSharePort, err := core.EscapeNAT(Config.InternalScreenSharePort, Config.InternalGameServerPort)
Config.NATEscapeScreenSharePort = ScreenSharePort if err != nil {
Config.NATEscapeBarrierPort = barrireKVM log.Fatalln(err)
}
err = Config.WriteConfig() Config.IPAddress = "64.227.168.102"
if err != nil { Config.NATEscapeGameServerPort = GameServerPort
log.Fatalln(err) Config.NATEscapeScreenSharePort = ScreenSharePort
} Config.NATEscapeBarrierPort = ""
// If both server and screenshare have be triggered (first set the according flags to true) err = Config.WriteConfig()
if *BothServers { if err != nil {
*headless = true log.Fatalln(err)
*tls = true }
*GameServer = true
}
if *GameServer { // If both server and screenshare have be triggered (first set the according flags to true)
go gameserver.Server(Config.InternalGameServerPort) if *BothServers {
time.Sleep(2 * time.Second) *headless = true
} *tls = true
*GameServer = true
}
if !*GameServer || *BothServers { if *GameServer {
if *tls { go gameserver.Server(Config.InternalGameServerPort)
log.Println("Listening on TLS:", *addr+":"+Config.InternalScreenSharePort) time.Sleep(2 * time.Second)
go http.ListenAndServeTLS(*addr+":"+Config.InternalScreenSharePort, *certFile, *keyFile, server) }
time.Sleep(2 * time.Second)
} else {
log.Println("Listening:", *addr+":"+Config.InternalScreenSharePort)
go http.ListenAndServe(*addr+":"+Config.InternalScreenSharePort, server)
time.Sleep(2 * time.Second)
}
}
// If both server selected set the remote Gameserver to local now. if !*GameServer || *BothServers {
if *BothServers { if *tls {
Config.BackendURL = "http://" + Config.IPAddress + ":" + Config.NATEscapeGameServerPort + "/" log.Println("Listening on TLS:", *addr+":"+Config.InternalScreenSharePort)
err = Config.WriteConfig() go http.ListenAndServeTLS(*addr+":"+Config.InternalScreenSharePort, *certFile, *keyFile, server)
if err != nil { time.Sleep(2 * time.Second)
fmt.Println(err) } else {
return log.Println("Listening:", *addr+":"+Config.InternalScreenSharePort)
} go http.ListenAndServe(*addr+":"+Config.InternalScreenSharePort, server)
} time.Sleep(2 * time.Second)
}
}
// Running in headless mode // If both server selected set the remote Gameserver to local now.
if *headless { if *BothServers {
// Running starting a browser as a background process Config.BackendURL = "http://" + Config.IPAddress + ":" + Config.NATEscapeGameServerPort + "/"
go func() { err = Config.WriteConfig()
Config, err = config.ConfigInit() if err != nil {
if err != nil { fmt.Println(err)
log.Fatalln(err) return
} }
}
//// Returns the URl address type // Running in headless mode
//Addr := Ip4or6(Config.IPAddress) if *headless {
// // Running starting a browser as a background process
//// If address is provided go func() {
//if *addr != "" { Config, err = config.ConfigInit()
// Addr = *addr if err != nil {
// // Add brackets if the ip address is ipv6 log.Fatalln(err)
// Addr = Ip4or6(Addr) }
//}
var TaskExecute string //// Returns the URl address type
//Addr := Ip4or6(Config.IPAddress)
//
//// If address is provided
//if *addr != "" {
// Addr = *addr
// // Add brackets if the ip address is ipv6
// Addr = Ip4or6(Addr)
//}
if *BinaryToExecute != "" { var TaskExecute string
TaskExecute = *BinaryToExecute
} else {
// Read binary from config file
TaskExecute = Config.ScriptToExecute
}
// Starting screen share headless if *BinaryToExecute != "" {
cmd := exec.Command(Config.BrowserCommand, "--no-sandbox", "--auto-select-desktop-capture-source="+Config.ScreenName, "--url", "https://"+*addr+":"+Config.InternalScreenSharePort+"/?mode=headless", "--ignore-certificate-errors") TaskExecute = *BinaryToExecute
if err := cmd.Start(); err != nil { } else {
log.Fatalln(err) // Read binary from config file
} TaskExecute = Config.ScriptToExecute
}
// Makes program sleep for 2 seconds to allow chromium browser to open // Starting screen share headless
time.Sleep(3 * time.Second) cmd := exec.Command(Config.BrowserCommand, "--no-sandbox", "--auto-select-desktop-capture-source="+Config.ScreenName, "--url", "https://"+*addr+":"+Config.InternalScreenSharePort+"/?mode=headless", "--ignore-certificate-errors")
if err := cmd.Start(); err != nil {
log.Fatalln(err)
}
err = core.BroadcastServerToBackend() // Makes program sleep for 2 seconds to allow chromium browser to open
if err != nil { time.Sleep(3 * time.Second)
fmt.Println(err)
} else {
fmt.Println("success broadcasting to game server")
}
// Task to be executed err = core.BroadcastServerToBackend()
err = RunTask(TaskExecute) if err != nil {
if err != nil { fmt.Println(err)
fmt.Println(err) } else {
return fmt.Println("success broadcasting to game server")
} }
}()
} // Task to be executed
err = RunTask(TaskExecute)
if err != nil {
fmt.Println(err)
return
}
}()
for { }
} for {
// Start P2PRC server }
//_, err = abstractions.Start()
//if err != nil { // Start P2PRC server
// return //_, err = abstractions.Start()
//} //if err != nil {
// return
//}
} }
// PrettyPrint print the contents of the obj ( // PrettyPrint print the contents of the obj (
// Reference: https://stackoverflow.com/questions/24512112/how-to-print-struct-variables-in-console // Reference: https://stackoverflow.com/questions/24512112/how-to-print-struct-variables-in-console
func PrettyPrint(data interface{}) { func PrettyPrint(data interface{}) {
var p []byte var p []byte
// var err := error // var err := error
p, err := json.MarshalIndent(data, "", "\t") p, err := json.MarshalIndent(data, "", "\t")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Printf("%s \n", p) fmt.Printf("%s \n", p)
} }
// Ip4or6 Helper function to check if the IP address is IPV4 or // Ip4or6 Helper function to check if the IP address is IPV4 or
// IPV6 (https://socketloop.com/tutorials/golang-check-if-ip-address-is-version-4-or-6) // IPV6 (https://socketloop.com/tutorials/golang-check-if-ip-address-is-version-4-or-6)
func Ip4or6(s string) string { func Ip4or6(s string) string {
for i := 0; i < len(s); i++ { for i := 0; i < len(s); i++ {
switch s[i] { switch s[i] {
case '.': case '.':
return s return s
case ':': case ':':
return "[" + s + "]" return "[" + s + "]"
} }
} }
return "[" + s + "]" return "[" + s + "]"
} }
func RunTask(task string) error { func RunTask(task string) error {
// Halts the process // Halts the process
cmd := exec.Command("sh", task) cmd := exec.Command("sh", task)
if err := cmd.Start(); err != nil { if err := cmd.Start(); err != nil {
return err return err
} }
return nil return nil
} }