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)
