org.infinispan.protostream.SerializationContext Java Examples

private void registerProto(boolean reset, String... protoKeys) {
    RemoteCache<Object, Object> cache = manager.getCache(PROTO_CACHE);
    if (cache == null) {
        throw new IllegalStateException(String.format("Missing %s cache!", PROTO_CACHE));
    }

    SerializationContext ctx = MarshallerUtil.getSerializationContext(manager);
    FileDescriptorSource fds = new FileDescriptorSource();
    for (String protoKey : protoKeys) {
        if (reset || !cache.containsKey(protoKey)) {
            String protoContent = IoUtil.toString(getClass().getResourceAsStream("/" + protoKey));
            log.info(String.format("Using proto schema: %s%n%s", protoKey, protoContent));
            fds.addProtoFile(protoKey, protoContent);
            cache.put(protoKey, protoContent);
        }
    }
    ctx.registerProtoFiles(fds);
    ctx.registerMarshaller(new ArtifactTypeMarshaller());
    ctx.registerMarshaller(new ArtifactMarshaller());
}
 

protected String javaTypeForMessage(FileDescriptor d, String messageName, SerializationContext serializationContext) {

        Map<String, FileDescriptor> descriptors = serializationContext.getFileDescriptors();
        for (Entry<String, FileDescriptor> entry : descriptors.entrySet()) {

            List<Descriptor> messages = entry.getValue().getMessageTypes();

            for (Descriptor msg : messages) {
                if (messageName.equals(msg.getName())) {

                    return packageFromOption(d, msg) + "." + messageName;
                } else if (messageName.equals(msg.getFullName())) {
                    return packageFromOption(d, msg) + "." + msg.getName();
                }
            }
        }
        return null;
    }
 

private String generateSchema() throws IOException {
    final SerializationContext serCtx = ProtoStreamMarshaller.getSerializationContext(this.remoteCacheManager);

    final String generatedSchema = new ProtoSchemaBuilder()

            .addClass(CredentialKey.class)
            .addClass(DeviceKey.class)
            .addClass(DeviceInformation.class)
            .addClass(DeviceCredential.class)

            .packageName(DeviceInformation.class.getPackageName())
            .fileName(GENERATED_PROTOBUF_FILE_NAME)
            .build(serCtx);

    return generatedSchema;
}
 

private static void addPersonSchema(RemoteCacheManager cacheManager) throws IOException {
   // Get the serialization context of the client
   SerializationContext ctx = MarshallerUtil.getSerializationContext(cacheManager);

   // Use ProtoSchemaBuilder to define a Protobuf schema on the client
   ProtoSchemaBuilder protoSchemaBuilder = new ProtoSchemaBuilder();
   String fileName = "person.proto";
   String protoFile = protoSchemaBuilder
         .fileName(fileName)
         .addClass(Person.class)
         .packageName("tutorial")
         .build(ctx);

   // Retrieve metadata cache
   RemoteCache<String, String> metadataCache =
         cacheManager.getCache(PROTOBUF_METADATA_CACHE_NAME);

   // Define the new schema on the server too
   metadataCache.put(fileName, protoFile);
}
 

private static void addInstapostsSchema(RemoteCacheManager cacheManager) throws IOException {
   // Get the serialization context of the client
   SerializationContext ctx = MarshallerUtil.getSerializationContext(cacheManager);

   // Use ProtoSchemaBuilder to define a Protobuf schema on the client
   ProtoSchemaBuilder protoSchemaBuilder = new ProtoSchemaBuilder();
   String fileName = "instapost.proto";
   String protoFile = protoSchemaBuilder
         .fileName(fileName)
         .addClass(InstaPost.class)
         .packageName("tutorial")
         .build(ctx);

   // Retrieve metadata cache
   RemoteCache<String, String> metadataCache =
         cacheManager.getCache(PROTOBUF_METADATA_CACHE_NAME);

   // Define the new schema on the server too
   metadataCache.putIfAbsent(fileName, protoFile);
}
 

private String generateSchema() throws Exception {
    final SerializationContext serCtx = ProtoStreamMarshaller.getSerializationContext(this.remoteCacheManager);

    return new ProtoSchemaBuilder()

            .addClass(DeviceConnectionKey.class)
            .packageName(DeviceConnectionKey.class.getPackageName())
            .fileName(GENERATED_PROTOBUF_FILE_NAME)
            .build(serCtx);

}
 

@Override
public void registerSchema(SerializationContext serCtx) {
    StringBuilder protoBuilder = new StringBuilder(FOOTER);

    for (SerializationHandle<?> serializationHandle : Bucket4j.getSerializationHandles()) {
        String typeName = "Bucket4jType_" + serializationHandle.getTypeId();
        String typeDefinition = TYPE_TEMPLATE.replace("[type_name]", typeName);
        protoBuilder.append(typeDefinition);
    }

    String generatedProtoFile = protoBuilder.toString();
    FileDescriptorSource protoSource = FileDescriptorSource.fromString(getProtoFileName(), generatedProtoFile);
    serCtx.registerProtoFiles(protoSource);
}
 

@Override
public void registerMarshallers(SerializationContext serCtx) {
    for (SerializationHandle<?> serializationHandle : Bucket4j.getSerializationHandles()) {
        String protoTypeId = "bucket4j.Bucket4jType_" + serializationHandle.getTypeId();
        serCtx.registerMarshaller(new ProtobufMessageMarshaller<>(serializationHandle, protoTypeId));
    }
}
 

@Substitute
public static void init(SerializationContext ctx) throws IOException {
    // Skip loading the proto definition files as this was already done at compile time with
    // HandleProtostreamMarshaller#handleQueryRequirements
    MarshallerRegistration.INSTANCE.registerMarshallers(ctx);
}