@Override public SchemaVersionLifecycleStateMachineInfo getSchemaVersionLifecycleStateMachineInfo() { return getEntity(currentSchemaRegistryTargets().schemaVersionsStatesMachineTarget, SchemaVersionLifecycleStateMachineInfo.class); }
@Override public Long addSerDes(SerDesPair serDesPair) { return postEntity(currentSchemaRegistryTargets().serializersTarget, serDesPair, Long.class); }
@Override public Collection<SchemaProviderInfo> getSupportedSchemaProviders() { return getEntities(currentSchemaRegistryTargets().schemaProvidersTarget, SchemaProviderInfo.class); }
@Override public Collection<SchemaVersionKey> findSchemasByFields(SchemaFieldQuery schemaFieldQuery) { WebTarget target = currentSchemaRegistryTargets().searchFieldsTarget; for (Map.Entry<String, String> entry : schemaFieldQuery.toQueryMap().entrySet()) { target = target.queryParam(entry.getKey(), entry.getValue()); } return getEntities(target, SchemaVersionKey.class); }
@Override public void mapSchemaWithSerDes(String schemaName, Long serDesId) { String path = String.format("%s/mapping/%s", encode(schemaName), serDesId.toString()); Boolean success = postEntity(currentSchemaRegistryTargets().schemasTarget.path(path), null, Boolean.class); LOG.info("Received response while mapping schema [{}] with serialzer/deserializer [{}] : [{}]", schemaName, serDesId, success); }
@Override public Collection<SchemaVersionInfo> getAllVersions(String schemaBranchName, String schemaName, List<Byte> stateIds) throws SchemaNotFoundException, SchemaBranchNotFoundException { WebTarget webTarget = currentSchemaRegistryTargets().schemasTarget.path(encode(schemaName) + "/versions").queryParam("branch", schemaBranchName).queryParam("states", stateIds.toArray()); return getEntities(webTarget, SchemaVersionInfo.class); }
@Override public CompatibilityResult checkCompatibility(String schemaBranchName, String schemaName, String toSchemaText) throws SchemaNotFoundException { WebTarget webTarget = currentSchemaRegistryTargets().schemasTarget.path(encode(schemaName) + "/compatibility").queryParam("branch", schemaBranchName); String response = Subject.doAs(subject, new PrivilegedAction<String>() { @Override public String run() { return webTarget.request().post(Entity.text(toSchemaText), String.class); } }); return readEntity(response, CompatibilityResult.class); }
@Override public SchemaVersionInfo getLatestSchemaVersionInfo(String schemaBranchName, String schemaName) throws SchemaNotFoundException { WebTarget webTarget = currentSchemaRegistryTargets().schemasTarget.path(encode(schemaName) + "/versions/latest").queryParam("branch", schemaBranchName);; return getEntity(webTarget, SchemaVersionInfo.class); }
@Override public Collection<SchemaVersionInfo> getAllVersions(String schemaBranchName, String schemaName) throws SchemaNotFoundException { WebTarget webTarget = currentSchemaRegistryTargets().schemasTarget.path(encode(schemaName) + "/versions").queryParam("branch", schemaBranchName); return getEntities(webTarget, SchemaVersionInfo.class); }
@Override public Collection<SerDesInfo> getSerDes(String schemaName) { String path = encode(schemaName) + "/serdes/"; return getEntities(currentSchemaRegistryTargets().schemasTarget.path(path), SerDesInfo.class); }
@Override public void deleteSchemaBranch(Long schemaBranchId) throws SchemaBranchNotFoundException, InvalidSchemaBranchDeletionException { WebTarget target = currentSchemaRegistryTargets().schemasTarget.path("branch/"+schemaBranchId); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return target.request().delete(); } }); int status = response.getStatus(); if (status == Response.Status.NOT_FOUND.getStatusCode()) { throw new SchemaBranchNotFoundException(response.readEntity(String.class)); } else if (status == Response.Status.BAD_REQUEST.getStatusCode()) { throw new InvalidSchemaBranchDeletionException(response.readEntity(String.class)); } else if (status != Response.Status.OK.getStatusCode()) { throw new RuntimeException(response.readEntity(String.class)); } }
@Override public Collection<SchemaBranch> getSchemaBranches(String schemaName) throws SchemaNotFoundException { WebTarget target = currentSchemaRegistryTargets().schemasTarget.path(encode(schemaName) + "/branches"); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return target.request().get(); } }); int status = response.getStatus(); if (status == Response.Status.NOT_FOUND.getStatusCode()) { throw new SchemaNotFoundException(response.readEntity(String.class)); } else if (status != Response.Status.OK.getStatusCode()) { throw new RuntimeException(response.readEntity(String.class)); } return parseResponseAsEntities(response.readEntity(String.class), SchemaBranch.class); }
private SchemaVersionInfo doGetSchemaVersionInfo(SchemaVersionKey schemaVersionKey) { LOG.info("Getting schema version from target registry for [{}]", schemaVersionKey); String schemaName = schemaVersionKey.getSchemaName(); WebTarget webTarget = currentSchemaRegistryTargets().schemasTarget.path(String.format("%s/versions/%d", schemaName, schemaVersionKey .getVersion())); return getEntity(webTarget, SchemaVersionInfo.class); }
private SchemaIdVersion doAddSchemaVersion(String schemaBranchName, String schemaName, SchemaVersion schemaVersion) throws IncompatibleSchemaException, InvalidSchemaException, SchemaNotFoundException { SchemaMetadataInfo schemaMetadataInfo = getSchemaMetadataInfo(schemaName); if (schemaMetadataInfo == null) { throw new SchemaNotFoundException("Schema with name " + schemaName + " not found"); } WebTarget target = currentSchemaRegistryTargets().schemasTarget.path(schemaName).path("/versions").queryParam("branch", schemaBranchName); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return target.request(MediaType.APPLICATION_JSON_TYPE).post(Entity.json(schemaVersion), Response.class); } }); return handleSchemaIdVersionResponse(schemaMetadataInfo, response); }
@Override public SchemaVersionMergeResult mergeSchemaVersion(Long schemaVersionId) throws SchemaNotFoundException, IncompatibleSchemaException { WebTarget target = currentSchemaRegistryTargets().schemasTarget.path(schemaVersionId + "/merge"); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return target.request().post(null); } }); int status = response.getStatus(); if (status == Response.Status.OK.getStatusCode()) { String msg = response.readEntity(String.class); return readEntity(msg, SchemaVersionMergeResult.class); } else if (status == Response.Status.NOT_FOUND.getStatusCode()) { throw new SchemaNotFoundException(response.readEntity(String.class)); } else if (status == Response.Status.BAD_REQUEST.getStatusCode()) { throw new IncompatibleSchemaException(response.readEntity(String.class)); } else { throw new RuntimeException(response.readEntity(String.class)); } }
@Override public SchemaMetadataInfo updateSchemaMetadata(String schemaName, SchemaMetadata schemaMetadata) { SchemaMetadataInfo schemaMetadataInfo = postEntity(currentSchemaRegistryTargets().schemasTarget.path(schemaName), schemaMetadata, SchemaMetadataInfo.class); if (schemaMetadataInfo != null) { schemaMetadataCache.put(SchemaMetadataCache.Key.of(schemaName), schemaMetadataInfo); } return schemaMetadataInfo; }
@Override public void deleteSchemaVersion(SchemaVersionKey schemaVersionKey) throws SchemaNotFoundException, SchemaLifecycleException { schemaVersionInfoCache.invalidateSchema(new SchemaVersionInfoCache.Key(schemaVersionKey)); WebTarget target = currentSchemaRegistryTargets().schemasTarget.path(String.format("%s/versions/%s", schemaVersionKey .getSchemaName(), schemaVersionKey.getVersion())); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return target.request(MediaType.APPLICATION_JSON_TYPE).delete(Response.class); } }); handleDeleteSchemaResponse(response); }
private boolean transitionSchemaVersionState(Long schemaVersionId, String operationOrTargetState, byte[] transitionDetails) throws SchemaNotFoundException, SchemaLifecycleException { WebTarget webTarget = currentSchemaRegistryTargets().schemaVersionsTarget.path(schemaVersionId + "/state/" + operationOrTargetState); Response response = Subject.doAs(subject, new PrivilegedAction<Response>() { @Override public Response run() { return webTarget.request().post(Entity.text(transitionDetails)); } }); boolean result = handleSchemaLifeCycleResponse(response); // invalidate this entry from cache. schemaVersionInfoCache.invalidateSchema(SchemaVersionInfoCache.Key.of(new SchemaIdVersion(schemaVersionId))); return result; }
private SchemaVersionInfo doGetSchemaVersionInfo(SchemaIdVersion schemaIdVersion) throws SchemaNotFoundException { if (schemaIdVersion.getSchemaVersionId() != null) { LOG.info("Getting schema version from target registry for [{}]", schemaIdVersion.getSchemaVersionId()); return getEntity(currentSchemaRegistryTargets() .schemaVersionsByIdTarget .path(schemaIdVersion.getSchemaVersionId().toString()), SchemaVersionInfo.class); } else if (schemaIdVersion.getSchemaMetadataId() != null) { SchemaMetadataInfo schemaMetadataInfo = getSchemaMetadataInfo(schemaIdVersion.getSchemaMetadataId()); SchemaVersionKey schemaVersionKey = new SchemaVersionKey(schemaMetadataInfo.getSchemaMetadata() .getName(), schemaIdVersion.getVersion()); LOG.info("Getting schema version from target registry for key [{}]", schemaVersionKey); return doGetSchemaVersionInfo(schemaVersionKey); } throw new IllegalArgumentException("Given argument not valid: " + schemaIdVersion); }
@Override public Long addSchemaMetadata(SchemaMetadata schemaMetadata) { SchemaMetadataInfo schemaMetadataInfo = schemaMetadataCache.getIfPresent(SchemaMetadataCache.Key.of(schemaMetadata .getName())); if (schemaMetadataInfo == null) { return doRegisterSchemaMetadata(schemaMetadata, currentSchemaRegistryTargets().schemasTarget); } return schemaMetadataInfo.getId(); }