ক্লাউড স্প্যানার গেম ট্রেডিং পোস্ট

1. ভূমিকা

ক্লাউড স্প্যানার হল একটি সম্পূর্ণরূপে পরিচালিত অনুভূমিকভাবে পরিমাপযোগ্য, বিশ্বব্যাপী বিতরণ করা, রিলেশনাল ডাটাবেস পরিষেবা যা কর্মক্ষমতা এবং উচ্চ প্রাপ্যতা ছাড়াই ACID লেনদেন এবং SQL শব্দার্থবিদ্যা প্রদান করে।

এই বৈশিষ্ট্যগুলি স্প্যানারকে গেমগুলির আর্কিটেকচারে একটি দুর্দান্ত ফিট করে তোলে যা বিশ্বব্যাপী প্লেয়ার বেস সক্ষম করতে চায় বা ডেটা সামঞ্জস্যের বিষয়ে উদ্বিগ্ন

এই ল্যাবে, আপনি দুটি Go পরিষেবা তৈরি করবেন যা খেলোয়াড়দের আইটেম এবং অর্থ ( item-service ) অর্জন করতে সক্ষম করার জন্য একটি আঞ্চলিক স্প্যানার ডাটাবেসের সাথে ইন্টারঅ্যাক্ট করে এবং তারপরে অন্যান্য খেলোয়াড়দের কেনার জন্য ট্রেডিং পোস্টে আইটেম তালিকাভুক্ত করে ( tradepost-service ) .

profile-service এবং matchmaking-service ব্যবহার করে খেলোয়াড় এবং গেম তৈরি করতে এই ল্যাবটি গেমস ডেভেলপমেন্ট কোডল্যাব দিয়ে শুরু করা ক্লাউড স্প্যানারের উপর নির্ভরশীল।

904c5193ee27626a.png

এরপরে আপনি "গেম প্লে" কোর্সের মাধ্যমে অর্থ এবং আইটেম অর্জনকারী খেলোয়াড়দের অনুকরণ করতে পাইথন লোড ফ্রেমওয়ার্ক Locust.io-এর সাহায্যে ডেটা তৈরি করবেন। খেলোয়াড়রা তারপরে একটি ট্রেডপোস্টে বিক্রয়ের জন্য আইটেমগুলি তালিকাভুক্ত করতে পারে, যেখানে পর্যাপ্ত অর্থ সহ অন্যান্য খেলোয়াড়রা সেই আইটেমগুলি কিনতে পারে।

আপনি খেলোয়াড়দের অ্যাকাউন্ট ব্যালেন্স এবং আইটেমের সংখ্যা এবং খোলা বা পূরণ করা ট্রেড অর্ডার সম্পর্কে কিছু পরিসংখ্যান নির্ধারণ করতে স্প্যানারকে জিজ্ঞাসা করবেন।

অবশেষে, আপনি এই ল্যাবে তৈরি করা সংস্থানগুলি পরিষ্কার করবেন।

আপনি কি নির্মাণ করবেন

এই ল্যাবের অংশ হিসাবে, আপনি করবেন:

  • ক্লাউড স্প্যানার গেম ডেভেলপমেন্টের সাথে শুরু করা থেকে স্প্যানার উদাহরণটি পুনরায় ব্যবহার করুন।
  • আইটেম এবং অর্থ অর্জনকারী খেলোয়াড়দের পরিচালনা করার জন্য Go লেখা একটি আইটেম পরিষেবা স্থাপন করুন
  • Go to লেখা একটি ট্রেডিং পোস্ট পরিষেবা স্থাপন করুন যা প্লেয়ারদের তালিকাভুক্ত আইটেম বিক্রয়ের জন্য অনুকরণ করে এবং অন্যান্য খেলোয়াড়রা সেই আইটেমগুলি ক্রয় করে।

আপনি কি শিখবেন

  • ডেটা পরিবর্তনের সামঞ্জস্য নিশ্চিত করতে কীভাবে পঠন-লিখতে লেনদেন ব্যবহার করবেন
  • ডেটা পরিবর্তন করতে ডিএমএল এবং স্প্যানার মিউটেশনগুলি কীভাবে ব্যবহার করবেন

আপনি কি প্রয়োজন হবে

2. সেটআপ এবং প্রয়োজনীয়তা

