Beispiel #1
0
    def testYAMLAliases(self):
        folderModel = Folder()
        aliasedFolders = list(folderModel.find({'name': 'Common'}, force=True))
        self.assertTrue(len(aliasedFolders) == 2)

        for folder in aliasedFolders:
            self.assertTrue(
                len(list(folderModel.childItems(folder, force=True))) == 2)
Beispiel #2
0
    def testYAMLAliases(self):
        folderModel = Folder()
        aliasedFolders = list(folderModel.find({'name': 'Common'}, force=True))
        self.assertTrue(len(aliasedFolders) == 2)

        for folder in aliasedFolders:
            self.assertTrue(
                len(list(folderModel.childItems(folder, force=True))) == 2
            )
    def getAdjacentImages(self, currentImage, currentFolder=None):
        folderModel = Folder()
        if currentFolder:
            folder = currentFolder
        else:
            folder = folderModel.load(
                currentImage['folderId'], user=self.getCurrentUser(), level=AccessType.READ)

        if folder.get('isVirtual'):
            children = folderModel.childItems(folder, includeVirtual=True)
        else:
            children = folderModel.childItems(folder)

        allImages = [item for item in children if _isLargeImageItem(item)]
        try:
            index = allImages.index(currentImage)
        except ValueError:
            raise RestException('Id is not an image', 404)

        return {
            'previous': allImages[index - 1],
            'next': allImages[(index + 1) % len(allImages)]
        }
    def getAdjacentImages(self, currentImage):
        folderModel = Folder()
        folder = folderModel.load(currentImage['folderId'],
                                  user=self.getCurrentUser(),
                                  level=AccessType.READ)
        allImages = [
            item for item in folderModel.childItems(folder)
            if _isLargeImageItem(item)
        ]
        try:
            index = allImages.index(currentImage)
        except ValueError:
            raise RestException('Id is not an image', 404)

        return {
            'previous': allImages[index - 1],
            'next': allImages[(index + 1) % len(allImages)]
        }
Beispiel #5
0
    def _syncItems(image, cli_dict, user):
        folderModel = Folder()
        itemModel = Item()

        children = folderModel.childItems(
            image.tagFolder, filters={'meta.slicerCLIType': 'task'})
        existingItems = {item['name']: item for item in children}

        for cli, desc in six.iteritems(cli_dict):
            item = itemModel.createItem(
                cli,
                user,
                image.tagFolder,
                'Slicer CLI generated CLI command item',
                reuseExisting=True)
            meta_data = dict(slicerCLIType='task',
                             type=desc.get('type', 'Unknown'))

            # copy some things from the image to be independent
            meta_data['image'] = image.name
            meta_data[
                'digest'] = image.digest if image.name != image.digest else None

            desc_type = desc.get('desc-type', 'xml')

            if desc_type == 'xml':
                meta_data.update(parse_xml_desc(item, desc, user))
            elif desc_type == 'yaml':
                meta_data.update(parse_yaml_desc(item, desc, user))
            elif desc_type == 'json':
                meta_data.update(parse_json_desc(item, desc, user))

            itemModel.setMetadata(item, meta_data)

            if cli in existingItems:
                del existingItems[cli]

        # delete superfluous items
        for item in six.itervalues(existingItems):
            itemModel.remove(item)
