def _scan_for_services(services_dir, pj):
    from son_editor.models.descriptor import Service
    session = db_session()
    try:
        for service_file in os.listdir(services_dir):
            if service_file.endswith(".yml"):
                service = Service()
                file_path = os.path.join(services_dir, service_file)
                load_ns_vnf_from_disk(file_path, service)
                db_service = session.query(Service). \
                    filter(Service.project == pj). \
                    filter(Service.name == service.name). \
                    filter(Service.vendor == service.vendor). \
                    filter(Service.version == service.version). \
                    first()
                if not db_service:
                    logger.info("Found service in project {}: {}".format(pj.name, service.uid))
                    service.project = pj
                    session.add(service)
                    session.commit()
                else:
                    session.rollback()
                if get_file_path("nsd", service) != file_path:
                    shutil.move(file_path, get_file_path("nsd", service))  # rename to expected name format
            elif os.path.isdir(os.path.join(services_dir, service_file)):
                _scan_for_services(os.path.join(services_dir, service_file), pj)
    except:
        session.rollback()
def _scan_for_services(services_dir, pj):
    from son_editor.models.descriptor import Service
    session = db_session()
    try:
        for service_file in os.listdir(services_dir):
            if service_file.endswith(".yml"):
                service = Service()
                file_path = os.path.join(services_dir, service_file)
                load_ns_vnf_from_disk(file_path, service)
                db_service = session.query(Service). \
                    filter(Service.project == pj). \
                    filter(Service.name == service.name). \
                    filter(Service.vendor == service.vendor). \
                    filter(Service.version == service.version). \
                    first()
                if not db_service:
                    logger.info("Found service in project {}: {}".format(
                        pj.name, service.uid))
                    service.project = pj
                    session.add(service)
                    session.commit()
                else:
                    session.rollback()
                if get_file_path("nsd", service) != file_path:
                    shutil.move(file_path, get_file_path(
                        "nsd", service))  # rename to expected name format
            elif os.path.isdir(os.path.join(services_dir, service_file)):
                _scan_for_services(os.path.join(services_dir, service_file),
                                   pj)
    except:
        session.rollback()
def create_service(ws_id: int, project_id: int, service_data: dict) -> dict:
    """
    Creates a service in the given project
    :param ws_id: The Workspace of the project
    :param project_id: The Project of the Service
    :param service_data: the service descriptor
    :return: The created service descriptor
    """
    session = db_session()
    project = session.query(Project).filter_by(id=project_id).first()

    if project:
        # Retrieve post parameters
        try:
            service_name = shlex.quote(service_data['descriptor']["name"])
            vendor_name = shlex.quote(service_data['descriptor']["vendor"])
            version = shlex.quote(service_data['descriptor']["version"])
        except KeyError as ke:
            raise InvalidArgument("Missing key {} in service data".format(
                str(ke)))

        existing_services = list(
            session.query(Service).join(Project).join(Workspace).filter(
                Workspace.id == ws_id).filter(
                    Service.project == project).filter(
                        Service.name == service_name).filter(
                            Service.vendor == vendor_name).filter(
                                Service.version == version))
        if len(existing_services) > 0:
            raise NameConflict(
                "A service with this name/vendor/version already exists")

        # validate service descriptor
        workspace = session.query(Workspace).filter(
            Workspace.id == ws_id).first()
        validate_service_descriptor(workspace.ns_schema_index,
                                    service_data["descriptor"])

        # Create db object
        service = Service(name=service_name,
                          vendor=vendor_name,
                          version=version,
                          project=project,
                          descriptor=json.dumps(service_data["descriptor"]),
                          meta=json.dumps(service_data["meta"]))
        session.add(service)
        try:
            write_ns_vnf_to_disk("nsd", service)
        except:
            logger.exception("Could not create service:")
            session.rollback()
            raise
        session.commit()
        return service.as_dict()

    else:
        session.rollback()
        raise NotFound("Project with id '{}‘ not found".format(project_id))
def create_service(ws_id: int, project_id: int, service_data: dict) -> dict:
    """
    Creates a service in the given project

    :param ws_id: The Workspace of the project
    :param project_id: The Project of the Service
    :param service_data: the service descriptor
    :return: The created service descriptor
    """
    session = db_session()
    project = session.query(Project).filter_by(id=project_id).first()

    if project:
        # Retrieve post parameters
        try:
            service_name = shlex.quote(service_data['descriptor']["name"])
            vendor_name = shlex.quote(service_data['descriptor']["vendor"])
            version = shlex.quote(service_data['descriptor']["version"])
        except KeyError as ke:
            raise InvalidArgument("Missing key {} in service data".format(str(ke)))

        existing_services = list(session.query(Service)
                                 .join(Project)
                                 .join(Workspace)
                                 .filter(Workspace.id == ws_id)
                                 .filter(Service.project == project)
                                 .filter(Service.name == service_name)
                                 .filter(Service.vendor == vendor_name)
                                 .filter(Service.version == version))
        if len(existing_services) > 0:
            raise NameConflict("A service with this name/vendor/version already exists")

        # validate service descriptor
        workspace = session.query(Workspace).filter(Workspace.id == ws_id).first()
        validate_service_descriptor(workspace.ns_schema_index, service_data["descriptor"])

        # Create db object
        service = Service(name=service_name,
                          vendor=vendor_name,
                          version=version,
                          project=project,
                          descriptor=json.dumps(service_data["descriptor"]),
                          meta=json.dumps(service_data["meta"]))
        session.add(service)
        try:
            write_ns_vnf_to_disk("nsd", service)
        except:
            logger.exception("Could not create service:")
            session.rollback()
            raise
        session.commit()
        return service.as_dict()

    else:
        session.rollback()
        raise NotFound("Project with id '{}‘ not found".format(project_id))
