How to use

WorkerOptions

in

com.obsidiandynamics.worker

public SingleNodeQueueLedger(Config config) {
 maxYields = config.maxYields;
 thread = WorkerThread.builder()
   .withOptions(new WorkerOptions()
          .daemon()
          .withName(SingleNodeQueueLedger.class, Integer.toHexString(System.identityHashCode(this))))
   .onCycle(this::cycle)
   .buildAndStart();
}

WorkerThread(WorkerOptions options, 
       WorkerCycle onCycle, 
       WorkerStartup onStartup, 
       WorkerShutdown onShutdown, 
       WorkerExceptionHandler onUncaughtException) {
 this.worker = onCycle;
 this.onStartup = onStartup;
 this.onShutdown = onShutdown;
 this.onUncaughtException = onUncaughtException;
 driver = new Thread(this::run);
 
 if (options.getName() != null) {
  driver.setName(options.getName());
 }
 
 driver.setDaemon(options.isDaemon());
 driver.setPriority(options.getPriority());
}

/**
 *  Helper for naming the thread by taking the simple name of the given class (i.e. {@link Class#getSimpleName()})
 *  and concatenating hyphen-delimited {@code nameFrags}.<p>
 *  
 *  Example 1: {@code withName(Reaper.class)} results in {@code Reaper}.<br>
 *  Example 2: {@code withName(Reaper.class, "collector", 0)} results in {@code Reaper-collector-0}.<br>
 *  
 *  @param cls The class name.
 *  @param nameFrags The name fragments.
 *  @return This {@link WorkerOptions} instance for fluent chaining.
 */
public WorkerOptions withName(Class<?> cls, Object... nameFrags) {
 final String name = new Concat()
   .append(cls.getSimpleName())
   .when(nameFrags.length > 0).append(new Concat().append("-").appendArray("-", nameFrags))
   .toString();
 return withName(name);
}

public TaskScheduler(String threadName) {
 executor = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(threadName))
   .onCycle(this::cycle)
   .build();
}

public Flow(FiringStrategy.Factory firingStrategyFactory, String threadName) {
 executor = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(threadName))
   .onCycle(firingStrategyFactory.create(this, tail))
   .buildAndStart();
}

public AsyncReceiver(Consumer<K, V> consumer, int pollTimeoutMillis, String threadName, 
           RecordHandler<K, V> recordHandler, ExceptionHandler exceptionHandler) {
 this.consumer = consumer;
 this.pollTimeoutMillis = pollTimeoutMillis;
 this.recordHandler = recordHandler;
 this.exceptionHandlerHandler = exceptionHandler;
 thread = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(threadName))
   .onCycle(this::cycle)
   .onShutdown(this::shutdown)
   .buildAndStart();
}

public ConsumerPipe(ConsumerPipeConfig config, RecordHandler<K, V> handler, String threadName) {
 this.handler = handler;
 if (config.isAsync()) {
  mustExist(threadName, "Thread name cannot be null");
  queue = new LinkedBlockingQueue<>(config.getBacklogBatches());
  thread = WorkerThread.builder()
    .withOptions(new WorkerOptions().daemon().withName(threadName))
    .onCycle(this::cycle)
    .buildAndStart();
 } else {
  queue = null;
  thread = null;
 }
}

DefaultReceiver(Subscriber subscriber, RecordHandler recordHandler, int pollTimeoutMillis) {
 this.subscriber = subscriber;
 this.recordHandler = recordHandler;
 this.pollTimeoutMillis = pollTimeoutMillis;
 pollerThread = WorkerThread.builder()
   .withOptions(new WorkerOptions()
          .daemon()
          .withName(Receiver.class, subscriber.getConfig().getStreamConfig().getName(), "poller"))
   .onCycle(this::pollerCycle)
   .buildAndStart();
}

