১. ভূমিকা
ক্লাউড স্প্যানার হলো একটি সম্পূর্ণভাবে পরিচালিত, হরাইজন্টালি স্কেলেবল, বিশ্বব্যাপী বিতরণযোগ্য রিলেশনাল ডাটাবেস পরিষেবা, যা পারফরম্যান্স ও উচ্চ প্রাপ্যতা বজায় রেখে ACID ট্রানজ্যাকশন এবং SQL সিম্যান্টিকস প্রদান করে।
এই বৈশিষ্ট্যগুলোর কারণে, স্প্যানার এমন গেমের আর্কিটেকচারের জন্য দারুণ উপযোগী, যেগুলো বিশ্বব্যাপী প্লেয়ার বেস তৈরি করতে চায় অথবা ডেটার সামঞ্জস্যতা নিয়ে চিন্তিত।
এই ল্যাবে, আপনি দুটি Go সার্ভিস তৈরি করবেন যা একটি আঞ্চলিক স্প্যানার ডেটাবেসের সাথে যোগাযোগ করে খেলোয়াড়দের আইটেম এবং অর্থ অর্জন করতে সক্ষম করবে ( item-service ) , এবং তারপর অন্যান্য খেলোয়াড়দের কেনার জন্য ট্রেডিং পোস্টে আইটেমগুলো তালিকাভুক্ত করবে ( tradepost-service )।
এই ল্যাবটি profile-service এবং matchmaking-service ব্যবহার করে প্লেয়ার ও গেম তৈরি করার জন্য ক্লাউড স্প্যানার গেটিং স্টার্টেড উইথ গেমস ডেভেলপমেন্ট কোডল্যাবের উপর নির্ভরশীল।
এরপর আপনি পাইথন লোড ফ্রেমওয়ার্ক Locust.io ব্যবহার করে ডেটা তৈরি করবেন, যা "গেম খেলার" সময় খেলোয়াড়দের অর্থ ও আইটেম অর্জনের বিষয়টি সিমুলেট করবে। তারপর খেলোয়াড়রা একটি ট্রেডপোস্টে বিক্রির জন্য আইটেম তালিকাভুক্ত করতে পারবে, যেখান থেকে পর্যাপ্ত অর্থসম্পন্ন অন্য খেলোয়াড়রা সেই আইটেমগুলো কিনতে পারবে।
এছাড়াও, খেলোয়াড়দের অ্যাকাউন্ট ব্যালেন্স ও আইটেমের সংখ্যা এবং খোলা বা পূরণ হয়ে যাওয়া ট্রেড অর্ডার সংক্রান্ত কিছু পরিসংখ্যান জানতে আপনি স্প্যানারকে কোয়েরি করবেন।
অবশেষে, এই ল্যাবে তৈরি করা রিসোর্সগুলো আপনি পরিষ্কার করবেন।
আপনি যা তৈরি করবেন
এই ল্যাবের অংশ হিসেবে, আপনি যা করবেন:
- ক্লাউড স্প্যানার গেটিং স্টার্টেড উইথ গেমস ডেভেলপমেন্ট থেকে স্প্যানার ইনস্ট্যান্সটি পুনরায় ব্যবহার করুন।
- খেলোয়াড়দের আইটেম ও অর্থ অর্জনের বিষয়টি পরিচালনা করার জন্য Go-তে লেখা একটি আইটেম সার্ভিস স্থাপন করুন।
- খেলোয়াড়দের বিক্রয়ের জন্য আইটেম তালিকাভুক্ত করা এবং অন্যান্য খেলোয়াড়দের সেই আইটেমগুলো ক্রয় করার বিষয়টি অনুকরণ করতে Go-তে লেখা একটি ট্রেডিং পোস্ট পরিষেবা স্থাপন করুন।
আপনি যা শিখবেন
- ডেটা পরিবর্তনের ক্ষেত্রে সামঞ্জস্য নিশ্চিত করতে রিড-রাইট ট্রানজ্যাকশন কীভাবে ব্যবহার করবেন
- ডেটা পরিবর্তন করতে DML এবং স্প্যানার মিউটেশন কীভাবে কাজে লাগাবেন
আপনার যা যা লাগবে
- একটি গুগল ক্লাউড প্রজেক্ট যা একটি বিলিং অ্যাকাউন্টের সাথে সংযুক্ত।
- একটি ওয়েব ব্রাউজার, যেমন ক্রোম বা ফায়ারফক্স ।
- পূর্বে ক্লাউড স্প্যানার দিয়ে গেম ডেভেলপমেন্ট শুরু করার কোর্সটি পরিষ্করণ ধাপটি ছাড়া সম্পন্ন করা হয়েছে।
২. সেটআপ এবং প্রয়োজনীয়তা
ক্লাউড স্প্যানার গেম ডেভেলপমেন্ট শুরু করার কোডল্যাবটি সম্পূর্ণ করুন।
ক্লাউড স্প্যানার গেটিং স্টার্টেড উইথ গেমস ডেভেলপমেন্ট কোডল্যাবটি সম্পূর্ণ করুন। প্লেয়ার এবং গেমের একটি ডেটাসেট পাওয়ার জন্য এটি প্রয়োজন। আইটেম ও অর্থ অর্জনের জন্য প্লেয়ার এবং গেম প্রয়োজন, যা পরবর্তীতে বিক্রয়ের জন্য আইটেম তালিকাভুক্ত করতে এবং ট্রেডিং পোস্ট থেকে আইটেম কিনতে ব্যবহৃত হয়।
ক্লাউড শেলে এনভায়রনমেন্ট ভেরিয়েবল কনফিগার করুন
Activate Cloud Shell-এ ক্লিক করে ক্লাউড শেল খুলুন। 
(যেহেতু আপনি এটি আগে করেছেন, তাই পরিবেশটি প্রস্তুত করতে এবং এর সাথে সংযোগ স্থাপন করতে মাত্র কয়েক মুহূর্ত সময় লাগা উচিত)।
ক্লাউড শেলে সংযুক্ত হওয়ার পর আপনি দেখতে পাবেন যে, আপনাকে ইতিমধ্যেই প্রমাণীকৃত করা হয়েছে এবং প্রজেক্টটি আপনার PROJECT_ID-তে সেট করা আছে।
ক্লাউড শেলে SPANNER এনভায়রনমেন্ট ভেরিয়েবল সেট করুন
export SPANNER_PROJECT_ID=$GOOGLE_CLOUD_PROJECT
export SPANNER_INSTANCE_ID=cloudspanner-gaming
export SPANNER_DATABASE_ID=sample-game
স্কিমা তৈরি করুন
এখন যেহেতু আপনার ডেটাবেস তৈরি হয়ে গেছে, আপনি sample-game ডেটাবেসে স্কিমাটি নির্ধারণ করতে পারেন।
এই ল্যাবে চারটি নতুন টেবিল তৈরি করা হবে: game_items , player_items , player_ledger_entries এবং trade_orders ।
খেলোয়াড়ের আইটেম সম্পর্ক
বাণিজ্য আদেশ সম্পর্ক
গেমের আইটেমগুলো game_items টেবিলে যোগ করা হয় এবং এরপর খেলোয়াড়রা সেগুলো অর্জন করতে পারে। খেলোয়াড়রা যেন শুধুমাত্র বৈধ আইটেমই অর্জন করে, তা নিশ্চিত করার জন্য player_items টেবিলে itemUUID এবং playerUUID উভয়ের জন্যই ফরেন কী থাকে।
player_ledger_entries টেবিলটি প্লেয়ারের অ্যাকাউন্ট ব্যালেন্সে হওয়া যেকোনো আর্থিক পরিবর্তনের হিসাব রাখে। এই পরিবর্তন লুট থেকে অর্থ অর্জনের মাধ্যমে, অথবা ট্রেডিং পোস্টে আইটেম বিক্রি করার মাধ্যমে হতে পারে।
এবং পরিশেষে, বিক্রয় অর্ডার পোস্ট করা এবং ক্রেতাদের দ্বারা সেই অর্ডারগুলো পূরণ করার জন্য trade_orders টেবিলটি ব্যবহৃত হয়।
স্কিমা তৈরি করতে, আপনাকে ক্লাউড কনসোলে থাকা Write DDL বোতামে ক্লিক করতে হবে:
এখানে, আপনি 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);
স্কিমা পরিবর্তন করতে ' Submit ' বাটনে ক্লিক করুন এবং স্কিমা আপডেট সম্পন্ন হওয়া পর্যন্ত অপেক্ষা করুন:
এরপরে
এরপরে, আপনি আইটেম সার্ভিসটি ডিপ্লয় করবেন।
৩. আইটেম পরিষেবাটি স্থাপন করুন
পরিষেবার সংক্ষিপ্ত বিবরণ
আইটেম সার্ভিসটি হলো Go-তে লেখা একটি REST API যা gin ফ্রেমওয়ার্ক ব্যবহার করে। এই API-এর মাধ্যমে, উন্মুক্ত গেমগুলিতে অংশগ্রহণকারী খেলোয়াড়রা অর্থ এবং আইটেম অর্জন করে।
./src/golang/item-service/main.go ফাইলটি গেমের আইটেম এবং খেলোয়াড়দের সেই আইটেমগুলো অর্জন করার জন্য নিম্নলিখিত এন্ডপয়েন্টগুলো কনফিগার করে। এছাড়াও, খেলোয়াড়দের অর্থ উপার্জনের জন্য একটি এন্ডপয়েন্ট রয়েছে।
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())
}
আগের কোডল্যাবের প্রোফাইল-সার্ভিস এবং ম্যাচমেকিং-সার্ভিসের মতোই স্প্যানার কানেকশনগুলোর কনফিগারেশন এবং ব্যবহার পরিচালনা করা হয়।
আইটেম সার্ভিসটি GameItem, Player, PlayerLedger, এবং PlayerItem-এর সাথে নিম্নলিখিত সংজ্ঞা অনুসারে কাজ করে:
// 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"`
}
প্রথমে, গেমটিতে কিছু আইটেম তৈরি করতে হবে। এটি করার জন্য, /items এন্ডপয়েন্টে একটি POST রিকোয়েস্ট পাঠানো হয়। এটি game_items টেবিলে একটি খুব সাধারণ DML ইনসার্ট প্রক্রিয়া।
// 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
}
কোনো আইটেম সংগ্রহ করার জন্য, /players/items এন্ডপয়েন্টে একটি POST রিকোয়েস্ট পাঠানো হয়। এই এন্ডপয়েন্টের কাজ হলো একটি গেম আইটেমের বর্তমান মান এবং প্লেয়ারের বর্তমান গেম সেশন সংগ্রহ করা। এরপর, আইটেমটি সংগ্রহের উৎস এবং সময় উল্লেখ করে উপযুক্ত তথ্য player_items টেবিলে সন্নিবেশ করা হয়।
এটি নিম্নলিখিত ফাংশনগুলির সাথে সম্পর্কিত:
// 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
}
কোনো খেলোয়াড়ের অর্থ অর্জনের জন্য, /players/updatebalance এন্ডপয়েন্টে একটি PUT রিকোয়েস্ট পাঠানো হয়।
এই এন্ডপয়েন্টের লজিক হলো, পরিমাণটি প্রয়োগ করার পর প্লেয়ারের ব্যালেন্স আপডেট করা এবং সেই সাথে প্লেয়ার_লেজার_এন্ট্রিজ টেবিলটিকে অধিগ্রহণের রেকর্ড দিয়ে আপডেট করা। প্লেয়ারের অ্যাকাউন্ট_ব্যালেন্স পরিবর্তন করে কলারকে ফেরত পাঠানো হয়। প্লেয়ার এবং প্লেয়ার_লেজার_এন্ট্রিজ উভয়কে পরিবর্তন করার জন্য ডিএমএল (DML) ব্যবহার করা হয়।
এটি নিম্নলিখিত ফাংশনগুলির সাথে সম্পর্কিত:
// 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
}
ডিফল্টরূপে, সার্ভিসটি এনভায়রনমেন্ট ভেরিয়েবল ব্যবহার করে কনফিগার করা হয়। ./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
}
আপনি দেখতে পাচ্ছেন যে, ডিফল্ট আচরণ অনুযায়ী সার্ভিসটি localhost:8082-এ চালু হয়।
এই তথ্য দিয়ে এখন পরিষেবাটি চালু করার সময় হয়েছে।
পরিষেবাটি চালান
সার্ভিসটি চালালে প্রয়োজনীয় ফাইলগুলো ডাউনলোড হবে এবং সার্ভিসটি ৮০৮২ পোর্টে চালু হবে।
cd ~/spanner-gaming-sample/src/golang/item-service
go run . &
কমান্ড আউটপুট:
[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
একটি আইটেম তৈরি করতে curl কমান্ড দিয়ে পরিষেবাটি পরীক্ষা করুন:
curl http://localhost:8082/items \
--include \
--header "Content-Type: application/json" \
--request "POST" \
--data '{"item_name": "test_item","item_value": "3.14"}'
কমান্ড আউটপুট:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"aecde380-0a79-48c0-ab5d-0da675d3412c"
এরপর, আপনি চাইবেন একজন খেলোয়াড় যেন এই আইটেমটি অর্জন করে। এটি করার জন্য, আপনার একটি ItemUUID এবং PlayerUUID প্রয়োজন। ItemUUID হলো পূর্ববর্তী কমান্ডের আউটপুট। এই উদাহরণে, এটি হলো: aecde380-0a79-48c0-ab5d-0da675d3412c ।
PlayerUUID পেতে, GET /players এন্ডপয়েন্টে কল করুন:
curl http://localhost:8082/players
কমান্ড আউটপুট:
{
"playerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"updated": "0001-01-01T00:00:00Z",
"account_balance": {},
"current_game": "7b97fa85-5658-4ded-a962-4c09269a0a79"
}
খেলোয়াড়ের আইটেমটি পাওয়ার জন্য, 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"}'
কমান্ড আউটপুট:
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
}
সারসংক্ষেপ
এই ধাপে, আপনি আইটেম সার্ভিসটি চালু করেছেন, যার মাধ্যমে গেম আইটেম তৈরি করা যায় এবং খোলা গেমগুলোতে নিযুক্ত খেলোয়াড়রা অর্থ ও গেম আইটেম অর্জন করতে পারে।
পরবর্তী পদক্ষেপ
পরবর্তী ধাপে, আপনি ট্রেডপোস্ট পরিষেবাটি স্থাপন করবেন।
৪. ট্রেডপোস্ট পরিষেবাটি স্থাপন করুন
পরিষেবার সংক্ষিপ্ত বিবরণ
ট্রেডপোস্ট সার্ভিসটি হলো Go-তে লেখা একটি REST API, যা gin ফ্রেমওয়ার্ক ব্যবহার করে। এই API-তে খেলোয়াড়দের আইটেমগুলো বিক্রির জন্য পোস্ট করা হয়। এরপর গেমের খেলোয়াড়রা খোলা ট্রেডগুলো দেখতে পারে এবং তাদের কাছে যথেষ্ট টাকা থাকলে আইটেমটি কিনতে পারে।
ট্রেডপোস্ট সার্ভিসের জন্য ./src/golang/tradepost-service/main.go ফাইলটির গঠন ও কোড অন্যান্য সার্ভিসগুলোর মতোই, তাই এখানে তার পুনরাবৃত্তি করা হয়নি। এই সার্ভিসটি নিম্নোক্তভাবে কয়েকটি এন্ডপয়েন্ট উন্মুক্ত করে:
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())
}
এই পরিষেবাটি একটি TradeOrder struct-এর পাশাপাশি GameItem, PlayerItem, Player, এবং PlayerLedger struct-গুলোর জন্য প্রয়োজনীয় স্ট্রাকচারগুলোও প্রদান করে:
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"`
}
একটি ট্রেড অর্ডার তৈরি করতে, /trades/sell এপিআই এন্ডপয়েন্টে একটি POST রিকোয়েস্ট পাঠানো হয়। প্রয়োজনীয় তথ্যগুলো হলো বিক্রয়যোগ্য player_item-এর playerItemUUID , লিস্টার এবং লিস্ট_প্রাইস।
ট্রেড অর্ডার তৈরি করতে এবং প্লেয়ার_আইটেমটিকে অদৃশ্য হিসেবে চিহ্নিত করতে স্প্যানার মিউটেশন বেছে নেওয়া হয়। এর ফলে বিক্রেতা বিক্রয়ের জন্য একই আইটেম একাধিকবার পোস্ট করতে পারেন না।
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
}
প্রকৃতপক্ষে অর্ডারটি তৈরি করার আগে, প্লেয়ারআইটেমটি যাচাই করা হয় যাতে এটি বিক্রয়ের জন্য তালিকাভুক্ত করা যায়। এর প্রধান অর্থ হলো, প্লেয়ারআইটেমটি প্লেয়ারের কাছে দৃশ্যমান এবং এর মেয়াদ শেষ হয়ে যায়নি।
// 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
}
/trades/buy এন্ডপয়েন্টে একটি PUT রিকোয়েস্ট পাঠানোর মাধ্যমে কেনাকাটা করা হয়। এর জন্য প্রয়োজনীয় তথ্য হলো orderUUID এবং buyer , যা হলো কেনাকাটাকারী প্লেয়ারের UUID।
এই জটিলতা এবং পরিবর্তনের পরিমাণের কারণে, অর্ডারটি ক্রয় করার জন্য আবারও মিউটেশন পদ্ধতি বেছে নেওয়া হয়। নিম্নলিখিত অপারেশনগুলো একটিমাত্র রিড-রাইট ট্রানজ্যাকশনের মাধ্যমে সম্পন্ন করা হয়:
- অর্ডারটি পূরণ করা যাবে কিনা তা যাচাই করুন, কারণ এটি পূর্বে পূরণ করা হয়নি এবং এর মেয়াদ শেষ হয়ে যায়নি।
// 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
}
- ক্রেতার তথ্য সংগ্রহ করুন এবং তিনি পণ্যটি কেনার যোগ্য কিনা তা যাচাই করুন। এর অর্থ হলো, ক্রেতা এবং বিক্রেতা একই ব্যক্তি হতে পারবেন না এবং তার কাছে পর্যাপ্ত অর্থ থাকতে হবে।
// 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
}
- অর্ডারের তালিকা মূল্য (list_price) তালিকাকারীর অ্যাকাউন্ট ব্যালেন্সে যোগ করুন এবং এর সাথে লেজারে একটি মিলযুক্ত এন্ট্রি যুক্ত করুন।
// 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
}
- ক্রেতার অ্যাকাউন্ট ব্যালেন্স থেকে অর্ডারের তালিকা মূল্য (list_price) বিয়োগ করুন এবং লেজারে এর একটি মিল খুঁজে বের করুন।
// Update buyer's account balance
negAmount := o.ListPrice.Neg(&o.ListPrice)
buyer.UpdateBalance(ctx, txn, *negAmount)
- PlayerItems টেবিলে গেম এবং ক্রেতার বিবরণসহ গেম আইটেমটির একটি নতুন ইনস্ট্যান্স যুক্ত করে player_item-টি নতুন প্লেয়ারের কাছে সরান এবং লিস্টারের কাছে থাকা আইটেমটির ইনস্ট্যান্সটি মুছে ফেলুন।
// 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
}
- আইটেমটি পূরণ করা হয়েছে এবং এটি আর সক্রিয় নেই, তা বোঝানোর জন্য অর্ডার এন্ট্রি আপডেট করে।
সব মিলিয়ে, ক্রয় ফাংশনটি দেখতে নিম্নরূপ:
// 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
}
ডিফল্টরূপে, সার্ভিসটি এনভায়রনমেন্ট ভেরিয়েবল ব্যবহার করে কনফিগার করা হয়। ./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
}
আপনি দেখতে পাচ্ছেন যে, অন্যান্য সার্ভিসের সাথে দ্বন্দ্ব এড়ানোর জন্য সার্ভিসটি ডিফল্টভাবে localhost:8083 এ চালু হয়।
এই তথ্যের ভিত্তিতে, এখন ট্রেডপোস্ট পরিষেবাটি চালু করার সময় হয়েছে।
পরিষেবাটি চালান
সার্ভিসটি চালালে এটি ৮০৮৩ পোর্টে চালু হবে। এই সার্ভিসটির অনেকগুলো ডিপেন্ডেন্সি আইটেম-সার্ভিসের মতোই, তাই নতুন কোনো ডিপেন্ডেন্সি ডাউনলোড করা হবে না।
cd ~/spanner-gaming-sample/src/golang/tradepost-service
go run . &
কমান্ড আউটপুট:
[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
একটি আইটেম পোস্ট করুন
বিক্রয়ের জন্য একটি PlayerItem আনতে একটি GET অনুরোধ পাঠিয়ে পরিষেবাটি পরীক্ষা করুন:
curl http://localhost:8083/trades/player_items
কমান্ড আউটপুট:
{
"PlayerUUID": "b74cc194-87b0-4a55-a67f-0f0742ef6352",
"PlayerItemUUID": "a42b1899-4509-4fce-9958-265d2a2838a0",
"Price": "3.14"
}
এখন, /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>"}'
কমান্ড আউটপুট:
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Date: <Date>
Content-Length: 38
"282ea691-b956-4c4c-95ff-f461d6415651"
সারসংক্ষেপ
এই ধাপে, আপনি বিক্রয় অর্ডার তৈরির কাজটি পরিচালনা করার জন্য ট্রেডপোস্ট-সার্ভিসটি স্থাপন করেছেন। এই সার্ভিসটি সেই অর্ডারগুলো কেনার কাজটিও পরিচালনা করে।
পরবর্তী পদক্ষেপ
এখন যেহেতু আপনার পরিষেবাগুলো চালু হয়ে গেছে, ট্রেডিং পোস্টে খেলোয়াড়দের কেনাবেচা অনুকরণ করার সময় এসেছে!
৫. ট্রেডিং শুরু করুন
এখন যেহেতু আইটেম এবং ট্রেডপোস্ট পরিষেবাগুলো চালু আছে, আপনি প্রদত্ত লোকাস্ট জেনারেটরগুলো ব্যবহার করে লোড তৈরি করতে পারবেন।
লোকাস্ট জেনারেটরগুলো চালানোর জন্য একটি ওয়েব-ইন্টারফেস প্রদান করে, কিন্তু এই ল্যাবে আপনি কমান্ড লাইন ( –headless অপশন) ব্যবহার করবেন।
গেমের আইটেম তৈরি করুন
প্রথমে, আপনাকে আইটেম তৈরি করতে হবে। ./generators/item_generator.py ফাইলটিতে এমন একটি টাস্ক রয়েছে যা নামের জন্য র্যান্ডম স্ট্রিং এবং দামের জন্য র্যান্ডম মান ব্যবহার করে গেম আইটেম তৈরি করে:
# 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)
নিম্নলিখিত কমান্ডটি item_generator.py ফাইলটিকে কল করে, যা ১০ সেকেন্ডের ( 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
কমান্ড আউটপুট:
*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
খেলোয়াড়রা জিনিসপত্র এবং অর্থ সংগ্রহ করে।
এরপর, খেলোয়াড়দের আইটেম ও অর্থ সংগ্রহ করার ব্যবস্থা করতে হবে, যাতে তারা ট্রেডিং পোস্টে অংশগ্রহণ করতে পারে। এটি করার জন্য, ./generators/game_server.py ফাইলটি খেলোয়াড়দেরকে বরাদ্দ করার জন্য গেমের আইটেম এবং সেইসাথে এলোমেলো পরিমাণ মুদ্রা সংগ্রহ করার কাজ করে।
# 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'")
এই কমান্ডটি খেলোয়াড়দের ৬০ সেকেন্ডের জন্য আইটেম এবং অর্থ অর্জন করতে দেবে:
locust -H http://127.0.0.1:8082 -f game_server.py --headless -u=1 -r=1 -t=60s
কমান্ড আউটপুট:
*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
ট্রেডিং পোস্টে খেলোয়াড়দের কেনাবেচা
এখন যেহেতু খেলোয়াড়দের কাছে আইটেম এবং সেগুলো কেনার মতো টাকা আছে, তারা ট্রেডিং পোস্ট ব্যবহার করা শুরু করতে পারে!
./generators/trading_server.py জেনারেটর ফাইলটি সেল অর্ডার তৈরি এবং সেই অর্ডারগুলো পূরণ করার জন্য টাস্ক সরবরাহ করে।
# 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'")
এই কমান্ডটি খেলোয়াড়দেরকে তাদের অর্জিত বিক্রয়যোগ্য আইটেমগুলোর তালিকা দেখানোর সুযোগ দেবে, এবং অন্য খেলোয়াড়রা ১০ সেকেন্ডের জন্য সেই আইটেমগুলো ক্রয় করতে পারবে।
locust -H http://127.0.0.1:8083 -f ./generators/trading_server.py --headless -u=1 -r=1 -t=10s
কমান্ড আউটপুট:
*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
সারসংক্ষেপ
এই ধাপে, আপনি খেলোয়াড়দের গেম খেলার জন্য সাইন আপ করার সিমুলেশন করেছেন এবং তারপর ম্যাচমেকিং পরিষেবা ব্যবহার করে খেলোয়াড়দের গেম খেলার সিমুলেশন চালিয়েছেন। এই সিমুলেশনগুলো আমাদের পরিষেবাগুলোর REST API-তে অনুরোধ পাঠানোর জন্য Locust পাইথন ফ্রেমওয়ার্ক ব্যবহার করেছে।
প্লেয়ার তৈরি করতে ও গেম খেলতে ব্যয়িত সময়, সেইসাথে একযোগে ব্যবহারকারীর সংখ্যা ( -u) ইচ্ছামতো পরিবর্তন করুন।
পরবর্তী পদক্ষেপ
সিমুলেশনের পরে, আপনি স্প্যানার কোয়েরি করে বিভিন্ন পরিসংখ্যান যাচাই করতে চাইবেন।
৬. বাণিজ্য পরিসংখ্যান পুনরুদ্ধার করুন
এখন যেহেতু আমরা খেলোয়াড়দের অর্থ ও জিনিসপত্র অর্জন করা এবং তারপর ট্রেডিং পোস্টে সেগুলো বিক্রি করার প্রক্রিয়াটি অনুকরণ করেছি, চলুন কিছু পরিসংখ্যান দেখে নেওয়া যাক।
এটি করার জন্য, ক্লাউড কনসোল ব্যবহার করে স্প্যানারে কোয়েরি অনুরোধ পাঠান।
খোলা এবং পূরণ হওয়া ট্রেড অর্ডারগুলি পরীক্ষা করা
ট্রেডিং পোস্টে যখন কোনো ট্রেডঅর্ডার কেনা হয়, তখন পূরণ করা মেটাডেটা ফিল্ডটি আপডেট করা হয়।
এই কোয়েরিটি আপনাকে দেখতে সাহায্য করবে যে কতগুলো অর্ডার খোলা আছে এবং কতগুলো পূরণ হয়েছে:
-- 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
)
ফলাফল:
প্রকার | নামট্রেডস |
খোলা ট্রেড | ১৫৯ |
পূরণ করা ট্রেড | ৪৫৪ |
খেলোয়াড়ের অ্যাকাউন্টের ব্যালেন্স এবং আইটেমের সংখ্যা পরীক্ষা করা
কোনো খেলোয়াড়ের 'current_game' কলামে যদি তথ্য দেওয়া থাকে, তাহলে তিনি একটি গেম খেলছেন। অন্যথায়, তিনি বর্তমানে কোনো গেম খেলছেন না।
বর্তমানে সবচেয়ে বেশি আইটেম নিয়ে গেম খেলছেন এমন শীর্ষ ১০ জন খেলোয়াড়কে তাদের অ্যাকাউন্ট ব্যালেন্স সহ খুঁজে বের করতে।
এই কোয়েরিটি ব্যবহার করুন :
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;
ফলাফল:
| | | |
| | | |
| | | |
| | | |
সারসংক্ষেপ
এই ধাপে, আপনি ক্লাউড কনসোল ব্যবহার করে স্প্যানারকে কোয়েরি করার মাধ্যমে প্লেয়ার এবং ট্রেড অর্ডারের বিভিন্ন পরিসংখ্যান পর্যালোচনা করেছেন।
পরবর্তী পদক্ষেপ
এরপর, সবকিছু পরিষ্কার করার পালা!
৭. পরিষ্কার করা
স্প্যানার নিয়ে এত মজা করার পর আমাদের খেলার জায়গাটা পরিষ্কার করতে হবে। সৌভাগ্যবশত, এই কাজটি বেশ সহজ; শুধু ক্লাউড কনসোলের ক্লাউড স্প্যানার বিভাগে যান এবং এই কোডল্যাবের জন্য তৈরি করা ইনস্ট্যান্সটি ডিলিট করে দিন।
৮. অভিনন্দন!
অভিনন্দন, আপনি স্প্যানারে সফলভাবে একটি নমুনা গেম স্থাপন করেছেন।
এরপর কী?
এই ল্যাবে, আপনি গেমের আইটেম তৈরি এবং ট্রেডিং পোস্টে বিক্রির জন্য খেলোয়াড়দের আইটেম সংগ্রহের কাজ সামলানোর জন্য দুটি সার্ভিস সেট আপ করা সম্পন্ন করেছেন।
এই কোড নমুনাগুলো আপনাকে আরও ভালোভাবে বুঝতে সাহায্য করবে যে, DML এবং স্প্যানার মিউটেশন উভয়ের ক্ষেত্রেই ট্রানজ্যাকশনের মধ্যে ক্লাউড স্প্যানার কনসিস্টেন্সি কীভাবে কাজ করে।
স্প্যানারের স্কেলিং অন্বেষণ করতে প্রদত্ত জেনারেটরগুলো নির্দ্বিধায় ব্যবহার করুন।