def create_dynamodb_table():
dynamodb_client = DynamoDBClient().get_client()
dynamodb = DynamoDB(dynamodb_client)
table_name = "Movies"
# define attributes
attribute_definitions = [{
'AttributeName': 'year',
'AttributeType': 'N'
}, {
'AttributeName': 'title',
'AttributeType': 'S'
}]
# key schema definitions
key_schema = [
{
'AttributeName': 'year',
'KeyType': 'HASH' # Partition key
},
{
'AttributeName': 'title',
'KeyType': 'RANGE' # Sort key
}
]
initial_iops = {'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5}
dynamodb_create_table_response = dynamodb.create_table(
table_name, attribute_definitions, key_schema, initial_iops)
print("Created DynamoDB Table named " + table_name + ":" +
str(dynamodb_create_table_response))
def login():
if request.method == 'POST':
session['username'] = request.form['username']
session['password'] = request.form['password']
db = DynamoDB(region=cfg['region'])
user_table = cfg['db_tbl']['user']
if not db._isTable_exists(user_table):
db.create_table(table_name=user_table,
attr_dict={'hash_name': "username"})
try:
user = db.get_item(user_table, {'username': session['username']})
if user and user['password'] == session['password']:
return redirect(url_for('home', user=session['username']))
except:
flash('Username or Password does not exist')
return redirect(request.url)
return render_template('login.html')
def signup():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
email = request.form['email']
db = DynamoDB(region=cfg['region'])
user_table = cfg['db_tbl']['user']
if not db._isTable_exists(user_table):
db.create_table(table_name=user_table,
attr_dict={'hash_name': "username"})
user_info = {
'username': username.strip(),
'password': password.strip(),
'email': email.strip()
}
db.insert_item(user_table, user_info)
return redirect(url_for('login'))
return render_template('signup.html')
def create_dynamodb_table():
dynamodb_client = DynamoDBClient().get_client()
dynamodb = DynamoDB(dynamodb_client)
table_name = 'Movies'
# define attributes
attribute_definitions = [
{
'AttributeName': 'year',
'AttributeType': 'N'
},
{
'AttributeName': 'title',
'AttributeType': 'S'
},
]
# key schema
key_schema = [
{
'AttributeName': 'year',
'KeyType': 'HASH'
},
{
'AttributeName': 'title',
'KeyType': 'RANGE'
}
]
initial_iops = {
'ReadCapacityUnits': 5,
'WriteCapacityUnits': 5
}
dynamodb_create_table_response = dynamodb.create_table(
table_name, attribute_definitions, key_schema, initial_iops
)
print(
f'Created table {table_name} : {str(dynamodb_create_table_response)}')
def upload_file(user):
if request.method == 'POST':
if 'image' not in request.files:
flash('No file part')
return redirect(url_for('home', user=session['username']))
img_file = request.files['image']
if img_file.filename == '':
flash('No selected file')
return redirect(request.url)
elif not allowed_file(img_file.filename):
flash('Wrong format. Not in ' +
', '.join(list(ALLOWED_EXTENSIONS)))
return redirect(url_for('home', user=user))
else:
local_img_path = os.path.join(app.config['UPLOAD_FOLDER'],
secure_filename(img_file.filename))
img_file.save(local_img_path)
if os.path.exists(local_img_path):
logger.debug('Image saved. %s', local_img_path)
try:
filename = secure_filename(img_file.filename)
session = S3(aws_key=cfg['aws_key'],
aws_secret=cfg['aws_secret'],
region=cfg['region'])
url = session.upload_file_to_s3(local_img_path,
cfg['bucket'], filename)
db = DynamoDB(region=cfg['region'])
photo_table = cfg['db_tbl']['album']
if not db._isTable_exists(photo_table):
db.create_table(table_name=photo_table,
attr_dict={
'hash_name': 'owner',
'range_name': 'group'
})
if url:
db.insert_item(
photo_table, {
'owner':
user,
'group':
cfg['group']['pub'],
'filename':
filename,
'url':
url,
'upload_date':
datetime.now().date().strftime('%Y-%m-%d'),
})
flash('Uploading finished.')
return redirect(url_for('home', user=user))
else:
logger.error("URL not returned")
except Exception as err:
logger.error(str(err))
return redirect(url_for('home', user=user))
else:
logger.error('Save to local folder failed')
flash('Upload failed. Try again')
return redirect(url_for('home', user=user))
return redirect(request.url)
class TestDynamoDBCounterTestCase(unittest.TestCase):
"""
Create table 'test_counter' and 'test_counter_shard_index' before you run this test
"""
def setUp(self):
self.settings = DB_SETTINGS['dynamodb']
self.db = DynamoDB(self.settings)
self.db.create_table('test_counter', 5, 5)
self.db.create_table('test_counter_shard_index', 5, 5)
self.db.create_table('test_counter_%Y%m%d', 5, 5)
self.db.create_table('test_counter_%Y%m%d', 5, 5,
transform_time=datetime.datetime.utcnow() - datetime.timedelta(1))
def test_incr(self):
table_name = 'test_counter'
key = str(uuid4())
self.db.incr(table_name, key)
self.assertEqual(self.db.get_count(table_name, key), 1)
self.db.incr(table_name, key, 2)
self.assertEqual(self.db.get_count(table_name, key), 3)
self.db.incr(table_name, key, -1)
self.assertEqual(self.db.get_count(table_name, key), 2)
self.db.delete_counter(table_name, key)
def test_multithread_counter(self):
table_name = 'test_counter'
count = 20
key = str(uuid4())
def incr_counter():
self.db.incr(table_name, key)
start = self.db.get_count(table_name, key) or 0
threadlist = []
for _ in xrange(0, count):
thread = Thread(target=incr_counter)
thread.start()
threadlist.append(thread)
time.sleep(0.01)
for t in threadlist:
t.join(60)
final = self.db.get_count(table_name, key)
self.assertEqual(start + count, final)
self.db.delete_counter(table_name, key)
def test_shard_counter(self):
table_name = 'test_counter'
shard_count = 100
key = str(uuid4())
self.db.incr(table_name, key, 1, shard_count=shard_count)
self.assertEqual(self.db.get_count(table_name, key, sharded=True), 1)
self.db.incr(table_name, key, 2, shard_count=shard_count)
self.assertEqual(self.db.get_count(table_name, key, sharded=True), 3)
self.db.delete_counter(table_name, key)
def test_multithread_shard_counter(self):
table_name = 'test_counter'
count = 50
shard_count = 60
key = str(uuid4())
def incr_counter():
self.db.incr(table_name, key, shard_count=shard_count)
start = self.db.get_count(table_name, key) or 0
threadlist = []
for _ in xrange(0, count):
thread = Thread(target=incr_counter)
thread.start()
threadlist.append(thread)
time.sleep(0.01)
for t in threadlist:
t.join(60)
final = self.db.get_count(table_name, key, sharded=True)
self.assertEqual(start + count, final)
self.db.delete_counter(table_name, key)
class TestDynamoDBTestCase(unittest.TestCase):
"""
Create a tables before you run the tests, and it takes a minute
"""
def setUp(self):
self.settings = DB_SETTINGS['dynamodb']
self.db = DynamoDB(self.settings)
try:
self.db.create_table('test', 5, 5)
self.db.create_table('test_%Y%m%d', 5, 5)
self.db.create_table('test_%Y%m%d', 5, 5,
transform_time=datetime.datetime.utcnow() - datetime.timedelta(1))
except DynamoDBError as e:
print e
def tearDown(self):
s = SomeRecord()
try:
self.db.delete_data('test', 'k')
except:
pass
try:
self.db.delete_data('test', 'c')
except:
pass
try:
self.db.delete_data('test', s.key)
except:
pass
return self
def test_create_table(self):
table = self.db.get_table('test')
self.assertTrue(table.table_name == 'test')
def test_create_delete_data(self):
# pickled
result = self.db.set_data('test', 'k', 'v')
self.assertEqual(result, True, 'fail to set data')
data = self.db.get_data('test', 'k')
self.assertEqual(data, 'v', 'fail to get data')
# pickled object
c = SomeRecord()
self.db.set_data('test', c.key, c)
new_c = self.db.get_data('test', c.key)
self.assertTrue(new_c.key == c.key)
self.assertTrue(new_c.answer == c.answer)
self.assertTrue(new_c.number == c.number)
# unpickled
self.db.set_data('test', 'k2', set(['a', 'b']), pickled=False)
data = self.db.get_data('test', 'k2', pickled=False)
self.assertEqual(data, set(['a', 'b']), 'fail getting correct unpickled data')
self.assertTrue(self.db.delete_data('test', 'k'))
self.assertTrue(self.db.delete_data('test', 'k2'))
self.assertTrue(self.db.delete_data('test', c.key))
self.assertFalse(self.db.get_data('test', 'k'))
def test_timesliced_table(self):
yesterday = datetime.datetime.utcnow() - datetime.timedelta(1)
self.db.set_data("test_%Y%m%d", "ky", "dy", transform_time=yesterday)
self.assertEqual(self.db.get_data("test_%Y%m%d", "ky"), "dy")
self.db.delete_data('test_%Y%m%d', 'ky')
self.assertEqual(self.db.get_data("test_%Y%m%d", "ky"), None)
