func (c *Command) Execute(message []byte) {
session := c.connection.GetSession()
if session == nil || !session.IsAuth {
return
}
var commandDetector CommandDetector
json.Unmarshal(message, &commandDetector)
user, _ := model_user.Get(session.UserUUID)
if user == nil {
user, _ = model_user.Create()
user.UUID = session.UserUUID
user.Load()
}
user.Update(model2.Fields{
"SectionName": commandDetector.SectionName,
})
}
func main() {
log.SetFlags(log.Llongfile)
expvar.Publish("Goroutines", expvar.Func(goroutines))
runtime.GOMAXPROCS(6)
var err *errors.Error
config, err = readConfig()
if err != nil {
// logger.Error(fmt.Sprintf("readConfig - %v", err))
log.Fatal(err)
// log.Fatal("ListenAndServe: ", err)
os.Exit(0)
}
logger.Init(config.Logger.Path)
if config.Daemonize {
flag.Parse()
daemon.AddCommand(daemon.StringFlag(signal, "quit"), syscall.SIGQUIT, termHandler)
daemon.AddCommand(daemon.StringFlag(signal, "stop"), syscall.SIGTERM, termHandler)
daemon.AddCommand(daemon.StringFlag(signal, "reload"), syscall.SIGHUP, reloadHandler)
cntxt := &daemon.Context{
PidFileName: config.PidFilepath,
PidFilePerm: 0644,
LogFileName: config.Logger.Path + "/stdout.log",
LogFilePerm: 0640,
WorkDir: "./",
Umask: 027,
Args: []string{"[spacecraft-online]"},
}
if len(daemon.ActiveFlags()) > 0 {
d, err := cntxt.Search()
if err != nil {
log.Fatalln("Unable send signal to the daemon:", err)
}
daemon.SendCommands(d)
return
}
d, err := cntxt.Reborn()
if err != nil {
log.Fatalln(err)
}
if d != nil {
return
}
defer cntxt.Release()
}
logger.String(fmt.Sprintf("started"))
cluster := gocql.NewCluster(config.Cassandra.IP)
cluster.Keyspace = "sc_2"
cluster.Consistency = 1
session, berr := cluster.CreateSession()
model_server.Init(session)
ip, t := localIP()
if t != nil {
logger.Error(errors.New(t))
os.Exit(0)
}
server := model_server.New(ip, config.Http.Port)
model.Init(server.UUID, session)
server.StartUpdater()
star.SetLocalServer(server)
bdispatcher := buildings.NewDispatcher(config.Buildings.PoolSize)
model2.InstallModels(session,
server.UUID,
model2_auth_session.InstallInfo,
model2_user.InstallInfo,
model2_live_planet.InstallInfo,
model2_building.InstallInfo,
model2_player.InstallInfo)
var connectionFactory = factory.New()
// clients commands
connectionFactory.InstallCommand("auth", cmd_auth.Generator)
connectionFactory.InstallCommand("logout", cmd_logout.Generator)
connectionFactory.InstallCommand("set_section", cmd_set_section.Generator)
connectionFactory.InstallCommand("start", cmd_start.Generator)
connectionFactory.InstallCommand("get_planet", cmd_get_planet.Generator)
connectionFactory.InstallCommand("get_planet_buildings_for_construct", cmd_get_planet_buildings_for_construct.Generator)
connectionFactory.InstallCommand("build", cmd_build.Generator)
// star commands
connectionFactory.InstallCommand("get_session_lock_state", cmd_session_lock_state.Generator)
connectionFactory.InstallCommand("get_user_lock_state", cmd_user_lock_state.Generator)
connectionFactory.InstallCommand("star_user_logout", cmd_user_logout.Generator)
commandContext := &command.Context{Factory: connectionFactory, CQLSession: session, Config: config, ServerUUID: server.UUID, BDispatcher: bdispatcher}
star.SetCommands(connectionFactory.GetCommands(), commandContext)
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
logger.String("/ws")
if r.Method != "GET" {
http.Error(w, "Method not allowed", 405)
return
}
ws, err := connection.Upgrader.Upgrade(w, r, nil)
if err != nil {
logger.Error(errors.New(err))
return
}
ra := r.RemoteAddr[:strings.Index(r.RemoteAddr, ":")]
c := connectionFactory.CreateConnection(ws, commandContext, ra, r.Header["User-Agent"][0])
// logger.String(ra)
// logger.String(r.Header["User-Agent"][0])
logger.String(fmt.Sprintf("accept connection %v", c.Id))
// go c.Writing()
c.Reading()
c.Close()
logger.String(fmt.Sprintf("close connection %v", c.Id))
})
http.HandleFunc("/debug", func(w http.ResponseWriter, r *http.Request) {
b, err := json.Marshal(connectionFactory.MakeDebugInfo())
if err != nil {
logger.Error(errors.New(err))
}
io.WriteString(w, string(b))
})
http.HandleFunc("/api/auth/success", func(w http.ResponseWriter, r *http.Request) {
logger.String("/api/auth/success")
/*
ra := r.RemoteAddr[:strings.Index(r.RemoteAddr, ":")]
logger.String("remoteAdder " + ra)
logger.String(fmt.Sprintf("%+v", r.Header))
*/
client := &http.Client{}
req, err := http.NewRequest("GET", "http://auth.spacecraft-online.org/api/check_token?token="+r.URL.Query().Get("token"), nil)
if err != nil {
logger.Error(errors.New(err))
return
}
resp, err := client.Do(req)
if err != nil {
logger.Error(errors.New(err))
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logger.Error(errors.New(err))
return
}
if string(body) != "{\"status\":\"ok\",\"result\":true}" {
logger.String(string(body))
http.Redirect(w, r, "/", http.StatusMovedPermanently)
// logger.Error(errors.New(err))
return
}
// logger.String(string(body))
sessionUUID, err := gocql.ParseUUID(r.URL.Query().Get("session_uuid"))
if err != nil {
http.Redirect(w, r, "/", http.StatusMovedPermanently)
return
}
session, err := model2_auth_session.Get(sessionUUID)
if err != nil || session == nil {
http.Redirect(w, r, "/", http.StatusMovedPermanently)
return
}
// session := model_auth_session.LoadOrCreateSession(session_uuid, "", r.Header["User-Agent"][0])
method := r.URL.Query().Get("method")
unique := r.URL.Query().Get("unique")
user, _ := model2_user.GetByMethod(method, unique)
if session.IsAuth {
// check for another user and relogin
if user.Exists && user.UUID.String() != session.UserUUID.String() {
user.AddMethod(method, unique)
} else {
}
} else {
// loging
if !user.Exists {
user, _ = model2_user.Create()
user.Update(model2.Fields{
"Name": r.URL.Query().Get("username"),
})
user.AddMethod(method, unique)
}
}
session.Update(model2.Fields{
"IsAuth": true,
"UserUUID": user.UUID,
"AuthMethod": method,
})
http.Redirect(w, r, "/", http.StatusMovedPermanently)
})
listen := fmt.Sprintf(":%v", config.Http.Port)
logger.String(fmt.Sprintf("listen http %v", listen))
berr = http.ListenAndServe(listen, nil)
if berr != nil {
// logger.Error(fmt.Sprintf("ListenAndServe - %v", err))
logger.Error(errors.New(berr))
// log.Fatal("ListenAndServe: ", err)
os.Exit(0)
}
go worker()
derr := daemon.ServeSignals()
if derr != nil {
log.Println("Error:", derr)
}
// log.Println("daemon terminated")
logger.String(fmt.Sprintf("daemon terminated"))
}
