Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.query.remote;
  
  import  com.google.protobuf.Descriptors;
 import  org.infinispan.protostream.BaseMarshaller;
 import  org.infinispan.protostream.ProtobufUtil;
 import  org.infinispan.protostream.SerializationContext;
 
 import java.util.UUID;
 
 //todo [anistor] use ClusterRegistry instead of reinventing it

Author(s):
anistor@redhat.com
Since:
6.0
 
        description = "Component that acts as a manager and container for Protocol Buffers metadata descriptors in the scope of a CacheManger.")
 public class ProtobufMetadataManager {
 
    public static final String OBJECT_NAME = "ProtobufMetadataManager";
 
    private static final String METADATA_CACHE_NAME = "__ProtobufMetadataManager__";
 
    private ObjectName objectName;
 
    private final EmbeddedCacheManager cacheManager;
 
    private Cache<Stringbyte[]> metadataCache;
 
    private final SerializationContext serCtx = ProtobufUtil.newSerializationContext();
 
    public ProtobufMetadataManager(EmbeddedCacheManager cacheManager) {
       this. = cacheManager;
    }
 
    public ObjectName getObjectName() {
       return ;
    }
 
    public void setObjectName(ObjectName objectName) {
       this. = objectName;
    }
 
    private Cache<Stringbyte[]> getMetadataCache() {
       if ( == null) {
          synchronized (this) {
             if ( == null) {
                 = .getCache();
                .addListener(new MetadataCacheListener());
             }
          }
       }
       return ;
    }
 
       ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
 
       //allow the registry to work for local caches as well as isClustered caches
       boolean isClustered = .getGlobalComponentRegistry().getGlobalConfiguration().isClustered();
       configurationBuilder.clustering().cacheMode(isClustered ? . : .);
 
       //use a transactional cache for high consistency as writes are expected to be rare in this cache
       configurationBuilder.transaction().transactionMode(.);
 
       //fetch the state (redundant as state transfer this is enabled by default, keep it here to document the intention)
       configurationBuilder.clustering().stateTransfer().fetchInMemoryState(true);
 
       return configurationBuilder.build();
    }
 
    public <T> void registerMarshaller(Class<? extends T> clazz, BaseMarshaller<T> marshaller) {
       .registerMarshaller(clazzmarshaller);
    }
 
    @ManagedOperation(description = "Registers a Protobuf definition file", displayName = "Register Protofile")
    public void registerProtofile(byte[] descriptorFilethrows IOException, Descriptors.DescriptorValidationException {
       getMetadataCache().put(UUID.randomUUID().toString(), descriptorFile);
   }
   public void registerProtofile(InputStream descriptorFilethrows IOException, Descriptors.DescriptorValidationException {
      registerProtofile(readStream(descriptorFile));
   }
   public void registerProtofile(String classpathResourcethrows IOException, Descriptors.DescriptorValidationException {
      InputStream is = getClass().getResourceAsStream(classpathResource);
      if (is == null) {
         throw new IllegalArgumentException("Missing resource: " + classpathResource);
      }
      registerProtofile(is);
   }
   private byte[] readStream(InputStream isthrows IOException {
      try {
         ByteArrayOutputStream os = new ByteArrayOutputStream();
         byte[] buf = new byte[1024];
         int len;
         while ((len = is.read(buf)) != -1) {
            os.write(buf, 0, len);
         }
         return os.toByteArray();
      } finally {
         is.close();
      }
   }
   SerializationContext getSerializationContext() {
      return ;
   }
   public static SerializationContext getSerializationContext(EmbeddedCacheManager cacheManager) {
      if (cacheManager == null) {
         throw new IllegalArgumentException("cacheManager cannot be null");
      }
      ProtobufMetadataManager metadataManager = cacheManager.getGlobalComponentRegistry().getComponent(ProtobufMetadataManager.class);
      if (metadataManager == null) {
         throw new IllegalStateException("ProtobufMetadataManager not initialised yet!");
      }
      return metadataManager.getSerializationContext();
   }
   public class MetadataCacheListener {
      public void created(CacheEntryCreatedEvent<Stringbyte[]> ethrows IOException, Descriptors.DescriptorValidationException {
         if (!e.isPre()) {
            registerProtofile(e.getValue());
         }
      }
      public void modified(CacheEntryModifiedEvent<Stringbyte[]> ethrows IOException, Descriptors.DescriptorValidationException {
         if (!e.isPre()) {
            registerProtofile(e.getValue());
         }
      }
      private void registerProtofile(byte[] descriptorFilethrows IOException, Descriptors.DescriptorValidationException {
         getSerializationContext().registerProtofile(new ByteArrayInputStream(descriptorFile));
      }
   }
New to GrepCode? Check out our FAQ X