public virtual T Read(byte[] bytes, byte[] schemaVersion)
{
try
{
if (schemaVersion == null)
{
return(Read(bytes));
}
else
{
var key = BytesSchemaVersion.Of(schemaVersion);
var sc = _readerCache.Get(key, new Func <BytesSchemaVersion, ISchemaReader <T> >(LoadReader));
return(sc.Read(bytes));
}
}
catch (Exception e) when(e is AvroTypeException)
{
if (e is AvroTypeException)
{
throw new SchemaSerializationException(e);
}
//LOG.error("Can't get generic schema for topic {} schema version {}", schemaInfoProvider.Topic, Hex.encodeHexString(schemaVersion), e);
throw new Exception("Can't get generic schema for topic " + schemaInfoProvider.TopicName);
}
}
public virtual T Read(Stream inputStream, byte[] schemaVersion)
{
try
{
var key = BytesSchemaVersion.Of(schemaVersion);
return(schemaVersion == null?Read(inputStream) : _readerCache.Get(key, new Func <BytesSchemaVersion, ISchemaReader <T> >(LoadReader)).Read(inputStream));
}
catch (Exception e)
{
//LOG.error("Can't get generic schema for topic {} schema version {}", schemaInfoProvider.Topic, Hex.encodeHexString(schemaVersion), e);
throw new Exception("Can't get generic schema for topic " + schemaInfoProvider.TopicName);
}
}
public async ValueTask <ISchemaInfo> LatestSchema()
{
var schema = await _lookup.Ask <AskResponse>(new GetSchema(_topicName)).ConfigureAwait(false);
if (schema.Failed)
{
throw schema.Exception;
}
var sch = schema.ConvertTo <GetSchemaInfoResponse>().SchemaInfo;
_cache.Put(BytesSchemaVersion.Of(sch.Schema), sch);
return(sch);
}
public ISchemaInfo GetSchemaByVersion(byte[] schemaVersion)
{
try
{
if (schemaVersion != null)
{
return(_cache.Get(BytesSchemaVersion.Of(schemaVersion)));
}
return(null);
}
catch (Exception e)
{
_log.Error($"Can't get schema for topic {_topicName} schema version {StringHelper.NewString(schemaVersion)}: {e}");
return(null);
}
}
protected internal override ISchemaReader <IGenericRecord> LoadReader(BytesSchemaVersion schemaVersion)
{
var schemaInfo = GetSchemaInfoByVersion(schemaVersion.Get());
if (schemaInfo != null)
{
//LOG.info("Load schema reader for version({}), schema is : {}", SchemaUtils.GetStringSchemaVersion(schemaVersion.Get()), schemaInfo);
var writerSchema = SchemaUtils.ParseAvroSchema(schemaInfo.SchemaDefinition);
var readerSchema = useProvidedSchemaAsReaderSchema ? ReaderSchema : writerSchema;
//readerSchema.GetProperty.addProp(GenericAvroSchema.OFFSET_PROP, schemaInfo.Properties.GetOrDefault(GenericAvroSchema.OFFSET_PROP, "0"));
return(new GenericAvroReader(writerSchema, readerSchema, schemaVersion.Get()));
}
else
{
//LOG.warn("No schema found for version({}), use latest schema : {}", SchemaUtils.getStringSchemaVersion(schemaVersion.get()), this.readerSchema);
return(providerSchemaReader);
}
}
public override ISchema <T> AtSchemaVersion(byte[] schemaVersion)
{
Precondition.Condition.RequireNonNull(schemaVersion, "schemaVersion");
if (_schemaInfoProvider == null)
{
// this schema is not downloaded from the registry
return(this);
}
try
{
var schemaInfo = _schemaInfoProvider.GetSchemaByVersion(schemaVersion);
if (schemaInfo == null)
{
throw new SchemaSerializationException("Unknown version " + BytesSchemaVersion.Of(schemaVersion));
}
return(GetAbstractStructSchemaAtVersion(schemaVersion, schemaInfo));
}
catch (Exception err)
{
throw new SchemaSerializationException(err);
}
}
/// <summary> /// Load the schema reader for reading messages encoded by the given schema version. /// </summary> /// <param name="schemaVersion"> the provided schema version </param> /// <returns> the schema reader for decoding messages encoded by the provided schema version. </returns> protected internal abstract ISchemaReader <T> LoadReader(BytesSchemaVersion schemaVersion);
public ISchemaReader <T> GetSchemaReader(byte[] schemaVersion)
{
var key = BytesSchemaVersion.Of(schemaVersion);
return(_readerCache.Get(key, new Func <BytesSchemaVersion, ISchemaReader <T> >(LoadReader)));
}
private async ValueTask GetSchema(TopicName topicName, byte[] version)
{
var request = Commands.NewGetSchema(_requestId, topicName.ToString(), BytesSchemaVersion.Of(version));
var payload = new Payload(request, _requestId, "SendGetRawSchema");
var askResponse = await _clientCnx.Ask <AskResponse>(payload);
if (askResponse.Failed)
{
_replyTo.Tell(askResponse);
return;
}
var schemaResponse = askResponse.ConvertTo <Messages.GetSchemaResponse>();
var err = schemaResponse.Response.ErrorCode;
if (err != ServerError.UnknownError)
{
var e = $"{err}: {schemaResponse.Response.ErrorMessage}";
_log.Error(e);
_replyTo.Tell(new AskResponse(new PulsarClientException(new Exception(e))));
}
else
{
var schema = schemaResponse.Response.Schema;
var info = new SchemaInfo
{
Schema = schema.SchemaData,
Name = schema.Name,
Properties = schema.Properties.ToDictionary(k => k.Key, v => v.Value),
Type = SchemaType.ValueOf((int)schema.type)
};
_replyTo.Tell(new AskResponse(new GetSchemaInfoResponse(info)));
}
}
