Beispiel #1
0
 def get(self, callback):
     logger.debug("INSIDE SPACES GET")
     key = self.get_key_name(self.context.request.url)
     buff = BytesIO()
     session = boto3.session.Session()
     client = session.resource(
         's3',
         region_name=self.context.config.SPACES_REGION,
         endpoint_url='https://' + self.context.config.SPACES_ENDPOINT +
         '.digitaloceanspaces.com',
         aws_access_key_id=self.context.config.SPACES_KEY,
         aws_secret_access_key=self.context.config.SPACES_SECRET)
     try:
         objkey = client.Bucket(
             self.context.config.SPACES_BUCKET).Object(key)
         objkey.download_fileobj(buff)
         result = ResultStorageResult()
         result.buffer = buff
         result.metadata = objkey.get_metadata("Metadata")
         result.metadata.pop('Body')
         logger.debug(result.metadata)
         callback(result)
     except:
         callback(None)
     callback(None)
Beispiel #2
0
        def return_result(key):
            if key is None or self._get_error(key) or self.is_expired(key):
                callback(None)
            else:
                result = ResultStorageResult()
                result.buffer     = key['Body'].read()
                result.successful = True
                result.metadata   = key.copy()
                result.metadata.pop('Body')

                logger.debug(str(result.metadata))

                callback(result)
        def return_result(key):
            if key is None or self._get_error(key) or self.is_expired(key):
                callback(None)
            else:
                result = ResultStorageResult()
                result.buffer = key['Body'].read()
                result.successful = True
                result.metadata = key.copy()
                result.metadata.pop('Body')

                logger.debug(str(result.metadata))

                callback(result)
Beispiel #4
0
    def _get(self, key):
        stored = next(
            self.storage.find(
                {
                    'key': key,
                    'created_at': {
                        '$gte':
                        datetime.utcnow() -
                        timedelta(seconds=self.get_max_age())
                    },
                }, {
                    'file_id': True,
                    'created_at': True,
                    'metadata': True
                }).limit(1), None)

        if not stored:
            return None

        file_storage = gridfs.GridFS(self.database)

        contents = file_storage.get(stored['file_id']).read()

        metadata = stored['metadata']
        metadata['LastModified'] = stored['created_at'].replace(
            tzinfo=pytz.utc)
        metadata['ContentLength'] = len(contents)
        metadata['ContentType'] = BaseEngine.get_mimetype(contents)
        result = ResultStorageResult(buffer=contents,
                                     metadata=metadata,
                                     successful=True)
        return result
Beispiel #5
0
    def get(self, callback):
        path = self.context.request.url
        file_abspath = self.normalize_path(path)
        if not self.validate_path(file_abspath):
            logger.warn(
                "[RESULT_STORAGE] unable to read from outside root path: %s" %
                file_abspath)
            return None
        logger.debug("[RESULT_STORAGE] getting from %s" % file_abspath)

        if not exists(file_abspath) or self.is_expired(file_abspath):
            logger.debug("[RESULT_STORAGE] image not found at %s" %
                         file_abspath)
            callback(None)
        else:
            with open(file_abspath, "rb") as f:
                buffer = f.read()

            result = ResultStorageResult(
                buffer=buffer,
                metadata={
                    "LastModified":
                    datetime.fromtimestamp(
                        getmtime(file_abspath)).replace(tzinfo=pytz.utc),
                    "ContentLength":
                    len(buffer),
                    "ContentType":
                    BaseEngine.get_mimetype(buffer),
                },
            )

            callback(result)
    async def get(self):
        path = self.context.request.url
        file_abspath = self.normalize_path(path)

        if not self.validate_path(file_abspath):
            logger.warning(
                "[RESULT_STORAGE] unable to read from outside root path: %s",
                file_abspath,
            )
            return None

        logger.debug("[RESULT_STORAGE] getting from %s", file_abspath)

        if isdir(file_abspath):
            logger.warning(
                "[RESULT_STORAGE] cache location is a directory: %s",
                file_abspath)
            return None

        if not exists(file_abspath):
            legacy_path = self.normalize_path_legacy(path)
            if isfile(legacy_path):
                logger.debug(
                    "[RESULT_STORAGE] migrating image from old location at %s",
                    legacy_path,
                )
                self.ensure_dir(dirname(file_abspath))
                move(legacy_path, file_abspath)
            else:
                logger.debug("[RESULT_STORAGE] image not found at %s",
                             file_abspath)
                return None

        expire_time = self.get_expire_time(file_abspath)
        if self.is_expired(file_abspath, expire_time):
            logger.debug("[RESULT_STORAGE] cached image has expired")
            return None

        with open(file_abspath, "rb") as image_file:
            buffer = image_file.read()

        if expire_time is not None:
            self.context.request.max_age = expire_time

        result = ResultStorageResult(
            buffer=buffer,
            metadata={
                "LastModified":
                datetime.fromtimestamp(
                    getmtime(file_abspath)).replace(tzinfo=pytz.utc),
                "ContentLength":
                len(buffer),
                "ContentType":
                BaseEngine.get_mimetype(buffer),
            },
        )

        return result