গেম ডেভেলপমেন্ট কোডল্যাব দিয়ে শুরু করা ক্লাউড স্প্যানার সম্পূর্ণ করুন

গেম ডেভেলপমেন্ট কোডল্যাব দিয়ে শুরু করা ক্লাউড স্প্যানার সম্পূর্ণ করুন। প্লেয়ার এবং গেমগুলির একটি ডেটাসেট পেতে এটি প্রয়োজন৷ আইটেম এবং অর্থ অর্জনের জন্য প্লেয়ার এবং গেমগুলির প্রয়োজন হয়, যা ফলস্বরূপ বিক্রির জন্য আইটেম তালিকাভুক্ত করতে এবং ট্রেডিং পোস্ট থেকে আইটেম কেনার জন্য ব্যবহৃত হয়।

ক্লাউড শেলে পরিবেশের ভেরিয়েবল কনফিগার করুন

অ্যাক্টিভেট ক্লাউড শেল ক্লিক করে ক্লাউড শেল খুলুন gcLMt5IuEcJJNnMId-Bcz3sxCd0rZn7IzT_r95C8UZeqML68Y1efBG_B0VRp7hc7qiZTLAF-TXD7SsOadxn8uadgHhaLeASnVS3ZHKLJXOgOg39g ddS2A (যেহেতু আপনি আগে এটি করেছেন সেহেতু পরিবেশের সাথে ব্যবস্থা এবং সংযোগের জন্য এটি শুধুমাত্র কয়েক মুহূর্ত লাগবে)।

JjEuRXGg0AYYIY6QZ8d-66gx_Mtc-_jDE9ijmbXLJSAXFvJt-qUpNtsBsYjNpv2W6BQSrDc1D-ARINNQ-1EkwUhz-iUK-FUCZhJ-NtjvDu64GoM8 Rw

স্ক্রীন শট 2017-06-14 10.13.43 PM.png এ

একবার ক্লাউড শেলের সাথে সংযুক্ত হয়ে গেলে, আপনি দেখতে পাবেন যে আপনি ইতিমধ্যেই প্রমাণীকৃত এবং প্রকল্পটি ইতিমধ্যেই আপনার PROJECT_ID-তে সেট করা আছে৷

ক্লাউড শেল এ স্প্যানারের পরিবেশের ভেরিয়েবল সেট করুন

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

402ce3310dd7141a.png

প্লেয়ার আইটেম সম্পর্ক

5e1229d85b75906.png

বাণিজ্য আদেশ সম্পর্ক

গেমের আইটেমগুলি game_items সারণীতে যোগ করা হয় এবং তারপরে খেলোয়াড়রা অধিগ্রহণ করতে পারে। player_items টেবিলে একটি আইটেমইউইউআইডি এবং প্লেয়ারইউইউআইডি উভয়ের বিদেশী কী রয়েছে যাতে নিশ্চিত করা যায় যে খেলোয়াড়রা শুধুমাত্র বৈধ আইটেমগুলি অর্জন করছে।

player_ledger_entries টেবিলটি প্লেয়ারের অ্যাকাউন্ট ব্যালেন্সে যেকোনো আর্থিক পরিবর্তনের ট্র্যাক রাখে। এটি লুট থেকে অর্থ অর্জন হতে পারে, বা ট্রেডিং পোস্টে আইটেম বিক্রি করে।

এবং সবশেষে, trade_orders টেবিলটি বিক্রির অর্ডার পোস্ট করার জন্য এবং ক্রেতাদের সেই অর্ডারগুলি পূরণ করতে ব্যবহার করা হয়।

স্কিমা তৈরি করতে, আপনি ক্লাউড কনসোলে Write DDL বোতামে ক্লিক করবেন:

e9ad931beb1d96b.png

এখানে, আপনি 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 ' বোতামে ক্লিক করুন, এবং স্কিমা আপডেট সম্পূর্ণ না হওয়া পর্যন্ত অপেক্ষা করুন:

94f44b2774bce914.png

পরবর্তী আপ

এর পরে, আপনি আইটেম পরিষেবা স্থাপন করবেন।

3. আইটেম পরিষেবা স্থাপন করুন

পরিষেবা ওভারভিউ

