def _get_package_by_definition(self, package_def):
        package_id = package_def.id
        package_name = package_def.fully_qualified_name
        package_directory = os.path.join(self._cache_directory, package_name)

        if os.path.exists(package_directory):
            try:
                return app_pkg.load_from_dir(package_directory, preload=True, loader=YaqlYamlLoader)
            except pkg_exc.PackageLoadError:
                LOG.exception("Unable to load package from cache. Clean-up...")
                shutil.rmtree(package_directory, ignore_errors=True)

        try:
            package_data = self._client.packages.download(package_id)
        except muranoclient_exc.HTTPException:
            LOG.exception("Unable to download " "package with id {0}".format(package_id))
            raise pkg_exc.PackageLoadError()
        try:
            with tempfile.NamedTemporaryFile(delete=False) as package_file:
                package_file.write(package_data)

            return app_pkg.load_from_file(
                package_file.name, target_dir=package_directory, drop_dir=False, loader=YaqlYamlLoader
            )
        except IOError:
            LOG.exception("Unable to write package file")
            raise pkg_exc.PackageLoadError()
        finally:
            try:
                os.remove(package_file.name)
            except OSError:
                pass
Пример #2
0
    def upload(self, req, body=None):
        """
        Upload new file archive for the new package
        together with package metadata
        """
        _check_content_type(req, 'multipart/form-data')
        file_obj, package_meta = _validate_body(body)
        try:
            jsonschema.validate(package_meta, schemas.PKG_UPLOAD_SCHEMA)
        except jsonschema.ValidationError as e:
            LOG.exception(e)
            raise exc.HTTPBadRequest(explanation=e.message)

        with tempfile.NamedTemporaryFile(delete=False) as tempf:
            LOG.debug("Storing package archive in a temporary file")
            content = file_obj.file.read()
            if not content:
                msg = _("Uploading file can't be empty")
                LOG.error(msg)
                raise exc.HTTPBadRequest(msg)
            tempf.write(content)
            package_meta['archive'] = content
        try:
            LOG.debug("Deleting package archive temporary file")
            pkg_to_upload = app_pkg.load_from_file(tempf.name,
                                                   target_dir=None,
                                                   drop_dir=True)
        except pkg_exc.PackageLoadError as e:
            LOG.exception(e)
            raise exc.HTTPBadRequest(e)
        finally:
            os.remove(tempf.name)

        # extend dictionary for update db
        for k, v in PKG_PARAMS_MAP.iteritems():
            if hasattr(pkg_to_upload, k):
                package_meta[v] = getattr(pkg_to_upload, k)
        try:
            package = db_api.package_upload(package_meta, req.context.tenant)
        except db_exc.DBDuplicateEntry:
            msg = _('Package with specified full name is already registered')
            LOG.exception(msg)
            raise exc.HTTPServerError(msg)
        return package.to_dict()
Пример #3
0
    def _get_package_by_definition(self, package_def):
        package_id = package_def.id
        package_name = package_def.fully_qualified_name
        package_directory = os.path.join(self._cache_directory, package_name)

        if os.path.exists(package_directory):
            try:
                return app_pkg.load_from_dir(package_directory, preload=True,
                                             loader=YaqlYamlLoader)
            except pkg_exc.PackageLoadError:
                LOG.exception('Unable to load package from cache. Clean-up...')
                shutil.rmtree(package_directory, ignore_errors=True)

        try:
            package_data = self._client.packages.download(package_id)
        except muranoclient_exc.HTTPException:
            LOG.exception('Unable to download '
                          'package with id {0}'.format(package_id))
            raise pkg_exc.PackageLoadError()
        try:
            with tempfile.NamedTemporaryFile(delete=False) as package_file:
                package_file.write(package_data)

            return app_pkg.load_from_file(
                package_file.name,
                target_dir=package_directory,
                drop_dir=False,
                loader=YaqlYamlLoader
            )
        except IOError:
            LOG.exception('Unable to write package file')
            raise pkg_exc.PackageLoadError()
        finally:
            try:
                os.remove(package_file.name)
            except OSError:
                pass