com.google.ipc.invalidation.external.client.SystemResources.Scheduler Java Examples

@Override
public void writeKey(final String key, final byte[] value, final Callback<Status> callback) {
  // Need to schedule immediately because C++ locks aren't reentrant, and
  // C++ locking code assumes that this call will not return directly.

  // Schedule the write even if the resources are started since the
  // scheduler will prevent it from running in case the resources have been
  // stopped.
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.writeKey") {
    @Override
    public void run() {
      ticlPersistentState.put(key, value);
      callback.accept(Status.newInstance(Status.Code.SUCCESS, ""));
    }
  });
}
 

/**
 * Creates a recurring task with the given parameters. The specs of the parameters are given in
 * the instance variables.
 * <p>
 * The created task is first scheduled with a smeared delay of {@code initialDelayMs}. If the
 * {@code this.run()} returns true on its execution, the task is rescheduled after a
 * {@code timeoutDelayMs} + smeared delay of {@code initialDelayMs} or {@code timeoutDelayMs} +
 * {@code delayGenerator.getNextDelay()} depending on whether the {@code delayGenerator} is null
 * or not.
 */

public RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    final int initialDelayMs, final int timeoutDelayMs) {
  this.delayGenerator = delayGenerator;
  this.name = Preconditions.checkNotNull(name);
  this.logger = Preconditions.checkNotNull(logger);
  this.scheduler = Preconditions.checkNotNull(scheduler);
  this.smearer = Preconditions.checkNotNull(smearer);
  this.initialDelayMs = initialDelayMs;
  this.isScheduled = false;
  this.timeoutDelayMs = timeoutDelayMs;

  // Create a runnable that runs the task. If the task asks for a retry, reschedule it after
  // at a timeout delay. Otherwise, resets the delayGenerator.
  this.runnable = createRunnable();
}
 

/**
 * Creates a recurring task with the given parameters. The specs of the parameters are given in
 * the instance variables.
 * <p>
 * The created task is first scheduled with a smeared delay of {@code initialDelayMs}. If the
 * {@code this.run()} returns true on its execution, the task is rescheduled after a
 * {@code timeoutDelayMs} + smeared delay of {@code initialDelayMs} or {@code timeoutDelayMs} +
 * {@code delayGenerator.getNextDelay()} depending on whether the {@code delayGenerator} is null
 * or not.
 */

public RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    final int initialDelayMs, final int timeoutDelayMs) {
  this.delayGenerator = delayGenerator;
  this.name = Preconditions.checkNotNull(name);
  this.logger = Preconditions.checkNotNull(logger);
  this.scheduler = Preconditions.checkNotNull(scheduler);
  this.smearer = Preconditions.checkNotNull(smearer);
  this.initialDelayMs = initialDelayMs;
  this.isScheduled = false;
  this.timeoutDelayMs = timeoutDelayMs;

  // Create a runnable that runs the task. If the task asks for a retry, reschedule it after
  // at a timeout delay. Otherwise, resets the delayGenerator.
  this.runnable = createRunnable();
}
 

@Override
public void writeKey(final String key, final byte[] value, final Callback<Status> callback) {
  // Need to schedule immediately because C++ locks aren't reentrant, and
  // C++ locking code assumes that this call will not return directly.

  // Schedule the write even if the resources are started since the
  // scheduler will prevent it from running in case the resources have been
  // stopped.
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.writeKey") {
    @Override
    public void run() {
      ticlPersistentState.put(key, value);
      callback.accept(Status.newInstance(Status.Code.SUCCESS, ""));
    }
  });
}
 

@Override
public void readKey(final String key, final Callback<SimplePair<Status, byte[]>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readKey") {
    @Override
    public void run() {
      byte[] value = TypedUtil.mapGet(ticlPersistentState, key);
      final SimplePair<Status, byte[]> result;
      if (value != null) {
        result = SimplePair.of(Status.newInstance(Status.Code.SUCCESS, ""), value);
      } else {
        String error = "No value present in map for " + key;
        result = SimplePair.of(Status.newInstance(Status.Code.PERMANENT_FAILURE, error), null);
      }
      done.accept(result);
    }
  });
}
 

@Override
public void readKey(final String key, final Callback<SimplePair<Status, byte[]>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readKey") {
    @Override
    public void run() {
      byte[] value = TypedUtil.mapGet(ticlPersistentState, key);
      final SimplePair<Status, byte[]> result;
      if (value != null) {
        result = SimplePair.of(Status.newInstance(Status.Code.SUCCESS, ""), value);
      } else {
        String error = "No value present in map for " + key;
        result = SimplePair.of(Status.newInstance(Status.Code.PERMANENT_FAILURE, error), null);
      }
      done.accept(result);
    }
  });
}
 