আইটেম পরিষেবা হল একটি REST API যা Go-তে লেখা যা জিন ফ্রেমওয়ার্কের সুবিধা দেয়। এই API-তে, যে খেলোয়াড়রা ওপেন গেমে অংশগ্রহণ করছে তারা অর্থ এবং আইটেম অর্জন করে।

6c29a0831b5f588d.png

./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 অনুরোধ বলা হয়। গেম_আইটেম টেবিলে এটি একটি খুব সাধারণ ডিএমএল সন্নিবেশ।

 // 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 অনুরোধ বলা হয়। এই শেষ পয়েন্টের যুক্তি হল একটি গেম আইটেমের বর্তমান মান এবং খেলোয়াড়ের বর্তমান গেম সেশন পুনরুদ্ধার করা। তারপরে প্লেয়ার_আইটেম টেবিলে উপযুক্ত তথ্য সন্নিবেশ করুন যাতে আইটেম অধিগ্রহণের উত্স এবং সময় নির্দেশ করে।

এই নিম্নলিখিত ফাংশন মানচিত্র:

 // 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 অনুরোধ বলা হয়।

এই এন্ডপয়েন্টের যুক্তি হল পরিমাণ প্রয়োগ করার পরে প্লেয়ারের ব্যালেন্স আপডেট করা, সেইসাথে অধিগ্রহণের রেকর্ড সহ player_ledger_entries টেবিল আপডেট করা। খেলোয়াড়ের অ্যাকাউন্ট_ব্যালেন্স কলকারীকে ফেরত দেওয়ার জন্য পরিবর্তন করা হয়। DML প্লেয়ার এবং player_ledger_entries উভয় পরিবর্তন করতে ব্যবহৃত হয়।

এই নিম্নলিখিত ফাংশন মানচিত্র:

 // 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
}

আপনি দেখতে পাচ্ছেন যে স্থানীয় হোস্ট:8082-এ পরিষেবা চালানোর জন্য ডিফল্ট আচরণ।

এই তথ্য দিয়ে পরিষেবাটি চালানোর সময় এসেছে।

পরিষেবা চালান

পরিষেবাটি চালানো নির্ভরতা ডাউনলোড করবে, এবং পোর্ট 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 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
}

সারাংশ

এই ধাপে, আপনি আইটেম পরিষেবা স্থাপন করেছেন যা গেমের আইটেমগুলি তৈরি করতে দেয় এবং গেমগুলি খোলার জন্য নির্ধারিত খেলোয়াড়দের অর্থ এবং গেমের আইটেমগুলি অর্জন করতে সক্ষম হয়৷

পরবর্তী পদক্ষেপ

পরবর্তী ধাপে, আপনি ট্রেডপোস্ট পরিষেবা স্থাপন করবেন।

4. ট্রেডপোস্ট পরিষেবা স্থাপন করুন

পরিষেবা ওভারভিউ

ট্রেডপোস্ট পরিষেবা হল গো-তে লেখা একটি REST API যা জিন ফ্রেমওয়ার্কের সুবিধা দেয়। এই API এ, প্লেয়ার আইটেম বিক্রি করার জন্য পোস্ট করা হয়। গেম প্লেয়াররা তখন খোলা ট্রেড পেতে পারে, এবং যদি তাদের পর্যাপ্ত টাকা থাকে, আইটেম কিনতে পারে।

c32372f9def89a4a.png

ট্রেডপোস্ট পরিষেবার জন্য ./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())
}

এই পরিষেবাটি একটি ট্রেডঅর্ডার কাঠামো প্রদান করে, সেইসাথে GameItem, PlayerItem, Player, এবং 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"`
}

একটি ট্রেড অর্ডার তৈরি করতে, API এন্ডপয়েন্ট /trades/sell- এ একটি POST অনুরোধ জারি করা হয়। প্রয়োজনীয় তথ্য হল player_item এর playerItemUUID বিক্রি করা হবে, লিস্টার , এবং list_price।

স্প্যানার মিউটেশনগুলি ট্রেড অর্ডার তৈরি করতে এবং প্লেয়ার_আইটেমটিকে দৃশ্যমান নয় হিসাবে চিহ্নিত করতে বেছে নেওয়া হয়। এটি করা বিক্রেতাকে বিক্রির জন্য ডুপ্লিকেট আইটেম পোস্ট করতে বাধা দেয়।

 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
}

