1. Wprowadzenie
Cloud Spanner to w pełni zarządzana, skalowalna w poziomie, rozproszona globalnie, relacyjna usługa baz danych, która zapewnia transakcje ACID i semantykę SQL bez utraty wydajności i wysokiej dostępności.
Te funkcje sprawiają, że usługa Spanner znakomicie sprawdza się w architekturze gier, które chcą zapewnić globalną grupę graczy lub którym zależy na spójności danych.
W tym module utworzysz 2 usługi Go, które będą korzystać z regionalnej bazy danych Spannera, by umożliwić graczom pozyskiwanie przedmiotów i pieniędzy (item-service), a następnie utworzysz pozycje na platformie handlowej, które inni gracze będą mogli kupić (tradepost-service).
Ten moduł wymaga ćwiczenia z programowania Cloud Spanner Started with Games Development (Pierwsze kroki z tworzeniem gier) w Cloud Spanner, aby wygenerować odtwarzacze i gry przy użyciu interfejsów profile-service i matchmaking-service.
Następnie wygenerujesz dane, używając platformy wczytywania Pythona Locust.io, aby symulować pozyskiwanie przez graczy pieniędzy i przedmiotów w trakcie rozgrywki. Następnie gracze mogą wystawić przedmioty na sprzedaż na platformie handlowej, gdzie inni gracze z wystarczającą ilością pieniędzy mogą je kupić.
Wysyłasz też zapytania do Spannera, aby określić salda kont i liczbę pozycji oraz niektóre statystyki dotyczące otwartych lub wypełnionych zamówień handlowych.
Na koniec usuniesz zasoby utworzone w tym module.
Co utworzysz
W ramach tego modułu:
- Ponownie użyj instancji Spannera z artykułu Wprowadzenie do tworzenia gier w Cloud Spanner.
- Wdrażanie usługi elementów napisanej w języku Go w celu obsługi graczy pozyskujących przedmioty i pieniądze
- Wdróż usługę Trading Post napisaną w Go, aby symulować graczy sprzedających przedmioty na sprzedaż oraz innych graczy, którzy je kupują.
Czego się nauczysz
- Jak korzystać z transakcji odczytu i zapisu, aby zapewnić spójność zmian danych
- Jak modyfikować dane za pomocą mutacji DML i Spannera
Czego potrzebujesz
- Projekt Google Cloud połączony z kontem rozliczeniowym.
- Przeglądarka, np. Chrome lub Firefox.
- Wcześniej ukończono zadanie Rozpoczęcie pracy z tworzeniem gier w Cloud Spanner, bez kroku czyszczenia.
2. Konfiguracja i wymagania
Wykonaj pierwsze kroki w Cloud Spanner z ćwiczeniem z programowania dla programistów gier
Wykonaj ćwiczenie z programowania w Cloud Spanner wprowadzające do tworzenia gier. Jest to wymagane do uzyskania zbioru danych z graczami i grami. Gracze i gry są potrzebne do pozyskiwania przedmiotów i pieniędzy, które z kolei umożliwiają sprzedaż przedmiotów i kupowanie ich na platformie handlowej.
Konfigurowanie zmiennych środowiskowych w Cloud Shell
Otwórz Cloud Shell, klikając Aktywuj Cloud Shell 
(udostępnienie środowiska i połączenie z nim powinno chwilę potrwać, ponieważ zostało to wcześniej zrobione).
Po nawiązaniu połączenia z Cloud Shell powinno pojawić się potwierdzenie, że użytkownik jest już uwierzytelniony, a projekt ma już ustawiony 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
Po utworzeniu bazy danych możesz zdefiniować schemat w bazie danych sample-game.
Ten moduł utworzy 4 nowe tabele: game_items, player_items, player_ledger_entries i trade_orders.
Relacje z elementami odtwarzacza
Relacje z zamówieniami handlowymi
Elementy w grze są dodawane do tabeli game_items, a następnie mogą je zdobywać. Tabela player_items zawiera obce klucze do identyfikatora itemUUID i PlayUUID, aby mieć pewność, że gracze zdobywają tylko prawidłowe przedmioty.
Tabela player_ledger_entries zawiera informacje o zmianach pieniężnych w saldzie konta gracza. Może to być pozyskiwanie pieniędzy za łupy lub sprzedaż przedmiotów na platformie handlowej.
Na koniec tabela trade_orders służy do obsługi publikowania zamówień sprzedaży i pozwala kupującym realizować te zamówienia.
Aby utworzyć schemat, kliknij przycisk Write DDL w konsoli Cloud:
Tutaj wpiszesz 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” i poczekaj na zakończenie aktualizacji schematu:
Następny krok
Następnie wdrożysz usługę item.
3. Wdrażanie usługi elementu
Omówienie usługi
Usługa elementu to interfejs API REST napisany w języku Go, który korzysta z platformy gin. Dzięki temu interfejsowi API gracze uczestniczący w grach otwartych zdobywają pieniądze i przedmioty.
Plik ./src/golang/item-service/main.go konfiguruje podane niżej punkty końcowe tak, aby współpracowały z elementami gry i graczami pobierającymi te elementy. W grze jest też punkt końcowy, w którym gracze mogą zbierać 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())
}
Konfiguracja połączeń Spannera i korzystanie z nich odbywa się dokładnie tak, jak w przypadku usługi profile-service i matchmaking-service z poprzedniego ćwiczenia z programowania.
Usługa produktów działa z elementami GameItem, Player, PlayerLedger i PlayerItem 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"`
}
Przede wszystkim musisz utworzyć w grze jakieś elementy. W tym celu wywoływane jest żądanie POST do punktu końcowego /items. To bardzo proste wstawienie DML 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 pozyskać element, wywoływane jest żądanie POST kierowane do punktu końcowego /players/items. Logika tego punktu końcowego polega na pobraniu bieżącej wartości elementu gry oraz bieżącej sesji gracza. Następnie wstaw do tabeli player_items odpowiednie informacje, które wskazują źródło i czas pozyskania elementu.
Są one mapowane na te funkcje:
// 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ł pozyskać 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 wartości amount oraz zaktualizowaniem tabeli player_ledger_entries rekordu pozyskania. Wartość parametru account_balance gracza jest zmodyfikowana, aby została zwrócona do elementu wywołującego. DML jest używany do modyfikowania zarówno odtwarzaczy, jak i odtwarzacza player_ledger_entries.
Są one mapowane na te funkcje:
// 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 przy użyciu zmiennych środowiskowych. Zapoznaj się z 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
}
Jak widać, działanie domyślne polega na uruchomieniu usługi na serwerze localhost:8082.
Gdy masz te informacje, możemy uruchomić usługę.
Uruchamianie usługi
Uruchomienie usługi spowoduje pobranie zależności i ustanowienie usługi na porcie 8082:
cd ~/spanner-gaming-sample/src/golang/item-service
go run . &
Dane wyjściowe 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ę, wykonując polecenie curl w celu utworzenia elementu:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
Dane wyjściowe 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 pozyskał ten przedmiot. Aby to zrobić, potrzebujesz ItemUUID oraz PlayerUUID. ItemUUID to dane wyjściowe poprzedniego polecenia. W tym przykładzie jest to: aecde380-0a79-48c0-ab5d-0da675d3412c.
Aby go uzyskać, wywołaj punkt końcowy GET /players:
curl http://localhost:8082/players
Dane wyjściowe polecenia:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
Aby odtwarzacz mógł pozyskać 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"}'
Dane wyjściowe 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żyliśmy usługę produktów, która pozwala tworzyć elementy w grach, a gracze przypisani do otwartych gier mogą zbierać pieniądze i przedmioty w grach.
Następne kroki
W następnym kroku wdrożysz usługę poczty e-mail.
4. Wdrożenie usługi poczty e-mail
Omówienie usługi
Usługa Tradepost to interfejs API typu REST napisany w języku Go, który korzysta z platformy gin. W tym interfejsie API elementy odtwarzacza są publikowane w celu sprzedaży. Gracze mogą wtedy wykazywać otwarte transakcje, a jeśli mają wystarczającą ilość pieniędzy, mogą kupić przedmiot.
Plik ./src/golang/tradepost-service/main.go dla usługi Tradepost ma taką samą konfigurację i kod jak w przypadku innych usług, dlatego nie powtarza się tutaj. Ta usługa ujawnia kilka punktów końcowych w następujący sposób:
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ć zamówienie handlowe, do punktu końcowego interfejsu API /trades/sell wysyłane jest żądanie POST. Wymagane informacje to playerItemUUID obiektu player_item do sprzedaży, lister i list_price.
Mutacje spannera są wybierane do utworzenia zamówienia handlowego i oznaczają element player_item jako niewidoczny widoczny. Dzięki temu sprzedawca nie będzie mógł publikować duplikatów produktów.
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 można było dodać go do sprzedaży. Przede wszystkim oznacza to, ż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
}
Dokonywanie zakupu jest realizowane za pomocą żądania PUT do punktu końcowego /trades/buy. Wymagane informacje to orderUUID i kupujący, czyli identyfikator UUID gracza dokonującego zakupu.
Ze względu na złożoność i liczbę zmian do zakupu zamówienia ponownie wybierane są mutacje. W ramach jednej transakcji odczytu i zapisu wykonywane są następujące operacje:
- Sprawdź, czy zamówienie można wypełnić, bo nie zostało wcześniej wypełnione 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 upewnij się, że może kupić produkt. Oznacza to, że kupujący nie może być tym samym właścicielem listy i ma wystarczającą ilość pieniędzy.
// 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 listy, podając odpowiedni wpis w rejestrze.
// 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
}
- Odejmij wartość list_price zamówienia od salda konta kupującego, podając odpowiedni wpis w rejestrze.
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- Przenieś element player_item do nowego gracza, wstawiając nowe wystąpienie produktu w grze wraz z danymi kupującego w tabeli PlayerItems, a następnie usuń wystąpienie elementu lister.
// 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, wskazując, że produkt został wypełniony i nie jest już aktywny.
Łącznie funkcja Kup 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 przy użyciu 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
}
Jak widać, działanie domyślne polega na uruchamianiu usługi w systemie localhost:8083, co pozwala uniknąć konfliktów z innymi usługami*.*
Mając te informacje, możemy przejść do działania Twojej firmy.
Uruchamianie usługi
Uruchomienie usługi spowoduje ustanowienie usługi na porcie 8083. Ta usługa ma wiele tych samych zależności co usługa item-usługa, więc nowe zależności nie zostaną pobrane.
cd ~/spanner-gaming-sample/src/golang/tradepost-service
go run . &
Dane wyjściowe 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
Opublikuj produkt
Przetestuj usługę, wysyłając żądanie GET, które pobiera element PlayerItem na potrzeby sprzedaży:
curl http://localhost:8083/trades/player_items
Dane wyjściowe polecenia:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
Teraz opublikujmy produkt na sprzedaż, wywołując punkt końcowy /trades/sel.
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>"}'
Dane wyjściowe 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żyłeś(-aś) tradepost-service do obsługi tworzenia zamówień sprzedaży. Ta usługa obsługuje również możliwość zakupu tych zamówień.
Następne kroki
Skoro Twoje usługi są już uruchomione, czas na symulowanie przez graczy sprzedaży i zakupów na platformie handlowej.
5. Zacznij inwestować
Gdy usługi i produkty są już uruchomione, możesz wygenerować ładunek za pomocą udostępnionych generatorów litowców.
Locust ma interfejs internetowy do uruchamiania generatorów, ale w tym module użyjesz wiersza poleceń (opcja –headless).
Wygeneruj elementy gry
Najpierw wygeneruj elementy. Plik ./generators/item_generator.py zawiera zadanie tworzenia elementów gry z losowymi ciągami nazw 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 przez 10 sekund generuje elementy gry (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
Dane wyjściowe 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
Niech gracze gromadzą przedmioty i pieniądze, aby móc uczestniczyć w transakcjach na giełdzie. W tym celu w pliku ./generators/game_server.py znajdziesz zadania pobierania elementów gry, które zostaną przypisane graczom, oraz losowe kwoty walut.
# 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 pozyskiwanie 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
Dane wyjściowe 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ą i sprzedają na giełdzie
Skoro gracze mają już przedmioty i pieniądze na zakup, mogą zacząć korzystać z platformy handlowej.
Plik generatora ./generators/trading_server.py zawiera zadania tworzenia i realizacji zamówień sprzedaży.
# 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 wyświetlanie listy przedmiotów zdobytych na sprzedaż, a inni gracze będą mogli je kupić przez 10 sekund:
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
Dane wyjściowe 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
Najpierw symulowane są gry, w które gracze rejestrują się w grach, oraz przeprowadzanie przez graczy symulacji dla dobierania graczy. W tych symulacji wykorzystano platformę Locust Python do wysyłania żądań do naszych usług. API REST.
Możesz zmienić czas poświęcony na tworzenie graczy i granie w gry, a także liczbę równoczesnych użytkowników (-u).
Następne kroki
Po zakończeniu symulacji warto sprawdzić różne statystyki, wysyłając zapytanie do Spannera.
6. Pobieranie statystyk handlu
Po symulowaniu zdobywania pieniędzy i przedmiotów, a następnie sprzedaży ich na platformie handlowej, sprawdźmy kilka statystyk.
W tym celu użyj konsoli Cloud, aby wysyłać żądania zapytań do usługi Spanner.
Sprawdzanie otwartych i zrealizowanych zamówień handlowych
W przypadku kupna TradeOrder na giełdzie, TradeOrder pole metadanych jest aktualizowane.
To zapytanie pozwala sprawdzić, ile zamówień jest otwartych, a ile zostało wypełnionych:
-- 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 |
Wypełnione transakcje | 454 |
Sprawdzanie salda konta gracza i liczby elementów
Gracz gra, jeśli ma ustawioną kolumnę current_game. W przeciwnym razie nie gra obecnie w grę.
Aby znaleźć 10 najlepszych graczy obecnie grających w gry z największą liczbą przedmiotów za pomocą wartości 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 przeanalizowaliśmy różne statystyki dotyczące zamówień graczy i zamówień handlowych, korzystając z konsoli Cloud do wysyłania zapytań do usługi Spanner.
Następne kroki
Czas posprzątać!
7. Czyszczenie
Po całej zabawie ze Spannerem musimy też posprzątać nasz plac zabaw. Na szczęście to łatwy krok. Wystarczy, że w sekcji Cloud Spanner w konsoli Cloud usuniesz instancję, którą utworzyliśmy na potrzeby tego ćwiczenia.
8. Gratulacje!
Gratulacje! Udało Ci się wdrożyć przykładową grę w usłudze Spanner
Co dalej?
W tym module ukończono konfigurację 2 usług do generowania elementów w grze i pozyskiwania przedmiotów na sprzedaż.
Dzięki temu przykładowemu kodowi lepiej zrozumiesz, jak działa spójność Cloud Spanner w transakcjach w przypadku mutacji DML i Spanner.
Jeśli chcesz poznać skalowanie usługi Spanner, możesz skorzystać z generatorów dostępnych na tej stronie.