1. Wprowadzenie
Cloud Spanner to usługa w pełni zarządzanej, skalowalnej w poziomie, globalnie rozproszonej relacyjnej bazy danych, która zapewnia transakcje ACID i semantykę SQL bez utraty wydajności i wysokiej dostępności.
Dzięki tym funkcjom Spanner doskonale sprawdza się w architekturze gier, które chcą obsługiwać graczy z całego świata lub dbają o spójność danych.
W tym laboratorium utworzysz 2 usługi w języku Go, które będą wchodzić w interakcje z regionalną bazą danych Spanner, aby umożliwić graczom zdobywanie przedmiotów i pieniędzy (item-service), a następnie wystawianie przedmiotów na aukcji, aby inni gracze mogli je kupić (tradepost-service).
Ten moduł zależy od modułu Cloud Spanner – wprowadzenie do tworzenia gier, w którym generuje się graczy i gry za pomocą poleceń profile-service i matchmaking-service.
Następnie wygenerujesz dane za pomocą platformy do testowania obciążenia w języku Python Locust.io, aby symulować zdobywanie przez graczy pieniędzy i przedmiotów w trakcie „rozgrywki”. Gracze mogą następnie wystawiać przedmioty na sprzedaż w punkcie handlowym, gdzie inni gracze z odpowiednią ilością pieniędzy mogą je kupić.
Będziesz też wysyłać zapytania do Spannera, aby określić saldo kont graczy i liczbę przedmiotów oraz niektóre statystyki dotyczące otwartych lub zrealizowanych zleceń handlowych.
Na koniec usuniesz zasoby utworzone w tym module.
Co utworzysz
W ramach tego modułu:
- Ponownie użyj instancji Spanner z artykułu Pierwsze kroki z Cloud Spanner w tworzeniu gier.
- Wdróż usługę Item napisaną w Go, która będzie obsługiwać zdobywanie przez graczy przedmiotów i pieniędzy.
- Wdróż usługę Trading Post napisaną w Go, aby symulować wystawianie przedmiotów na sprzedaż przez graczy i kupowanie ich przez innych graczy.
Czego się nauczysz
- Jak używać transakcji odczytu i zapisu, aby zapewnić spójność zmian danych
- Jak modyfikować dane za pomocą DML i mutacji Spanner
Czego potrzebujesz
- Projekt Google Cloud połączony z kontem rozliczeniowym.
- przeglądarka, np. Chrome lub Firefox;
- Ukończony wcześniej samouczek Wprowadzenie do Cloud Spanner w kontekście tworzenia gier bez kroku czyszczenia.
2. Konfiguracja i wymagania
Wykonaj ćwiczenia z programowania w ramach przewodnika Wprowadzenie do Cloud Spanner w kontekście tworzenia gier
Wykonaj ćwiczenie programistyczne Cloud Spanner – pierwsze kroki w tworzeniu gier. Jest to wymagane, aby uzyskać zbiór danych o graczach i meczach. Gracze i gry są potrzebni do zdobywania przedmiotów i pieniędzy, które z kolei służą do wystawiania przedmiotów na sprzedaż i kupowania ich na targu.
Konfigurowanie zmiennych środowiskowych w Cloud Shell
Otwórz Cloud Shell, klikając Aktywuj Cloud Shell 
(uzyskanie dostępu do środowiska i połączenie się z nim powinno zająć tylko kilka chwil, ponieważ zostało to już wcześniej zrobione).
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator PROJECT_ID.
Ustawianie zmiennych środowiskowych SPANNER w Cloud Shell
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
Tworzenie schematu
Teraz, gdy baza danych jest już utworzona, możesz zdefiniować schemat w sample-game.
W tym laboratorium utworzymy 4 nowe tabele: game_items, player_items, player_ledger_entries i trade_orders.
Relacje między elementami odtwarzacza
Relacje dotyczące zamówień handlowych
Produkty w grze są dodawane w game_items tabeli, a następnie mogą być zdobywane przez graczy. Tabela player_items zawiera klucze obce do identyfikatorów itemUUID i playerUUID, aby mieć pewność, że gracze zdobywają tylko prawidłowe przedmioty.
Tabela player_ledger_entries śledzi wszelkie zmiany pieniężne na saldzie konta gracza. Możesz zdobywać pieniądze, zbierając łupy lub sprzedając przedmioty na targu.
Ostatnia tabela, trade_orders, służy do publikowania zleceń sprzedaży i realizowania ich przez kupujących.
Aby utworzyć schemat, kliknij przycisk Write DDL w konsoli Google Cloud:
Wpisz tutaj definicję schematu z pliku schema/trading.sql:
CREATE TABLE game_items
(
itemUUID STRING(36) NOT NULL,
item_name STRING(MAX) NOT NULL,
item_value NUMERIC NOT NULL,
available_time TIMESTAMP NOT NULL,
duration int64
)PRIMARY KEY (itemUUID);
CREATE TABLE player_items
(
playerItemUUID STRING(36) NOT NULL,
playerUUID STRING(36) NOT NULL,
itemUUID STRING(36) NOT NULL,
price NUMERIC NOT NULL,
source STRING(MAX) NOT NULL,
game_session STRING(36) NOT NULL,
acquire_time TIMESTAMP NOT NULL DEFAULT (CURRENT_TIMESTAMP()),
expires_time TIMESTAMP,
visible BOOL NOT NULL DEFAULT(true),
FOREIGN KEY (itemUUID) REFERENCES game_items (itemUUID),
FOREIGN KEY (game_session) REFERENCES games (gameUUID)
) PRIMARY KEY (playerUUID, playerItemUUID),
INTERLEAVE IN PARENT players ON DELETE CASCADE;
CREATE TABLE player_ledger_entries (
playerUUID STRING(36) NOT NULL,
source STRING(MAX) NOT NULL,
game_session STRING(36) NOT NULL,
amount NUMERIC NOT NULL,
entryDate TIMESTAMP NOT NULL OPTIONS (allow_commit_timestamp=true),
FOREIGN KEY (game_session) REFERENCES games (gameUUID)
) PRIMARY KEY (playerUUID, entryDate DESC),
INTERLEAVE IN PARENT players ON DELETE CASCADE;
CREATE TABLE trade_orders
(
orderUUID STRING(36) NOT NULL,
lister STRING(36) NOT NULL,
buyer STRING(36),
playerItemUUID STRING(36) NOT NULL,
trade_type STRING(5) NOT NULL,
list_price NUMERIC NOT NULL,
created TIMESTAMP NOT NULL DEFAULT (CURRENT_TIMESTAMP()),
ended TIMESTAMP,
expires TIMESTAMP NOT NULL DEFAULT (TIMESTAMP_ADD(CURRENT_TIMESTAMP(), interval 24 HOUR)),
active BOOL NOT NULL DEFAULT (true),
cancelled BOOL NOT NULL DEFAULT (false),
filled BOOL NOT NULL DEFAULT (false),
expired BOOL NOT NULL DEFAULT (false),
FOREIGN KEY (playerItemUUID) REFERENCES player_items (playerItemUUID)
) PRIMARY KEY (orderUUID);
CREATE INDEX TradeItem ON trade_orders(playerItemUUID, active);
Kliknij przycisk „Submit”, aby zmodyfikować schemat, i poczekaj na zakończenie aktualizacji schematu:
Następny
Następnie wdrożysz usługę produktu.
3. Wdróż usługę dotyczącą produktu
Omówienie usługi
Usługa elementów to interfejs REST API napisany w Go, który korzysta z platformy Gin. W tym interfejsie API gracze biorący udział w otwartych grach zdobywają pieniądze i przedmioty.
Plik ./src/golang/item-service/main.go konfiguruje te punkty końcowe do pracy z elementami gry i graczami, którzy je zdobywają. Dodatkowo istnieje punkt końcowy, w którym gracze mogą zdobywać pieniądze.
func main() {
configuration, _ := config.NewConfig()
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection(configuration))
router.GET("/items", getItemUUIDs)
router.POST("/items", createItem)
router.GET("/items/:id", getItem)
router.PUT("/players/balance", updatePlayerBalance)
router.GET("/players", getPlayer)
router.POST("/players/items", addPlayerItem)
router.Run(configuration.Server.URL())
}
Konfigurowanie i używanie połączeń Spanner odbywa się dokładnie tak samo jak w przypadku usług profile-service i matchmaking-service z poprzedniego ćwiczenia.
Usługa elementów współpracuje z GameItem, Player, PlayerLedger i PlayerItem zgodnie z tymi definicjami:
// models/game_items.go
type GameItem struct {
ItemUUID string `json:"itemUUID"`
Item_name string `json:"item_name"`
Item_value big.Rat `json:"item_value"`
Available_time time.Time `json:"available_time"`
Duration int64 `json:"duration"`
}
// models/players.go
type Player struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Updated time.Time `json:"updated"`
Account_balance big.Rat `json:"account_balance"`
Current_game string `json:"current_game"`
}
type PlayerLedger struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Amount big.Rat `json:"amount"`
Game_session string `json:"game_session"`
Source string `json:"source"`
}
// models/player_items.go
type PlayerItem struct {
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
ItemUUID string `json:"itemUUID" binding:"required,uuid4"`
Source string `json:"source" binding:"required"`
Game_session string `json:"game_session" binding:"omitempty,uuid4"`
Price big.Rat `json:"price"`
AcquireTime time.Time `json:"acquire_time"`
ExpiresTime spanner.NullTime `json:"expires_time"`
Visible bool `json:"visible"`
}
Najpierw w grze musi być utworzonych kilka produktów. W tym celu wywoływane jest żądanie POST do punktu końcowego /items. Jest to bardzo proste polecenie DML wstawiające dane do tabeli game_items.
// main.go
func createItem(c *gin.Context) {
var item models.GameItem
if err := c.BindJSON(&item); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := item.Create(ctx, client)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.IndentedJSON(http.StatusCreated, item.ItemUUID)
}
// models/game_items.go
func (i *GameItem) Create(ctx context.Context, client spanner.Client) error {
// Initialize item values
i.ItemUUID = generateUUID()
if i.Available_time.IsZero() {
i.Available_time = time.Now()
}
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
stmt := spanner.Statement{
SQL: `INSERT game_items (itemUUID, item_name, item_value, available_time, duration)
VALUES (@itemUUID, @itemName, @itemValue, @availableTime, @duration)
`,
Params: map[string]interface{}{
"itemUUID": i.ItemUUID,
"itemName": i.Item_name,
"itemValue": i.Item_value,
"availableTime": i.Available_time,
"duration": i.Duration,
},
}
_, err := txn.Update(ctx, stmt)
return err
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Aby zdobyć element, wywołaj żądanie POST do punktu końcowego /players/items. Logika tego punktu końcowego polega na pobraniu bieżącej wartości elementu gry i bieżącej sesji gry gracza. Następnie wstaw odpowiednie informacje do tabeli player_items, wskazując źródło i czas pozyskania produktu.
Odpowiada to tym funkcjom:
// main.go
func addPlayerItem(c *gin.Context) {
var playerItem models.PlayerItem
if err := c.BindJSON(&playerItem); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := playerItem.Add(ctx, client)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.IndentedJSON(http.StatusCreated, playerItem)
}
// models/player_items.go
func (pi *PlayerItem) Add(ctx context.Context, client spanner.Client) error {
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Get item price at time of transaction
price, err := GetItemPrice(ctx, txn, pi.ItemUUID)
if err != nil {
return err
}
pi.Price = price
// Get Game session
session, err := GetPlayerSession(ctx, txn, pi.PlayerUUID)
if err != nil {
return err
}
pi.Game_session = session
pi.PlayerItemUUID = generateUUID()
// Insert
cols := []string{"playerItemUUID", "playerUUID", "itemUUID", "price", "source", "game_session"}
txn.BufferWrite([]*spanner.Mutation{
spanner.Insert("player_items", cols,
[]interface{}{pi.PlayerItemUUID, pi.PlayerUUID, pi.ItemUUID, pi.Price, pi.Source, pi.Game_session}),
})
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Aby gracz mógł zdobyć pieniądze, wywoływane jest żądanie PUT do punktu końcowego /players/updatebalance.
Logika tego punktu końcowego polega na zaktualizowaniu salda gracza po zastosowaniu kwoty, a także na zaktualizowaniu tabeli player_ledger_entries o rekord dotyczący pozyskania. Wartość account_balance gracza jest modyfikowana i zwracana do wywołującego. DML służy do modyfikowania zarówno graczy, jak i wpisów w księdze graczy.
Odpowiada to tym funkcjom:
// main.go
func updatePlayerBalance(c *gin.Context) {
var player models.Player
var ledger models.PlayerLedger
if err := c.BindJSON(&ledger); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
ctx, client := getSpannerConnection(c)
err := ledger.UpdateBalance(ctx, client, &player)
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
type PlayerBalance struct {
PlayerUUID, AccountBalance string
}
balance := PlayerBalance{PlayerUUID: player.PlayerUUID, AccountBalance: player.Account_balance.FloatString(2)}
c.IndentedJSON(http.StatusOK, balance)
}
// models/players.go
func (l *PlayerLedger) UpdateBalance(ctx context.Context, client spanner.Client, p *Player) error {
// Update balance with new amount
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
p.PlayerUUID = l.PlayerUUID
stmt := spanner.Statement{
SQL: `UPDATE players SET account_balance = (account_balance + @amount) WHERE playerUUID = @playerUUID`,
Params: map[string]interface{}{
"amount": l.Amount,
"playerUUID": p.PlayerUUID,
},
}
numRows, err := txn.Update(ctx, stmt)
if err != nil {
return err
}
// No rows modified. That's an error
if numRows == 0 {
errorMsg := fmt.Sprintf("Account balance for player '%s' could not be updated", p.PlayerUUID)
return errors.New(errorMsg)
}
// Get player's new balance (read after write)
stmt = spanner.Statement{
SQL: `SELECT account_balance, current_game FROM players WHERE playerUUID = @playerUUID`,
Params: map[string]interface{}{
"playerUUID": p.PlayerUUID,
},
}
iter := txn.Query(ctx, stmt)
defer iter.Stop()
for {
row, err := iter.Next()
if err == iterator.Done {
break
}
if err != nil {
return err
}
var accountBalance big.Rat
var gameSession string
if err := row.Columns(&accountBalance, &gameSession); err != nil {
return err
}
p.Account_balance = accountBalance
l.Game_session = gameSession
}
stmt = spanner.Statement{
SQL: `INSERT INTO player_ledger_entries (playerUUID, amount, game_session, source, entryDate)
VALUES (@playerUUID, @amount, @game, @source, PENDING_COMMIT_TIMESTAMP())`,
Params: map[string]interface{}{
"playerUUID": l.PlayerUUID,
"amount": l.Amount,
"game": l.Game_session,
"source": l.Source,
},
}
numRows, err = txn.Update(ctx, stmt)
if err != nil {
return err
}
return nil
})
if err != nil {
return err
}
return nil
}
Domyślnie usługa jest konfigurowana za pomocą zmiennych środowiskowych. Zobacz odpowiednią sekcję pliku ./src/golang/item-service/config/config.go.
func NewConfig() (Config, error) {
*snip*
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8082)
// Bind environment variable override
viper.BindEnv("server.host", "SERVICE_HOST")
viper.BindEnv("server.port", "SERVICE_PORT")
viper.BindEnv("spanner.project_id", "SPANNER_PROJECT_ID")
viper.BindEnv("spanner.instance_id", "SPANNER_INSTANCE_ID")
viper.BindEnv("spanner.database_id", "SPANNER_DATABASE_ID")
*snip*
return c, nil
}
Widzisz, że domyślnie usługa jest uruchamiana na localhost:8082.
Mając te informacje, możesz uruchomić usługę.
Uruchamianie usługi
Uruchomienie usługi spowoduje pobranie zależności i uruchomienie usługi na porcie 8082:
cd ~/spanner-gaming-sample/src/golang/item-service
go run . &
Wynik polecenia:
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: gin.SetMode(gin.ReleaseMode)
[GIN-debug] GET /items --> main.getItemUUIDs (4 handlers)
[GIN-debug] POST /items --> main.createItem (4 handlers)
[GIN-debug] GET /items/:id --> main.getItem (4 handlers)
[GIN-debug] PUT /players/balance --> main.updatePlayerBalance (4 handlers)
[GIN-debug] GET /players --> main.getPlayer (4 handlers)
[GIN-debug] POST /players/items --> main.addPlayerItem (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8082
Przetestuj usługę, wydając polecenie curl, aby utworzyć element:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
Wynik polecenia:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"aecde380-0a79-48c0-ab5d-0da675d3412c"
Następnie chcesz, aby gracz zdobył ten produkt. Aby to zrobić, potrzebujesz ItemUUID i PlayerUUID. ItemUUID to dane wyjściowe poprzedniego polecenia. W tym przykładzie jest to: aecde380-0a79-48c0-ab5d-0da675d3412c.
Aby uzyskać identyfikator PlayerUUID, wywołaj punkt końcowy GET /players:
curl http://localhost:8082/players
Wynik polecenia:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
Aby gracz mógł zdobyć element, wyślij żądanie do punktu końcowego POST /players/items:
curl http://localhost:8082/players/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352","itemUUID": "109ec745-9906-402b-9d03-ca7153a10312", "source": "loot"}'
Wynik polecenia:
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 369
{
"playerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"itemUUID": "109ec745-9906-402b-9d03-ca7153a10312",
"source": "loot",
"game_session": "7b97fa85-5658-4ded-a962-4c09269a0a79",
"price": {},
"acquire_time": "0001-01-01T00:00:00Z",
"expires_time": null,
"visible": false
}
Podsumowanie
W tym kroku wdrożysz usługę dotyczącą produktów, która umożliwia tworzenie produktów w grze, a graczom przypisanym do otwartych gier – zdobywanie pieniędzy i produktów w grze.
Następne kroki
W następnym kroku wdrożysz usługę punktu handlowego.
4. Wdróż usługę punktu handlowego
Omówienie usługi
Usługa tradepost to interfejs REST API napisany w Go, który korzysta z platformy gin. W tym interfejsie API produkty gracza są publikowane w celu sprzedaży. Gracze mogą wtedy uzyskać dostęp do otwartych transakcji i jeśli mają wystarczająco dużo pieniędzy, mogą kupić produkt.
Plik ./src/golang/tradepost-service/main.go usługi tradepost ma podobną konfigurację i kod jak inne usługi, więc nie jest tu powtarzany. Ta usługa udostępnia kilka punktów końcowych:
func main() {
configuration, _ := config.NewConfig()
router := gin.Default()
router.SetTrustedProxies(nil)
router.Use(setSpannerConnection(configuration))
router.GET("/trades/player_items", getPlayerItem)
router.POST("/trades/sell", createOrder)
router.GET("/trades/open", getOpenOrder)
router.PUT("/trades/buy", purchaseOrder)
router.Run(configuration.Server.URL())
}
Ta usługa udostępnia strukturę TradeOrder oraz wymagane struktury GameItem, PlayerItem, Player i PlayerLedger:
type TradeOrder struct {
OrderUUID string `json:"orderUUID" binding:"omitempty,uuid4"`
Lister string `json:"lister" binding:"omitempty,uuid4"`
Buyer string `json:"buyer" binding:"omitempty,uuid4"`
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
TradeType string `json:"trade_type"`
ListPrice big.Rat `json:"list_price" spanner:"list_price"`
Created time.Time `json:"created"`
Ended spanner.NullTime `json:"ended"`
Expires time.Time `json:"expires"`
Active bool `json:"active"`
Cancelled bool `json:"cancelled"`
Filled bool `json:"filled"`
Expired bool `json:"expired"`
}
type GameItem struct {
ItemUUID string `json:"itemUUID"`
ItemName string `json:"item_name"`
ItemValue big.Rat `json:"item_value"`
AvailableTime time.Time `json:"available_time"`
Duration int64 `json:"duration"`
}
type PlayerItem struct {
PlayerItemUUID string `json:"playerItemUUID" binding:"omitempty,uuid4"`
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
ItemUUID string `json:"itemUUID" binding:"required,uuid4"`
Source string `json:"source"`
GameSession string `json:"game_session" binding:"omitempty,uuid4"`
Price big.Rat `json:"price"`
AcquireTime time.Time `json:"acquire_time" spanner:"acquire_time"`
ExpiresTime spanner.NullTime `json:"expires_time" spanner:"expires_time"`
Visible bool `json:"visible"`
}
type Player struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Updated time.Time `json:"updated"`
AccountBalance big.Rat `json:"account_balance" spanner:"account_balance"`
CurrentGame string `json:"current_game" binding:"omitempty,uuid4" spanner:"current_game"`
}
type PlayerLedger struct {
PlayerUUID string `json:"playerUUID" binding:"required,uuid4"`
Amount big.Rat `json:"amount"`
GameSession string `json:"game_session" spanner:"game_session"`
Source string `json:"source"`
}
Aby utworzyć zlecenie handlowe, wyślij żądanie POST do punktu końcowego interfejsu API /trades/sell. Wymagane informacje to playerItemUUID sprzedawanego elementu gracza, lister i list_price.
Mutacje Spannera są wybierane w celu utworzenia zlecenia handlowego i oznaczenia elementu player_item jako niewidocznego. Zapobiega to publikowaniu przez sprzedawcę duplikatów produktów na sprzedaż.
func (o *TradeOrder) Create(ctx context.Context, client spanner.Client) error {
// insert into spanner
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// get the Item to be listed
pi, err := GetPlayerItem(ctx, txn, o.Lister, o.PlayerItemUUID)
if err != nil {
return err
}
// Set expires to 1 day by default
if o.Expires.IsZero() {
currentTime := time.Now()
o.Expires = currentTime.Add(time.Hour * 24)
}
// Item is not visible or expired, so it can't be listed. That's an error
if !validateSellOrder(pi) {
errorMsg := fmt.Sprintf("Item (%s, %s) cannot be listed.", o.Lister, o.PlayerItemUUID)
return errors.New(errorMsg)
}
// Initialize order values
o.OrderUUID = generateUUID()
o.Active = true // TODO: Have to set this by default since testing with emulator does not support 'DEFAULT' schema option
// Insert the order
var m []*spanner.Mutation
cols := []string{"orderUUID", "playerItemUUID", "lister", "list_price", "trade_type", "expires", "active"}
m = append(m, spanner.Insert("trade_orders", cols, []interface{}{o.OrderUUID, o.PlayerItemUUID, o.Lister, o.ListPrice, "sell", o.Expires, o.Active}))
// Mark the item as invisible
cols = []string{"playerUUID", "playerItemUUID", "visible"}
m = append(m, spanner.Update("player_items", cols, []interface{}{o.Lister, o.PlayerItemUUID, false}))
txn.BufferWrite(m)
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Przed utworzeniem zamówienia element PlayerItem jest weryfikowany, aby upewnić się, że można go wystawić na sprzedaż. Oznacza to przede wszystkim, że element PlayerItem jest widoczny dla odtwarzacza i nie wygasł.
// Validate that the order can be placed: Item is visible and not expired
func validateSellOrder(pi PlayerItem) bool {
// Item is not visible, can't be listed
if !pi.Visible {
return false
}
// item is expired. can't be listed
if !pi.ExpiresTime.IsNull() && pi.ExpiresTime.Time.Before(time.Now()) {
return false
}
// All validation passed. Item can be listed
return true
}
Zakupu dokonuje się za pomocą żądania PUT do punktu końcowego /trades/buy. Wymagane informacje to orderUUID i buyer, czyli identyfikator UUID gracza dokonującego zakupu.
Ze względu na złożoność i liczbę zmian do zakupu zamówienia ponownie wybrano mutacje. Poniższe operacje są wykonywane w ramach jednej transakcji zapisu i odczytu:
- Sprawdź, czy zamówienie może zostać zrealizowane, ponieważ nie zostało jeszcze zrealizowane i nie wygasło.
// Validate that the order can be filled: Order is active and not expired
func validatePurchase(o TradeOrder) bool {
// Order is not active
if !o.Active {
return false
}
// order is expired. can't be filled
if !o.Expires.IsZero() && o.Expires.Before(time.Now()) {
return false
}
// All validation passed. Order can be filled
return true
}
- Pobierz informacje o kupującym i sprawdź, czy może on kupić produkt. Oznacza to, że kupujący nie może być tą samą osobą co sprzedający i musi mieć wystarczającą ilość środków.
// Validate that a buyer can buy this item.
func validateBuyer(b Player, o TradeOrder) bool {
// Lister can't be the same as buyer
if b.PlayerUUID == o.Lister {
return false
}
// Big.rat returns -1 if Account_balance is less than price
if b.AccountBalance.Cmp(&o.ListPrice) == -1 {
return false
}
return true
}
- Dodaj wartość list_price zamówienia do salda konta sprzedawcy, tworząc odpowiedni wpis w księdze.
// models/trade_order.go
// Buy an order
func (o *TradeOrder) Buy(ctx context.Context, client spanner.Client) error {
*snip*
// Update seller's account balance
lister.UpdateBalance(ctx, txn, o.ListPrice)
*snip*
}
// models/players.go
// Update a player's balance, and add an entry into the player ledger
func (p *Player) UpdateBalance(ctx context.Context, txn *spanner.ReadWriteTransaction, newAmount big.Rat) error {
// This modifies player's AccountBalance, which is used to update the player entry
p.AccountBalance.Add(&p.AccountBalance, &newAmount)
txn.BufferWrite([]*spanner.Mutation{
spanner.Update("players", []string{"playerUUID", "account_balance"}, []interface{}{p.PlayerUUID, p.AccountBalance}),
spanner.Insert("player_ledger_entries", []string{"playerUUID", "amount", "game_session", "source", "entryDate"},
[]interface{}{p.PlayerUUID, newAmount, p.CurrentGame, "tradepost", spanner.CommitTimestamp}),
})
return nil
}
- Odjąć od salda konta kupującego wartość list_price zamówienia, tworząc odpowiedni wpis w księdze.
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- Przenieś element gracza do nowego gracza, wstawiając nową instancję elementu gry ze szczegółami gry i kupującego do tabeli PlayerItems, i usuń instancję elementu sprzedawcy.
// models/player_items.go
// Move an item to a new player, removes the item entry from the old player
func (pi *PlayerItem) MoveItem(ctx context.Context, txn *spanner.ReadWriteTransaction, toPlayer string) error {
fmt.Printf("Buyer: %s", toPlayer)
txn.BufferWrite([]*spanner.Mutation{
spanner.Insert("player_items", []string{"playerItemUUID", "playerUUID", "itemUUID", "price", "source", "game_session"},
[]interface{}{pi.PlayerItemUUID, toPlayer, pi.ItemUUID, pi.Price, pi.Source, pi.GameSession}),
spanner.Delete("player_items", spanner.Key{pi.PlayerUUID, pi.PlayerItemUUID}),
})
return nil
}
- Aktualizuje wpis Zamówienia, aby wskazać, że produkt został zrealizowany i nie jest już aktywny.
Funkcja Buy wygląda tak:
// Buy an order
func (o *TradeOrder) Buy(ctx context.Context, client spanner.Client) error {
// Fulfil the order
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Get Order information
err := o.getOrderDetails(ctx, txn)
if err != nil {
return err
}
// Validate order can be filled
if !validatePurchase(*o) {
errorMsg := fmt.Sprintf("Order (%s) cannot be filled.", o.OrderUUID)
return errors.New(errorMsg)
}
// Validate buyer has the money
buyer := Player{PlayerUUID: o.Buyer}
err = buyer.GetBalance(ctx, txn)
if err != nil {
return err
}
if !validateBuyer(buyer, *o) {
errorMsg := fmt.Sprintf("Buyer (%s) cannot purchase order (%s).", buyer.PlayerUUID, o.OrderUUID)
return errors.New(errorMsg)
}
// Move money from buyer to seller (which includes ledger entries)
var m []*spanner.Mutation
lister := Player{PlayerUUID: o.Lister}
err = lister.GetBalance(ctx, txn)
if err != nil {
return err
}
// Update seller's account balance
lister.UpdateBalance(ctx, txn, o.ListPrice)
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
// Move item from seller to buyer, mark item as visible.
pi, err := GetPlayerItem(ctx, txn, o.Lister, o.PlayerItemUUID)
if err != nil {
return err
}
pi.GameSession = buyer.CurrentGame
// Moves the item from lister (current pi.PlayerUUID) to buyer
pi.MoveItem(ctx, txn, o.Buyer)
// Update order information
cols := []string{"orderUUID", "active", "filled", "buyer", "ended"}
m = append(m, spanner.Update("trade_orders", cols, []interface{}{o.OrderUUID, false, true, o.Buyer, time.Now()}))
txn.BufferWrite(m)
return nil
})
if err != nil {
return err
}
// return empty error on success
return nil
}
Domyślnie usługa jest konfigurowana za pomocą zmiennych środowiskowych. Zapoznaj się z odpowiednią sekcją pliku ./src/golang/tradepost-service/config/config.go.
func NewConfig() (Config, error) {
*snip*
// Server defaults
viper.SetDefault("server.host", "localhost")
viper.SetDefault("server.port", 8083)
// Bind environment variable override
viper.BindEnv("server.host", "SERVICE_HOST")
viper.BindEnv("server.port", "SERVICE_PORT")
viper.BindEnv("spanner.project_id", "SPANNER_PROJECT_ID")
viper.BindEnv("spanner.instance_id", "SPANNER_INSTANCE_ID")
viper.BindEnv("spanner.database_id", "SPANNER_DATABASE_ID")
*snip*
return c, nil
}
Możesz zauważyć, że domyślnie usługa jest uruchamiana na localhost:8083, aby uniknąć konfliktów z innymi usługami*.
Mając te informacje, możesz uruchomić usługę punktu handlowego.
Uruchamianie usługi
Uruchomienie usługi spowoduje jej działanie na porcie 8083. Ta usługa ma wiele tych samych zależności co usługa produktu, więc nowe zależności nie zostaną pobrane.
cd ~/spanner-gaming-sample/src/golang/tradepost-service
go run . &
Wynik polecenia:
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env: export GIN_MODE=release
- using code: gin.SetMode(gin.ReleaseMode)
[GIN-debug] GET /trades/player_items --> main.getPlayerItem (4 handlers)
[GIN-debug] POST /trades/sell --> main.createOrder (4 handlers)
[GIN-debug] GET /trades/open --> main.getOpenOrder (4 handlers)
[GIN-debug] PUT /trades/buy --> main.purchaseOrder (4 handlers)
[GIN-debug] Listening and serving HTTP on localhost:8083
Publikowanie elementu
Przetestuj usługę, wysyłając żądanie GET, aby pobrać PlayerItem na sprzedaż:
curl http://localhost:8083/trades/player_items
Wynik polecenia:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
Teraz opublikujmy przedmiot na sprzedaż, wywołując punkt końcowy /trades/sell.
curl http://localhost:8083/trades/sell \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"lister": "<PlayerUUID>","playerItemUUID": "<PlayerItemUUID>", "list_price": "<some price higher than item's price>"}'
Wynik polecenia:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"282ea691-b956-4c4c-95ff-f461d6415651"
Podsumowanie
W tym kroku wdrożono usługę tradepost-service, która będzie obsługiwać tworzenie zleceń sprzedaży. Usługa ta umożliwia też kupowanie tych zamówień.
Następne kroki
Usługi już działają, więc czas zasymulować sprzedaż i zakupy na targu!
5. Rozpocznij handel
Po uruchomieniu usług dotyczących produktów i punktów handlowych możesz wygenerować obciążenie za pomocą podanych generatorów Locust.
Locust udostępnia interfejs internetowy do uruchamiania generatorów, ale w tym laboratorium użyjesz wiersza poleceń (opcja –headless).
Generowanie elementów gry
Najpierw wygeneruj produkty. Plik ./generators/item_generator.py zawiera zadanie tworzenia elementów gry z losowymi ciągami znaków jako nazwami i losowymi wartościami cen:
# Generate random items
class ItemLoad(HttpUser):
def generateItemName(self):
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
def generateItemValue(self):
return str(decimal.Decimal(random.randrange(100, 10000))/100)
@task
def createItem(self):
headers = {"Content-Type": "application/json"}
data = {"item_name": self.generateItemName(), "item_value": self.generateItemValue()}
self.client.post("/items", data=json.dumps(data), headers=headers)
To polecenie wywołuje plik item_generator.py, który będzie generować elementy gry przez 10 sekund (t=10s):
cd ~/spanner-gaming-sample
locust -H http://127.0.0.1:8082 -f ./generators/item_generator.py --headless -u=1 -r=1 -t=10s
Wynik polecenia:
*snip*
/INFO/locust.main: --run-time limit reached. Stopping Locust
/INFO/locust.main: Shutting down (exit code 0)
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
POST /items 606 0(0.00%) | 16 12 161 15 | 60.61 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 606 0(0.00%) | 16 12 161 15 | 60.61 0.00
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
POST /items 15 16 16 17 18 19 21 34 160 160 160 606
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 15 16 16 17 18 19 21 34 160 160 160 606
Gracze zdobywają przedmioty i pieniądze
Następnie niech gracze zdobędą przedmioty i pieniądze, aby mogli uczestniczyć w handlu. W tym celu plik ./generators/game_server.py zawiera zadania pobierania elementów gry do przypisania graczom, a także losowych kwot waluty.
# Players generate items and money at 5:2 ratio. We don't want to devalue the currency!
class GameLoad(HttpUser):
def on_start(self):
self.getItems()
def getItems(self):
headers = {"Content-Type": "application/json"}
r = requests.get(f"{self.host}/items", headers=headers)
global itemUUIDs
itemUUIDs = json.loads(r.text)
def generateAmount(self):
return str(round(random.uniform(1.01, 49.99), 2))
@task(2)
def acquireMoney(self):
headers = {"Content-Type": "application/json"}
# Get a random player that's part of a game, and update balance
with self.client.get("/players", headers=headers, catch_response=True) as response:
try:
data = {"playerUUID": response.json()["playerUUID"], "amount": self.generateAmount(), "source": "loot"}
self.client.put("/players/balance", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
@task(5)
def acquireItem(self):
headers = {"Content-Type": "application/json"}
# Get a random player that's part of a game, and add an item
with self.client.get("/players", headers=headers, catch_response=True) as response:
try:
itemUUID = itemUUIDs[random.randint(0, len(itemUUIDs)-1)]
data = {"playerUUID": response.json()["playerUUID"], "itemUUID": itemUUID, "source": "loot"}
self.client.post("/players/items", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
To polecenie umożliwi graczom zdobywanie przedmiotów i pieniędzy przez 60 sekund:
locust -H http://127.0.0.1:8082 -f game_server.py --headless -u=1 -r=1 -t=60s
Wynik polecenia:
*snip*
dev-machine/INFO/locust.main: --run-time limit reached. Stopping Locust
dev-machine/INFO/locust.main: Shutting down (exit code 0)
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
GET /players 231 0(0.00%) | 14 9 30 13 | 23.16 0.00
PUT /players/balance 53 0(0.00%) | 33 30 39 34 | 5.31 0.00
POST /players/items 178 0(0.00%) | 26 22 75 26 | 17.85 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 462 0(0.00%) | 21 9 75 23 | 46.32 0.00
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
GET /players 13 16 17 17 19 20 21 23 30 30 30 231
PUT /players/balance 34 34 35 35 36 37 38 40 40 40 40 53
POST /players/items 26 27 27 27 28 29 34 53 76 76 76 178
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 23 26 27 27 32 34 36 37 76 76 76 462
Gracze kupujący i sprzedający na targu
Teraz, gdy gracze mają przedmioty i pieniądze na ich zakup, mogą zacząć korzystać z punktu handlowego.
Plik generatora ./generators/trading_server.py zawiera zadania tworzenia zleceń sprzedaży i ich realizacji.
# Players can sell and buy items
class TradeLoad(HttpUser):
def itemMarkup(self, value):
f = float(value)
return str(f*1.5)
@task
def sellItem(self):
headers = {"Content-Type": "application/json"}
# Get a random item
with self.client.get("/trades/player_items", headers=headers, catch_response=True) as response:
try:
playerUUID = response.json()["PlayerUUID"]
playerItemUUID = response.json()["PlayerItemUUID"]
list_price = self.itemMarkup(response.json()["Price"])
# Currently don't have any items that can be sold, retry
if playerItemUUID == "":
raise RescheduleTask()
data = {"lister": playerUUID, "playerItemUUID": playerItemUUID, "list_price": list_price}
self.client.post("/trades/sell", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
@task
def buyItem(self):
headers = {"Content-Type": "application/json"}
# Get a random item
with self.client.get("/trades/open", headers=headers, catch_response=True) as response:
try:
orderUUID = response.json()["OrderUUID"]
buyerUUID = response.json()["BuyerUUID"]
# Currently don't have any buyers that can fill the order, retry
if buyerUUID == "":
raise RescheduleTask()
data = {"orderUUID": orderUUID, "buyer": buyerUUID}
self.client.put("/trades/buy", data=json.dumps(data), headers=headers)
except json.JSONDecodeError:
response.failure("Response could not be decoded as JSON")
except KeyError:
response.failure("Response did not contain expected key 'playerUUID'")
To polecenie umożliwi graczom wystawianie zdobytych przedmiotów na sprzedaż, a innym graczom kupowanie tych przedmiotów przez 10 sekund:
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
Wynik polecenia:
*snip*
Name # reqs # fails | Avg Min Max Median | req/s failures/s
----------------------------------------------------------------------------------------------------------------------------------------------------------------
PUT /trades/buy 20 5(25.00%) | 43 10 78 43 | 2.07 0.52
GET /trades/open 20 0(0.00%) | 358 7 971 350 | 2.07 0.00
GET /trades/player_items 20 0(0.00%) | 49 35 113 41 | 2.07 0.00
POST /trades/sell 20 0(0.00%) | 29 21 110 24 | 2.07 0.00
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Aggregated 80 5(6.25%) | 120 7 971 42 | 8.29 0.52
Response time percentiles (approximated)
Type Name 50% 66% 75% 80% 90% 95% 98% 99% 99.9% 99.99% 100% # reqs
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
PUT /trades/buy 43 45 49 50 71 78 78 78 78 78 78 20
GET /trades/open 360 500 540 550 640 970 970 970 970 970 970 20
GET /trades/player_items 43 55 57 59 72 110 110 110 110 110 110 20
POST /trades/sell 24 25 25 27 50 110 110 110 110 110 110 20
--------|--------------------------------------------------------------------------------|---------|------|------|------|------|------|------|------|------|------|------|------|
None Aggregated 42 50 71 110 440 550 640 970 970 970 970 80
Podsumowanie
W tym kroku symulujesz rejestrację graczy w celu grania w gry, a następnie przeprowadzasz symulacje grania w gry przez graczy za pomocą usługi dobierania graczy. W tych symulacjach wykorzystaliśmy platformę Locust w języku Python do wysyłania żądań do interfejsu REST API naszych usług.
Możesz dowolnie modyfikować czas spędzony na tworzeniu graczy i graniu w gry, a także liczbę jednoczesnych użytkowników (-u).
Następne kroki
Po symulacji warto sprawdzić różne statystyki, wysyłając zapytania do usługi Spanner.
6. Pobieranie statystyk handlowych
Po przeprowadzeniu symulacji zdobywania przez graczy pieniędzy i przedmiotów, a następnie sprzedaży tych przedmiotów na targu sprawdźmy niektóre statystyki.
Aby to zrobić, użyj Cloud Console do wysyłania zapytań do Spannera.
Sprawdzanie otwartych i zrealizowanych zleceń handlowych
Gdy na platformie handlowej zostanie kupione TradeOrder, pole metadanych filled zostanie zaktualizowane.
To zapytanie pozwoli Ci sprawdzić, ile zamówień jest otwartych, a ile zrealizowanych:
-- Open vs Filled Orders
SELECT Type, NumTrades FROM
(SELECT "Open Trades" as Type, count(*) as NumTrades FROM trade_orders WHERE active=true
UNION ALL
SELECT "Filled Trades" as Type, count(*) as NumTrades FROM trade_orders WHERE filled=true
)
Wynik:
Typ | NumTrades |
Otwarte transakcje | 159 |
Zrealizowane transakcje | 454 |
Sprawdzanie salda konta gracza i liczby elementów
Gracz gra w grę, jeśli ustawiona jest kolumna current_game. W przeciwnym razie nie grają w żadną grę.
Aby uzyskać dostęp do 10 najlepszych graczy, którzy obecnie grają w gry z największą liczbą elementów, wraz z ich account_balance
użyj tego zapytania :
SELECT playerUUID, account_balance, (SELECT COUNT(*) FROM player_items WHERE playerUUID=p.PlayerUUID) AS numItems, current_game
FROM players AS p
WHERE current_game IS NOT NULL
ORDER BY numItems DESC
LIMIT 10;
Wynik:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Podsumowanie
W tym kroku sprawdzisz różne statystyki dotyczące graczy i zamówień handlowych, używając konsoli Cloud do wysyłania zapytań do Spannera.
Następne kroki
Następnie czas na zwolnienie miejsca!
7. Czyszczę dane
Po zabawie z Spannerem musimy posprzątać plac zabaw. Na szczęście to łatwy krok. Wystarczy przejść do sekcji Cloud Spanner w Cloud Console i usunąć instancję utworzoną na potrzeby tego laboratorium.
8. Gratulacje!
Gratulacje, udało Ci się wdrożyć przykładową grę w Spannerze.
Co dalej?
W tym module udało Ci się skonfigurować 2 usługi do obsługi generowania elementów w grze i pozyskiwania przez graczy elementów, które mają być sprzedawane na targu.
Te przykłady kodu powinny pomóc Ci lepiej zrozumieć, jak działa spójność Cloud Spanner w transakcjach w przypadku mutacji DML i Spanner.
Możesz użyć udostępnionych generatorów, aby sprawdzić, jak skaluje się Spanner.