Example #5
0
 def setUp(self):
     # Initializes test context
     self.app = init_test_context()
     self.project = Project(name="Project A")
     self.workspace = Workspace(name="Workspace A")
     self.service = Service(name="Service A")
     self.function = Function(name="Function A")
     self.catalogue = Catalogue(name="Catalogue A", url="")
     self.platform = Catalogue(name="Platform A", url="")
     self.user = User(name="User A")
def update_service(ws_id, project_id, service_id, service_data):
    """
    Update the service using the service data from the request

    :param ws_id:
    :param project_id:
    :param service_id:
    :param service_data:
    :return:
    """
    session = db_session()
    project = session.query(Project). \
        filter(Project.id == project_id).first()
    service = session.query(Service). \
        join(Project). \
        join(Workspace). \
        filter(Workspace.id == ws_id). \
        filter(Service.project == project). \
        filter(Service.id == service_id).first()
    if service:
        refs = get_references(service, session)
        old_file_name = get_file_path("nsd", service)
        old_uid = get_uid(service.vendor, service.name, service.version)
        # Parse parameters and update record
        if 'descriptor' in service_data:
            # validate service descriptor
            workspace = session.query(Workspace).filter(Workspace.id == ws_id).first()
            validate_service_descriptor(workspace.ns_schema_index, service_data["descriptor"])
            try:
                newName = shlex.quote(service_data["descriptor"]["name"])
                newVendor = shlex.quote(service_data["descriptor"]["vendor"])
                newVersion = shlex.quote(service_data["descriptor"]["version"])
            except KeyError as ke:
                raise InvalidArgument("Missing key {} in function data".format(str(ke)))
            new_uid = get_uid(newVendor, newName, newVersion)
            if old_uid != new_uid:
                if refs:
                    # keep old version and create new version in db
                    service = Service(newName, newVersion, newVendor, project=project)
                    session.add(service)
                else:
                    service.name = newName
                    service.vendor = newVendor
                    service.version = newVersion
            service.descriptor = json.dumps(service_data["descriptor"])

        if 'meta' in service_data:
            service.meta = json.dumps(service_data["meta"])

        if old_uid != new_uid:
            new_file_name = get_file_path("nsd", service)
            try:
                if not old_file_name == new_file_name:
                    if refs:
                        shutil.copy(old_file_name, new_file_name)
                    else:
                        shutil.move(old_file_name, new_file_name)
            except:
                logger.exception("Could not update descriptor file:")
                raise

        write_ns_vnf_to_disk("nsd", service)
        session.commit()
        return service.as_dict()
    else:
        raise NotFound("Could not update service '{}', because no record was found".format(service_id))
def update_service(ws_id, project_id, service_id, service_data):
    """
    Update the service using the service data from the request
    
    Will also check for references by other services and create a copy if so

    :param ws_id: The Workspace ID
    :param project_id: The project ID
    :param service_id: The service ID
    :param service_data: The service data containing the "descriptor" and optionally some "meta" data
    :return: The updated service data
    """
    session = db_session()
    project = session.query(Project). \
        filter(Project.id == project_id).first()
    service = session.query(Service). \
        join(Project). \
        join(Workspace). \
        filter(Workspace.id == ws_id). \
        filter(Service.project == project). \
        filter(Service.id == service_id).first()
    if service:
        refs = get_references(service, session)
        old_file_name = get_file_path("nsd", service)
        old_uid = get_uid(service.vendor, service.name, service.version)
        # Parse parameters and update record
        if 'descriptor' in service_data:
            # validate service descriptor
            workspace = session.query(Workspace).filter(Workspace.id == ws_id).first()
            validate_service_descriptor(workspace.schema_index, service_data["descriptor"])
            try:
                newName = shlex.quote(service_data["descriptor"]["name"])
                newVendor = shlex.quote(service_data["descriptor"]["vendor"])
                newVersion = shlex.quote(service_data["descriptor"]["version"])
            except KeyError as ke:
                raise InvalidArgument("Missing key {} in function data".format(str(ke)))
            new_uid = get_uid(newVendor, newName, newVersion)
            if old_uid != new_uid:
                if refs:
                    # keep old version and create new version in db
                    service = Service(newName, newVersion, newVendor, project=project)
                    session.add(service)
                else:
                    service.name = newName
                    service.vendor = newVendor
                    service.version = newVersion
            service.descriptor = json.dumps(service_data["descriptor"])

        if 'meta' in service_data:
            service.meta = json.dumps(service_data["meta"])

        if old_uid != new_uid:
            new_file_name = get_file_path("nsd", service)
            try:
                if not old_file_name == new_file_name:
                    if refs:
                        shutil.copy(old_file_name, new_file_name)
                    else:
                        shutil.move(old_file_name, new_file_name)
            except:
                logger.exception("Could not update descriptor file:")
                raise

        write_ns_vnf_to_disk("nsd", service)
        session.commit()
        return service.as_dict()
    else:
        raise NotFound("Could not update service '{}', because no record was found".format(service_id))