def create_bucket():
ec2 = boto3.client('ec2')
if request.method == 'GET':
# response_regions = ec2.describe_regions()
# region_list = []
# for region in response_regions['Regions']:
# region_list.append({'name': region['RegionName']})
region_list = get_regions_list()
print(region_list)
return render_template('create-bucket.html', regions=region_list)
elif request.method == 'POST':
bucket_name = request.form['bucket-name']
region_name = request.form['region-name']
print('\n\n\ncreate bucket region name', region_name)
switch_regions(region_name)
local_client = boto3.client('s3', region_name=get_current_region())
try:
response = local_client.create_bucket(Bucket=bucket_name,
CreateBucketConfiguration={'LocationConstraint': region_name})
flash(Markup('Successfully created <b>{}</b> in region <b>{}</b>'.format(
bucket_name, region_name)))
except Exception as e:
flash(Markup(e.args[0]))
return redirect(url_for('buckets_list', region_name=get_current_region()))
def delete_file(bucket_name, file_name):
local_client = boto3.client('s3', region_name=get_current_region())
t1 = time()
response = local_client.delete_object(Bucket=bucket_name, Key=file_name)
t2 = time()
dt = t2 - t1
flash(Markup('Successfully deleted <b>{}</b> (<i>{} seconds</i>)'.format(file_name, dt)))
return redirect(url_for('bucket', bucket_name=bucket_name,
region_name=get_current_region()))
def start_node(node_id):
driver = get_ec2_driver(get_current_region())
node = driver.list_nodes(ex_node_ids=[node_id])[0]
driver.ex_start_node(node)
flash(Markup('Starting {}...'.format(node.name)))
return redirect(url_for('node_details', node_id=node_id))
def upload_file(bucket_name):
local_client = boto3.client('s3', region_name=get_current_region())
form = UploadForm()
f = form.file.data
filename = secure_filename(f.filename)
t1 = time()
response = local_client.upload_fileobj(f, bucket_name, filename)
t2 = time()
dt = t2 - t1
flash(Markup('Successfully uploaded <b>{}</b> (<i>{} seconds</i>)'.format(filename, dt)))
return redirect(url_for('bucket', bucket_name=bucket_name,
region_name=get_current_region()))
def buckets_list(region_name=None):
# # safety
# if region_name is None:
# region_name = 'global'
region_name = get_current_region()
s3 = boto3.client('s3', region_name=get_current_region())
response_buckets = s3.list_buckets()
bucket_list = []
for bucket in response_buckets['Buckets']:
try:
bucket_location = s3.get_bucket_location(Bucket=bucket['Name'])['LocationConstraint']
if region_name.lower() == 'global' or region_name == bucket_location:
bucket_list.append({'name': bucket['Name'], 'bucket_location': bucket_location})
except:
print('{} is a ghost'.format(bucket['Name']), file=sys.stdout)
return render_template('buckets-list.html', buckets=bucket_list, region_name=region_name)
def terminate_node(node_id):
driver = get_ec2_driver(get_current_region())
# cls = get_driver(Provider.EC2)
# access_id, access_key = get_credentials()
# driver = cls(access_id, access_key, region='eu-west-1')
node = driver.list_nodes(ex_node_ids=[node_id])[0]
driver.destroy_node(node=node)
flash(Markup('Terminating {}...'.format(node.name)))
return redirect(url_for('node_details', node_id=node_id))
def bucket(bucket_name):
form = UploadForm()
region_name = request.args['region_name']
# switch_regions(region_name)
local_client = boto3.client('s3', region_name=get_current_region())
response = local_client.list_objects(Bucket=bucket_name)
file_list = []
if 'Contents' in response:
for file in response['Contents']:
file_list.append({'name': file['Key']})
return render_template('bucket.html', files=file_list, bucket_name=bucket_name, form=form)
def delete_bucket(region_name, bucket_name):
# s3 = boto3.client('s3')
# bucket_location = s3.get_bucket_location(Bucket=bucket_name)['LocationConstraint']
# switch_regions(bucket_location)
local_resource = boto3.resource('s3', region_name=get_current_region())
# delete all objects in bucket first
bucket = local_resource.Bucket(bucket_name)
for key in bucket.objects.all():
key.delete()
bucket.delete()
flash(Markup('Successfully deleted <b>{}</b>'.format(bucket_name)))
return redirect(url_for('buckets_list', region_name=region_name))
def node_details(node_id):
driver = get_ec2_driver(get_current_region())
# check for error?
node = driver.list_nodes(ex_node_ids=[node_id])[0]
pretty_node = {
'id': node_id,
'name': node.name,
'state': node.extra['status'],
'type': node.extra['instance_type'],
'zone': node.extra['availability'],
'private_ips': node.private_ips,
'public_ips': node.public_ips,
'private_dns': node.extra['private_dns'],
'public_dns': node.extra['dns_name'],
'security_groups': node.extra['groups'],
'image_id': node.extra['image_id'],
'key': node.extra['key_name']
}
return render_template('node-details.html', node=pretty_node)
def create_node():
form = CreateNodeForm()
if request.method == 'GET':
region = get_current_region()
driver = get_ec2_driver(region)
# form.image.choices = images_choice[region]
images_local = get_ec2_images_list()
form.image.choices = [(image.id, image.name)
for image in images_local[:20]]
sizes_local = get_ec2_sizes_list()
form.size.choices = [(size.id, size.name) for size in sizes_local]
form.key_pair.choices = [(key_pair.name, key_pair.name)
for key_pair in driver.list_key_pairs()]
form.key_pair.choices = [('None', 'None')] + form.key_pair.choices
form.security_group.choices = [
(sg.id, sg.name) for sg in driver.ex_get_security_groups()
]
form.security_group.choices = [('None', 'None')
] + form.security_group.choices
return render_template('create-node.html', form=form)
elif request.method == 'POST':
name = form.name.data
image_id = form.image.data
size_id = form.size.data
nodes_no_str = form.nodes_no.data
key_pair = form.key_pair.data
security_group = form.security_group.data
try:
nodes_no = int(nodes_no_str)
except:
flash(
Markup(
'Please, provide a valid number of instances to create.'))
return redirect(url_for('create_node'))
print('\n\n\nimage id', image_id)
size = [s for s in get_ec2_sizes_list() if s.id == size_id][0]
image = [im for im in get_ec2_images_list() if im.id == image_id][0]
driver = get_ec2_driver(get_current_region())
if ((key_pair != 'None') and (security_group != 'None')):
print('both none')
node = driver.create_node(name=name, image=image, size=size,\
ex_mincount=nodes_no, ex_maxcount=nodes_no, ex_keyname=key_pair, \
ex_security_group_ids=[security_group]
)
elif (key_pair != 'None' and security_group == 'None'):
node = driver.create_node(name=name, image=image, size=size, \
ex_mincount=nodes_no, ex_maxcount=nodes_no, ex_keyname=key_pair
)
elif (key_pair == 'None' and security_group != 'None'):
node = driver.create_node(name=name, image=image, size=size, \
ex_mincount=nodes_no, ex_maxcount=nodes_no, \
ex_security_group_ids=[security_group]
)
else:
node = driver.create_node(name=name, image=image, size=size, \
ex_mincount=nodes_no, ex_maxcount=nodes_no)
flash(
Markup(
'Successfully created <b>{}</b> instance(s) <b>{}</b>'.format(
nodes_no, name)))
if (nodes_no == 1):
return redirect(url_for('node_details', node_id=node.id))
else:
return redirect(url_for('node_details', node_id=node[0].id))
def node_stats(node_id):
driver = get_ec2_driver(get_current_region())
# check for error?
node = driver.list_nodes(ex_node_ids=[node_id])[0]
pretty_node = {'id': node_id, 'name': node.name}
stats = {
'cpu': {},
'network_in': {
'data': [],
'labels': []
},
'network_out': {
'data': [],
'labels': []
},
'disk_read': {
'data': [],
'labels': []
},
'disk_write': {
'data': [],
'labels': []
}
}
metrics = [
'CPUUtilization', 'NetworkIn', 'NetworkOut', 'DiskReadBytes',
'DiskWriteBytes'
]
query = []
for m in metrics:
query.append({
'Id': 'metric_' + m,
'MetricStat': {
'Metric': {
'Namespace': 'AWS/EC2',
'MetricName': m,
'Dimensions': [
{
'Name': 'InstanceId',
'Value': node_id
},
]
},
'Period': 60,
'Stat': 'Average',
}
})
cloudwatch = boto3.client('cloudwatch',
region_name=session['current_region'])
response = cloudwatch.get_metric_data(MetricDataQueries=query,
StartTime=datetime.now() -
timedelta(hours=2),
EndTime=datetime.now(),
ScanBy='TimestampAscending')
for metric in response['MetricDataResults']:
index = metrics.index(metric['Label'])
key = [*stats][index]
stats[key]['data'] = metric['Values']
stats[key]['labels'] = [
t.strftime('%d-%m-%Y %H:%M') for t in metric['Timestamps']
]
return render_template('node-stats.html', node=pretty_node, stats=stats)
def nodes_list():
print(get_credentials())
driver = get_ec2_driver(get_current_region())
nodes = driver.list_nodes()
return render_template('nodes-list.html', nodes=nodes)