@Override
public void attach(MessageHandler handler) {
 if (handler.getGroupId() != null && ! groups.add(handler.getGroupId())) return;
 
 final WorkerThread thread = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(MultiNodeQueueLedger.class, handler.getGroupId()))
   .onCycle(new NodeWorker(handler, handler.getGroupId(), queue.consumer()))
   .buildAndStart();
 threads.add(thread);
}

public MonitorEngine(MonitorAction action, String groupId, MonitorEngineConfig config) {
 this.groupId = groupId;
 trackingEnabled = config.isTrackingEnabled();
 gcIntervalMillis = config.getGCInterval();
 outcomeLifetimeMillis = config.getOutcomeLifetime();
 timeoutIntervalMillis = config.getTimeoutInterval();
 metadataEnabled = config.isMetadataEnabled();
 this.action = action;
 
 if (trackingEnabled) {
  gcThread = WorkerThread.builder()
    .withOptions(new WorkerOptions()
           .daemon()
           .withName(MonitorEngine.class, groupId, "gc", Integer.toHexString(System.identityHashCode(this))))
    .onCycle(this::gcCycle)
    .buildAndStart();
 } else {
  gcThread = null;
 }
 
 timeoutThread = WorkerThread.builder()
   .withOptions(new WorkerOptions()
          .daemon()
          .withName(MonitorEngine.class, groupId, "timeout", Integer.toHexString(System.identityHashCode(this))))
   .onCycle(this::timeoutCycle)
   .buildAndStart();
}

public ProducerPipe(ProducerPipeConfig config, Producer<K, V> producer, String threadName, ExceptionHandler exceptionHandler) {
 this.producer = producer;
 this.exceptionHandler = exceptionHandler;
 if (config.isAsync()) {
  queue = new NodeQueue<>();
  queueConsumer = queue.consumer();
  thread = WorkerThread.builder()
    .withOptions(new WorkerOptions().daemon().withName(threadName))
    .onCycle(this::cycle)
    .buildAndStart();
 } else {
  queue = null;
  queueConsumer = null;
  thread = null;
 }
}

public Election(ElectionConfig config, IMap<String, byte[]> leases) {
 this.config = config;
 final Retry retry = new Retry()
   .withExceptionClass(HazelcastException.class)
   .withAttempts(Integer.MAX_VALUE)
   .withBackoff(100)
   .withFaultHandler(config.getZlg()::w)
   .withErrorHandler(config.getZlg()::e);
 this.leases = new RetryableMap<>(retry, leases);
 registry = new Registry();
 
 scavengerThread = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(Election.class, "scavenger"))
   .onCycle(this::scavegerCycle)
   .build();
}

public Election(ElectionConfig config, IMap<String, byte[]> leases) {
 this.config = config;
 final Retry retry = new Retry()
   .withExceptionMatcher(isA(HazelcastException.class))
   .withAttempts(Integer.MAX_VALUE)
   .withBackoff(100)
   .withFaultHandler(config.getZlg()::w)
   .withErrorHandler(config.getZlg()::e);
 this.leases = new RetryableMap<>(retry, leases);
 registry = new Registry();
 
 scavengerThread = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(Election.class, "scavenger"))
   .onCycle(this::scavegerCycle)
   .build();
}

DefaultPublisher(HazelcastInstance instance, PublisherConfig config) {
 this.instance = instance;
 this.config = config;
 final StreamConfig streamConfig = config.getStreamConfig();
 final Retry retry = new Retry()
   .withExceptionMatcher(isA(HazelcastException.class))
   .withAttempts(Integer.MAX_VALUE)
   .withBackoff(100)
   .withFaultHandler(config.getZlg()::w)
   .withErrorHandler(config.getZlg()::e);
 buffer = new RetryableRingbuffer<>(retry, StreamHelper.getRingbuffer(instance, streamConfig));
 
 publishThread = WorkerThread.builder()
   .withOptions(new WorkerOptions().daemon().withName(Publisher.class, streamConfig.getName(), "publisher"))
   .onCycle(this::publisherCycle)
   .buildAndStart();
}