//Genertor to generate a handler that loads a template and applies a Page loaded from json.
func GenJSONServer(root string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, req *http.Request) {
filename := getFilename(req, "index")
logger.Logf(1, "Serving document to %s: %s", req.RemoteAddr, filename)
page, err := jsonLoadPage(root, filename)
p := entity.GetPlayer(1337, "hunter02")
if err == nil {
page.ApplyPageTemplate(p)
template, err := FileGet(root, "/template.html")
if err != nil {
Error(404, root, w, req)
return
}
err = ApplyTemplate(w, page, template)
if err != nil {
Error(404, root, w, req)
return
}
} else {
logger.Logf(2, "Error: %s", err.Error())
Error(404, root, w, req)
}
}
}
func init() {
os.MkdirAll(*dataFolder+"/logs", 0666)
var err error
l, err = logger.NewFileLogger("meta")
if err != nil {
l = logger.NewLoggie("meta", os.Stdout)
logger.Logf(logger.MINOR, "Could not open logfile: %s\n Continuing without logging to file.", err)
}
logger.Logf(0, "l: %v", l)
l.SetLogLevel(logger.GetLogLevel(loglvl))
}
//Writes the slice to all registered connections.
func (net Network) Write(p []byte) (n int, err error) {
for c := range net.conns {
m, e := c.Write(p)
n += m
if e != nil {
logger.Logf(5, "Error: %s", e)
logger.Logf(6, "p: %s", string(p))
go c.Close()
}
}
return
}
// Blocking function that reads JSON objects from the connection and broadcasts them on the network.
func (wsc WSConnection) Reader() {
for {
var data interface{}
err := websocket.JSON.Receive(wsc.connection, &data)
logger.Logf(10, "Data from player: %d", wsc.p.Id)
logger.Logf(10, "%v", data)
wsc.n.world.broadcast <- &data
if err != nil {
logger.Logf(5, "Error on read: %s", err.Error())
break
}
}
go wsc.Close()
}
// Closes the connection and frees system resources connected to it.
func (wsc WSConnection) Close() {
if wsc.online {
wsc.online = false
logger.Logf(5, "Closing connection to: %s", wsc.connection.RemoteAddr())
wsc.connection.Close()
}
}
//Generates a function that serves resources.
//Resources includes anything not html or plain text.
func GenResourceServer(root string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, req *http.Request) {
filename := root + "/" + req.URL.Path[1:]
logger.Logf(2, "Serving resource to %s: %s", req.RemoteAddr, filename)
http.ServeFile(w, req, filename)
}
}
// Goable blocking function that looks for messages on the channel and writes it in JSON format.
func (wsc WSConnection) Writer() {
for message := range wsc.send {
err := websocket.JSON.Send(wsc.connection, message)
if err != nil {
logger.Logf(5, "Error on write: %s", err.Error())
break
}
}
}
/**
* Based on the request, it loads a file into a buffer and returns it.
* If the requested file ends with a / then index.html is appended.
*
*/
func FileGet(root string, filename string) (b []byte, err error) {
buf := bytes.NewBufferString("")
logger.Logf(4, "Opening file: %s", root+filename)
r, err := os.Open(root + filename)
if err == nil {
defer r.Close()
defer func() {
if r := recover(); r != nil {
logger.Logf(1, "Panic while reading file: %s\n", filename)
b = []byte("")
}
}()
buf.ReadFrom(r)
}
b = buf.Bytes()
return
}
func (sys *System) RunPhysics() {
ticker := time.Tick(time.Second)
var dt time.Duration = 0
for t := range ticker {
logger.Logf(logger.INFO, "Time since last physics update: %G ns", dt)
//TODO DO MAGICAL PHYSICS STUFFS ON CHILDREN AND SHIPS.
//WILL SOMEONE PLEASE THINK OF THE CHILDREN!?!?!?!?
dt = time.Since(t)
}
}
//Root server generates a function that serves html content from the root directory and all subdirectories except res/.
//That is the folder dedicated to resources and need special treatment.
//It loads a file from disk and treats it as a template and processes it based on the player object
//it gets from the GetPlayer(...) metod.
func GenRootServer(root string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, req *http.Request) {
filename := getFilename(req, "index.html")
logger.Logf(1, "Serving document to %s: %s", req.RemoteAddr, filename)
b, err := FileGet(root, filename)
if len(b) < 1 || err != nil {
logger.Logf(5, "len(b): %d, err: %s", len(b), err)
Error(404, root, w, req)
return
}
p := entity.GetPlayer(1337, "hunter02")
err = ApplyTemplate(w, p, b)
if err != nil {
logger.Logf(2, "Failed to apply template: %s", err)
Error(404, root, w, req)
return
}
}
}
func setVars(c config.Config) {
root = c["root"]
t, err := strconv.Atoi(c["port"])
if err == nil {
port = t
} else {
logger.Logf(logger.NORMAL, "Error while setting port to %v: %s", t, err.Error())
}
t, err = strconv.Atoi(c["wsport"])
if err == nil {
wsport = t
} else {
logger.Logf(logger.NORMAL, "Error while setting wsport to %v: %s", t, err.Error())
}
t, err = strconv.Atoi(c["loglevel"])
if err == nil {
loglvl = t
} else {
logger.Logf(logger.NORMAL, "Error while setting loglevel to %v: %s", t, err.Error())
}
}
// Echo the data received on the Web Socket.
func GenNewConnectionHandeler(w *structures.World) func(*websocket.Conn) {
logger.Log(5, "WS: Handlerfunction registered for the world!")
return func(ws *websocket.Conn) {
logger.Logf(3, "WS: Connection established from %s!", ws.RemoteAddr().String())
n := getNetwork(w, ws)
p := GetPlayer(ws)
c := structures.NewWSConnection(p, n, ws, make(chan interface{}, 7))
n.Register(c)
defer func() { n.GetDisconnecting() <- c }()
ws.Write(structures.NewAssignMessage(p))
go c.Writer()
c.Reader()
}
}
func (c *CommandLine) ListenAndServe() {
fmt.Println("For help using the commandline, use \"help\".")
reader := bufio.NewReader(os.Stdin)
var line string
var cmd *command
for !c.stop {
c.printPrompt()
line = readLine(reader)
input := strings.Split(line, " ")
cmd = c.ComMap[input[0]]
if cmd != nil {
logger.Logf(1, "Console used command: %s", line)
cmd.function(input[1:])
} else {
c.printHelp()
}
}
fmt.Println("End of the line! All passangers, prepare for landing!")
c.exit <- true
}
//Adds a new connection to the network.
func (net Network) Register(c Connection) {
net.conns[c] = true
logger.Logf(6, "net.conns: %v", net.conns)
}
func Error(code int, root string, w http.ResponseWriter, req *http.Request) {
filename := fmt.Sprintf("%s/%d.html", root, code)
logger.Logf(3, "Serving Error to %s: %s", req.RemoteAddr, filename)
http.ServeFile(w, req, filename)
//w.Write([]byte(E404TEXT))
}