প্রকৃতপক্ষে অর্ডার তৈরি করার আগে, PlayerItem বিক্রয়ের জন্য তালিকাভুক্ত করা যেতে পারে তা নিশ্চিত করার জন্য যাচাই করা হয়। প্রাথমিকভাবে এর অর্থ হল প্লেয়ার আইটেমটি প্লেয়ারের কাছে দৃশ্যমান এবং এটির মেয়াদ শেষ হয়নি৷

 // 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
}

একটি কেনাকাটা করা হয় একটি PUT অনুরোধ /trades/buy endpoint-এ। প্রয়োজনীয় তথ্য হল অর্ডার ইউইউআইডি এবং ক্রেতা , যা ক্রয়কারী প্লেয়ারের ইউইউআইডি।

এই জটিলতা এবং পরিবর্তনের পরিমাণের কারণে, অর্ডার ক্রয়ের জন্য আবার মিউটেশন বেছে নেওয়া হয়। নিম্নলিখিত ক্রিয়াকলাপগুলি একটি একক রিড-রাইট লেনদেনে করা হয়:

  • যাচাই করুন অর্ডারটি পূরণ করা যেতে পারে কারণ এটি আগে পূরণ করা হয়নি এবং মেয়াদ শেষ হয়নি।
 // 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
}
  • ক্রেতার অ্যাকাউন্টের ব্যালেন্স থেকে অর্ডারের তালিকা_মূল্য বিয়োগ করুন, একটি ম্যাচিং লেজার এন্ট্রি সহ।
 // 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 অন্যান্য পরিষেবার সাথে বিরোধ এড়াতে*।*

এই তথ্য দিয়ে, এখন ট্রেডপোস্ট পরিষেবা চালানোর সময়।

পরিষেবা চালান

পরিষেবাটি চালানোর ফলে পোর্ট 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/sel l এন্ডপয়েন্টে কল করে বিক্রয়ের জন্য একটি আইটেম পোস্ট করা যাক

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"

সারাংশ

এই ধাপে, আপনি বিক্রয় অর্ডার তৈরি পরিচালনা করতে ট্রেডপোস্ট-পরিষেবা স্থাপন করেছেন। এই পরিষেবাটি সেই অর্ডারগুলি কেনার ক্ষমতাও পরিচালনা করে।

পরবর্তী পদক্ষেপ

এখন যেহেতু আপনার পরিষেবাগুলি চলছে, এটি ট্রেডিং পোস্টে খেলোয়াড়দের বিক্রি এবং কেনার অনুকরণ করার সময়!

5. ট্রেডিং শুরু করুন

এখন যেহেতু আইটেম এবং ট্রেডপোস্ট পরিষেবাগুলি চলছে, আপনি প্রদত্ত পঙ্গপাল জেনারেটর ব্যবহার করে লোড তৈরি করতে পারেন৷

পঙ্গপাল জেনারেটর চালানোর জন্য একটি ওয়েব-ইন্টারফেস অফার করে, কিন্তু এই ল্যাবে আপনি কমান্ড লাইন ( -হেডলেস বিকল্প) ব্যবহার করবেন।

গেম আইটেম তৈরি করুন

প্রথমত, আপনি আইটেম তৈরি করতে চান। ./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 ফাইলটিকে কল করে যা 10 সেকেন্ডের জন্য গেম আইটেম তৈরি করবে ( 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'")

এই কমান্ডটি খেলোয়াড়দের 60 সেকেন্ডের জন্য আইটেম এবং অর্থ অর্জনের অনুমতি দেবে:

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'")

এই কমান্ডটি খেলোয়াড়দের তাদের বিক্রির জন্য অর্জিত আইটেমগুলি তালিকাভুক্ত করতে এবং অন্যান্য খেলোয়াড়দের 10 সেকেন্ডের জন্য সেই আইটেমগুলি কেনার অনুমতি দেবে:

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 এপিআই-তে অনুরোধ জারি করার জন্য Locust Python ফ্রেমওয়ার্কের সাহায্য করেছে।

প্লেয়ার তৈরি এবং গেম খেলতে ব্যয় করা সময়, সেইসাথে সমসাময়িক ব্যবহারকারীর সংখ্যা ( -u) পরিবর্তন করতে নির্দ্বিধায়।

পরবর্তী পদক্ষেপ

সিমুলেশনের পরে, আপনি স্প্যানারকে জিজ্ঞাসা করে বিভিন্ন পরিসংখ্যান পরীক্ষা করতে চাইবেন।

6. বাণিজ্য পরিসংখ্যান পুনরুদ্ধার করুন

এখন যেহেতু আমরা সিমুলেটেড প্লেয়াররা অর্থ এবং আইটেম অর্জন করেছি, তারপর সেই আইটেমগুলিকে ট্রেডিং পোস্টে বিক্রি করছি, আসুন কিছু পরিসংখ্যান পরীক্ষা করা যাক।

এটি করতে, স্প্যানারকে ক্যোয়ারী অনুরোধ ইস্যু করতে ক্লাউড কনসোল ব্যবহার করুন।

b5e3154c6f7cb0cf.png

ওপেন বনাম পূরণকৃত ট্রেড অর্ডার চেক করা হচ্ছে

যখন একটি ট্রেডঅর্ডার ট্রেডিং পোস্টে কেনা হয়, ভরা মেটাডেটা ক্ষেত্র আপডেট করা হয়।

এই ক্যোয়ারীটি আপনাকে পরীক্ষা করবে যে কতগুলি অর্ডার খোলা আছে এবং কতগুলি পূরণ হয়েছে:

-- 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
)

