protected AbstractPrimitiveService(PrimitiveType primitiveType, Class<C> clientInterface) { this.primitiveType = primitiveType; this.clientInterface = clientInterface; this.serializer = Serializer.using(primitiveType.namespace()); }
/** * Opens a new {@link MetaStore}, recovering metadata from disk if it exists. * <p> * The meta store will be loaded using based on the configured {@link StorageLevel}. If the storage level is persistent * then the meta store will be loaded from disk, otherwise a new meta store will be created. * * @return The metastore. */ public MetaStore openMetaStore() { return new MetaStore(this, Serializer.using(namespace)); }
private static <S> Collection<ProxySession<S>> createSessions( PrimitiveType primitiveType, Class<S> serviceType, Collection<SessionClient> partitions) { Serializer serializer = Serializer.using(primitiveType.namespace()); return partitions.stream() .map(partition -> new DefaultProxySession<>(partition, serviceType, serializer)) .collect(Collectors.toList()); }
private static <S> Collection<ProxySession<S>> createSessions( String name, PrimitiveType primitiveType, Class<S> serviceType, ServiceConfig serviceConfig, Collection<LogSession> partitions) { Serializer serializer = Serializer.using(primitiveType.namespace()); return partitions.stream() .map(partition -> new LogProxySession<S>(name, primitiveType, serviceType, serviceConfig, serializer, partition)) .collect(Collectors.toList()); }
public DefaultProxyClient( String name, PrimitiveType type, PrimitiveProtocol protocol, Class<S> serviceType, Collection<SessionClient> partitions, Partitioner<String> partitioner) { super(name, type, protocol, createSessions(type, serviceType, partitions)); this.partitioner = checkNotNull(partitioner); this.serializer = Serializer.using(type.namespace()); }
@Override public Serializer build() { return Serializer.using(name != null ? namespaceBuilder.build(name) : namespaceBuilder.build()); } }
public LogProxyClient( String name, PrimitiveType type, PrimitiveProtocol protocol, Class<S> serviceType, ServiceConfig serviceConfig, LogClient client) { super(name, type, protocol, createSessions(name, type, serviceType, serviceConfig, client.getPartitions())); this.client = client; this.serializer = Serializer.using(type.namespace()); }
public DefaultDistributedListService() { super(DistributedListType.instance(), Collections.synchronizedList(new ArrayList<>())); this.serializer = Serializer.using(Namespace.builder() .register(DistributedListType.instance().namespace()) .register(SessionId.class) .register(DefaultDistributedCollectionService.IteratorContext.class) .register(IteratorContext.class) .build()); }
public AbstractAtomicMapService(PrimitiveType primitiveType) { super(primitiveType, AtomicMapClient.class); serializer = Serializer.using(Namespace.builder() .register(primitiveType.namespace()) .register(SessionId.class) .register(TransactionId.class) .register(TransactionScope.class) .register(MapEntryValue.class) .register(MapEntryValue.Type.class) .register(new HashMap().keySet().getClass()) .register(DefaultIterator.class) .build()); map = createMap(); }
protected DefaultDistributedCollectionService(PrimitiveType primitiveType, T collection) { super(primitiveType, DistributedCollectionClient.class); this.collection = collection; this.serializer = Serializer.using(Namespace.builder() .register(primitiveType.namespace()) .register(SessionId.class) .register(IteratorContext.class) .build()); }
public DefaultDistributedMultisetService() { super(DistributedMultisetType.instance(), HashMultiset.create()); this.serializer = Serializer.using(Namespace.builder() .register(DistributedMultisetType.instance().namespace()) .register(SessionId.class) .register(DefaultDistributedCollectionService.IteratorContext.class) .register(IteratorContext.class) .build()); }
public AbstractAtomicNavigableMapService(PrimitiveType primitiveType) { super(primitiveType); serializer = Serializer.using(Namespace.builder() .register(AtomicNavigableMapType.instance().namespace()) .register(SessionId.class) .register(TransactionId.class) .register(TransactionScope.class) .register(MapEntryValue.class) .register(MapEntryValue.Type.class) .register(new HashMap().keySet().getClass()) .register(DefaultIterator.class) .register(AscendingIterator.class) .register(DescendingIterator.class) .build()); }
public DefaultDistributedNavigableSetService() { super(DistributedNavigableSetType.instance(), new ConcurrentSkipListSet<>()); this.serializer = Serializer.using(Namespace.builder() .register(DistributedNavigableSetType.instance().namespace()) .register(SessionId.class) .register(IteratorContext.class) .register(SubSetIteratorContext.class) .register(DescendingIteratorContext.class) .register(DescendingSubSetIteratorContext.class) .build()); }
/** * Creates a Raft client. */ private RaftPartitionClient createClient(PartitionManagementService managementService) { return new RaftPartitionClient( this, managementService.getMembershipService().getLocalMember().id(), new RaftClientCommunicator( name(), Serializer.using(RaftNamespaces.RAFT_PROTOCOL), managementService.getMessagingService()), threadContextFactory); }
/** * Takes a snapshot of the given service. * * @param writer the snapshot writer * @param service the service to snapshot */ private void snapshotService(SnapshotWriter writer, RaftServiceContext service) { writer.writeLong(service.serviceId().id()); writer.writeString(service.serviceType().name()); writer.writeString(service.serviceName()); byte[] config = Serializer.using(service.serviceType().namespace()).encode(service.serviceConfig()); writer.writeInt(config.length).writeBytes(config); try { service.takeSnapshot(writer); } catch (Exception e) { logger.error("Failed to take snapshot of service {}", service.serviceId(), e); } }
/** * Initializes a new service. */ @SuppressWarnings("unchecked") private RaftServiceContext initializeService(PrimitiveId primitiveId, PrimitiveType primitiveType, String serviceName, byte[] config) { RaftServiceContext oldService = raft.getServices().getService(serviceName); ServiceConfig serviceConfig = config == null ? new ServiceConfig() : Serializer.using(primitiveType.namespace()).decode(config); RaftServiceContext service = new RaftServiceContext( primitiveId, serviceName, primitiveType, serviceConfig, primitiveType.newService(serviceConfig), raft, threadContextFactory); raft.getServices().registerService(service); // If a service with this name was already registered, remove all of its sessions. if (oldService != null) { raft.getSessions().removeSessions(oldService.serviceId()); } return service; }
private PrimaryBackupServer buildServer() { return PrimaryBackupServer.builder() .withServerName(partition.name()) .withMembershipService(managementService.getMembershipService()) .withMemberGroupProvider(memberGroupProvider) .withProtocol(new PrimaryBackupServerCommunicator( partition.name(), Serializer.using(PrimaryBackupNamespaces.PROTOCOL), managementService.getMessagingService())) .withPrimaryElection(managementService.getElectionService().getElectionFor(partition.id())) .withPrimitiveTypes(managementService.getPrimitiveTypes()) .withThreadContextFactory(threadFactory) .build(); }
private PrimaryBackupClient newClient() { return PrimaryBackupClient.builder() .withClientName(partition.name()) .withPartitionId(partition.id()) .withMembershipService(managementService.getMembershipService()) .withProtocol(new PrimaryBackupClientCommunicator( partition.name(), Serializer.using(PrimaryBackupNamespaces.PROTOCOL), managementService.getMessagingService())) .withPrimaryElection(managementService.getElectionService().getElectionFor(partition.id())) .withSessionIdProvider(managementService.getSessionIdService()) .withThreadContextFactory(threadFactory) .build(); }
private DistributedLogSessionClient newClient() { return DistributedLogSessionClient.builder() .withClientName(partition.name()) .withPartitionId(partition.id()) .withMembershipService(managementService.getMembershipService()) .withProtocol(new LogClientCommunicator( partition.name(), Serializer.using(LogNamespaces.PROTOCOL), managementService.getMessagingService())) .withSessionIdProvider(() -> managementService.getSessionIdService().nextSessionId()) .withPrimaryElection(managementService.getElectionService().getElectionFor(partition.id())) .withThreadContextFactory(threadFactory) .build(); }
private DistributedLogServer buildServer() { return DistributedLogServer.builder() .withServerName(partition.name()) .withMembershipService(managementService.getMembershipService()) .withMemberGroupProvider(config.getMemberGroupProvider()) .withProtocol(new LogServerCommunicator( partition.name(), Serializer.using(LogNamespaces.PROTOCOL), managementService.getMessagingService())) .withPrimaryElection(managementService.getElectionService().getElectionFor(partition.id())) .withStorageLevel(config.getStorageConfig().getLevel()) .withDirectory(config.getStorageConfig().getDirectory(partition.name())) .withMaxSegmentSize((int) config.getStorageConfig().getSegmentSize().bytes()) .withMaxEntrySize((int) config.getStorageConfig().getMaxEntrySize().bytes()) .withFlushOnCommit(config.getStorageConfig().isFlushOnCommit()) .withMaxLogSize(config.getCompactionConfig().getSize().bytes()) .withMaxLogAge(config.getCompactionConfig().getAge()) .withThreadContextFactory(threadFactory) .build(); }