testbed/minio__minio-py/minio/select/reader.py

# -*- coding: utf-8 -*-
# MinIO Python Library for Amazon S3 Compatible Cloud Storage, (C)
# 2019 MinIO, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
minio.select.reader
~~~~~~~~~~~~~~~

This module implements the reader for SelectObject response body.

:copyright: (c) 2019 by MinIO, Inc.
:license: Apache 2.0, see LICENSE for more details.

"""

from __future__ import absolute_import

import io
import sys
from xml.etree import ElementTree

from .errors import SelectCRCValidationError, SelectMessageError
from .helpers import (ERROR, EVENT, EVENT_CONTENT_TYPE, EVENT_RECORDS,
                      EVENT_STATS, byte_int, calculate_crc, validate_crc)


def _extract_header(header_bytes):
    """
    populates the header map after reading the header in bytes
    """
    header_map = {}
    header_byte_parsed = 0
    # While loop ends when all the headers present are read
    # header contains multipe headers
    while header_byte_parsed < len(header_bytes):
        header_name_byte_length = byte_int(
            header_bytes[header_byte_parsed:header_byte_parsed+1])
        header_byte_parsed += 1
        header_name = header_bytes[
            header_byte_parsed:header_byte_parsed+header_name_byte_length
        ]
        header_byte_parsed += header_name_byte_length
        # Header Value Type is of 1 bytes and is skipped
        header_byte_parsed += 1
        value_string_byte_length = byte_int(
            header_bytes[header_byte_parsed:header_byte_parsed+2]
        )
        header_byte_parsed += 2
        header_value = header_bytes[
            header_byte_parsed:header_byte_parsed+value_string_byte_length
        ]
        header_byte_parsed += value_string_byte_length
        header_map[header_name.decode(
            "utf-8").lstrip(":")] = header_value.decode("utf-8").lstrip(":")
    return header_map


def _parse_stats(stats):
    """
    Parses stats XML and populates the stat dict.
    """
    stat = {}
    for attribute in ElementTree.fromstring(stats):
        if attribute.tag == 'BytesScanned':
            stat['BytesScanned'] = attribute.text
        elif attribute.tag == 'BytesProcessed':
            stat['BytesProcessed'] = attribute.text
        elif attribute.tag == 'BytesReturned':
            stat['BytesReturned'] = attribute.text

    return stat


class SelectObjectReader:
    """
    SelectObjectReader returns a Reader that upon read
    returns queried data, but stops when the response ends.
    LimitedRandomReader is compatible with BufferedIOBase.
    """

    def __init__(self, response):
        self.response = response
        self.remaining_bytes = bytes()
        self.stat = {}
        self.prog = {}

    def readable(self):  # pylint: disable=no-self-use
        """Return this is readable."""
        return True

    def writeable(self):  # pylint: disable=no-self-use
        """Return this is not writeable."""
        return False

    def close(self):
        """Close response."""
        self.response.close()

    def stats(self):
        """Get stats information."""
        return self.stat

    def progress(self):
        """Get progress information."""
        return self.prog

    def __extract_message(self):
        """
        Process the response sent from server.
        https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectSELECTContent.html
        """

        crc_bytes = io.BytesIO()
        total_bytes_len = self.response.read(4)
        if not total_bytes_len:
            return {}

        total_length = byte_int(total_bytes_len)
        header_bytes_len = self.response.read(4)
        if not header_bytes_len:
            return {}

        header_len = byte_int(header_bytes_len)

        crc_bytes.write(total_bytes_len)
        crc_bytes.write(header_bytes_len)

        prelude_bytes_crc = self.response.read(4)
        if not validate_crc(crc_bytes.getvalue(), prelude_bytes_crc):
            raise SelectCRCValidationError(
                {"Checksum Mismatch, PreludeCRC of " +
                 str(calculate_crc(crc_bytes.getvalue())) +
                 " does not equal expected CRC of " +
                 str(byte_int(prelude_bytes_crc))})

        crc_bytes.write(prelude_bytes_crc)

        header_bytes = self.response.read(header_len)
        if not header_bytes:
            raise SelectMessageError(
                "Premature truncation of select message header" +
                ", server is sending corrupt message?")

        crc_bytes.write(header_bytes)

        header_map = _extract_header(header_bytes)
        payload_length = total_length - header_len - int(16)
        payload_bytes = b''
        event_type = header_map["event-type"]

        if header_map["message-type"] == ERROR:
            raise SelectMessageError(
                header_map["error-code"] + ":\"" +
                header_map["error-message"] + "\"")

        if header_map["message-type"] != EVENT:
            raise SelectMessageError(
                "Unrecognized message-type {0}".format(
                    header_map["message-type"])
            )

        if event_type == EVENT_STATS:
            content_type = header_map["content-type"]
            if content_type != EVENT_CONTENT_TYPE:
                raise SelectMessageError(
                    "Unrecognized content-type {0}".format(content_type))

            payload_bytes = self.response.read(payload_length)
            self.stat = _parse_stats(payload_bytes)
        elif event_type == EVENT_RECORDS:
            payload_bytes = self.response.read(payload_length)

        crc_bytes.write(payload_bytes)

        message_crc = self.response.read(4)
        if not message_crc:
            return {}

        if not validate_crc(crc_bytes.getvalue(), message_crc):
            raise SelectCRCValidationError(
                {"Checksum Mismatch, MessageCRC of " +
                 str(calculate_crc(crc_bytes.getvalue())) +
                 " does not equal expected CRC of " +
                 str(byte_int(message_crc))})

        message = {event_type: payload_bytes}
        return message

    def stream(self, num_bytes=32*1024):
        """
        extract each record from the response body ... and buffer it.
        send only up to requested bytes such as message[:num_bytes]
        rest is buffered and added to the next iteration.

        caller should call self.close() to close the stream.
        """
        while not self.response.isclosed():
            if not self.remaining_bytes:
                message = self.__extract_message()
                if EVENT_RECORDS not in message:
                    continue

                self.remaining_bytes = message.get(EVENT_RECORDS, b'')

            result = self.remaining_bytes
            if num_bytes < len(self.remaining_bytes):
                result = self.remaining_bytes[:num_bytes]
            self.remaining_bytes = self.remaining_bytes[len(result):]

            if result == b'':
                break
            if sys.version_info.major == 3:
                yield result.decode('utf-8', errors='ignore')
            else:
                # Python 2.x needs explicit conversion.
                yield result.decode('utf-8', errors='ignore').encode('utf-8')