package server import ( // "io" "net" // "errors" "fmt" "math/rand" "os" "path/filepath" "runtime" "time" "github.com/beoran/woe/monolog" "github.com/beoran/woe/world" ) var MSSP map[string]string const STATUS_OK = 0 const STATUS_CANNOT_LISTEN = 1 const STATUS_RESTART = 0 const STATUS_SHUTDOWN = 4 const MAX_CLIENTS = 1000 func init() { MSSP = map[string]string{ "NAME": "Workers Of Eruta", "UPTIME": string(time.Now().Unix()), "PLAYERS": "0", "CRAWL DELAY": "0", "CODEBASE": "WOE", "CONTACT": "beoran@gmail.com", "CREATED": "2015", "ICON": "None", "LANGUAGE": "English", "LOCATION": "USA", "MINIMUM AGE": "18", "WEBSITE": "beoran.net", "FAMILY": "Custom", "GENRE": "Science Fiction", "GAMEPLAY": "Adventure", "STATUS": "Alpha", "GAMESYSTEM": "Custom", "INTERMUD": "", "SUBGENRE": "None", "AREAS": "0", "HELPFILES": "0", "MOBILES": "0", "OBJECTS": "0", "ROOMS": "1", "CLASSES": "0", "LEVELS": "0", "RACES": "3", "SKILLS": "900", "ANSI": "1", "MCCP": "1", "MCP": "0", "MSDP": "0", "MSP": "0", "MXP": "0", "PUEBLO": "0", "UTF-8": "1", "VT100": "1", "XTERM 255 COLORS": "1", "PAY TO PLAY": "0", "PAY FOR PERKS": "0", "HIRING BUILDERS": "0", "HIRING CODERS": "0"} } type Server struct { address string listener net.Listener clients map[int]*Client tickers map[string]*Ticker alive bool World *world.World exitstatus int } type Ticker struct { *time.Ticker Server *Server Name string Milliseconds int callback func(me *Ticker, t time.Time) (stop bool) } const DEFAULT_MOTD_OK = ` ############################### # Workers Of Eruta # ############################### ` const DEFAULT_MOTD = ` Welcome! ` func (me *Server) SetupWorld() (err error) { me.World, err = world.LoadWorld(me.DataPath(), "WOE") if err != nil { monolog.Error("Could not load world WOE: %s", err) return err } if me.World == nil { monolog.Info("Creating new default world...") me.World = world.NewWorld("WOE", DEFAULT_MOTD, me.DataPath()) err := me.World.Save(me.DataPath()) if err != nil { monolog.Error("Could not save world: %v", err) return err } else { monolog.Info("Saved default world.") } } return nil } func NewServer(address string) (server *Server, err error) { listener, err := net.Listen("tcp", address) if err != nil { return nil, err } monolog.Info("Server listening on %s.", address) clients := make(map[int]*Client) tickers := make(map[string]*Ticker) server = &Server{address, listener, clients, tickers, true, nil, STATUS_RESTART} err = server.SetupWorld() if err != nil { monolog.Error("Could not set up or load world!") return nil, err } monolog.Info("Server world set up.") server.AddDefaultTickers() monolog.Info("Tickers set up.") return server, err } func NewTicker(server *Server, name string, milliseconds int, callback func(me *Ticker, t time.Time) bool) *Ticker { ticker := time.NewTicker(time.Millisecond * time.Duration(milliseconds)) return &Ticker{ticker, server, name, milliseconds, callback} } func (me *Ticker) Run() { OUTER: for me.Server.alive { for tick := range me.C { if !me.callback(me, tick) { break OUTER } } } } func (me *Server) RemoveTicker(name string) { ticker, have := me.tickers[name] if !have { return } ticker.Stop() delete(me.tickers, name) } func (me *Server) StopTicker(name string) { ticker, have := me.tickers[name] if !have { return } ticker.Stop() } func (me *Server) AddTicker(name string, milliseconds int, callback func(me *Ticker, t time.Time) bool) *Ticker { _, have := me.tickers[name] if have { me.RemoveTicker(name) } ticker := NewTicker(me, name, milliseconds, callback) me.tickers[name] = ticker go ticker.Run() return ticker } func onWeatherTicker(me *Ticker, t time.Time) bool { me.Server.BroadcastToChannel("weather", "The weather is changing...\n") return true } func (me *Server) AddDefaultTickers() { me.AddTicker("weather", 30000, onWeatherTicker) } func (me *Server) handleDisconnectedClients() { for me.alive { time.Sleep(1) for id, client := range me.clients { if !client.IsAlive() { monolog.Info("Client %d has disconnected.", client.id) client.Close() delete(me.clients, id) } } } } func (me *Server) findFreeID() (id int, err error) { for id = 0; id < MAX_CLIENTS; id++ { client, have := me.clients[id] if (!have) || (client == nil) { return id, nil } } return -1, fmt.Errorf("Too many clients!") } func (me *Server) onConnect(conn net.Conn) (err error) { id, err := me.findFreeID() if err != nil { monolog.Info("Refusing connection for %s: too many clients. ", conn.RemoteAddr().String()) conn.Close() return nil } monolog.Info("New client connected from %s, id %d. ", conn.RemoteAddr().String(), id) client := NewClient(me, id, conn) me.clients[id] = client return client.Serve() } func (me *Server) Shutdown() { monolog.Info("Server is going to shut down.") me.alive = false me.exitstatus = STATUS_SHUTDOWN } func (me *Server) Restart() { monolog.Info("Server is going to restart.") me.alive = false me.exitstatus = STATUS_RESTART } func (me *Server) Close() { monolog.Info("Closing server, shutting down tickers.") for name, _ := range me.tickers { me.RemoveTicker(name) } monolog.Info("Closing server, shutting down clients.") for _, client := range me.clients { if client.IsAlive() { client.Close() } } me.handleDisconnectedClients() monolog.Info("Closed server.") } func (me *Server) Serve() (status int, err error) { // Setup random seed here, or whatever rand.Seed(time.Now().UTC().UnixNano()) go me.handleDisconnectedClients() for me.alive { if tcplistener, ok := me.listener.(*net.TCPListener); ok { tcplistener.SetDeadline(time.Now().Add(5 * time.Second)) } conn, err := me.listener.Accept() if err != nil { if noe, ok := err.(*net.OpError); ok && noe.Timeout() { // it's a timeout. Do nothing, just listen again. // this to allow the alive flag to do it's work. } else { return STATUS_CANNOT_LISTEN, err } } else { go me.onConnect(conn) } runtime.Gosched() } return me.exitstatus, nil } func (me *Server) BroadcastString(message string) { for _, client := range me.clients { if client.IsAlive() { client.WriteString(message) } } } func (me *Server) Broadcast(format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) me.BroadcastString(msg) } func (me *Server) BroadcastStringToChannel(channelname string, message string) { for _, client := range me.clients { if client.IsLoginFinished() && client.IsListeningToChannel(channelname) { client.WriteString(message) } } } func (me *Server) BroadcastToChannel(channelname string, format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) me.BroadcastStringToChannel(channelname, msg) } // Returns the data path of the server func (me *Server) DataPath() string { // cwd, err := os.Getwd() monolog.Debug("Current direcory: %s (%v).", cwd, err) if err != nil { cwd = "." } fp := filepath.Join(cwd, "data", "var") monolog.Debug("Data path: %s (%v). ", fp, err) return fp } // Returns the script path of the server func (me *Server) ScriptPath() string { // cwd, err := os.Getwd() if err != nil { cwd = "." } return filepath.Join(cwd, "data", "script") }