def api_instance_lifecycle(type, instance_name):
if (check_user_credential(request) is False):
return Response("Invalid Credential", 401)
username = request.authorization.get('username')
if (check_instance_ownership(username, instance_name) is False):
return Response("Invalid Credential", 401)
if (type == "start"):
conn = create_connection_from_config()
if (start_instance(conn, instance_name) is True):
conn.close()
return Response(response=json.dumps({"status": "OK"}), status=200)
elif (type == "shutdown"):
conn = create_connection_from_config()
if (shut_off_instance(conn, instance_name) is True):
conn.close()
return Response(response=json.dumps({"status": "OK"}), status=200)
elif (type == "reboot"):
conn = create_connection_from_config()
if (reboot_instance(conn, instance_name) is True):
conn.close()
return Response(response=json.dumps({"status": "OK"}), status=200)
else:
return Response("Invalid operation", 400)
return Response("Failed", 400)
def api_create_user():
content = request.get_json()
# Try to get data from json body
try:
username = content["username"]
password = content["password"]
email = content["email"]
# If data is not correct in the body, return 400
except TypeError:
return Response("Bad Request", 400)
# Create user
else:
# Open conenction
conn = create_connection_from_config()
# If creation failed, return 500
if (create_user(conn, username, password, email) is False):
conn.close()
return Response("Creating failed", 403)
# Creation succeed, return 200
else:
conn.close()
return Response(response=json.dumps({'username': username}),
status=200)
def mq_create_instance(username, instance_name, image, flavor, root_password):
conn = create_connection_from_config()
if (check_instance_name_available(conn, instance_name) is True):
keypair = get_keypair(username)
instance = create_instance(conn,
image,
flavor,
get_network_name(),
instance_name,
root_password=root_password,
keypair=keypair)
add_instance_to_user(username, instance_name, instance.id)
conn.compute.wait_for_server(instance, status='ACTIVE', wait=60)
# Wait for 30 second to let instance boot up
time.sleep(30)
# Try to set the root password if it fails
for i in range(0, 10):
time.sleep(10)
try:
conn.compute.change_server_password(instance, root_password)
except openstack.exceptions.HttpException:
continue
else:
break
conn.close()
def mq_create_image(username, image_name, instance_name, description):
conn = create_connection_from_config()
if (check_image_name_available(conn, image_name) is True):
image = create_image_from_instance(conn, instance_name, image_name,
description)
create_image_document(username, image_name, instance_name, description)
add_image_to_user(username, image_name, image.id)
conn.close()
def mq_delete_instance(username, instance_name):
if (check_instance_ownership(username, instance_name) is False):
return
conn = create_connection_from_config()
delete_instance(conn, instance_name)
remove_instance_from_user(username, instance_name)
print(username)
conn.close()
def create_keypair(user, pubkey):
conn = create_connection_from_config()
try:
conn.compute.create_keypair(name=user + "_key", public_key=pubkey)
except:
conn.close()
return False
else:
add_keypair_to_user(user, user + "_key")
conn.close()
return True
def api_get_user_info():
if (check_user_credential(request) is False):
return Response("Invalid Credential", 401)
username = request.authorization.get('username')
conn = create_connection_from_config()
result = get_user_info(username)
if (result is not None):
for instance in result['instance']:
instance['status'] = get_instance_status(conn,
instance["instance_name"])
address = get_instance_address(conn, instance["instance_name"])
instance['address'] = list(address[list(address)[0]])[0]
conn.close()
return Response(response=json.dumps(result), status=200)
def api_update_user(field):
# If the variable is not email or password, return 404
if (field != ("email" and "password")):
return Response("URL not found", 404)
# Check if the username and password in authorization is correct
if (check_user_credential(request) is False):
return Response("Invalid Credential", 401)
content = request.get_json()
# Update email
if (field == "email"):
try:
username = request.authorization.get('username')
email = content["email"]
# If data is not correct in the body, return 400
except TypeError:
return Response("Bad Request, insufficient data", 400)
else:
conn = create_connection_from_config()
if (update_user_email(conn, username, email) is True):
return Response("OK", 200)
else:
return Response("Update email failed", 400)
# Update password
if (field == "password"):
try:
username = request.authorization.get('username')
password = content["password"]
# If data is not correct in the body, return 400
except TypeError:
return Response("Bad Request, insufficient data", 400)
else:
conn = create_connection_from_config()
if (update_user_password(conn, username, password) is True):
return Response(response=json.dumps({"status": "OK"}),
status=200)
else:
return Response("Update password failed", 400)
def update_keypair(user, pubkey):
client = create_db_connection()
user_col = client["t2ee"]["user"]
result = user_col.find_one({"name": user})
client.close()
#If cannot find the user
if (result is None):
return False
#If the user doesn't have a key, create it
if (result["key"] == ""):
return create_keypair(user, pubkey)
else:
conn = create_connection_from_config()
key = conn.compute.find_keypair(result["key"])
if (key is not None):
conn.compute.delete_keypair(key)
return create_keypair(user, pubkey)
def api_instance_transfer():
if (check_user_credential(request) is False):
return Response("Invalid Credential", 401)
content = request.get_json()
try:
username = request.authorization.get('username')
instance_name = content['instance_name']
new_owner = content['new_owner']
except KeyError:
return Response("Bad Request, insufficient data", 400)
else:
if (check_instance_ownership(username, instance_name) is False):
return Response("Invalid Credential", 401)
if (get_user_info(new_owner) is None):
return Response("New owner not exist", 400)
conn = create_connection_from_config()
instance = conn.compute.find_server(instance_name)
if (instance is None):
return Response("Instance not exist", 400)
remove_instance_from_user(username, instance_name)
add_instance_to_user(new_owner, instance_name, instance.id)
return Response(response=json.dumps({"status": "OK"}), status=200)
def create_image_document(name, image_name, instance_name, description):
client = create_db_connection()
db = client["t2ee"]
image_col = db["image"]
conn = create_connection_from_config()
instance = conn.compute.find_server(instance_name)
try:
image_id = conn.compute.get_server(instance.id).image.id
except:
return
else:
base_image_name = conn.image.find_image(image_id).name
print(base_image_name)
image_data = {
"username" : name,
"image_id": image_id,
"image_name": image_name,
"base_image_name": base_image_name,
"description": description,
"count": 0
}
image_col.insert_one(image_data)
client.close()
#!/usr/bin/python3
import unittest
from lib.ConnectionUtilities import create_connection_from_config
from lib.CredentialUtilities import create_user
conn = create_connection_from_config()
class test_user(unittest.TestCase):
def test_creating(self):
#Delete the user before creating it
if (conn.identity.find_user("test_user") is not None):
conn.identity.delete_user(conn.identity.find_user("test_user"))
create_user(conn, "test_user", "test123", "*****@*****.**")
user = conn.identity.find_user("test_user")
print(user.id)
self.assertEqual(user.name, "test_user")
self.assertEqual(user.email, "*****@*****.**")
if __name__ == '__main__':
unittest.main()
def mq_delete_image(username, image_name):
conn = create_connection_from_config()
remove_image_from_user(username, image_name)
remove_image_from_image_database(image_name)
delete_image(conn, image_name)
conn.close()
def test_change_password(self):
conn = create_connection_from_config()
conn.compute.change_server_password(
conn.compute.find_server("test_creation2"), "whatever")
def test_deleting(self):
conn = create_connection_from_config()
self.assertTrue(delete_instance(conn, "test"))
def test_creating(self):
conn = create_connection_from_config()
create_instance(conn, " Ubuntu16.04", "small", "provider1", "test")
self.assertFalse(check_instance_name_available(conn, "test"))