Java StorageLevel类代码示例

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
private RaftStorage(
    String prefix,
    StorageLevel storageLevel,
    File directory,
    Serializer serializer,
    int maxSegmentSize,
    int maxEntriesPerSegment,
    boolean dynamicCompaction,
    double freeDiskBuffer,
    boolean flushOnCommit,
    boolean retainStaleSnapshots) {
  this.prefix = prefix;
  this.storageLevel = storageLevel;
  this.directory = directory;
  this.serializer = serializer;
  this.maxSegmentSize = maxSegmentSize;
  this.maxEntriesPerSegment = maxEntriesPerSegment;
  this.dynamicCompaction = dynamicCompaction;
  this.freeDiskBuffer = freeDiskBuffer;
  this.flushOnCommit = flushOnCommit;
  this.retainStaleSnapshots = retainStaleSnapshots;
  this.statistics = new StorageStatistics(directory);
  directory.mkdirs();
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
public MetaStore(RaftStorage storage, Serializer serializer) {
  this.serializer = checkNotNull(serializer, "serializer cannot be null");

  if (!(storage.directory().isDirectory() || storage.directory().mkdirs())) {
    throw new IllegalArgumentException(String.format("Can't create storage directory [%s].", storage.directory()));
  }

  // Note that for raft safety, irrespective of the storage level, <term, vote> metadata is always persisted on disk.
  File metaFile = new File(storage.directory(), String.format("%s.meta", storage.prefix()));
  metadataBuffer = FileBuffer.allocate(metaFile, 12);

  if (storage.storageLevel() == StorageLevel.MEMORY) {
    configurationBuffer = HeapBuffer.allocate(32);
  } else {
    File confFile = new File(storage.directory(), String.format("%s.conf", storage.prefix()));
    configurationBuffer = FileBuffer.allocate(confFile, 32);
  }
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
/**
 * Creates a Raft server.
 */
private RaftServer createServer(NodeId nodeId) {
  RaftServer.Builder builder = RaftServer.builder(nodeId)
      .withClusterService(mock(ClusterService.class))
      .withProtocol(protocolFactory.newServerProtocol(nodeId))
      .withStorage(RaftStorage.builder()
          .withStorageLevel(StorageLevel.DISK)
          .withDirectory(new File(String.format("target/test-logs/%s", nodeId)))
          .withSerializer(storageSerializer)
          .withMaxSegmentSize(1024 * 10)
          .withMaxEntriesPerSegment(10)
          .build())
      .addPrimitiveType(TestPrimitiveType.INSTANCE);

  RaftServer server = builder.build();
  servers.add(server);
  return server;
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
public SegmentedJournal(
    String name,
    StorageLevel storageLevel,
    File directory,
    Serializer serializer,
    int maxSegmentSize,
    int maxEntriesPerSegment) {
  this.name = checkNotNull(name, "name cannot be null");
  this.storageLevel = checkNotNull(storageLevel, "storageLevel cannot be null");
  this.directory = checkNotNull(directory, "directory cannot be null");
  this.serializer = checkNotNull(serializer, "serializer cannot be null");
  this.maxSegmentSize = maxSegmentSize;
  this.maxEntriesPerSegment = maxEntriesPerSegment;
  open();
  this.writer = openWriter();
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
private RaftServer buildServer() {
    RaftServer.Builder builder = RaftServer.newBuilder(localMemberId)
            .withName(String.format("partition-%s", partition.getId()))
            .withProtocol(new RaftServerCommunicator(
                    String.format("partition-%s-%s", partition.getId(), partition.getVersion()),
                    Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
                    clusterCommunicator))
            .withElectionTimeout(Duration.ofMillis(ELECTION_TIMEOUT_MILLIS))
            .withHeartbeatInterval(Duration.ofMillis(HEARTBEAT_INTERVAL_MILLIS))
            .withElectionThreshold(ELECTION_THRESHOLD)
            .withStorage(RaftStorage.newBuilder()
                    .withPrefix(String.format("partition-%s", partition.getId()))
                    .withStorageLevel(StorageLevel.DISK)
                    .withFlushOnCommit()
                    .withSerializer(new AtomixSerializerAdapter(Serializer.using(StorageNamespaces.RAFT_STORAGE)))
                    .withDirectory(partition.getDataFolder())
                    .withMaxSegmentSize(MAX_SEGMENT_SIZE)
                    .build());
    StoragePartition.RAFT_SERVICES.forEach(builder::addService);
    return builder.build();
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
/**
 * Creates a Raft server.
 */
private RaftServer createServer(RaftMember member) {
    RaftServer.Builder builder = RaftServer.newBuilder(member.memberId())
            .withType(member.getType())
            .withProtocol(new RaftServerCommunicator(
                    "partition-1",
                    Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
                    communicationServiceFactory.newCommunicationService(NodeId.nodeId(member.memberId().id()))))
            .withStorage(RaftStorage.newBuilder()
                    .withStorageLevel(StorageLevel.MEMORY)
                    .withDirectory(new File(String.format("target/primitives/%s", member.memberId())))
                    .withSerializer(new AtomixSerializerAdapter(Serializer.using(StorageNamespaces.RAFT_STORAGE)))
                    .withMaxSegmentSize(1024 * 1024)
                    .build())
            .addService("test", this::createService);

    RaftServer server = builder.build();
    servers.add(server);
    return server;
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
@Override
protected ManagedPartitionGroup buildCorePartitionGroup() {
  return RaftPartitionGroup.builder("core")
      .withStorageLevel(StorageLevel.MEMORY)
      .withDataDirectory(new File(dataDirectory, "core"))
      .withNumPartitions(1)
      .build();
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
@Override
protected ManagedPartitionService buildPartitionService() {
  if (partitionGroups.isEmpty()) {
    partitionGroups.add(RaftPartitionGroup.builder(COORDINATION_GROUP_NAME)
        .withStorageLevel(StorageLevel.MEMORY)
        .withDataDirectory(new File(dataDirectory, "coordination"))
        .withNumPartitions(numCoordinationPartitions > 0 ? numCoordinationPartitions : bootstrapNodes.size())
        .withPartitionSize(coordinationPartitionSize)
        .build());
    partitionGroups.add(PrimaryBackupPartitionGroup.builder(DATA_GROUP_NAME)
        .withNumPartitions(numDataPartitions)
        .build());
  }
  return new DefaultPartitionService(partitionGroups);
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
/**
 * Creates a new snapshot buffer.
 */
private Snapshot newSnapshot(String serviceName, SnapshotDescriptor descriptor, StorageLevel storageLevel) {
  if (storageLevel == StorageLevel.MEMORY) {
    return createMemorySnapshot(serviceName, descriptor);
  } else {
    return createDiskSnapshot(serviceName, descriptor);
  }
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
@Override
public Snapshot persist() {
  if (store.storage.storageLevel() != StorageLevel.MEMORY) {
    try (Snapshot newSnapshot = store.newSnapshot(serviceId(), name, index(), timestamp())) {
      try (SnapshotWriter newSnapshotWriter = newSnapshot.openWriter()) {
        buffer.flip().skip(SnapshotDescriptor.BYTES);
        newSnapshotWriter.write(buffer.array(), buffer.position(), buffer.remaining());
      }
      return newSnapshot;
    }
  }
  return this;
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
/**
 * Returns a new snapshot store.
 */
protected SnapshotStore createSnapshotStore() {
  RaftStorage storage = RaftStorage.builder()
      .withPrefix("test")
      .withStorageLevel(StorageLevel.MEMORY)
      .build();
  return new SnapshotStore(storage);
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
/**
 * Returns a new snapshot store.
 */
protected SnapshotStore createSnapshotStore() {
  RaftStorage storage = RaftStorage.builder()
      .withPrefix("test")
      .withDirectory(new File(String.format("target/test-logs/%s", testId)))
      .withStorageLevel(StorageLevel.DISK)
      .build();
  return new SnapshotStore(storage);
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
private Journal<TestEntry> createJournal() {
  return SegmentedJournal.<TestEntry>builder()
      .withName("test")
      .withSerializer(serializer)
      .withStorageLevel(StorageLevel.MEMORY)
      .build();
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testSnapshot() throws Exception {
    SnapshotStore store = new SnapshotStore(RaftStorage.newBuilder()
            .withPrefix("test")
            .withStorageLevel(StorageLevel.MEMORY)
            .build());
    Snapshot snapshot = store.newSnapshot(ServiceId.from(1), "test", 2, new WallClockTimestamp());

    AtomixConsistentSetMultimapService service = new AtomixConsistentSetMultimapService();
    service.put(new DefaultCommit<>(
            2,
            PUT,
            new AtomixConsistentSetMultimapOperations.Put(
                    "foo", Collections.singletonList("Hello world!".getBytes()), Match.ANY),
            mock(RaftSessionContext.class),
            System.currentTimeMillis()));

    try (SnapshotWriter writer = snapshot.openWriter()) {
        service.snapshot(writer);
    }

    snapshot.complete();

    service = new AtomixConsistentSetMultimapService();
    try (SnapshotReader reader = snapshot.openReader()) {
        service.install(reader);
    }

    Versioned<Collection<? extends byte[]>> value = service.get(new DefaultCommit<>(
            2,
            GET,
            new AtomixConsistentSetMultimapOperations.Get("foo"),
            mock(RaftSessionContext.class),
            System.currentTimeMillis()));
    assertNotNull(value);
    assertEquals(1, value.value().size());
    assertArrayEquals("Hello world!".getBytes(), value.value().iterator().next());
}
 

import io.atomix.storage.StorageLevel; //导入依赖的package包/类
@Test
public void testSnapshot() throws Exception {
    SnapshotStore store = new SnapshotStore(RaftStorage.newBuilder()
            .withPrefix("test")
            .withStorageLevel(StorageLevel.MEMORY)
            .build());
    Snapshot snapshot = store.newSnapshot(ServiceId.from(1), "test", 2, new WallClockTimestamp());

    AtomixAtomicCounterMapService service = new AtomixAtomicCounterMapService();
    service.put(new DefaultCommit<>(
            2,
            PUT,
            new AtomixAtomicCounterMapOperations.Put("foo", 1),
            mock(RaftSessionContext.class),
            System.currentTimeMillis()));

    try (SnapshotWriter writer = snapshot.openWriter()) {
        service.snapshot(writer);
    }

    snapshot.complete();

    service = new AtomixAtomicCounterMapService();
    try (SnapshotReader reader = snapshot.openReader()) {
        service.install(reader);
    }

    long value = service.get(new DefaultCommit<>(
            2,
            GET,
            new AtomixAtomicCounterMapOperations.Get("foo"),
            mock(RaftSessionContext.class),
            System.currentTimeMillis()));
    assertEquals(1, value);
}