def check_version( self, subject: str, avro_schema: AvroSchema, headers: dict = None) -> typing.Optional[utils.SchemaVersion]: """ POST /subjects/(string: subject) Check if a schema has already been registered under the specified subject. If so, this returns the schema string along with its globally unique identifier, its version under this subject and the subject name. Args: subject (str): subject name avro_schema (avro.schema.RecordSchema): Avro schema headers (dict): Extra headers to add on the requests Returns: dict: subject (string) -- Name of the subject that this schema is registered under id (int) -- Globally unique identifier of the schema version (int) -- Version of the returned schema schema (dict) -- The Avro schema None: If schema not found. """ schemas_to_version = self.subject_to_schema_versions[subject] version = schemas_to_version.get(avro_schema) schemas_to_id = self.subject_to_schema_ids[subject] schema_id = schemas_to_id.get(avro_schema) if all((version, schema_id)): return utils.SchemaVersion(subject, schema_id, version, avro_schema) url, method = self.url_manager.url_for("check_version", subject=subject) body = {"schema": json.dumps(avro_schema.schema)} result, code = self.request(url, method=method, body=body, headers=headers) if code == status.HTTP_404_NOT_FOUND: logger.error(f"Not found: {code}") return None elif status.is_success(code): schema_id = result.get("id") version = result.get("version") self._cache_schema(avro_schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, version, result.get("schema")) raise ClientError("Unable to get version of a schema", http_code=code, server_traceback=result)
def check_version( self, subject: str, avro_schema: AvroSchema, headers: dict = None, timeout: typing.Union[TimeoutTypes, UnsetType] = UNSET, ) -> typing.Optional[utils.SchemaVersion]: """ POST /subjects/(string: subject) Check if a schema has already been registered under the specified subject. If so, this returns the schema string along with its globally unique identifier, its version under this subject and the subject name. Args: subject (str): subject name avro_schema (avro.schema.RecordSchema): Avro schema headers (dict): Extra headers to add on the requests timeout (httpx._client.TimeoutTypes): The timeout configuration to use when sending requests. Default UNSET Returns: SchemaVersion (nametupled): (subject, schema_id, schema, version) None: If schema not found. """ schemas_to_version = self.subject_to_schema_versions[subject] version = schemas_to_version.get(avro_schema) schemas_to_id = self.subject_to_schema_ids[subject] schema_id = schemas_to_id.get(avro_schema) if all((version, schema_id)): return utils.SchemaVersion(subject, schema_id, version, avro_schema) url, method = self.url_manager.url_for("check_version", subject=subject) body = {"schema": json.dumps(avro_schema.schema)} result, code = self.request(url, method=method, body=body, headers=headers, timeout=timeout) if code == status.HTTP_404_NOT_FOUND: logger.error(f"Not found: {code}") return None elif status.is_success(code): schema_id = result.get("id") version = result.get("version") self._cache_schema(avro_schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, version, result.get("schema")) raise ClientError("Unable to get version of a schema", http_code=code, server_traceback=result)
def get_schema(self, subject, version="latest", headers=None): """ GET /subjects/(string: subject)/versions/(versionId: version) Get a specific version of the schema registered under this subject If the subject is not found a Nametupled (None,None,None) is returned. Args: subject (str): subject name version (int, optional): version id. If is None, the latest schema is returned headers (dict): Extra headers to add on the requests Returns: SchemaVersion (nametupled): (subject, schema_id, schema, version) """ url = "/".join( [self.url, "subjects", subject, "versions", str(version)]) result, code = self.request(url, headers=headers) if code == status.HTTP_404_NOT_FOUND: log.error(f"Schema not found: {code}") return utils.SchemaVersion(None, None, None, None) elif code == status.HTTP_422_UNPROCESSABLE_ENTITY: log.error(f"Invalid version: {code}") return utils.SchemaVersion(None, None, None, None) elif not status.is_success(code): return utils.SchemaVersion(None, None, None, None) schema_id = result["id"] version = result["version"] if schema_id in self.id_to_schema: schema = self.id_to_schema[schema_id] else: try: schema = loads(result["schema"]) except ClientError: # bad schema - should not happen raise self._cache_schema(schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, schema, version)
def get_schema( self, subject: str, version: typing.Union[int, str] = "latest", headers: dict = None, timeout: typing.Union[TimeoutTypes, UnsetType] = UNSET, ) -> typing.Optional[utils.SchemaVersion]: """ GET /subjects/(string: subject)/versions/(versionId: version) Get a specific version of the schema registered under this subject Args: subject (str): subject name version (int, optional): version id. If is None, the latest schema is returned headers (dict): Extra headers to add on the requests timeout (httpx._client.TimeoutTypes): The timeout configuration to use when sending requests. Default UNSET Returns: SchemaVersion (nametupled): (subject, schema_id, schema, version) None: If server returns a not success response: 404: Schema not found 422: Unprocessable entity ~ (200 - 299): Not success """ url, method = self.url_manager.url_for("get_schema", subject=subject, version=version) result, code = self.request(url, method=method, headers=headers, timeout=timeout) if code == status.HTTP_404_NOT_FOUND: logger.error(f"Schema not found: {code}") return None elif code == status.HTTP_422_UNPROCESSABLE_ENTITY: logger.error(f"Invalid version: {code}") return None elif not status.is_success(code): logger.error(f"Not success version: {code}") return None schema_id = result.get("id") if schema_id in self.id_to_schema: schema = self.id_to_schema[schema_id] else: schema = AvroSchema(result["schema"]) version = result["version"] self._cache_schema(schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, schema, version)
def get_schema(self, subject, version="latest", headers=None): """ GET /subjects/(string: subject)/versions/(versionId: version) Get a specific version of the schema registered under this subject Args: subject (str): subject name version (int, optional): version id. If is None, the latest schema is returned headers (dict): Extra headers to add on the requests Returns: SchemaVersion (nametupled): (subject, schema_id, schema, version) None: If server returns a not success response: 404: Schema not found 422: Unprocessable entity ~ (200 - 299): Not success """ url = "/".join( [self.url, "subjects", subject, "versions", str(version)]) result, code = self.request(url, headers=headers) if code == status.HTTP_404_NOT_FOUND: log.error(f"Schema not found: {code}") return elif code == status.HTTP_422_UNPROCESSABLE_ENTITY: log.error(f"Invalid version: {code}") return elif not status.is_success(code): log.error(f"Not success version: {code}") return schema_id = result.get("id") if schema_id in self.id_to_schema: schema = self.id_to_schema[schema_id] else: try: schema = AvroSchema(result["schema"]) except ClientError: raise version = result.get("version") self._cache_schema(schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, schema, version)