def create_platform(workspace_id: int, platform_data) -> dict:
"""
Create a new platform entry
:param workspace_id:
:param platform_data:
:return:
"""
platform_name = shlex.quote(platform_data['name'])
platform_url = shlex.quote(platform_data['url'])
session = db_session()
workspace = session.query(Workspace).filter(Workspace.id == workspace_id).first()
if workspace is None:
raise NotFound("workspace with id {} could not be found".format(workspace_id))
existing_platforms = session.query(Platform). \
filter(Platform.workspace == workspace). \
filter(Platform.name == platform_data['name']). \
all()
if len(existing_platforms) > 0:
raise NameConflict("Platform with name {} already exists".format(platform_data['name']))
platform = Platform(name=platform_name, url=platform_url, workspace=workspace)
session.add(platform)
update_workspace_descriptor(platform.workspace)
session.commit()
return platform.as_dict()
def create_platform(workspace_id: int, platform_data) -> dict:
"""
Create a new platform entry
:param workspace_id:
:param platform_data:
:return:
"""
platform_name = shlex.quote(platform_data['name'])
platform_url = shlex.quote(platform_data['url'])
session = db_session()
workspace = session.query(Workspace).filter(
Workspace.id == workspace_id).first()
if workspace is None:
raise NotFound(
"workspace with id {} could not be found".format(workspace_id))
existing_platforms = session.query(Platform). \
filter(Platform.workspace == workspace). \
filter(Platform.name == platform_data['name']). \
all()
if len(existing_platforms) > 0:
raise NameConflict("Platform with name {} already exists".format(
platform_data['name']))
platform = Platform(name=platform_name,
url=platform_url,
workspace=workspace)
session.add(platform)
update_workspace_descriptor(platform.workspace)
session.commit()
return platform.as_dict()
def create_workspace(login: str, workspace_data: dict) -> dict:
"""
Creates a workspace (on disk and in the database) from the given workspace data
:param workspace_data: The workspace configuration data
:return: The created workspace
"""
wsName = shlex.quote(workspace_data["name"])
session = db_session()
# test if ws Name exists in database
user = get_user(login)
existingWorkspaces = list(session.query(Workspace)
.filter(Workspace.owner == user)
.filter(Workspace.name == wsName))
if len(existingWorkspaces) > 0:
raise NameConflict("Workspace with name " + wsName + " already exists")
wsPath = path.join(WORKSPACES_DIR, user.name, wsName)
# prepare db insert
try:
ws = Workspace(name=wsName, path=wsPath, owner=user)
session.add(ws)
if 'platforms' in workspace_data:
for platform in workspace_data['platforms']:
ptf = Platform(platform['name'], platform['url'], True, ws)
if 'token' in platform:
ptf.token_path = create_token_file(platform['token'])
session.add(ptf)
test_url(platform['name'], platform['url'] + "/api/v2/packages")
if 'catalogues' in workspace_data:
for catalogue in workspace_data['catalogues']:
session.add(Catalogue(catalogue['name'], catalogue['url'], True, ws))
test_url(catalogue['name'], catalogue['url'])
except Exception as e:
logger.exception(e)
session.rollback()
raise
# create workspace on disk
proc = Popen(['son-workspace', '--init', '--workspace', wsPath], stdout=PIPE, stderr=PIPE)
out, err = proc.communicate()
exitcode = proc.returncode
if out.decode().find('existing') >= 0:
workspace_exists = True
else:
workspace_exists = False
if exitcode == 0 and not workspace_exists:
update_workspace_descriptor(ws)
session.commit()
return ws.as_dict()
else:
session.rollback()
if workspace_exists:
raise NameConflict(out.decode())
raise Exception(err, out)
def test_deploy_project(self):
package_path = self.test_package_location
result = publishutil.push_to_platform(package_path=package_path,
platform=Platform(url="http://fg-cn-sandman2.cs.upb.de:1234"))
self.assertTrue('service_uuid' in result)
result = publishutil.deploy_on_platform(service_uuid=result,
platform=Platform(url="http://fg-cn-sandman2.cs.upb.de:1234"))
self.assertTrue(result)
def test_push_project(self):
package_path = self.test_package_location
result = publishutil.push_to_platform(package_path=package_path,
platform=Platform(url="http://fg-cn-sandman2.cs.upb.de:1234"))
self.assertTrue('service_uuid' in result)
caught = False
try:
result = publishutil.push_to_platform(package_path=package_path,
platform=Platform(
url="http://fg-cn-sandman2.cs.upb.de:1010")) # wrong port
except ExtNotReachable:
caught = True
self.assertTrue(caught)
def load_workspace_descriptor(workspace) -> None:
"""
Loads the workspace descriptor from disk and updates the database model
:param workspace: The workspace database model
"""
from son_editor.models.repository import Catalogue
from son_editor.models.repository import Platform
with open(os.path.join(workspace.path, "workspace.yml"), "r") as stream:
ws_descriptor = yaml.safe_load(stream)
if 'catalogue_servers' in ws_descriptor:
catalogues = ws_descriptor['catalogue_servers']
for catalogue_server in catalogues:
workspace.catalogues.append(
Catalogue(name=catalogue_server['id'],
url=catalogue_server['url'],
publish=catalogue_server['publish'] == 'yes'))
if 'service_platforms' in ws_descriptor:
platforms = ws_descriptor['service_platforms']
for platform_id, platform in platforms.items():
workspace.platforms.append(
Platform(name=platform_id,
url=platform['url'],
publish=ws_descriptor['default_service_platform']
== platform_id))
if 'schema_index' in ws_descriptor:
workspace.schema_index = ws_descriptor['schema_index']
def create_workspace(login: str, workspace_data: dict) -> dict:
"""
Creates a workspace (on disk and in the database) from the given workspace data
:param workspace_data: The workspace configuration data
:return: The created workspace
"""
wsName = shlex.quote(workspace_data["name"])
session = db_session()
# test if ws Name exists in database
user = get_user(login)
existingWorkspaces = list(
session.query(Workspace).filter(Workspace.owner == user).filter(
Workspace.name == wsName))
if len(existingWorkspaces) > 0:
raise NameConflict("Workspace with name " + wsName + " already exists")
wsPath = path.join(WORKSPACES_DIR, user.name, wsName)
# prepare db insert
try:
ws = Workspace(name=wsName, path=wsPath, owner=user)
session.add(ws)
if 'platforms' in workspace_data:
for platform in workspace_data['platforms']:
session.add(Platform(platform['name'], platform['url'], ws))
test_url(platform['name'], platform['url'] + "/packages")
if 'catalogues' in workspace_data:
for catalogue in workspace_data['catalogues']:
session.add(Catalogue(catalogue['name'], catalogue['url'], ws))
test_url(catalogue['name'], catalogue['url'])
except:
logger.exception()
session.rollback()
raise
# create workspace on disk
proc = Popen(['son-workspace', '--init', '--workspace', wsPath],
stdout=PIPE,
stderr=PIPE)
out, err = proc.communicate()
exitcode = proc.returncode
if out.decode().find('existing') >= 0:
workspace_exists = True
else:
workspace_exists = False
if exitcode == 0 and not workspace_exists:
synchronize_workspace_descriptor(ws, session)
session.commit()
return ws.as_dict()
else:
session.rollback()
if workspace_exists:
raise NameConflict(out.decode())
raise Exception(err, out)
def update_workspace(workspace_data, wsid):
"""
Updates the workspace with the given workspace data
:param workspace_data: The new workspace configuration
:param wsid: the workspace ID
:return: The updated workspace
"""
session = db_session()
workspace = session.query(Workspace).filter(
Workspace.id == int(wsid)).first() # type: Workspace
if workspace is None:
raise NotFound("Workspace with id {} could not be found".format(wsid))
# Update name
if 'name' in workspace_data:
if path.exists(workspace.path):
new_name = workspace_data['name']
old_path = workspace.path
# only update if name has changed
if new_name != workspace.name:
new_path = rreplace(workspace.path, workspace.name, new_name,
1)
if path.exists(new_path):
raise NameConflict(
"Invalid name parameter, workspace '{}' already exists"
.format(new_name))
# Do not allow move directories outside of the workspaces_dir
if not new_path.startswith(WORKSPACES_DIR):
raise Exception(
"Invalid path parameter, you are not allowed to break out of {}"
.format(WORKSPACES_DIR))
else:
# Move the directory
shutil.move(old_path, new_path)
workspace.name = new_name
workspace.path = new_path
for platform in workspace.platforms:
deleted = True
if 'platforms' in workspace_data:
for updated_platform in workspace_data['platforms']:
if 'id' in updated_platform and platform.id == updated_platform[
'id']:
deleted = False
break
if deleted:
session.delete(platform)
if 'platforms' in workspace_data:
for updated_platform in workspace_data['platforms']:
platform = None
if 'id' in updated_platform:
platform = session.query(Platform). \
filter(Platform.id == updated_platform['id']). \
filter(Platform.workspace == workspace). \
first()
if platform:
# update existing
test_url(updated_platform['name'],
updated_platform['url'] + "/api/v2/packages")
platform.name = updated_platform['name']
platform.url = updated_platform['url']
if 'token' in updated_platform:
platform.token_path = create_token_file(
updated_platform['token'])
else:
# create new
test_url(updated_platform['name'], updated_platform['url'] +
"/api/v2/packages") # TODO test this!
new_platform = Platform(updated_platform['name'],
updated_platform['url'], True,
workspace)
session.add(new_platform)
for catalogue in workspace.catalogues:
deleted = True
if 'catalogues' in workspace_data:
for updated_catalogue in workspace_data['catalogues']:
if 'id' in updated_catalogue and catalogue.id == updated_catalogue[
'id']:
deleted = False
break
if deleted:
# check if catalogue is still referenced
for project in workspace.projects:
if catalogue.name in project.publish_to:
raise InvalidArgument(
"Cannot delete catalogue '{}' because it is still used in project '{}'!"
.format(catalogue.name, project.name))
session.delete(catalogue)
if 'catalogues' in workspace_data:
for updated_catalogue in workspace_data['catalogues']:
catalogue = None
if 'id' in updated_catalogue:
catalogue = session.query(Catalogue). \
filter(Catalogue.id == updated_catalogue['id']). \
filter(Catalogue.workspace == workspace). \
first()
if catalogue:
# update existing
test_url(updated_catalogue['name'], updated_catalogue['url'])
catalogue.name = updated_catalogue['name']
catalogue.url = updated_catalogue['url']
else:
# create new
test_url(updated_catalogue['name'], updated_catalogue['url'])
new_catalogue = Catalogue(updated_catalogue['name'],
updated_catalogue['url'], True,
workspace)
session.add(new_catalogue)
update_workspace_descriptor(workspace)
db_session.commit()
return workspace.as_dict()
