How to use

builder

method

in

com.palantir.lock.LockServerOptions

@Override
public LockServerOptions getLockServerOptions() {
  LockServerOptions options = LockServerOptions.builder()
      .isStandaloneServer(isStandaloneServer)
      .maxAllowedLockTimeout(maxAllowedLockTimeout)
      .maxAllowedClockDrift(maxAllowedClockDrift)
      .randomBitCount(RANDOM_BIT_COUNT)
      .build();
  if (log.isTraceEnabled()) {
    log.trace(".getLockServerOptions() returns {}", options);
  }
  return options;
}

  private CloseableLockService createTimeLimitedLockService(long slowLogTriggerMillis) {
    LockServerOptions lockServerOptions = LockServerOptions.builder()
        .slowLogTriggerMillis(slowLogTriggerMillis)
        .build();

    LockServiceImpl rawLockService = LockServiceImpl.create(lockServerOptions);

    if (deprecated.useLockTimeLimiter()) {
      return BlockingTimeLimitedLockService.create(
          rawLockService,
          deprecated.blockingTimeoutInMs());
    }
    return rawLockService;
  }
}

@BeforeClass
public static void setupLockService() {
  if (lockService == null) {
    lockService = LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build());
  }
}

private static LockServiceImpl createLockServiceWithSlowLogEnabled(boolean isSlowLogEnabled) {
  return LockServiceImpl.create(LockServerOptions.builder()
      .isStandaloneServer(false)
      .slowLogTriggerMillis(isSlowLogEnabled ? SLOW_LOG_TRIGGER_MILLIS : 0)
      .build());
}

@Test
public void testSerialisationAndDeserialisationOfLockServerOptions() throws Exception {
  LockServerOptions lockServerOptions = LockServerOptions.builder()
      .isStandaloneServer(false)
      .slowLogTriggerMillis(10L)
      .build();
  ObjectMapper mapper = new ObjectMapper();
  String serializedForm = mapper.writeValueAsString(lockServerOptions);
  LockServerOptions deserialzedlockServerOptions = mapper.readValue(serializedForm, LockServerOptions.class);
  assertEquals(lockServerOptions, deserialzedlockServerOptions);
  assertEquals(false, deserialzedlockServerOptions.isStandaloneServer());
  assertEquals(10L, deserialzedlockServerOptions.slowLogTriggerMillis());
}

  @Override
  protected LockService getLockService() {
    return SerializingProxy.newProxyInstance(LockService.class, LockServiceImpl.create(
        LockServerOptions.builder()
        .isStandaloneServer(false)
        .lockStateLoggerDir(LockServiceTestUtils.TEST_LOG_STATE_DIR)
        .build()));
  }
}

(TimestampManagementService) timestampService,
LockClient.of("test"),
LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build()),
transactionService,
() -> AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING,

    = TransactionServices.createForTesting(keyValueService, ts, false);
LockService lock = LockRefreshingLockService.create(LockServiceImpl.create(
     LockServerOptions.builder().isStandaloneServer(false).build()));
LockClient client = LockClient.of("in memory atlasdb instance");
ConflictDetectionManager conflictManager = ConflictDetectionManagers.createWithoutWarmingCache(keyValueService);

@Before public void setUp() {
  server = LockRefreshingLockService.create(LockServiceImpl.create(LockServerOptions.builder()
      .isStandaloneServer(false)
      .build()));
  lock1 = StringLockDescriptor.of("lock1");
}

public static TransactionManager setupTxManager(KeyValueService kvs,
    TimestampService tsService,
    TimestampManagementService tsmService,
    SweepStrategyManager ssm,
    TransactionService txService) {
  MetricsManager metricsManager = MetricsManagers.createForTests();
  LockClient lockClient = LockClient.of("sweep client");
  LockService lockService = LockServiceImpl.create(
      LockServerOptions.builder().isStandaloneServer(false).build());
  Supplier<AtlasDbConstraintCheckingMode> constraints = () ->
      AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING;
  ConflictDetectionManager cdm = ConflictDetectionManagers.createWithoutWarmingCache(kvs);
  Cleaner cleaner = new NoOpCleaner();
  MultiTableSweepQueueWriter writer = TargetedSweeper.createUninitializedForTest(() -> 1);
  TransactionManager txManager = SerializableTransactionManager.createForTest(
      metricsManager, kvs, tsService, tsmService, lockClient, lockService, txService,
      constraints, cdm, ssm, cleaner,
      AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE,
      AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY,
      writer);
  setupTables(kvs);
  writer.initialize(txManager);
  return txManager;
}

