Exemplo n.º 1
0
    def get_or_create_stream(self, namespace_id, stream):
        """Tells Sds Service to create a stream based on the local 'stream' SdsStream object"""
        if namespace_id is None:
            raise TypeError
        if stream is None or not isinstance(stream, SdsStream):
            raise TypeError
        response = requests.post(
            self.url + self.__streamsPath.format(tenant_id=self.tenantId,
                                                 namespace_id=namespace_id,
                                                 stream_id=stream.Id),
            data=stream.to_json(),
            headers=self.__sds_headers())

        if response.status_code < 200 or response.status_code >= 300:
            response.close()
            cleanup(self, namespace_id, self.type_names)
            raise SdsError(
                "Failed to create SdsStream, {stream_id}. {status}:{reason}".
                format(stream_id=stream.Id,
                       status=response.status_code,
                       reason=response.text))

        stream = SdsStream.from_json(json.loads(response.content))
        response.close()
        return stream
Exemplo n.º 2
0
    def get_streams(self, namespace_id, query="", skip=0, count=100):
        """Retrieves a list of streams associated with 'namespace_id' under the current tenant"""
        if namespace_id is None:
            raise TypeError
        if query is None:
            raise TypeError

        response = requests.get(
            self.url + self.__getStreamsPath.format(tenant_id=self.tenantId,
                                                    namespace_id=namespace_id,
                                                    query=query,
                                                    skip=skip,
                                                    count=count),
            headers=self.__sds_headers())
        if response.status_code < 200 or response.status_code >= 300:
            response.close()
            cleanup(self, namespace_id, self.type_names)
            raise SdsError(
                "Failed to get all SdsStreams. {status}:{reason}".format(
                    status=response.status_code, reason=response.text))

        content = json.loads(response.content)
        results = []
        for item in content:
            results.append(SdsStream.from_json(item))
        response.close()
        return results
Exemplo n.º 3
0
 def init_stream(self, type_id, stream_id):
     """Initializes an SdsStream object"""
     sds_stream = SdsStream(stream_id=stream_id,
                            name=stream_id,
                            description="A stream to store {} "
                            "events".format(type_id),
                            type_id=type_id)
     self.client.create_or_update_stream(self.namespace_id, sds_stream)
     if not sds_stream:
         self.raise_error("init_stream() ERROR: Failed to initialize "
                          "stream")
     self.streams[sds_stream.Id] = sds_stream
     return sds_stream
Exemplo n.º 4
0
    def get_stream(self, namespace_id, stream_id):
        """Retrieves a stream specified by 'stream_id' from the Sds Service"""
        if namespace_id is None:
            raise TypeError
        if stream_id is None:
            raise TypeError

        response = requests.get(
            self.url + self.__streamsPath.format(tenant_id=self.tenantId,
                                                 namespace_id=namespace_id,
                                                 stream_id=stream_id),
            headers=self.__sds_headers())
        if response.status_code < 200 or response.status_code >= 300:
            response.close()
            cleanup(self, namespace_id, self.type_names)
            raise SdsError(
                "Failed to get SdsStream, {stream_id}. {status}:{reason}".
                format(stream_id=stream_id,
                       status=response.status_code,
                       reason=response.text))

        stream = SdsStream.from_json(json.loads(response.content))
        response.close()
        return stream