272 lines
8.7 KiB
Python
272 lines
8.7 KiB
Python
import datetime
|
|
import time
|
|
import boto3
|
|
import json
|
|
import os
|
|
import requests
|
|
|
|
|
|
local_region = os.environ['AWS_REGION']
|
|
|
|
dynamo_client = boto3.client('dynamodb', region_name=local_region)
|
|
timestream_client = boto3.client('timestream-write', region_name=local_region)
|
|
tables = {
|
|
'retail': {
|
|
'recent': 'wow-token-price-recent',
|
|
'current': 'wow-token-price',
|
|
'timestream': 'wow-token-price-history'
|
|
},
|
|
'classic': {
|
|
'recent': 'wow-token-classic-price-recent',
|
|
'current': 'wow-token-classic-price',
|
|
'timestream': 'wow-token-classic-price-history'
|
|
}
|
|
}
|
|
|
|
|
|
# a lambda handler to handle eventbridge triggered vents
|
|
def lambda_handler(event, context):
|
|
flavors = ['retail', 'classic']
|
|
regions = ['us', 'eu', 'kr', 'tw']
|
|
timestamp = int(datetime.datetime.utcnow().timestamp())
|
|
for flavor in flavors:
|
|
flavor_handler(flavor, regions, timestamp)
|
|
|
|
|
|
def flavor_handler(flavor: str, regions: list, timestamp: int) -> None:
|
|
for region in regions:
|
|
if flavor == 'retail':
|
|
namespace = 'dynamic'
|
|
else:
|
|
namespace = 'dynamic-classic'
|
|
live_price = get_token_price_from_blizzard(region, namespace)
|
|
print(f"{flavor} {region} live price {live_price}")
|
|
print(f'Updating {region.upper()}...')
|
|
update_token_price(flavor, region, timestamp, live_price)
|
|
|
|
|
|
def update_token_price(flavor: str, region: str, current_time_epoch: int, live_price: int) -> None:
|
|
stored_price = get_stored_price(flavor, region)
|
|
regional_item = get_regional_update_item(flavor, region)
|
|
print(f'Current live price {live_price}')
|
|
print(f'Current stored price {stored_price}')
|
|
regional_price = int(regional_item['price']['S'])
|
|
print(f'Current regional price {regional_price}')
|
|
if stored_price != live_price:
|
|
# If the stored price is not the same as the live price, nor the regional price
|
|
# assume no other Lambda has updated it and update it
|
|
print(f"Stored price is differing from the live price, updating all databases")
|
|
update_stored_token_price(flavor, region, live_price, current_time_epoch)
|
|
update_recent_token_price(flavor, region, live_price, current_time_epoch)
|
|
update_regional_price(flavor, region, live_price, current_time_epoch)
|
|
update_timestream_token_price(flavor, region, live_price, current_time_epoch)
|
|
if (stored_price == live_price) and (regional_price != stored_price):
|
|
print(f"Stored price differs from regional price but not live price, updating regional databases")
|
|
update_regional_price(flavor, region, live_price, current_time_epoch)
|
|
update_timestream_token_price(flavor, region, live_price, current_time_epoch)
|
|
else:
|
|
print(f"Price hasn't changed for {flavor} {region.upper()}")
|
|
|
|
|
|
# update the current price records in DynamoDB
|
|
def update_stored_token_price(flavor: str, region: str, price: int, current_time_epoch: int) -> None:
|
|
dynamo_client.update_item(
|
|
TableName=tables[flavor]['current'],
|
|
Key={
|
|
'region': {
|
|
'S': region
|
|
}
|
|
},
|
|
UpdateExpression='SET price = :p, current_time = :t',
|
|
ExpressionAttributeValues={
|
|
':p': {
|
|
'S': str(price)
|
|
},
|
|
':t': {
|
|
'S': str(current_time_epoch)
|
|
}
|
|
}
|
|
# ReturnValues="UPDATED_NEW"
|
|
)
|
|
print(f'Updated {flavor} {region.upper()} price to {price}')
|
|
|
|
|
|
def update_regional_price(flavor: str, region: str, price: int, current_time_epoch: int) -> None:
|
|
if flavor == 'retail':
|
|
key = region
|
|
else:
|
|
key = f"{flavor}-{region}"
|
|
dynamo_client.update_item(
|
|
TableName='wow-token-regional',
|
|
Key={
|
|
'region': {
|
|
'S': key
|
|
}
|
|
},
|
|
UpdateExpression='SET price = :p, current_time = :t',
|
|
ExpressionAttributeValues={
|
|
':p': {
|
|
'S': str(price)
|
|
},
|
|
':t': {
|
|
'S': str(current_time_epoch)
|
|
}
|
|
}
|
|
# ReturnValues="UPDATED_NEW"
|
|
)
|
|
print(f'Updated regional {flavor} {region.upper()} price to {price}')
|
|
|
|
|
|
def create_regional_item(flavor: str, region: str) -> None:
|
|
print(f"Creating default regional item in {flavor} {region}")
|
|
if flavor == 'retail':
|
|
key = region
|
|
else:
|
|
key = f"{flavor}-{region}"
|
|
dynamo_client.put_item(
|
|
TableName='wow-token-regional',
|
|
Item={
|
|
'region': {
|
|
'S': key
|
|
},
|
|
'price': {
|
|
'S': str(1)
|
|
},
|
|
'timestamp': {
|
|
'N': str(1)
|
|
}
|
|
}
|
|
)
|
|
|
|
|
|
# add a record to the recent token price table in DynamoDB
|
|
def update_recent_token_price(flavor: str, region: str, price: int, current_time_epoch: int) -> None:
|
|
dynamo_client.put_item(
|
|
TableName=tables[flavor]['recent'],
|
|
Item={
|
|
'region': {
|
|
'S': region
|
|
},
|
|
'price': {
|
|
'S': str(price)
|
|
},
|
|
'timestamp': {
|
|
'N': str(current_time_epoch)
|
|
},
|
|
'expire': {
|
|
'N': str(current_time_epoch + (60 * 60 * 24 * 31 * 12))
|
|
}
|
|
}
|
|
# ReturnValues="UPDATED_NEW"
|
|
)
|
|
print(f'Added {region.upper()} price {price} to {tables[flavor]["recent"]} table')
|
|
|
|
|
|
def update_timestream_token_price(flavor: str, region: str, price: int, current_time_epoch: int) -> None:
|
|
record_inserted = False
|
|
while not record_inserted:
|
|
try:
|
|
print('Attempting to write to Timestream')
|
|
timestream_client.write_records(
|
|
DatabaseName=tables[flavor]['timestream'],
|
|
TableName=f'{region}-price-history',
|
|
Records=[
|
|
build_timestream_record(region, price, current_time_epoch),
|
|
]
|
|
)
|
|
record_inserted = True
|
|
except Exception as e:
|
|
print(f'Error writing to Timestream: {e}')
|
|
time.sleep(2)
|
|
print(f'Updated {flavor} {region.upper()} price to {price} in Timestream')
|
|
|
|
|
|
def build_timestream_record(region: str, price: int, current_time_epoch: int) -> dict:
|
|
return {
|
|
'Dimensions': [
|
|
{
|
|
'Name': 'region',
|
|
'Value': region,
|
|
'DimensionValueType': 'VARCHAR'
|
|
}
|
|
],
|
|
'MeasureName': 'price',
|
|
'MeasureValue': str(price),
|
|
'MeasureValueType': 'BIGINT',
|
|
'Time': str(current_time_epoch),
|
|
'TimeUnit': 'SECONDS',
|
|
}
|
|
|
|
|
|
# get the current stored token price from dynamodb
|
|
def get_stored_price(flavor: str, region: str) -> int:
|
|
response = dynamo_client.get_item(
|
|
TableName=tables[flavor]['current'],
|
|
Key={
|
|
'region': {
|
|
'S': region
|
|
}
|
|
}
|
|
)
|
|
return int(response['Item']['price']['S'])
|
|
|
|
|
|
def get_regional_update_item(flavor: str, region: str) -> dict:
|
|
if flavor == 'retail':
|
|
key = region
|
|
else:
|
|
key = f"{flavor}-{region}"
|
|
response = dynamo_client.get_item(
|
|
TableName='wow-token-regional',
|
|
Key={
|
|
'region': {
|
|
'S': key
|
|
}
|
|
}
|
|
)
|
|
if 'Item' in response:
|
|
return response['Item']
|
|
else:
|
|
create_regional_item(flavor, region)
|
|
time.sleep(5)
|
|
return get_regional_update_item(flavor, region)
|
|
|
|
|
|
def get_combined_live_price(game_flavor: str) -> dict:
|
|
if game_flavor == 'retail':
|
|
namespace = 'dynamic'
|
|
else:
|
|
namespace = 'dynamic-classic'
|
|
|
|
return {
|
|
'us': get_token_price_from_blizzard('us', namespace),
|
|
'eu': get_token_price_from_blizzard('eu', namespace),
|
|
'kr': get_token_price_from_blizzard('kr', namespace),
|
|
'tw': get_token_price_from_blizzard('tw', namespace)
|
|
}
|
|
|
|
|
|
def get_token_price_from_blizzard(region: str, namespace: str) -> int:
|
|
api_endpoint = f'https://{region}.api.blizzard.com/data/wow/token/index'
|
|
params = {'namespace': f'{namespace}-{region}'}
|
|
headers = {'Authorization': f'Bearer {get_oauth_token()}'}
|
|
response = requests.get(api_endpoint, params=params, headers=headers)
|
|
response.raise_for_status()
|
|
return int(response.json()['price'])
|
|
|
|
|
|
def get_oauth_token() -> str:
|
|
url = 'https://us.battle.net/oauth/token'
|
|
payload = {
|
|
'grant_type': 'client_credentials',
|
|
'client_id': os.environ.get('BLIZZARD_CLIENT_ID'),
|
|
'client_secret': os.environ.get('BLIZZARD_CLIENT_SECRET')
|
|
}
|
|
response = requests.post(url, data=payload)
|
|
response.raise_for_status()
|
|
return json.loads(response.text)['access_token']
|
|
|
|
|
|
if __name__ == '__main__':
|
|
lambda_handler(None, None)
|