new File("lock_server_timestamp.dat").delete();
server = SimulatingServerProxy.newProxyInstance(LockService.class, LockServiceImpl.create(
    LockServerOptions.builder()
    .maxAllowedClockDrift(SimpleTimeDuration.of(0, TimeUnit.MILLISECONDS))
    .build()), 100);

@Before
public void setUp() {
  lockService = LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build());
  lockClient = LockClient.of("test_client");

@Before
public void setup() {
  kvs = new InMemoryKeyValueService(true);
  InMemoryTimestampService tsService = new InMemoryTimestampService();
  LockClient lockClient = LockClient.of("sweep client");
  lockService = LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build());
  txService = TransactionServices.createForTesting(kvs, tsService, false);
  Supplier<AtlasDbConstraintCheckingMode> constraints = Suppliers.ofInstance(
      AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING);
  ConflictDetectionManager cdm = ConflictDetectionManagers.createWithoutWarmingCache(kvs);
  SweepStrategyManager ssm = SweepStrategyManagers.createDefault(kvs);
  Cleaner cleaner = new NoOpCleaner();
  metricsManager = MetricsManagers.createForTests();
  TransactionManager transactionManager = SerializableTransactionManager.createForTest(
      metricsManager,
      kvs, tsService, tsService, lockClient, lockService, txService, constraints, cdm, ssm, cleaner,
      AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE,
      AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY,
      MultiTableSweepQueueWriter.NO_OP);
  txManager = transactionManager;
}

new File("lock_server_timestamp.dat").delete();
server = SimulatingServerProxy.newProxyInstance(LockService.class, LockServiceImpl.create(
    LockServerOptions.builder()
        .maxAllowedClockDrift(SimpleTimeDuration.of(0, TimeUnit.MILLISECONDS))
        .build()), 100);

new File("lock_server_timestamp.dat").delete();
server = SimulatingServerProxy.newProxyInstance(LockService.class, LockServiceImpl.create(
    LockServerOptions.builder()
        .maxAllowedClockDrift(SimpleTimeDuration.of(0, TimeUnit.MILLISECONDS))
        .build()), 10);

    = TransactionServices.createForTesting(keyValueService, ts, false);
LockService lock = LockRefreshingLockService.create(LockServiceImpl.create(
     LockServerOptions.builder().isStandaloneServer(false).build()));
LockClient client = LockClient.of("in memory atlasdb instance");
ConflictDetectionManager conflictManager = ConflictDetectionManagers.createWithoutWarmingCache(keyValueService);

public static TransactionManager setupTxManager(KeyValueService kvs,
    TimestampService tsService,
    TimestampManagementService tsmService,
    SweepStrategyManager ssm,
    TransactionService txService) {
  MetricsManager metricsManager = MetricsManagers.createForTests();
  LockClient lockClient = LockClient.of("sweep client");
  LockService lockService = LockServiceImpl.create(
      LockServerOptions.builder().isStandaloneServer(false).build());
  Supplier<AtlasDbConstraintCheckingMode> constraints = () ->
      AtlasDbConstraintCheckingMode.NO_CONSTRAINT_CHECKING;
  ConflictDetectionManager cdm = ConflictDetectionManagers.createWithoutWarmingCache(kvs);
  Cleaner cleaner = new NoOpCleaner();
  MultiTableSweepQueueWriter writer = TargetedSweeper.createUninitializedForTest(() -> 1);
  TransactionManager txManager = SerializableTransactionManager.createForTest(
      metricsManager, kvs, tsService, tsmService, lockClient, lockService, txService,
      constraints, cdm, ssm, cleaner,
      AbstractTransactionTest.GET_RANGES_THREAD_POOL_SIZE,
      AbstractTransactionTest.DEFAULT_GET_RANGES_CONCURRENCY,
      writer);
  setupTables(kvs);
  writer.initialize(txManager);
  return txManager;
}

@Before
public void setUp() {
  lockService = LockServiceImpl.create(LockServerOptions.builder().isStandaloneServer(false).build());
  lockClient = LockClient.of("test_client");