Beispiel #6
0
class App(Resource):
    def __init__(self):
        super(App, self).__init__()
        self.resourceName = 'app'
        self._model = Folder()

        self.route('POST', (), self.initApp)
        self.route('GET', (), self.listApp)
        self.route('DELETE', (':app_id', ), self.deleteApp)
        self.route('POST', (':app_id', 'release'), self.createNewRelease)
        self.route('GET', (':app_id', 'release'), self.getAllReleases)
        self.route('GET', (':app_id', 'release', ':release_id_or_name'),
                   self.getReleaseByIdOrName)
        self.route('DELETE', (':app_id', 'release', ':release_id_or_name'),
                   self.deleteReleaseByIdOrName)
        self.route('GET', (':app_id', 'extension'), self.getExtensions)
        self.route('GET', (':app_id', 'extension', ':extension_name'),
                   self.getExtensionByName)
        self.route('POST', (':app_id', 'extension'),
                   self.createOrUpdateExtension)
        self.route('DELETE', (':app_id', 'extension', ':ext_id'),
                   self.deleteExtension)

    @autoDescribeRoute(
        Description('Create a new application.').responseClass('Folder').notes(
            'If collectionId is missing or collectionName does not match an existing '
            'collection, a fresh new collection will be created with the "collection_name" '
            'given in parameters. '
            'By default the name "Applications" will be given to the collection.'
        ).param('name', 'The name of the application.').param(
            'app_description', 'Application description.',
            required=False).param(
                'collection_id',
                'The ID of the collection which contain the application',
                required=False).param(
                    'collection_name',
                    'The Name of the collection which be created to contain'
                    ' the application',
                    required=False).param('collection_description',
                                          'Collection description.',
                                          required=False).
        param('public',
              'Whether the collection should be publicly visible.',
              required=False,
              dataType='boolean',
              default=True).errorResponse(
                  'Write permission denied on the application.', 403))
    @access.user(scope=TokenScope.DATA_WRITE)
    def initApp(self, name, app_description, collection_id, collection_name,
                collection_description, public):
        """
        Create the directory for start a new application. By default, without specifying
        a ``collection_id``, it will create a new collection name either ``collection_name``
        if provided, or **'Applications'**. If the collection 'Applications already exist it will
        get it.
        Return the new application (as a folder) that always contain a default
        sub-folder named 'nightly'.

        :param name: Name of the new application
        :param app_description: Description of the new application
        :param collection_id: Id of the collection within create the application
        :param collection_name: Name of the collection which will be created
        :param collection_description: Description of the new collection
        :param public: Whether the new collection should be publicly visible
        :return: The new application folder
        """
        creator = self.getCurrentUser()
        # Load or create the collection that contain the application
        if collection_id:
            collection = Collection().load(collection_id, force=True)
        elif collection_name:
            collection = list(Collection().find({'name': collection_name},
                                                user=creator))
            if not collection:
                collection = Collection().createCollection(
                    name=collection_name,
                    description=collection_description,
                    public=public,
                    creator=creator)
            else:
                collection = collection[0]
        else:
            collection = list(Collection().find({'name': 'Applications'},
                                                user=creator))
            if not collection:
                collection = Collection().createCollection(
                    name='Applications',
                    description=collection_description,
                    public=public,
                    creator=creator)
            else:
                collection = collection[0]
        # Create the application
        if not app_description:
            app_description = ''
        app = self._model.createFolder(parent=collection,
                                       name=name,
                                       description=app_description,
                                       parentType='Collection',
                                       public=public,
                                       creator=creator)
        # Create the 'nightly' release which will be the default folder when uploading an extension
        self._model.createFolder(
            parent=app,
            name=constants.NIGHTLY_RELEASE_NAME,
            description='Uploaded each night, always up-to-date',
            parentType='Folder',
            public=public,
            creator=creator)
        # Set a default template name for extensions in the application,
        # this can be changed in anytime.
        return self._model.setMetadata(
            app, {
                'extensionNameTemplate':
                '{app_revision}_{os}_{arch}_{baseName}_{revision}'
            })

    @autoDescribeRoute(
        Description('List existing application.').responseClass(
            'Folder', array=True).param('app_id',
                                        'The ID of the application.',
                                        required=False).param(
                                            'collection_id',
                                            'The ID of the collection.',
                                            required=False).param(
                                                'name',
                                                'The name of the application.',
                                                required=False).
        param('text',
              'Provide text search of the application.',
              required=False).pagingParams(
                  defaultSort='name').errorResponse().errorResponse(
                      'Read permission denied on the application.', 403))
    @access.user(scope=TokenScope.DATA_READ)
    def listApp(self, app_id, collection_id, name, text, limit, offset, sort):
        """
        List existing applications base on some optional parameters:

        :param app_id: Application ID
        :param collection_id: Collection ID
        :param name: Name of the application
        :param text: Provide text search on the name of the application
        :return: List of applications
        """
        user = self.getCurrentUser()

        if ObjectId.is_valid(app_id):
            return self._model.load(app_id, user=user)
        else:
            if collection_id:
                parent = Collection().load(collection_id,
                                           user=user,
                                           level=AccessType.READ,
                                           exc=True)
            else:
                parent = Collection().findOne(query={'name': 'Applications'},
                                              user=user,
                                              offset=offset)
            if parent:
                filters = {}
                if text:
                    filters['$text'] = {'$search': text}
                if name:
                    filters['name'] = name

                return list(
                    self._model.childFolders(parentType='collection',
                                             parent=parent,
                                             user=user,
                                             offset=offset,
                                             limit=limit,
                                             sort=sort,
                                             filters=filters))
            return []

    @access.user(scope=TokenScope.DATA_WRITE)
    @autoDescribeRoute(
        Description('Delete an Application by ID.').modelParam(
            'app_id', model=Folder, level=AccessType.ADMIN).param(
                'progress',
                'Whether to record progress on this task.',
                required=False,
                dataType='boolean',
                default=False).errorResponse('ID was invalid.').errorResponse(
                    'Admin access was denied for the application.', 403))
    def deleteApp(self, folder, progress):
        """
        Delete the application by ID.

        :param id: Id of the application
        :return: Confirmation message with the deleted application name
        """
        return _deleteFolder(folder, progress, self.getCurrentUser())

    @autoDescribeRoute(
        Description('Create a new release.').responseClass('Folder').notes(
            'The application\'s revision is stored as metadata of the new release.'
        ).param('name', 'The release\'s name.').param(
            'app_id', 'The application\'s ID which contain the release').param(
                'app_revision',
                'The application\'s revision which correspond to the release'
            ).param('description',
                    'The application\'s description.',
                    required=False).param(
                        'public',
                        'Whether the release should be publicly visible.',
                        required=False,
                        dataType='boolean',
                        default=True).errorResponse())
    @access.user(scope=TokenScope.DATA_WRITE)
    def createNewRelease(self, name, app_id, app_revision, description,
                         public):
        """
        Create a new release with the ``name`` within the application. The ``app_revision``
        will permit to automatically choose this release when uploading an extension
        with a matching `app_revision`` metadata.

        :param name: Name of the new release
        :param app_id: Application ID
        :param app_revision: Revision of the application corresponding to this release
        :param description: Description of the new release
        :param public: Whether the release should be publicly visible

        :return: The new release folder
        """
        creator = self.getCurrentUser()
        application = self._model.load(app_id, user=creator)
        if not description:
            description = ''
        release = self._model.createFolder(parent=application,
                                           name=name,
                                           description=description,
                                           parentType='Folder',
                                           public=public,
                                           creator=creator)

        return self._model.setMetadata(release, {'revision': app_revision})

    @autoDescribeRoute(
        Description('Get all the releases from an application.').responseClass(
            'Folder').param('app_id', 'The application\'s ID.').pagingParams(
                defaultSort='name').errorResponse(
                    'ID was invalid.').errorResponse(
                        'Read permission denied on the application.', 403))
    @access.user(scope=TokenScope.DATA_READ)
    def getAllReleases(self, app_id, limit, offset, sort):
        """
        Get a list of all the release of an application.

        :param app_id: Application ID
        :return: List of all release within the application
        """
        user = self.getCurrentUser()
        application = self._model.load(app_id, user=user)
        # It returns the nightly release too
        return list(
            self._model.childFolders(application,
                                     'Folder',
                                     user=user,
                                     limit=limit,
                                     offset=offset,
                                     sort=sort))

    @autoDescribeRoute(
        Description(
            'Get a particular releases by ID or name from an application.').
        responseClass('Folder').param(
            'app_id', 'The application\'s ID.').param(
                'release_id_or_name',
                'The release\'s ID or name.').errorResponse(
                    'ID or name was invalid.').errorResponse(
                        'Read permission denied on the application.', 403))
    @access.user(scope=TokenScope.DATA_READ)
    def getReleaseByIdOrName(self, app_id, release_id_or_name):
        """
        Get the release folder by ID or by name.

        :param app_id: Application ID
        :param release_id_or_name: Could be either the release ID or the release name
        :return: The release folder
        """
        user = self.getCurrentUser()
        application = self._model.load(app_id, user=user)

        if ObjectId.is_valid(release_id_or_name):
            return self._model.load(release_id_or_name, user=user)
        release_folder = list(
            self._model.childFolders(
                application,
                'Folder',
                filters={'lowerName': release_id_or_name.lower()}))
        if not release_folder:
            return None
        return release_folder[0]

    @access.user(scope=TokenScope.DATA_WRITE)
    @autoDescribeRoute(
        Description('Delete a release by ID or name.').modelParam(
            'app_id', model=Folder,
            level=AccessType.ADMIN).param('release_id_or_name',
                                          'The release\'s ID or name.').
        param('progress',
              'Whether to record progress on this task.',
              required=False,
              dataType='boolean',
              default=False).errorResponse('ID was invalid.').errorResponse(
                  'Admin access was denied for the release.', 403))
    def deleteReleaseByIdOrName(self, folder, release_id_or_name, progress):
        """
        Delete a release by ID or name.

        :param app_id: Application ID
        :param release_id_or_name: Could be either the release ID or the release name
        :param progress: Whether to record progress on this task
        :return: Confirmation message with the deleted release name
        """
        user = self.getCurrentUser()

        if ObjectId.is_valid(release_id_or_name):
            release = self._model.load(release_id_or_name, user=user)
        else:
            release_folder = list(
                self._model.childFolders(
                    folder,
                    'Folder',
                    filters={'lowerName': release_id_or_name.lower()}))
            if not release_folder:
                raise Exception("Couldn't find release %s" %
                                release_id_or_name)
            release = release_folder[0]

        return _deleteFolder(release, progress, self.getCurrentUser())

    @autoDescribeRoute(
        Description('List or search available extensions.').responseClass(
            'Extension').param('app_id', 'The ID of the application.').param(
                'release_id', 'The release id.', required=False).param(
                    'extension_id', 'The extension id.', required=False).param(
                        'os',
                        'The target operating system of the package.',
                        required=False,
                        enum=['linux', 'win',
                              'macosx']).param('arch',
                                               'The os chip architecture.',
                                               required=False,
                                               enum=['i386', 'amd64']).
        param('app_revision', 'The revision of the package.',
              required=False).param(
                  'search',
                  'Text matched against extension name or description.',
                  required=False).pagingParams(
                      defaultSort='created').errorResponse())
    @access.cookie
    @access.public
    def getExtensions(self, app_id, release_id, extension_id, os, arch,
                      app_revision, search, limit, offset, sort):
        """
        Get a list of extension which is filtered by some optional parameters:

        :param app_id: Application ID
        :param release_id: Release ID
        :param extension_id: Extension ID
        :param os: The operation system used for the extension.
        :param arch: The architecture compatible with the extension.
        :param app_revision: The revision of the application
        :param search: Text search on the name of the extension
        :return: The list of extensions
        """
        filters = {
            '$and': [{
                'meta.app_id': {
                    '$eq': app_id
                }
            }, {
                'meta.os': {
                    '$exists': True
                }
            }, {
                'meta.arch': {
                    '$exists': True
                }
            }, {
                'meta.revision': {
                    '$exists': True
                }
            }]
        }
        if ObjectId.is_valid(extension_id):
            filters['_id'] = ObjectId(extension_id)
        if ObjectId.is_valid(release_id):
            filters['folderId'] = ObjectId(release_id)
        if os:
            filters['meta.os'] = os
        if arch:
            filters['meta.arch'] = arch
        if app_revision:
            filters['meta.revision'] = app_revision
        if search:
            # Provide a full text search on baseName
            filters['meta.baseName'] = search

        return list(ExtensionModel().find(query=filters,
                                          limit=limit,
                                          offset=offset,
                                          sort=sort))

    @autoDescribeRoute(
        Description('Get a particular extension by name from an application.').
        responseClass('Item').param('app_id', 'The application\'s ID.').param(
            'extension_name', 'The extension\'s name.').errorResponse(
                'ID or name was invalid.').errorResponse(
                    'Read permission denied on the application.', 403))
    @access.user(scope=TokenScope.DATA_READ)
    def getExtensionByName(self, app_id, extension_name):
        """
        Get the extension item by name.

        :param app_id: Application ID
        :param extension_name: The extension name
        :return: The extension item
        """
        user = self.getCurrentUser()
        application = self._model.load(app_id, user=user)

        release_folder = list(self._model.childFolders(application, 'Folder'))
        if not release_folder:
            raise Exception('The application has no release')
        for release in release_folder:
            extensions = list(
                self._model.childItems(
                    release, filters={'lowerName': extension_name.lower()}))
            if extensions:
                return extensions[0]
        return None

    @autoDescribeRoute(  # noqa: C901
        Description('Create or Update an extension package.').param(
            'app_id', 'The ID of the App.').param(
                'os',
                'The target operating system of the package.',
                enum=['linux', 'win',
                      'macosx']).param('arch',
                                       'The os chip architecture.',
                                       enum=['i386', 'amd64']).
        param('baseName',
              'The baseName of the package (ie installer baseName).').param(
                  'repository_type',
                  'The type of the repository (svn, git).').param(
                      'repository_url', 'The url of the repository.').param(
                          'revision',
                          'The svn or git revision of the extension.').param(
                              'app_revision',
                              'The revision of the application '
                              'that the extension was built against.').param(
                                  'packagetype',
                                  'Installer, data, etc.').param(
                                      'codebase',
                                      'The codebase baseName (Ex: Slicer4).').
        param('description', 'Text describing the extension.').param(
            'release',
            'Release identifier (Ex: 0.0.1, 0.0.2, 0.1).',
            required=False).param(
                'icon_url',
                'The url of the icon for the extension.',
                required=False).param(
                    'development_status',
                    'Arbitrary description of the status of the extension '
                    '(stable, active, etc).',
                    required=False).
        param(
            'category',
            'Category under which to place the extension. Subcategories should be '
            'delimited by character. If none is passed, will render under '
            'the Miscellaneous category..',
            required=False
        ).param(
            'enabled',
            'Boolean indicating if the extension should be automatically enabled '
            'after its installation.',
            required=False).param('homepage',
                                  'The url of the extension homepage.',
                                  required=False).
        param('screenshots',
              'Space-separate list of URLs of screenshots for the extension.',
              required=False).param('contributors',
                                    'List of contributors of the extension',
                                    required=False).errorResponse())
    @access.cookie
    @access.public
    def createOrUpdateExtension(self, app_id, os, arch, baseName,
                                repository_type, repository_url, revision,
                                app_revision, packagetype, codebase,
                                description, release, icon_url,
                                development_status, category, enabled,
                                homepage, screenshots, contributors):
        """
        Upload an extension package in the database, in a specific release with providing
        ``release_id``. Or by default in the **'Nightly'** folder.

        :param app_id: The ID of the application.
        :param os: The operation system used for the extension.
        :param arch: The architecture compatible with the extension.
        :param baseName: The base name of the extension.
        :param repository_type: The type of repository (github, gitlab, ...).
        :param repository_url: The Url of the repository.
        :param revision: The revision of the extension.
        :param app_revision: The revision of the application.
        :param packagetype: Type of the extension.
        :param codebase: The codebase baseName.
        :param description: The description of the extension.
        :return: The status of the upload.
        """
        creator = self.getCurrentUser()
        application = self._model.load(app_id, user=creator)
        release_folder = None
        # Find the release by metadata revision
        releases = self._model.childFolders(application,
                                            'Folder',
                                            user=creator)
        for folder in releases:
            if 'meta' in folder:
                if folder['meta']['revision'] == app_revision:
                    release_folder = folder
                    break
        if not release_folder:
            # Only the nightly folder in the list
            release_folder = list(
                self._model.childFolders(
                    application,
                    'Folder',
                    user=creator,
                    filters={'name': constants.NIGHTLY_RELEASE_NAME}))
            if not release_folder:
                raise Exception('The %s folder not found.' %
                                constants.NIGHTLY_RELEASE_NAME)
            release_folder = release_folder[0]

        params = {
            'app_id': app_id,
            'baseName': baseName,
            'os': os,
            'arch': arch,
            'repository_type': repository_type,
            'repository_url': repository_url,
            'revision': revision,
            'app_revision': app_revision,
            'packagetype': packagetype,
            'codebase': codebase,
            'description': description
        }
        if release:
            params['release'] = release
        if icon_url:
            params['icon_url'] = icon_url
        if development_status:
            params['development_status'] = development_status
        if category:
            params['category'] = category
        if enabled:
            params['enabled'] = enabled
        if homepage:
            params['homepage'] = homepage
        if screenshots:
            params['screenshots'] = screenshots
        if contributors:
            params['contributors'] = contributors

        name = application['meta']['extensionNameTemplate'].format(**params)
        filters = {'name': name}
        # Only one extensions should be in this list
        extensions = list(ExtensionModel().get(release_folder,
                                               filters=filters))
        if not len(extensions):
            # The extension doesn't exist yet:
            extension = ExtensionModel().createExtension(
                name, creator, release_folder, params)
        elif len(extensions) == 1:
            extension = extensions[0]
        else:
            raise Exception(
                'Too many extensions found for the same name :"%s"' % name)

        # Check the file inside the extension Item
        files = Item().childFiles(extension)
        if files.count() == 1:
            old_file = files.next()
            # catch the event of upload success and remove the file
            events.bind('model.file.finalizeUpload.after', 'application',
                        File().remove(old_file))
        elif not files.count():
            # Extension new or empty
            pass
        else:
            raise Exception("More than 1 binary file in the extension.")

        old_meta = {
            'baseName': extension['meta']['baseName'],
            'os': extension['meta']['os'],
            'arch': extension['meta']['arch'],
            'revision': extension['meta']['revision'],
            'app_revision': extension['meta']['app_revision']
        }
        identifier_meta = {
            'baseName': baseName,
            'os': os,
            'arch': arch,
            'revision': revision,
            'app_revision': app_revision
        }
        if identifier_meta == old_meta and len(extensions):
            # The revision is the same than these before, no need to upload
            extension = ExtensionModel().setMetadata(extension, params)
            events.unbind('model.file.finalizeUpload.after', 'application')

        # Ready to upload the binary file
        return extension

    @access.user(scope=TokenScope.DATA_WRITE)
    @autoDescribeRoute(
        Description('Delete an Extension by ID.').param(
            'app_id', 'The ID of the App.').modelParam(
                'ext_id', model=Item, level=AccessType.WRITE).errorResponse(
                    'ID was invalid.').errorResponse(
                        'Admin access was denied for the extension.', 403))
    def deleteExtension(self, app_id, item):
        """
        Delete the extension by ID.

        :param app_id: Application ID
        :param ext_id: Extension ID
        :return: Confirmation message with the name of the deleted extension
        """
        Item().remove(item)
        return {'message': 'Deleted extension %s.' % item['name']}