def put(self, token):
try:
data = self.parser.parse_args()
validateObj = ServiceModel.validateData(data, request)
if type(validateObj) is dict:
return {"success": False, "errors": validateObj}, 400
service_id = decodeID(token)
service = ServiceModel.find_by_id(service_id)
if not service or service.token != token:
return {"success": False, 'message': 'Record Not Found'}, 404
service.service_name = data['service_name']
service.logo = data['logo']
service.brand_id = data['brand_id']
service.category_id = data['category_id']
service.modified_on = datetime.now()
service.modified_by = 1
name = data['service_name']
if name.strip():
service.save_to_db()
else:
return {
"success": False,
"message": "String Should not be empty"
}
return {
"success": True,
"message": "Record updated successfully."
}, 200
except Exception as e:
return {"success": False, "message": str(e)}
def post(self, service_name):
db.create_all()
db.session.commit()
if ServiceModel.find_by_name(service_name):
return {
'message':
"An Record with name '{}' already exists.".format(service_name)
}, 400
data = self.parser.parse_args()
service = ServiceModel(
service_name,
**data,
)
service.created_by = 1
service.created_on = datetime.now()
service.modified_by = 0
service.deleted_by = 0
try:
service.save_to_db()
except Exception as e:
return {
"message":
"An error occurred while inserting the Record.'{}'".format(e)
}
return service.json(), 201
def post(cls):
data = request.get_json()
service = ServiceModel(name=data["name"],
description=data["description"],
status=data["status"],
image=data["image"])
try:
service.save_to_db()
return {"message": "OK"}, 200
except:
return {"message": "error"}, 400
def get(self, service_name):
service = ServiceModel.find_by_name(service_name)
try:
if service:
return service.json()
except Exception as e:
return {"message": "Record not found'{}'".format(e)}, 404
def get(cls):
try:
return {
"data": service_list_schema.dump(ServiceModel.get_all())
}, 200
except:
return {"message": "error"}, 400
def get_compose_data(services, stack_name):
from traceback import print_exc
from models.blueprint import BlueprintModel
from models.service import ServiceModel
"""Helper method to pass the necessary data to the function creating the string which ends up as the
docker-compose.yml.
Args:
services (:obj:`list` of :obj:`service`): A list with the services this stack is defined for.
stack_name (str): The name of the stack defining the services.
Returns:
list: A list with the necessary information, None if exception is thrown.
"""
data = []
try:
for service in services:
tmp = {}
tmp['stack_name'] = stack_name
tmp['name'] = service.name
tmp['image'] = BlueprintModel.find_by_id(service.blueprint_id).image
tmp['exposed_ports'] = ServiceModel.port_list(service.exposed_ports)
tmp['ip'] = service.ip
tmp['restart'] = service.restart
if service.volumes:
tmp['volumes'] = ServiceModel.split_string(service.volumes)
if service.env:
tmp['environment'] = ServiceModel.split_string(service.env)
if service.mapped_ports:
tmp['mapped_ports'] = [x for x in service.mapped_ports.split(',')]
data.append(tmp)
except:
print_exc()
return None
return data
def get(cls, token):
try:
service_id = decodeID(token)
service = ServiceModel.find_by_id(service_id)
if not service or service.token != token:
return {"success": False, 'message': 'Record Not Found'}, 404
return service.json(), 200
except Exception as e:
return {"success": False, "message": str(e)}
def delete(cls, service_name):
service = ServiceModel.find_by_name(service_name)
if service:
service.deleted_by = 1
service.deleted_on = datetime.now()
service.save_to_db()
#service.delete_from_db()
return {'message': 'Record deleted'}
else:
return {"Message": "Record Not FOUND"}
def delete(cls, token):
try:
service_id = decodeID(token)
service = ServiceModel.find_by_id(service_id)
if not service or service.token != token:
return {"success": False, 'message': 'Record Not Found'}, 404
service.deleted_by = 1
service.deleted_on = datetime.now()
service.save_to_db()
#service.delete_from_db()
return {"success": True, 'message': 'Record deleted.'}, 200
except Exception as e:
return {"success": False, "message": str(e)}
def put(self, service_name):
data = self.parser.parse_args()
service = ServiceModel.find_by_name(service_name)
if service:
service.modified_on = datetime.now()
service.modified_by = 1
service.logo = data['logo']
service.brand_id = data['brand_id']
service.category_id = data['category_id']
service.save_to_db()
else:
return {"Message": "Record Not FOUND"}
return service.json()
def delete(self, _id):
"""DELETE method to delete service by ID."""
try:
service = ServiceModel.find_by_id(_id)
except:
return response(500, None, f"An error occured while trying to delete service {service.name}.", None), 500
if service:
try:
service.delete_from_db()
except:
return response(500, None, f"An error occured while trying delete service {data['name']}.", None), 500
return response(200, f"Service {service.name} has been deleted.", None, None), 200
return response(404, None, f"Service with id {_id} does not exist.", None), 404
def get(self, _id):
"""GET method to retrieve a service by ID."""
try:
service = ServiceModel.find_by_id(_id)
except:
return {
'error': f"An error occured while trying to retrieve service."
}, 500
if service:
return response(201, f"Service {service.name} has been retrieved.", None, service.json()), 201
return {
'error': f"Service with ID {_id} does not exist."
}, 400
def post(self, _id):
"""POST method to save the project files to the file system."""
if not StackModel.find_by_id(_id):
return response(404, None, f"Stack with ID {_id} does not exist.", None), 404
stack = StackModel.find_by_id(_id)
if not stack.proxy_service:
return response(400, None, f"Stack {stack.name} has no proxy_service defined.", None), 400
if not stack.proxy_port:
return response(400, None, f"Stack {stack.name} has no proxy_port defined.", None), 400
# Creating necessary folders
stacks_folder = StackModel.get_stacks_folder()
caddyconf_folder = stacks_folder + "/conf.d"
project_folder = stack.get_project_folder()
compose_location = project_folder + "/docker-compose.yml"
caddyconf_location = caddyconf_folder + f"/{stack.name}.conf"
if not path.exists(project_folder):
makedirs(project_folder)
if not path.exists(caddyconf_folder):
makedirs(caddyconf_folder)
data_compose = get_compose_data(services=stack.services, stack_name=stack.name)
data_caddyconf = {
'subdomain': stack.subdomain,
'email': stack.email,
'proxy_service': ServiceModel.find_by_id(stack.proxy_service).name,
'proxy_port': stack.proxy_port
}
if data_compose:
compose_string = get_compose(data_compose)
caddyconf_string = get_caddyconf(data_caddyconf)
if create_file(compose_location, compose_string) and create_file(caddyconf_location, caddyconf_string):
return response(200, f"Stack {stack.name} has been applied.", None, None), 200
else:
return response(500, None, f"An error has occured while trying to save compose file.", None), 500
else:
return response(500, None, f"An error has occured while trying to assemble data for compose file", None), 500
def post(self):
"""POST method to create a new stack."""
data = self.parser.parse_args()
if StackModel.find_by_name(data['name']):
return response(400, None, f"Stack with name {data['name']} already exists.", None), 400
# Argument check
args = self.check_args(data)
if args['code'] is not 200:
return response(args['code'], None, args['error'], None), args['code']
stack = StackModel(name = data['name'],
description = data['description'],
subdomain = data['subdomain'] if data['subdomain'] else 'localhost',
email = data['email'],
proxy_port = data['proxy_port'])
if data['services'] and data['services'] != [None]:
for x in data['services']:
service = ServiceModel.find_by_id(x)
if service:
stack.services.append(service)
else:
return response(400, None, f"Service with ID {x} cannot be found.", None), 400
# Check if proxy_serve is part of stack.services
if data['proxy_service']:
try:
if data['proxy_service'] not in [x.id for x in stack.services]:
return response(400, None, f"Service with ID {data['proxy_service']} is not part of Stack {stack.name}'s services.", None), 400
else:
stack.proxy_service = data['proxy_service']
except:
print_exc()
return response(500, None, f"An internal error occured while checking the proxy_service.", None), 500
try:
stack.save_to_db()
except:
return response(500, None, f"An error occured while trying to update stack {data['name']}.", None), 500
return response(201, f"Stack {data['name']} has been updated.", None, stack.json()), 201
def check_args(self, data):
"""Helper method to check various passed payload arguments
Note:
This does not check if the proxy_port is part of the published ports ports
Args:
data (:obj:`dict`): Request payload with parsed arguments. Arguments to be checked:
data['name'] (str): Name of the stack.
data['description'] (str): Description for the stack.
data['subdomain'] (str): Subdomain of the stack.
data['email'] (str): The email needed for Caddy to grab a TLS certificate.
data['proxy_port'] (int): The main port Caddy will forward requests to for this stack.
Returns:
dict: If all checks pass, dict of type {'code': 200}.
If one check fails, dict of type {'code': <error code>, 'error' <error message>}, where the code and
message will be directly fed into a response.
"""
# Regex check for valid name
if not StackModel.valid_name(data['name']):
return {'code': 400, 'error': f"Invalid stack name {data['name']}."}
# Regex check for valid proxy_port
if data['proxy_port'] and not ServiceModel.valid_ports([data['proxy_port']]):
return {'code': 400, 'error': f"Invalid proxy_port {data['proxy_port']}"}
# Regex check for valid subdomain
if data['subdomain'] and not StackModel.valid_subdomain(data['subdomain']):
return {'code': 400, 'error': f"Invalid subdomain {data['subdomain']}."}
# Regex check for valid email
if data['email'] and not StackModel.valid_email(data['email']):
return {'code': 400, 'error': f"Email {data['email']} is invalid."}
return {'code': 200}
def post(self):
data = self.parser.parse_args()
service = ServiceModel(**data)
service.created_by = 1
service.created_on = datetime.now()
service.modified_by = 0
service.deleted_by = 0
service.modified_on = None
service.deleted_on = None
try:
validateObj = ServiceModel.validateData(data, request)
if type(validateObj) is dict:
return {"success": False, "errors": validateObj}, 400
if ServiceModel.find_by_name(data['service_name']):
return {
"success": False,
"message": "A service with that Record Name already exists"
}, 400
name = data['service_name']
if name.strip():
service.save_to_db()
service.token = encodeID(service.service_id)
service.save_to_db()
else:
return {
"success": False,
"message": "String Should not be empty"
}
except Exception as e:
return {
"message":
"An error occurred creating the Record.'{}'".format(e)
}, 500
return service.json(), 201
def put(self):
"""PUT method to create or update a stack."""
data = self.parser.parse_args()
# Argument check
args = self.check_args(data)
if args['code'] is not 200:
return response(args['code'], None, args['error'], None), args['code']
stack = StackModel.find_by_name(data['name'])
if stack:
stack.name = data['name']
stack.description = data['description']
stack.subdomain = data['subdomain'] if data['subdomain'] else 'localhost',
stack.email = data['email']
stack.proxy_port = data['proxy_port']
stack.proxy_service = data['proxy_service']
stack.last_changed = datetime.now()
# Update m:n-Table for stacks:services
if data['services'] and data['services'] != [None]:
# Get sets of services which need to be updated and deleted
old = {x.id for x in stack.services}
new = set(data['services'])
to_update = new - old
to_delete = old - new
# Remove old services
for x in to_delete:
stack.services.remove(ServiceModel.find_by_id(x))
# Add new services
for x in to_update:
service = ServiceModel.find_by_id(x)
if service:
stack.services.append(service)
else:
return response(400, None, f"Service with ID {x} cannot be found.", None), 400
else:
for x in [y.id for y in stack.services]:
stack.services.remove(ServiceModel.find_by_id(x))
else:
stack = StackModel(name = data['name'],
description = data['description'],
subdomain = data['subdomain'] if data['subdomain'] else 'localhost',
email = data['email'],
proxy_port = data['proxy_port'])
if data['services'] and data['services'] != [None]:
for x in data['services']:
service = ServiceModel.find_by_id(x)
if service:
stack.services.append(service)
else:
return response(400, None, f"Service with ID {x} cannot be found.", None), 400
# Check if proxy_service is part of stack.services
if data['proxy_service']:
try:
if data['proxy_service'] not in [x.id for x in stack.services]:
return response(400, None, f"Service with ID {data['proxy_service']} is not part of Stack {stack.name}'s services.", None), 400
else:
pass
except:
print_exc()
return response(500, None, f"An internal error occured while checking the proxy_service.", None), 500
try:
stack.save_to_db()
except:
print_exc()
return response(500, None, f"An error occured while trying to update stack {data['name']}.", None), 500
return response(201, f"Stack {data['name']} has been updated.", None, stack.json()), 201
def check_args(self, data):
"""Helper method to check various passed payload arguments
Args:
data (:obj:`dict`): Request payload with parsed arguments.
data['blueprint'] (int): Blueprint ID which service will be derived from.
data['description'] (string): The service description.
data['name'] (str): Name of service.
data['exposed_ports'] (list of int): Ports to be exposed.
data['mapped_ports'] (list of str): Ports to be mapped between host and container.
data['volumes'](list of str): Volumes to be mapped between host and container.
data['env'] (list of str): Environment variables for container.
data['restart'] (str): The restart flag for the container.
data['stacks'] (list of int): Stack this service should be a part of.
Returns:
dict: If all checks pass, dict of type {'code': 200}.
If one check fails, dict of type {'code': <error code>, 'error' <error message>}, where the code and
message will be directly fed into a response.
"""
# Check if blueprint exists
if not BlueprintModel.find_by_id(data['blueprint']):
return {'code': 400, 'error': f"Blueprint with ID {data['blueprint']} hasn't been found."}
# Regex check for name
if not StackModel.valid_name(data['name']):
return {'code': 400, 'error': f"Invalid service name {data['name']}."}
if data['exposed_ports']:
# Regex check if passed exposed_ports are correct
if not ServiceModel.valid_ports(data['exposed_ports']):
return {'code': 400, 'error': f"Invalid exposed_ports."}
if data['mapped_ports']:
# Regex check if mapped_ports are correct, those are passed as string like '80:80,8080:8080'
if not ServiceModel.valid_mapped_ports(data['mapped_ports']):
return {'code': 400, 'error': f"Invalid mapped_ports."}
# Regex check if volumes are correct
if data['volumes']:
if not ServiceModel.valid_volumes(data['volumes']):
return {'code': 400, 'error': f"Invalid volumes"}
# Regex check if environment variables are correct
if data['env']:
if not ServiceModel.valid_env(data['env']):
return {'code': 400, 'error': f"Invalid environment variables."}
# Check if restart flag is part of allowed options:
if data['restart']:
if data['restart'].lower() not in ["no", "always"]:
return {'code': 400, 'error': f"Invalid restart flag."}
# Check if passed stack exists.
if data['stacks'] and data['stacks'] != [None]:
for x in data['stacks']:
if not StackModel.find_by_id(x):
return {'code': 400, 'error': f"Stack with ID {x} cannot be found."}
return {'code': 200}
def create_services(services):
objects: List[ServiceModel] = []
for service in services:
objects.append(ServiceModel(service["name"], service["value"], service["tag"],
service["instances"], service["instanceType"]))
return objects
def post(self):
"""POST method to create a new service."""
data = self.parser.parse_args()
if ServiceModel.find_by_name(data['name']):
return response(400, None, f"Service with name {data['name']} already exists.", None), 400
args = self.check_args(data)
if args['code'] is not 200:
return response(args['code'], None, args['error'], None), args['code']
volumes = ServiceModel.join_volume_string(data)
env = ServiceModel.join_env_string(data)
exposed_ports = ServiceModel.join_port_string(data['exposed_ports'])
mapped_ports = ServiceModel.join_port_string(data['mapped_ports'])
service = ServiceModel(name = data['name'],
blueprint_id = data['blueprint'],
description = data['description'],
exposed_ports = exposed_ports,
mapped_ports = mapped_ports,
volumes = volumes,
restart = data['restart'],
env = env)
# Add stack to service table
if data['stacks'] and data['stacks'] != [None]:
for x in data['stacks']:
stack = StackModel.find_by_id(x)
service.stacks.append(stack)
try:
service.save_to_db()
service.ip = service.get_ip(service.id)
service.save_to_db()
except:
return response(500, None, f"An error occured while trying to update service {data['name']}.", None), 500
return response(201, f"Service {data['name']} has been updated.", None, service.json()), 201
def put(self):
"""PUT method to create or update a service."""
data = self.parser.parse_args()
args = self.check_args(data)
if args['code'] is not 200:
return response(args['code'], None, args['error'], None), args['code']
service = ServiceModel.find_by_name(data['name'])
volumes = ServiceModel.join_volume_string(data)
env = ServiceModel.join_env_string(data)
exposed_ports = ServiceModel.join_port_string(data['exposed_ports'])
mapped_ports = ServiceModel.join_port_string(data['mapped_ports'])
if service:
service.name = data['name']
service.description = data['description']
service.exposed_ports = exposed_ports
service.mapped_ports = mapped_ports
service.volumes = volumes
service.env = env
service.restart = data['restart']
service.blueprint_id = data['blueprint']
if data['stacks'] and data['stacks'] != [None]:
# Get sets of stacks which need to be updated or deleted
old = {x.id for x in service.stacks}
new = set(data['stacks'])
to_update = new - old
to_delete = old - new
# Remove old stacks
for x in to_delete:
service.stacks.remove(StackModel.find_by_id(x))
# Add new services
for x in to_update:
service.stacks.append(StackModel.find_by_id(x))
else:
for x in [y.id for y in service.stacks]:
service.stacks.remove(StackModel.find_by_id(x))
else:
service = ServiceModel(name = data['name'],
description = data['description'],
exposed_ports = exposed_ports,
mapped_ports = mapped_ports,
volumes = volumes,
env = env,
restart = data['restart'],
blueprint_id = data['blueprint'])
if data['stacks'] and data['stacks'] != [None]:
for x in data['stacks']:
stack = StackModel.find_by_id(x)
service.stacks.append(stack)
try:
service.save_to_db()
service.ip = service.get_ip(service.id)
service.save_to_db()
except:
return response(500, None, f"An error occured while trying to update service {data['name']}.", None), 500
return response(201, f"Service {data['name']} has been updated.", None, service.json()), 201
len(article_type) - 1)]
# append to list
article_model = ArticleModel(**article)
articles.append(article_model)
# initialize list
services = []
# generate services
for _ in range(100):
service = {}
service['name'] = fake.job()
# append to list
service_model = ServiceModel(**service)
services.append(service_model)
#print("Users")
#print([f"{user.first_name} {user.last_name}" for user in users])
#print('\n')
#print("Organizations")
#print([organization.name for organization in organizations])
#print('\n')
#print("Events")
#print([event.name for event in events])
#print('\n')
#print("Articles")
#print([article.title for article in articles])
#print('\n')
#print("Services")
def get(self):
return {
'services': [service.json() for service in ServiceModel.objects()]
}