ফলাফল:

টাইপ

NumTrades

ওপেন ট্রেডস

159

ভরা ট্রেডস

454

প্লেয়ার অ্যাকাউন্ট ব্যালেন্স এবং আইটেম সংখ্যা পরীক্ষা করা হচ্ছে

একজন খেলোয়াড় একটি গেম খেলছে যদি তাদের বর্তমান_গেম কলাম সেট করা থাকে। অন্যথায়, তারা বর্তমানে একটি খেলা খেলছে না.

শীর্ষ 10 জন খেলোয়াড়ের কাছে যাওয়ার জন্য যারা বর্তমানে সর্বাধিক আইটেম সহ গেম খেলছেন, তাদের অ্যাকাউন্ট_ব্যালেন্স সহ

, এই ক্যোয়ারী ব্যবহার করুন:

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;

ফলাফল:

playerUUID

account_balance

numItems

current_game

04d14288-a7c3-4515-9296-44eeae184d6d

1396.55

201

79f24cd4-102d-4d7d-bbe8-be69d364ebbf

03836948-d591-4967-a8a8-80506454916d

2005.085

192

053c353e-e56d-4b2e-9431-76eedf58bea5


snip


snip


snip


snip

সারাংশ

এই ধাপে, আপনি স্প্যানারকে জিজ্ঞাসা করতে ক্লাউড কনসোল ব্যবহার করে প্লেয়ার এবং ট্রেড অর্ডারের বিভিন্ন পরিসংখ্যান পর্যালোচনা করেছেন।

পরবর্তী পদক্ষেপ

পরবর্তী, এটা পরিষ্কার করার সময়!

7. পরিষ্কার করা

স্প্যানারের সাথে মজা করার পরে আমাদের খেলার মাঠ পরিষ্কার করতে হবে। ভাগ্যক্রমে এটি একটি সহজ পদক্ষেপ, শুধু ক্লাউড কনসোলের ক্লাউড স্প্যানার বিভাগে যান এবং এই কোডল্যাবের জন্য আমরা যে উদাহরণটি তৈরি করেছি তা মুছুন।

8. অভিনন্দন!

অভিনন্দন, আপনি সফলভাবে স্প্যানারে একটি নমুনা গেম স্থাপন করেছেন৷

এরপর কি?

এই ল্যাবে, আপনি গেম আইটেম তৈরি এবং ট্রেডিং পোস্টে বিক্রি করা আইটেম অর্জনকারী খেলোয়াড়দের পরিচালনা করার জন্য দুটি পরিষেবা সেট আপ সম্পূর্ণ করেছেন।

এই কোড নমুনাগুলি আপনাকে DML এবং স্প্যানার মিউটেশন উভয়ের জন্য লেনদেনের মধ্যে ক্লাউড স্প্যানারের সামঞ্জস্য কিভাবে কাজ করে সে সম্পর্কে আরও ভালভাবে বুঝতে হবে৷

স্কেলিং স্প্যানার অন্বেষণ করতে প্রদত্ত জেনারেটর ব্যবহার করতে দ্বিধা বোধ করুন।