Renaming methods/classes based on review. (Azure#24474)

* Rename endpoint to fullyQualifiedNamespace.

* Add SchemaRegistryVersion[

* Setting service version.

* Exposing getFullyQualifiedNamespace.

* Use constant for API version

* Using ServiceVersion.

* Making class final.

* Rename to SchemaFormat.

* Updating schema format usages.

* Fixing revapi suppression.

Author: conniey

eng/code-quality-reports/src/main/resources/revapi/revapi.json

@@ -171,19 +171,10 @@
         "justification": "azure-cosmos classes are allowed to be exposed by dependencies using them."
       },
       {
-        "code": "java.class.externalClassExposedInAPI",
-        "new": "class com.azure.data.schemaregistry.SchemaRegistryAsyncClient",
-        "justification": "This is a preview release"
-      },
-      {
-        "code": "java.class.externalClassExposedInAPI",
-        "new": "class com.azure.data.schemaregistry.models.SchemaProperties",
-        "justification": "This is a preview release"
-      },
-      {
-        "code": "java.class.externalClassExposedInAPI",
-        "new": "class com.azure.data.schemaregistry.models.SerializationType",
-        "justification": "This is a preview release"
+        "regex": true,
+        "code": "java\\.class\\.externalClassExposedInAPI",
+        "new": "(class|enum) com\\.azure\\.data\\.schemaregistry\\..+",
+        "justification": "azure-data-schemaregistry-avro depends on the schema registry classes."
       },
       {
         "regex": true,

sdk/schemaregistry/azure-data-schemaregistry-avro/src/main/java/com/azure/data/schemaregistry/avro/SchemaRegistryAvroSerializer.java

@@ -7,8 +7,8 @@
 import com.azure.core.util.serializer.ObjectSerializer;
 import com.azure.core.util.serializer.TypeReference;
 import com.azure.data.schemaregistry.SchemaRegistryAsyncClient;
+import com.azure.data.schemaregistry.models.SchemaFormat;
 import com.azure.data.schemaregistry.models.SchemaProperties;
-import com.azure.data.schemaregistry.models.SerializationType;
 import org.apache.avro.Schema;
 import reactor.core.publisher.Mono;
 
@@ -198,11 +198,11 @@ public Mono<Void> serializeAsync(OutputStream outputStream, Object object) {
     private Mono<String> maybeRegisterSchema(String schemaGroup, String schemaName, String schemaString) {
         if (this.autoRegisterSchemas) {
             return this.schemaRegistryClient
-                .registerSchema(schemaGroup, schemaName, schemaString, SerializationType.AVRO)
+                .registerSchema(schemaGroup, schemaName, schemaString, SchemaFormat.AVRO)
                 .map(SchemaProperties::getSchemaId);
         } else {
             return this.schemaRegistryClient.getSchemaId(
-                schemaGroup, schemaName, schemaString, SerializationType.AVRO);
+                schemaGroup, schemaName, schemaString, SchemaFormat.AVRO);
         }
     }
 

sdk/schemaregistry/azure-data-schemaregistry-avro/src/samples/java/com/azure/data/schemaregistry/avro/ReadmeSamples.java

@@ -32,7 +32,7 @@ public SchemaRegistryAvroSerializer createAvroSchemaRegistrySerializer() {
         TokenCredential tokenCredential = new DefaultAzureCredentialBuilder().build();
 
         SchemaRegistryAsyncClient schemaRegistryAsyncClient = new SchemaRegistryClientBuilder()
-            .endpoint("{schema-registry-endpoint")
+            .fullyQualifiedNamespace("{schema-registry-endpoint")
             .credential(tokenCredential)
             .buildAsyncClient();
 

sdk/schemaregistry/azure-data-schemaregistry-avro/src/samples/java/com/azure/data/schemaregistry/avro/SchemaRegistryAvroDeserilizationSample.java

@@ -31,7 +31,7 @@ public static void main(String[] args) throws IOException {
         // Create the schema registry async client
         SchemaRegistryAsyncClient schemaRegistryAsyncClient = new SchemaRegistryClientBuilder()
             .credential(tokenCredential)
-            .endpoint("{schema-registry-endpoint}")
+            .fullyQualifiedNamespace("{schema-registry-endpoint}")
             .buildAsyncClient();
 
         // Create the serializer instance by configuring the serializer with the schema registry client and

sdk/schemaregistry/azure-data-schemaregistry-avro/src/samples/java/com/azure/data/schemaregistry/avro/SchemaRegistryAvroSerializationSample.java

@@ -29,7 +29,7 @@ public static void main(String[] args) {
         // Create the schema registry async client
         SchemaRegistryAsyncClient schemaRegistryAsyncClient = new SchemaRegistryClientBuilder()
             .credential(tokenCredential)
-            .endpoint("{schema-registry-endpoint}")
+            .fullyQualifiedNamespace("{schema-registry-endpoint}")
             .buildAsyncClient();
 
         // Create the serializer instance by configuring the serializer with the schema registry client and

sdk/schemaregistry/azure-data-schemaregistry-avro/src/test/java/com/azure/data/schemaregistry/avro/SchemaRegistryAvroSerializerTest.java

@@ -7,8 +7,8 @@
 import com.azure.data.schemaregistry.SchemaRegistryAsyncClient;
 import com.azure.data.schemaregistry.avro.generatedtestsources.PlayingCard;
 import com.azure.data.schemaregistry.avro.generatedtestsources.PlayingCardSuit;
+import com.azure.data.schemaregistry.models.SchemaFormat;
 import com.azure.data.schemaregistry.models.SchemaProperties;
-import com.azure.data.schemaregistry.models.SerializationType;
 import org.apache.avro.Schema;
 import org.apache.avro.generic.GenericData;
 import org.apache.avro.io.DecoderFactory;
@@ -88,11 +88,11 @@ void testRegistryGuidPrefixedToPayload() throws IOException {
         final PlayingCard playingCard = new PlayingCard(true, 10, PlayingCardSuit.DIAMONDS);
         final Schema playingClassSchema = PlayingCard.getClassSchema();
         final byte[] schemaBytes = playingClassSchema.toString().getBytes(StandardCharsets.UTF_8);
-        final SchemaProperties registered = new SchemaProperties(MOCK_GUID, SerializationType.AVRO,
+        final SchemaProperties registered = new SchemaProperties(MOCK_GUID, SchemaFormat.AVRO,
             playingClassSchema.getFullName(), schemaBytes);
 
         when(client.getSchemaId(MOCK_SCHEMA_GROUP, registered.getSchemaName(), playingClassSchema.toString(),
-            SerializationType.AVRO)).thenReturn(Mono.just(MOCK_GUID));
+            SchemaFormat.AVRO)).thenReturn(Mono.just(MOCK_GUID));
 
         final SchemaRegistryAvroSerializer serializer = new SchemaRegistryAvroSerializer(client, avroSerializer,
             MOCK_SCHEMA_GROUP, false);
@@ -145,7 +145,7 @@ void testGetSchemaAndDeserialize() throws IOException {
             DECODER_FACTORY);
         final PlayingCard playingCard = new PlayingCard(true, 10, PlayingCardSuit.DIAMONDS);
         final Schema playingClassSchema = PlayingCard.getClassSchema();
-        final SchemaProperties registered = new SchemaProperties(MOCK_GUID, SerializationType.AVRO,
+        final SchemaProperties registered = new SchemaProperties(MOCK_GUID, SchemaFormat.AVRO,
             playingClassSchema.getFullName(), playingClassSchema.toString().getBytes(StandardCharsets.UTF_8));
         final SchemaRegistryAvroSerializer serializer = new SchemaRegistryAvroSerializer(client, decoder,
             MOCK_SCHEMA_GROUP, true);

sdk/schemaregistry/azure-data-schemaregistry/README.md

@@ -119,7 +119,7 @@ String schemaContent = "{\n"
     + "    ]\n"
     + "}";
 SchemaProperties schemaProperties = schemaRegistryClient.registerSchema("{schema-group}", "{schema-name}",
-    schemaContent, SerializationType.AVRO);
+    schemaContent, SerializationFormat.AVRO);
 System.out.println("Registered schema: " + schemaProperties.getSchemaId());
 ```
 
@@ -164,7 +164,7 @@ String schemaContent = "{\n"
     + "    ]\n"
     + "}";
 String schemaId = schemaRegistryClient.getSchemaId("{schema-group}", "{schema-name}",
-    schemaContent, SerializationType.AVRO);
+    schemaContent, SerializationFormat.AVRO);
 System.out.println("Retreived schema id: " + schemaId);
 ```
 

sdk/schemaregistry/azure-data-schemaregistry/src/main/java/com/azure/data/schemaregistry/SchemaRegistryAsyncClient.java

@@ -13,8 +13,8 @@
 import com.azure.core.util.logging.ClientLogger;
 import com.azure.data.schemaregistry.implementation.AzureSchemaRegistry;
 import com.azure.data.schemaregistry.implementation.models.SchemaId;
+import com.azure.data.schemaregistry.models.SchemaFormat;
 import com.azure.data.schemaregistry.models.SchemaProperties;
-import com.azure.data.schemaregistry.models.SerializationType;
 import reactor.core.publisher.Mono;
 
 import java.net.URI;
@@ -54,21 +54,30 @@ public final class SchemaRegistryAsyncClient {
         this.restService = restService;
     }
 
+    /**
+     * Gets the fully qualified namespace of the Schema Registry instance.
+     *
+     * @return The fully qualified namespace of the Schema Registry instance.
+     */
+    public String getFullyQualifiedNamespace() {
+        return this.restService.getEndpoint();
+    }
+
     /**
      * Registers a new schema in the specified schema group with the given schema name. If the schema name already
      * exists in this schema group, a new version with the updated schema string will be registered.
      *
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The {@link SchemaProperties} of a successfully registered schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public Mono<SchemaProperties> registerSchema(String groupName, String name, String content,
-        SerializationType serializationType) {
-        return registerSchemaWithResponse(groupName, name, content, serializationType)
+        SchemaFormat schemaFormat) {
+        return registerSchemaWithResponse(groupName, name, content, schemaFormat)
             .map(Response::getValue);
     }
 
@@ -79,28 +88,28 @@ public Mono<SchemaProperties> registerSchema(String groupName, String name, Stri
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The schema properties on successful registration of the schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public Mono<Response<SchemaProperties>> registerSchemaWithResponse(String groupName, String name, String content,
-        SerializationType serializationType) {
+        SchemaFormat schemaFormat) {
         return FluxUtil.withContext(context -> registerSchemaWithResponse(groupName, name, content,
-            serializationType, context));
+                schemaFormat, context));
     }
 
     Mono<Response<SchemaProperties>> registerSchemaWithResponse(String groupName, String name, String content,
-        SerializationType serializationType, Context context) {
+        SchemaFormat schemaFormat, Context context) {
         logger.verbose("Registering schema. Group: '{}', name: '{}', serialization type: '{}', payload: '{}'",
-            groupName, name, serializationType, content);
+            groupName, name, schemaFormat, content);
 
         return this.restService.getSchemas().registerWithResponseAsync(groupName, name,
             com.azure.data.schemaregistry.implementation.models.SerializationType.AVRO, content)
             .handle((response, sink) -> {
                 SchemaId schemaId = response.getValue();
                 SchemaProperties registered = new SchemaProperties(schemaId.getId(),
-                    serializationType,
+                        schemaFormat,
                     name,
                     content.getBytes(SCHEMA_REGISTRY_SERVICE_ENCODING));
 
@@ -139,8 +148,8 @@ Mono<Response<SchemaProperties>> getSchemaWithResponse(String id, Context contex
         Objects.requireNonNull(id, "'id' should not be null");
         return this.restService.getSchemas().getByIdWithResponseAsync(id)
             .handle((response, sink) -> {
-                final SerializationType serializationType =
-                    SerializationType.fromString(response.getDeserializedHeaders().getSchemaType());
+                final SchemaFormat schemaFormat =
+                    SchemaFormat.fromString(response.getDeserializedHeaders().getSchemaType());
                 final URI location = URI.create(response.getDeserializedHeaders().getLocation());
                 final Matcher matcher = SCHEMA_PATTERN.matcher(location.getPath());
 
@@ -153,7 +162,7 @@ Mono<Response<SchemaProperties>> getSchemaWithResponse(String id, Context contex
 
                 final String schemaName = matcher.group("schemaName");
                 final SchemaProperties schemaObject = new SchemaProperties(id,
-                    serializationType,
+                        schemaFormat,
                     schemaName,
                     response.getValue());
                 final SimpleResponse<SchemaProperties> schemaResponse = new SimpleResponse<>(
@@ -171,14 +180,14 @@ Mono<Response<SchemaProperties>> getSchemaWithResponse(String id, Context contex
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The unique identifier for this schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public Mono<String> getSchemaId(String groupName, String name, String content,
-        SerializationType serializationType) {
-        return getSchemaIdWithResponse(groupName, name, content, serializationType)
+        SchemaFormat schemaFormat) {
+        return getSchemaIdWithResponse(groupName, name, content, schemaFormat)
             .map(response -> response.getValue());
     }
 
@@ -188,16 +197,16 @@ public Mono<String> getSchemaId(String groupName, String name, String content,
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The unique identifier for this schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public Mono<Response<String>> getSchemaIdWithResponse(String groupName, String name, String content,
-        SerializationType serializationType) {
+        SchemaFormat schemaFormat) {
 
         return FluxUtil.withContext(context ->
-            getSchemaIdWithResponse(groupName, name, content, serializationType, context));
+            getSchemaIdWithResponse(groupName, name, content, schemaFormat, context));
     }
 
     /**
@@ -206,16 +215,16 @@ public Mono<Response<String>> getSchemaIdWithResponse(String groupName, String n
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      * @param context Context to pass along with this request.
      *
      * @return A mono that completes with the schema id.
      */
     Mono<Response<String>> getSchemaIdWithResponse(String groupName, String name, String content,
-        SerializationType serializationType, Context context) {
+        SchemaFormat schemaFormat, Context context) {
 
         return this.restService.getSchemas()
-            .queryIdByContentWithResponseAsync(groupName, name, getSerialization(serializationType), content)
+            .queryIdByContentWithResponseAsync(groupName, name, getSerialization(schemaFormat), content)
             .handle((response, sink) -> {
                 SchemaId schemaId = response.getValue();
                 SimpleResponse<String> schemaIdResponse = new SimpleResponse<>(
@@ -229,18 +238,18 @@ Mono<Response<String>> getSchemaIdWithResponse(String groupName, String name, St
     /**
      * Gets the matching implementation class serialization type.
      *
-     * @param serializationType Model serialization type.
+     * @param schemaFormat Model serialization type.
      *
      * @return Implementation serialization type.
      *
      * @throws UnsupportedOperationException if the serialization type is not supported.
      */
     private static com.azure.data.schemaregistry.implementation.models.SerializationType getSerialization(
-        SerializationType serializationType) {
-        if (serializationType == SerializationType.AVRO) {
+        SchemaFormat schemaFormat) {
+        if (schemaFormat == SchemaFormat.AVRO) {
             return com.azure.data.schemaregistry.implementation.models.SerializationType.AVRO;
         } else {
-            throw new UnsupportedOperationException("Serialization type is not supported: " + serializationType);
+            throw new UnsupportedOperationException("Serialization type is not supported: " + schemaFormat);
         }
     }
 }

sdk/schemaregistry/azure-data-schemaregistry/src/main/java/com/azure/data/schemaregistry/SchemaRegistryClient.java

@@ -8,8 +8,8 @@
 import com.azure.core.annotation.ServiceMethod;
 import com.azure.core.http.rest.Response;
 import com.azure.core.util.Context;
+import com.azure.data.schemaregistry.models.SchemaFormat;
 import com.azure.data.schemaregistry.models.SchemaProperties;
-import com.azure.data.schemaregistry.models.SerializationType;
 
 /**
  * HTTP-based client that interacts with Azure Schema Registry service to store and retrieve schemas on demand.
@@ -34,21 +34,30 @@ public final class SchemaRegistryClient {
         this.asyncClient = asyncClient;
     }
 
+    /**
+     * Gets the fully qualified namespace of the Schema Registry instance.
+     *
+     * @return The fully qualified namespace of the Schema Registry instance.
+     */
+    public String getFullyQualifiedNamespace() {
+        return asyncClient.getFullyQualifiedNamespace();
+    }
+
     /**
      * Registers a new schema in the specified schema group with the given schema name. If the schema name already
      * exists in this schema group, a new version with the updated schema string will be registered.
      *
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The schema properties on successful registration of the schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public SchemaProperties registerSchema(String groupName, String name, String content,
-        SerializationType serializationType) {
-        return this.asyncClient.registerSchema(groupName, name, content, serializationType).block();
+        SchemaFormat schemaFormat) {
+        return this.asyncClient.registerSchema(groupName, name, content, schemaFormat).block();
     }
 
     /**
@@ -58,15 +67,15 @@ public SchemaProperties registerSchema(String groupName, String name, String con
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      * @param context The context to pass to the Http pipeline.
      *
      * @return The schema properties on successful registration of the schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
     public Response<SchemaProperties> registerSchemaWithResponse(String groupName, String name, String content,
-        SerializationType serializationType, Context context) {
-        return this.asyncClient.registerSchemaWithResponse(groupName, name, content, serializationType,
+        SchemaFormat schemaFormat, Context context) {
+        return this.asyncClient.registerSchemaWithResponse(groupName, name, content, schemaFormat,
             context).block();
     }
 
@@ -88,12 +97,12 @@ public SchemaProperties getSchema(String id) {
      * @param groupName The schema group.
      * @param name The schema name.
      * @param content The string representation of the schema.
-     * @param serializationType The serialization type of this schema.
+     * @param schemaFormat The serialization type of this schema.
      *
      * @return The unique identifier for this schema.
      */
     @ServiceMethod(returns = ReturnType.SINGLE)
-    public String getSchemaId(String groupName, String name, String content, SerializationType serializationType) {
-        return this.asyncClient.getSchemaId(groupName, name, content, serializationType).block();
+    public String getSchemaId(String groupName, String name, String content, SchemaFormat schemaFormat) {
+        return this.asyncClient.getSchemaId(groupName, name, content, schemaFormat).block();
     }
 }