def post(self, user_data):
"""Create/Edit user"""
user = User.fetch(self.username)
if user is None:
if not User.create(self.username, user_data):
# Handle error
return "Error creating user %s with data %s" % (self.username, user_data)
return "User %s created" % self.username
else:
if not user.update(user_data):
# Handle error
return "Error editing"
return "User %s edited" % self.username
def post(self, user_data):
"""Create/Edit user"""
user = User.fetch(self.username)
if user is None:
if not User.create(self.username, user_data):
# Handle error
return "Error creating user %s with data %s" % (self.username,
user_data)
return "User %s created" % self.username
else:
if not user.update(user_data):
# Handle error
return "Error editing"
return "User %s edited" % self.username
def delete(self):
"""Delete user and user folder"""
user = User.fetch(self.username)
if user is not None:
user.delete()
return "User %s deleted" % self.username
return "User Doesn't exist"
def delete(self):
"""Delete user and user folder"""
user = User.fetch(self.username)
if user is not None:
user.delete()
return "User %s deleted" % self.username
return "User Doesn't exist"
def get_all(self):
"""Returns all builds."""
project_name = pecan.request.context['project_name']
user = User.fetch(pecan.request.context['username'])
project = Project.fetch(user, project_name)
builds = [Build.fetch(project, b_id, False) for b_id in project.get_builds()]
builds = [b for b in builds if b]
return builds
def get(self):
"""Returns log of a specific distro."""
project_name = pecan.request.context['project_name']
user = User.fetch(pecan.request.context['username'])
project = Project.fetch(user, project_name)
build_id = pecan.request.context['build_id']
if build_id in ["latest"]:
build_id = project.get_latest_build()
build = Build.fetch(project, build_id, full_data=True)
if build is None:
return
# Get options
archive = pecan.request.GET.get('archive', 'tgz')
distro = pecan.request.GET.get('distro', None)
if distro not in supported_distros:
distro = None
# Prepare content type
content_type = archive_types.get(archive, 'application/x-gzip')
pecan.core.override_template(None, content_type)
# Get output folder
output_folder = build.get_output_folder_path(distro)
# Test if output folder exists
if not os.path.isdir(output_folder):
return
# Prepare archive
f = BytesIO()
if archive == 'zip':
# Zip
zip_archive = zipfile.ZipFile(f, "w" )
for file_ in glob.glob(output_folder + "/*"):
zip_archive.write(file_, os.path.basename(file_))
zip_archive.close()
extension = "zip"
else:
# Tarball
tar_archive = tarfile.open(fileobj=f, mode="w:gz")
for file_ in glob.glob(output_folder + "/*"):
tar_archive.add(file_, os.path.basename(file_))
tar_archive.close()
extension = "tar.gz"
# Set headers
headers = pecan.response.headers
if build.package_name is None:
return
filename = project_name + "_%(package_version)s-%(package_release)s" % build.as_dict()
if distro is not None:
filename = filename + "-" + distro
else:
filename = filename + "-all_distros"
filename = ".".join((filename, extension))
headers.add("Content-Disposition", str("attachment;filename=%s" % filename))
# returns
return f.getvalue()
def get(self):
"""Returns log of a specific distro."""
project_name = pecan.request.context['project_name']
user = User.fetch(pecan.request.context['username'])
project = Project.fetch(user, project_name)
build_id = pecan.request.context['build_id']
if build_id in ["latest"]:
build_id = project.get_latest_build()
build = Build.fetch(project, build_id, full_data=True)
job = Job.fetch(build, self.id_, False)
return job
def get(self):
"""Returns build status"""
project_name = pecan.request.context['project_name']
user = User.fetch(pecan.request.context['username'])
project = Project.fetch(user, project_name)
build_id = self.id_
if self.id_ in ["latest"]:
build_id = project.get_latest_build()
build = Build.fetch(project, build_id, sub_objects=True)
if build:
return build
return None
def save(self):
""" Write user data on disk """
data = json.dumps({"username": self.username,
"name": self.name or None,
"password": self.password or None,
"email": self.email or None,
"github": self.github or None,
"token": self.token or None,
})
userdata_file = User.get_data_file_path(self.username)
with open(userdata_file, 'w') as f:
try:
f.write(data)
except Exception as exp:
# TODO handle error
raise Exception("Error saving user data")
return True
def post(self, build):
""" launch build """
project_name = pecan.request.context['project_name']
user = User.fetch(pecan.request.context['username'])
project = Project.fetch(user, project_name)
if project is None:
# The project doesn't exist
# We have to create it
# TODO Maybe it's better to force users to create project before
# they can create builds
project = Project.create(user, project_name, {"name": project_name})
build = Build.create(project, build)
build_tasks.put(build)
# TODO: save build in database ???
# for now is in build.cfg ...
return {"result": {"build": int(build.id_)}}
def get(self):
"""Returns user"""
user = User.fetch(self.username)
# TODO hide password/token if password is not correct...
# delattr(user, 'password')
return user
def delete(self):
""" delete project """
user_folder_abs = User.get_folder_path(self.username)
shutil.rmtree(user_folder_abs)
return True
def __init__(self, project_name):
pecan.request.context['project_name'] = project_name
self.project_name = project_name
self.user = User.fetch(pecan.request.context['username'])
if self.user is None:
raise Exception("User not found")
def get(self):
"""Returns user"""
user = User.fetch(self.username)
# TODO hide password/token if password is not correct...
# delattr(user, 'password')
return user
def __init__(self, project_name):
pecan.request.context['project_name'] = project_name
self.project_name = project_name
self.user = User.fetch(pecan.request.context['username'])
if self.user is None:
raise Exception("User not found")