@Override
public void readKey(final String key, final Callback<SimplePair<Status, byte[]>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readKey") {
    @Override
    public void run() {
      byte[] value = TypedUtil.mapGet(ticlPersistentState, key);
      final SimplePair<Status, byte[]> result;
      if (value != null) {
        result = SimplePair.of(Status.newInstance(Status.Code.SUCCESS, ""), value);
      } else {
        String error = "No value present in map for " + key;
        result = SimplePair.of(Status.newInstance(Status.Code.PERMANENT_FAILURE, error), null);
      }
      done.accept(result);
    }
  });
}
 

@Override
public void writeKey(final String key, final byte[] value, final Callback<Status> callback) {
  // Need to schedule immediately because C++ locks aren't reentrant, and
  // C++ locking code assumes that this call will not return directly.

  // Schedule the write even if the resources are started since the
  // scheduler will prevent it from running in case the resources have been
  // stopped.
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.writeKey") {
    @Override
    public void run() {
      ticlPersistentState.put(key, value);
      callback.accept(Status.newInstance(Status.Code.SUCCESS, ""));
    }
  });
}
 

/**
 * Creates a recurring task with the given parameters. The specs of the parameters are given in
 * the instance variables.
 * <p>
 * The created task is first scheduled with a smeared delay of {@code initialDelayMs}. If the
 * {@code this.run()} returns true on its execution, the task is rescheduled after a
 * {@code timeoutDelayMs} + smeared delay of {@code initialDelayMs} or {@code timeoutDelayMs} +
 * {@code delayGenerator.getNextDelay()} depending on whether the {@code delayGenerator} is null
 * or not.
 */

public RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    final int initialDelayMs, final int timeoutDelayMs) {
  this.delayGenerator = delayGenerator;
  this.name = Preconditions.checkNotNull(name);
  this.logger = Preconditions.checkNotNull(logger);
  this.scheduler = Preconditions.checkNotNull(scheduler);
  this.smearer = Preconditions.checkNotNull(smearer);
  this.initialDelayMs = initialDelayMs;
  this.isScheduled = false;
  this.timeoutDelayMs = timeoutDelayMs;

  // Create a runnable that runs the task. If the task asks for a retry, reschedule it after
  // at a timeout delay. Otherwise, resets the delayGenerator.
  this.runnable = createRunnable();
}
 

/**
 * Creates a recurring task from {@code marshalledState}. Other parameters are as in the
 * constructor above.
 */
RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    RecurringTaskState marshalledState) {
  this(name, scheduler, logger, smearer, delayGenerator, marshalledState.getInitialDelayMs(),
      marshalledState.getTimeoutDelayMs());
  this.isScheduled = marshalledState.getScheduled();
}
 

@Override
public void deleteKey(final String key, final Callback<Boolean> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.deleteKey") {
    @Override
    public void run() {
      TypedUtil.remove(ticlPersistentState, key);
      done.accept(true);
    }
  });
}
 

@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readAllKeys") {
    @Override
    public void run() {
      Status successStatus = Status.newInstance(Status.Code.SUCCESS, "");
      for (String key : ticlPersistentState.keySet()) {
        done.accept(SimplePair.of(successStatus, key));
      }
      done.accept(null);
    }
  });
}
 

/** See specs at {@code DefaultResourcesFactory.createDefaultResourcesBuilder}. */
public SystemResourcesBuilder(Logger logger, Scheduler internalScheduler,
    Scheduler listenerScheduler, NetworkChannel network, Storage storage) {
  this.logger = logger;
  this.internalScheduler = internalScheduler;
  this.listenerScheduler = listenerScheduler;
  this.network = network;
  this.storage = storage;
}
 

CheckingInvalidationListener(InvalidationListener delegate, Scheduler internalScheduler,
    Scheduler listenerScheduler, Logger logger) {
  this.delegate = Preconditions.checkNotNull(delegate, "Delegate cannot be null");
  this.internalScheduler = Preconditions.checkNotNull(internalScheduler,
      "Internal scheduler cannot be null");
  this.listenerScheduler = Preconditions.checkNotNull(listenerScheduler,
      "Listener scheduler cannot be null");
  this.logger = Preconditions.checkNotNull(logger, "Logger cannot be null");
}
 

CheckingInvalidationListener(InvalidationListener delegate, Scheduler internalScheduler,
    Scheduler listenerScheduler, Logger logger) {
  this.delegate = Preconditions.checkNotNull(delegate, "Delegate cannot be null");
  this.internalScheduler = Preconditions.checkNotNull(internalScheduler,
      "Internal scheduler cannot be null");
  this.listenerScheduler = Preconditions.checkNotNull(listenerScheduler,
      "Listener scheduler cannot be null");
  this.logger = Preconditions.checkNotNull(logger, "Logger cannot be null");
}
 

