def get(self):
"""
Get containers list
:return: containers data
"""
populate_containers_table()
current_identity = import_user()
containers = []
for c in Container.query.all():
container = Container.query.filter_by(name=c.name).first()
if c.id in current_identity.containers or current_identity.admin:
# containers.append('/api/v1/containers/' + c.name) # USE THIS LINE FOR QUERY BY NAME
# containers.append('/api/v1/containers/' + str(c.id))
container_json = container.__jsonapi__()
#url = '/api/v1/containers/' + str(i.id)
#container_json['attributes']['url'] = url
res = lgw.lxd_api_get('containers/' + c.name)
container_json['attributes'] = res.json()['metadata']
res_state = lgw.lxd_api_get('containers/' + c.name + '/state')
container_json['attributes']['state'] = res_state.json(
)['metadata']
containers.append(container_json)
return {'data': containers}
def get(self, id):
"""
Container information
:param id:
:return: container data
"""
populate_containers_table()
current_identity = import_user()
try:
# c = Container.query.filter_by(name=name).first() # USE FOR QUERY BY NAME
c = Container.query.filter_by(id=id).first()
if c and (c.id in current_identity.containers
or current_identity.admin):
res = lgw.lxd_api_get('containers/' + c.name)
container_json = c.__jsonapi__()
container_json['attributes'] = res.json()['metadata']
res_state = lgw.lxd_api_get('containers/' + c.name + '/state')
container_json['attributes']['state'] = res_state.json(
)['metadata']
return {'data': container_json}
else:
api.abort(code=403, message='Unauthorized access')
except KeyError:
api.abort(code=404, message='Container doesn\'t exists')
def get(self, server, alias):
"""
:return
"""
lxdserver = Server.query.filter_by(name=server).first()
res = lgw.lxd_api_get(lxdserver, 'images/aliases/' + alias)
return {'data': res.json()['metadata']}
def get(self, url, server, name):
"""
:return
"""
lxdserver = Server.query.filter_by(name=server).first()
res = lgw.lxd_api_get(lxdserver, url + '/' + name)
return {'data': res.json()['metadata']}
def post(self, id, name):
"""
Restore snapshot
"""
current_identity = import_user()
instance = Instance.query.get(id)
lxdserver = Server.query.filter_by(name=instance.location).first()
if instance.name and (id in current_identity.instances
or current_identity.admin):
try:
app.logger.info('User: %s restoring snapshot on container %s',
current_identity.username, instance.name)
resx = lgw.lxd_api_get(
lxdserver,
'instances/' + instance.name + '/snapshots/' + name)
if resx:
try:
res = lgw.lxd_api_put(lxdserver,
'instances/' + instance.name,
{'restore': name})
return {}, 204
except:
api.abort(code=500, message='Error restoring snapshot')
except:
api.abort(code=404, message='Snapshot doesn\'t exists')
api.abort(code=404, message='Instance doesn\'t exists')
def put(self, id, name, d=None):
"""
Update snapshot
"""
if d:
data = d
else:
data = request.get_json()['data']
current_identity = import_user()
instance = Instance.query.get(id)
lxdserver = Server.query.filter_by(name=instance.location).first()
if instance.name and (id in current_identity.instances
or current_identity.admin):
try:
app.logger.info('User: %s updating snapshot on container %s',
current_identity.username, instance.name)
res = lgw.lxd_api_get(
lxdserver,
'instances/' + instance.name + '/snapshots/' + name)
r = res.json()['metadata']
if r['expires_at']:
try:
res = lgw.lxd_api_put(
'instances/' + instance.name + '/snapshots/' +
name, {'expires_at': data['expires_at']})
return {}, 204
except:
api.abort(code=500, message='Error deleting snapshot')
except:
api.abort(code=404, message='Snapshot doesn\'t exists')
api.abort(code=404, message='Instance doesn\'t exists')
def get(self, id, name):
"""
Get snapshot
"""
current_identity = import_user()
instance = Instance.query.get(id)
lxdserver = Server.query.filter_by(name=instance.location).first()
if instance.name and (id in current_identity.instances
or current_identity.admin):
try:
res = lgw.lxd_api_get(
lxdserver,
'instances/' + instance.name + '/snapshots/' + name)
r = res.json()['metadata']
# print(r)
snapshot_json = {
'type': 'snapshots',
'attributes': {
'name': r['name'],
'created_at': r['created_at'],
'stateful': r['stateful']
}
}
return {'data': snapshot_json}
except:
api.abort(code=404, message='Snapshot doesn\'t exists')
api.abort(code=404, message='Instance doesn\'t exists')
def get(self, id):
"""
Get snapshot list
"""
current_identity = import_user()
instance = Instance.query.get(id)
snapshots = []
lxdserver = Server.query.filter_by(name=instance.location).first()
if instance.name and (id in current_identity.instances
or current_identity.admin):
res = lgw.lxd_api_get(
lxdserver, 'instances/' + instance.name +
'/snapshots?recursion=1') #recursion=1 returns objects
for i, r in enumerate(res.json()['metadata']):
# print(r['name'] + r['created_at'] + str(r['stateful']))
snapshot_json = {
'type': 'snapshots',
'id': i,
'attributes': {
'name': r['name'],
'created_at': r['created_at'],
'stateful': r['stateful']
}
}
snapshots.append(snapshot_json)
# return {'data': res.json()['metadata']}
return {'data': snapshots}
else:
api.abort(code=404, message='Instance not found')
def populate_containers_table():
"""
Search for new or deleted containers and update their status in local database
"""
all = []
res = lxd_api_get('containers')
for c in res.json()['metadata']:
all.append(c[16:]) # get container name from api url
current_containers_list = tuple(all)
database_containers_list = [str(i.name) for i in Container.query.all()]
# Removing old containers from database
for ct in database_containers_list:
if not ct in current_containers_list:
container = Container.query.filter_by(name=ct).first()
db.session.delete(container)
# Adding new containers to database
for ct in current_containers_list:
if not ct in database_containers_list:
container = Container(name=ct)
db.session.add(container)
db.session.commit()
def get(self):
"""
Get lxd host resources
:return data
"""
json_output = lgw.lxd_api_get('resources').json()['metadata']
return {'data': {'attributes': json_output}}
def get(self, server, id):
"""
Get images list
:return: images data
"""
lxdserver = Server.query.filter_by(name=server).first()
res = lgw.lxd_api_get(lxdserver, 'operations/' + id + '/wait')
return res.json()
def get(self):
"""
Get instances list
:return: instances data
"""
populate_instances_table()
current_identity = import_user()
instances = []
database_lxdservers_list = Server.query.all()
for lxdserver in database_lxdservers_list:
# starttime = time.time()
for c in Instance.query.filter_by(location=lxdserver.name):
#instance = Instance.query.filter_by(name=c.name).first()
if c.id in current_identity.instances or current_identity.admin:
instance_json = c.__jsonapi__()
try:
instance_json.update(
json.loads(
redis_store.get('server:' + lxdserver.name +
':instance:' + c.name +
':info')))
instance_json['state'] = (json.loads(
redis_store.get('server:' + lxdserver.name +
':instance:' + c.name + ':state')))
except TypeError:
res = lgw.lxd_api_get(lxdserver, 'instances/' + c.name)
#print(res.json())
instance_json.update(res.json()['metadata'])
res_state = lgw.lxd_api_get(
lxdserver, 'instances/' + c.name + '/state')
instance_json['state'] = res_state.json()['metadata']
instances.append(instance_json)
# print('time: ', time.time() - starttime)
return {'data': instances}
def get(self, server):
"""
:return
"""
response = []
lxdserver = Server.query.filter_by(name=server).first()
relationships = lxdserver.get_as_relationships()
res = lgw.lxd_api_get(lxdserver, 'images/aliases')
res_meta = res.json()['metadata']
for r in res_meta:
r.update({'relationships': relationships})
response += res_meta
return {'data': response}
def get(self, id):
"""
Instance information
:param id:
:return: instance data
"""
populate_instances_table()
current_identity = import_user()
try:
# c = Instance.query.filter_by(name=name).first() # USE FOR QUERY BY NAME
c = Instance.query.filter_by(id=id).first()
if c and (c.id in current_identity.instances
or current_identity.admin):
lxdserver = Server.query.filter_by(name=c.location).first()
res = lgw.lxd_api_get(lxdserver, 'instances/' + c.name)
instance_json = c.__jsonapi__()
instance_json.update(res.json()['metadata'])
res_state = lgw.lxd_api_get(lxdserver,
'instances/' + c.name + '/state')
instance_json['state'] = res_state.json()['metadata']
# update redis data about instance
#redis_store.set('instances:' + c.name + ':info', json.dumps(res.json()['metadata']))
redis_store.set(
'server:' + lxdserver.name + ':instance:' + c.name +
':info', json.dumps(res.json()['metadata']))
#redis_store.set('instances:' + c.name + ':state', json.dumps(res_state.json()['metadata']))
redis_store.set(
'server:' + lxdserver.name + ':instance:' + c.name +
':state', json.dumps(res_state.json()['metadata']))
return {'data': instance_json}
else:
api.abort(code=403, message='Unauthorized access')
except KeyError:
api.abort(code=404, message='Instance doesn\'t exists')
def get(self):
"""
:return
"""
response = []
database_lxdservers_list = Server.query.all()
for lxdserver in database_lxdservers_list:
relationships = lxdserver.get_as_relationships()
res = lgw.lxd_api_get(lxdserver, 'images/aliases')
res_meta = res.json()['metadata']
for r in res_meta:
r.update({'relationships': relationships})
response += res_meta
return {'data': response}
def get(self, server):
"""
Get images list from server x
:return: images data
"""
response = []
lxdserver = Server.query.filter_by(name=server).first()
relationships = lxdserver.get_as_relationships()
res = lgw.lxd_api_get(lxdserver, 'images?recursion=1')
res_meta = res.json()['metadata']
for r in res_meta:
r.update({'relationships': relationships})
response += res_meta
# print(response)
return {'data': response}
def get(self):
"""
Get images list
:return: images data
"""
response = []
database_lxdservers_list = Server.query.all()
for lxdserver in database_lxdservers_list:
relationships = lxdserver.get_as_relationships()
res = lgw.lxd_api_get(lxdserver, 'images?recursion=1')
res_meta = res.json()['metadata']
for r in res_meta:
r.update({'relationships': relationships})
response += res_meta
# print(response)
return {'data': response}
def get(self, id):
"""
Container state information
:param id:
:return container data
"""
populate_containers_table()
current_identity = import_user()
try:
# c = Container.query.filter_by(name=name).first() # USE FOR QUERY BY NAME
c = Container.query.filter_by(id=id).first()
if c and (c.id in current_identity.containers
or current_identity.admin):
res = lgw.lxd_api_get('containers/' + c.name + '/state')
return res.json()
else:
api.abort(code=403, message='Unauthorized access')
except:
api.abort(code=404, message='Container doesn\'t exists')
def get(self):
"""
Containers stats resources
:return data
"""
populate_containers_table()
current_identity = import_user()
alist = []
all = []
res = lgw.lxd_api_get('containers')
for c in res.json()['metadata']:
all.append(c[16:])
for ct in all:
container = Container.query.filter_by(name=ct).first()
if container.id in current_identity.containers or current_identity.admin:
alist.append(ct)
json_output = lgw.cts_stats(alist)
return {'data': {'attributes': json_output}}
def get(self, id):
"""
Instance state information
:param id:
:return instance data
"""
populate_instances_table()
current_identity = import_user()
try:
# c = Instance.query.filter_by(name=name).first() # USE FOR QUERY BY NAME
c = Instance.query.filter_by(id=id).first()
lxdserver = Server.query.filter_by(name=c.location).first()
if c and (c.id in current_identity.instances
or current_identity.admin):
res = lgw.lxd_api_get(lxdserver,
'instances/' + c.name + '/state')
return {'data': res.json()}
else:
api.abort(code=403, message='Unauthorized access')
except:
api.abort(code=404, message='Instance doesn\'t exists')
def get(self, url):
"""
Get 'universal' list
:return: 'universal' data
"""
#if url in ['instances', 'containers', 'virtual-machines', 'cluster', 'resources', 'events', 'operations']:
# api.abort(code=404, message='URL: '+url+' doesn\'t exists')
response = []
database_lxdservers_list = Server.query.all()
for lxdserver in database_lxdservers_list:
relationships = lxdserver.get_as_relationships()
res = lgw.lxd_api_get(lxdserver, url + '?recursion=1')
res_meta = res.json()['metadata']
# if response is list of objects
if isinstance(res_meta, list):
for r in res_meta:
if not isinstance(r, str):
r.update({'relationships': relationships})
response += res_meta
else:
res_meta.update({'relationships': relationships})
response.append(res_meta)
return {'data': response}