// ConnectPlayer handles connecting a new player to the game func (s *Server) ConnectPlayer(socket *glue.Socket) { // Logging log15.Debug("socket connected", "address", socket.RemoteAddr()) socket.OnClose(func() { log15.Debug("socket closed", "address", socket.RemoteAddr()) }) // Attempt to allocate free player Slot if slot := s.nextSlot(); slot != -1 { log15.Info("Accepting new player connection", "slot", slot) s.ConnectedPlayers[slot] = &Player{ Server: s, Slot: slot, Socket: socket, } s.ConnectedPlayers[slot].Socket.OnClose(func() { log15.Debug("socket closed", "address", socket.RemoteAddr()) s.DisconnectPlayer(slot) }) s.NumConnectedPlayers++ s.ConnectedPlayers[slot].Socket.Write(msg.SConnected) s.ConnectedPlayers[slot].Socket.Write(msg.SDisplayMessage + ":Press [SPACEBAR] To Spawn!") go s.ConnectedPlayers[slot].ReadLoop() } else { // No free slots available log15.Info("Rejecting new player connection: Server is full!") socket.Write(msg.SGameFull) } }
func main() { log.Info("Initialising ObamaPhony REST API..") log.Info("*** ObamaPhony REST API Version 0.1.0 loaded ***") controllers.Server() }
// initial ConnPool of pgx func (pgdb *PostgresDB) InitConnection() error { //var pool *pgx.ConnPool var err error pgdb.Pool, err = pgx.NewConnPool(pgdb.poolConfig) if err != nil { log.Info("Unable to create connection pool", "error", err) os.Exit(1) } log.Info("database connect sueecss") return nil }
func (pgdb *PostgresDB) RemoveTask(itemNum int32) error { commandTag, err := pgdb.Pool.Exec("deleteTask", itemNum) if commandTag.RowsAffected() != 1 { log.Info("No row found to delete", "error", err) return errors.New("No row found to delete") } return err }
func (t *Timer) runTimer() { log15.Info("Timer started", "number", t.number, "remaining", t.remaining) tt := time.NewTimer(t.remaining) for { select { case <-t.stop: log15.Info("Stopping timer", "number", t.number, "remaining", t.remaining) t.finished = true close(t.C) return case <-t.pause: log15.Info("Pausing timer", "number", t.number, "remaining", t.remaining) t.pausedat = time.Now() t.remaining -= t.pausedat.Sub(t.startedat) tt.Stop() case <-t.resume: t.startedat = time.Now() elapsed := t.startedat.Sub(t.pausedat) if elapsed > t.remaining { log15.Info("Timer completed (b)", "number", t.number, "remaining", t.remaining) t.C <- time.Now().Add(-t.remaining) t.finished = true return } log15.Info("Resuming timer", "number", t.number, "remaining", t.remaining, "elapsed", elapsed) tt = time.NewTimer(t.remaining - elapsed) t.remaining -= elapsed case ttt := <-tt.C: log15.Info("Timer completed", "number", t.number, "remaining", t.remaining) t.C <- ttt t.finished = true return } } }
func main() { log15.Info("Starting Marqit") // debug.InstallCtrlCPanic() Mkt := market1.NewMarket1() Bnk, AKey := bank1.NewBank1() log15.Info("Bank created", "admin", AKey) Mkt.RegisterBank("the bank", Bnk) Mkt.RegisterTrader("t.irrational", irrational.NewIrrational) Mkt.RegisterTrader("t.netplayer", netplayer.NewNetPlayer) Mkt.SetCount(manager.TraderCfg{Type: "t.irrational", Count: 10}, manager.TraderCfg{Type: "t.netplayer", Count: 1}) Mkt.SpawnTraders() NStocks := 2 + rand.Intn(30) log15.Info("Creating stocks", "n", NStocks) for i := 0; i <= NStocks; i++ { symbol := "" sl := 1 + rand.Intn(3) for n := 0; n <= sl; n++ { symbol += string(byte(65 + rand.Intn(26))) } s := exchange.Stock{ Symbol: exchange.Symbol(symbol), Shares: uint(rand.Int31n(100000)), Trading: true, Mode: exchange.M_AUCTION, } log15.Info("Adding", "symbol", s.Symbol, "shares", s.Shares) Mkt.AddStock(s) } for _, v := range Mkt.List() { recip := 2 * (1 + rand.Intn(5)) log15.Info("Spreading initial", "symbol", v.Symbol, "volume", v.Shares, "recipients", recip) NTraders := len(Mkt.Traders()) for i := 0; i <= recip; i++ { act := rand.Intn(NTraders - 1) ba := Mkt.Traders()[act].GetAcct() log15.Info("Initial", "recipient", ba, "count", uint64(int(v.Shares)/recip)) Bnk.SetAsset(ba, v.Symbol, uint64(int(v.Shares)/recip)) } } for k := range Mkt.Traders() { act := Mkt.Traders()[k].GetAcct() amt := float32(rand.Int31n(100000)) log15.Info("Granting funds", "recipient", act, "ammount", amt) Bnk.Transfer(bank.Token{Account: bank.BA_Start, PIN: AKey}, amt, act) } Mkt.Start(10*time.Second, 15*time.Second, 5) }
func startGrpcServer() { addr := localIP() + ":" + *grpcPort log15.Info("starting gRPC echo service", "listen", addr) lis, err := net.Listen("tcp", addr) if err != nil { Log.Crit("failed to listen", "error", err) os.Exit(1) } // Start GRPC server s := grpc.NewServer() echo.RegisterEchoserviceServer(s, &service{}) if err := s.Serve(lis); err != nil { Log.Error("error serving grpc server", "error", err) } }
// ReadLoop receives data from the player client func (p *Player) ReadLoop() { for { // Wait for available data data, err := p.Socket.Read() if err != nil { // return and release this goroutine if the socket was closed if err == glue.ErrSocketClosed { return } log15.Error("read error", "error", err) continue } components := strings.Split(data, ":") switch components[0] { case msg.CRequestState: p.Socket.Write(msg.SNewState + ":" + p.Server.Sim.LatestState) case msg.CSpawn: if !p.neededComponents(components, 2) { break } if p.Bike != nil && p.Bike.GetState() != "dead" { log15.Debug("Player attempted to spawn with existing bike", "bike", p.Bike) break } p.Bike = p.Server.Sim.SpawnGridBike(components[1], components[2]) p.Socket.Write(msg.SDisplayMessage + ":") case msg.CTurn: if !p.neededComponents(components, 1) { break } if p.Bike == nil || p.Bike.GetState() != "move" { log15.Debug("Player attemped to turn without existing bike", "bike", p.Bike) break } dir := components[1] switch dir { case "RIGHT": p.Bike.SetTurn(0) case "DOWN": p.Bike.SetTurn(math.Pi / 2) case "LEFT": p.Bike.SetTurn(math.Pi) case "UP": p.Bike.SetTurn(3 * math.Pi / 2) default: log15.Error("invalid TURN argument", "arg", dir) } // case msg.CBroadcast: // // Echo the received data to all other clients // for i := range gs.ConnectedPlayers { // if gs.ConnectedPlayers[i].Socket.ID() == p.Socket.ID() { // continue // } // gs.ConnectedPlayers[i].Socket.Write(strings.Join(components[1:], ":")) // } default: log15.Info("Returning unknown request to the client", "request", data) p.Socket.Write(data) } } }
func (c *client) GetAllInto(destination interface { Add(interface{}) error Count() int MaxCreatedAt() time.Time MaxUpdatedAt() time.Time }) (err error) { var response ItembaseResponse DocumentsReceived := 0 err = c.api.Call("GET", c.url, c.auth, nil, c.params, &response) if err != nil { return } for _, document := range response.Documents { if destination.Add != nil { err = destination.Add(document) if err != nil { log.Info("Error when adding document", "error", err) } } } log.Debug("Documents", "found", response.NumDocumentsFound) log.Debug("Documents", "returned", response.NumDocumentsReturned) if response.NumDocumentsFound == response.NumDocumentsReturned { log.Debug("same amount of documents that were found as returned") return } else { DocumentsReceived = response.NumDocumentsReturned TotalDocuments := response.NumDocumentsFound log.Debug("expecting to receive", "NumDocumentsFound", response.NumDocumentsFound) for DocumentsReceived < TotalDocuments { log.Debug("expecting", "TotalDocuments", TotalDocuments) if c.max > 0 { log.Debug("Max", "max", c.max) if DocumentsReceived >= c.max { log.Debug("Max is reached", "DocumentsReceived", DocumentsReceived) return } } if _, ok := c.params["created_at_from"]; ok { if c.params["created_at_from"] == destination.MaxCreatedAt().Format(time.RFC3339) { log.Error("created_at_from equals to previous created_at_from - We got a loop?", "created_at_from", c.params["created_at_from"]) return } } c = c.clientWithNewParam("start_at_document", DocumentsReceived) err = c.api.Call("GET", c.url, c.auth, nil, c.params, &response) if err != nil { log.Error("Error when retrieving paginated results", "error", err) } log.Debug("Documents", "found", response.NumDocumentsFound) log.Debug("Documents", "returned", response.NumDocumentsReturned) if len(response.Documents) == 0 { log.Debug("no documents in response", "response.Documents", len(response.Documents)) return } for _, document := range response.Documents { if destination.Add != nil { destination.Add(document) if err != nil { log.Info("Error when adding document", "error", err) } } } if DocumentsReceived == destination.Count() { log.Error("Same amount of documents in destination interface as before. Can happen due to created_at collission during pagination.") return } log.Debug("Documents", "saved", destination.Count()) DocumentsReceived = destination.Count() if len(response.Documents) == 1 { log.Debug("only 1 document in response", "response.Documents", len(response.Documents)) return } } } return }
// DisconnectPlayer handles removing a player from the game func (s *Server) DisconnectPlayer(slot int) { log15.Info("Player disconnected", "address", s.ConnectedPlayers[slot].Socket.RemoteAddr(), "slot", slot) s.NumConnectedPlayers-- delete(s.ConnectedPlayers, slot) }
// Shutdown is called when the server should prepare for program termination func (s *Server) Shutdown() { log15.Info("Server shutting down!") // add shutdown sequence here }