@Override
public void deleteKey(final String key, final Callback<Boolean> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.deleteKey") {
    @Override
    public void run() {
      TypedUtil.remove(ticlPersistentState, key);
      done.accept(true);
    }
  });
}
 

@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readAllKeys") {
    @Override
    public void run() {
      Status successStatus = Status.newInstance(Status.Code.SUCCESS, "");
      for (String key : ticlPersistentState.keySet()) {
        done.accept(SimplePair.of(successStatus, key));
      }
      done.accept(null);
    }
  });
}
 

/** See specs at {@code DefaultResourcesFactory.createDefaultResourcesBuilder}. */
public SystemResourcesBuilder(Logger logger, Scheduler internalScheduler,
    Scheduler listenerScheduler, NetworkChannel network, Storage storage) {
  this.logger = logger;
  this.internalScheduler = internalScheduler;
  this.listenerScheduler = listenerScheduler;
  this.network = network;
  this.storage = storage;
}
 

CheckingInvalidationListener(InvalidationListener delegate, Scheduler internalScheduler,
    Scheduler listenerScheduler, Logger logger) {
  this.delegate = Preconditions.checkNotNull(delegate, "Delegate cannot be null");
  this.internalScheduler = Preconditions.checkNotNull(internalScheduler,
      "Internal scheduler cannot be null");
  this.listenerScheduler = Preconditions.checkNotNull(listenerScheduler,
      "Listener scheduler cannot be null");
  this.logger = Preconditions.checkNotNull(logger, "Logger cannot be null");
}
 

/**
 * Creates a recurring task from {@code marshalledState}. Other parameters are as in the
 * constructor above.
 */
RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    RecurringTaskState marshalledState) {
  this(name, scheduler, logger, smearer, delayGenerator, marshalledState.getInitialDelayMs(),
      marshalledState.getTimeoutDelayMs());
  this.isScheduled = marshalledState.getScheduled();
}
 

/**
 * Creates a recurring task from {@code marshalledState}. Other parameters are as in the
 * constructor above.
 */
RecurringTask(String name, Scheduler scheduler, Logger logger, Smearer smearer,
    TiclExponentialBackoffDelayGenerator delayGenerator,
    RecurringTaskState marshalledState) {
  this(name, scheduler, logger, smearer, delayGenerator, marshalledState.getInitialDelayMs(),
      marshalledState.getTimeoutDelayMs());
  this.isScheduled = marshalledState.getScheduled();
}
 

@Override
public void deleteKey(final String key, final Callback<Boolean> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.deleteKey") {
    @Override
    public void run() {
      TypedUtil.remove(ticlPersistentState, key);
      done.accept(true);
    }
  });
}
 

@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readAllKeys") {
    @Override
    public void run() {
      Status successStatus = Status.newInstance(Status.Code.SUCCESS, "");
      for (String key : ticlPersistentState.keySet()) {
        done.accept(SimplePair.of(successStatus, key));
      }
      done.accept(null);
    }
  });
}
 

/** See specs at {@code DefaultResourcesFactory.createDefaultResourcesBuilder}. */
public SystemResourcesBuilder(Logger logger, Scheduler internalScheduler,
    Scheduler listenerScheduler, NetworkChannel network, Storage storage) {
  this.logger = logger;
  this.internalScheduler = internalScheduler;
  this.listenerScheduler = listenerScheduler;
  this.network = network;
  this.storage = storage;
}
 

/**
 * Sets the scheduler for scheduling listener events to be {@code listenerScheduler}.
 * <p>
 * REQUIRES: {@link #build} has not been called.
 */
public SystemResourcesBuilder setListenerScheduler(Scheduler listenerScheduler) {
  Preconditions.checkState(!sealed, "Builder's build method has already been called");
  this.listenerScheduler = listenerScheduler;
  return this;
}
 

/**
 * Sets the scheduler for scheduling internal events to be {@code internalScheduler}.
 * <p>
 * REQUIRES: {@link #build} has not been called.
 */
public SystemResourcesBuilder setInternalScheduler(Scheduler internalScheduler) {
  Preconditions.checkState(!sealed, "Builder's build method has already been called");
  this.internalScheduler = internalScheduler;
  return this;
}
 

/** Returns the listener scheduler. */
public Scheduler getListenerScheduler() {
  return listenerScheduler;
}
 

/** Returns the internal scheduler. */
public Scheduler getInternalScheduler() {
  return internalScheduler;
}
 

@Override
public Scheduler getInternalSchedulerForTest() {
  return resources.getInternalScheduler();
}
 

/** Returns the internal scheduler. */
public Scheduler getInternalScheduler() {
  return internalScheduler;
}