Java Queue類代碼示例

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
public static void scheduleNotificationBuild(String objectType, Long id,
		String action) {
	if (objectType == null || objectType.isEmpty()) {
		throw new IllegalArgumentException("No Specified Object Type");
	}

	if (id == null) {
		throw new IllegalArgumentException("No Specified Object Id");
	}

	if (action == null || action.isEmpty()) {
		throw new IllegalArgumentException("No Action Specified");
	}

	// Execute the servlet to pull from the queue
	Queue executionQueue = QueueFactory.getQueue("notification-building");
	executionQueue.add(TaskOptions.Builder
			.withUrl("/notifications/builder/").method(Method.GET)
			.param("objectType", objectType)
			.param("id", String.valueOf(id.longValue()))
			.param("action", action));

}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
public UserInviteService(UserInviteLinkRepository userInviteLinkRepository,
                         LoginIdentifierService loginIdentifierService,
                         AppUserService userService,
                         Router router,
                         Queue queue,
                         Mailer mailer,
                         String host,
                         String mailerSenderEmail) {
    this.userInviteLinkRepository = userInviteLinkRepository;
    this.loginIdentifierService = loginIdentifierService;
    this.userService = userService;
    this.router = router;
    this.queue = queue;
    this.mailer = mailer;
    this.host = host;
    this.mailerSenderEmail = mailerSenderEmail;
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
public MagicLinkService(MagicLinkRepository magicLinkRepository,
    AppUserService userService,
    Router router,
    Queue queue,
    Mailer mailer,
    String host,
    String mailerSenderEmail,
    String magicLinkExpiryInMinutes) {
    this.magicLinkRepository = magicLinkRepository;
    this.userService = userService;
    this.router = router;
    this.queue = queue;
    this.mailer = mailer;
    this.host = host;
    this.mailerSenderEmail = mailerSenderEmail;
    setMagicNumberExpiry(magicLinkExpiryInMinutes);
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
@Override protected void configure() {
  StoreModuleHelper.makeBasicBindingsAndExposures(binder(), ConvStore.class);
  StoreModuleHelper.bindEntityKinds(binder(), ROOT_ENTITY_KIND);

  bind(SlobModel.class).to(WaveObjectStoreModel.class);
  bind(AccessChecker.class).to(ConvAccessChecker.class);
  bind(PermissionSource.class).to(ConvPermissionSource.class);

  Multibinder<PreCommitAction> preCommitActions =
      Multibinder.newSetBinder(binder(), PreCommitAction.class);
  preCommitActions.addBinding().to(IndexTask.ConvPreCommit.class);

  Multibinder<PostCommitAction> postCommitActions =
      Multibinder.newSetBinder(binder(), PostCommitAction.class);
  postCommitActions.addBinding().to(IndexTask.Conv.class);

  bind(Queue.class).annotatedWith(PostCommitActionQueue.class).toInstance(
      QueueFactory.getQueue("post-commit-conv"));
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
@Inject
public PostCommitActionScheduler(Set<PostCommitAction> actions,
    @PostCommitActionQueue Queue postCommitActionQueue,
    @PostCommitActionIntervalMillis int postCommitActionIntervalMillis,
    MemcacheTable.Factory memcacheFactory,
    @SlobRootEntityKind String rootEntityKind,
    @SlobSynchronizationEntityKind String syncEntityKind,
    @PostCommitTaskUrl String taskUrl,
    Random random,
    SlobStoreImpl.InternalPostCommitAction internalPostCommit,
    CheckedDatastore datastore) {
  this.actions = actions;
  this.postCommitActionQueue = postCommitActionQueue;
  this.postCommitActionIntervalMillis = postCommitActionIntervalMillis;
  this.postCommitActionPending = memcacheFactory.create(MEMCACHE_TAG_PREFIX + rootEntityKind);
  this.rootEntityKind = rootEntityKind;
  this.syncEntityKind = syncEntityKind;
  this.taskUrl = taskUrl;
  this.random = random;
  this.internalPostCommit = internalPostCommit;
  this.datastore = datastore;
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) {
    Enumeration e = req.getHeaderNames();
    while(e.hasMoreElements()) {
        String param = (String)e.nextElement();
        log.info("header:" + param + req.getHeader(param));
    }

    String cronHeader = req.getHeader("X-Appengine-Cron");
    if(cronHeader == null || !cronHeader.trim().equals("true")) {
        resp.setStatus(403);
        return;
    }

    Queue queue = QueueFactory.getQueue("reaper");
    queue.add(TaskOptions.Builder.withUrl("/reaper"));

}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
/** Leases and returns all tasks from the queue with the specified tag tld, in batches. */
public static List<TaskHandle> loadAllTasks(Queue queue, String tld) {
  ImmutableList.Builder<TaskHandle> allTasks = new ImmutableList.Builder<>();
  int numErrors = 0;
  long backOff = backOffMillis;
  while (true) {
    try {
      List<TaskHandle> tasks = queue.leaseTasks(LeaseOptions.Builder
          .withTag(tld)
          .leasePeriod(LEASE_PERIOD.getMillis(), TimeUnit.MILLISECONDS)
          .countLimit(BATCH_SIZE));
      allTasks.addAll(tasks);
      if (tasks.isEmpty()) {
        return allTasks.build();
      }
    } catch (TransientFailureException | DeadlineExceededException e) {
      if (++numErrors >= 3) {
        throw new RuntimeException("Error leasing tasks", e);
      }
      Uninterruptibles.sleepUninterruptibly(backOff, TimeUnit.MILLISECONDS);
      backOff *= 2;
    }
  }
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
/** Deletes a list of tasks from the given queue using a retrier. */
private static void deleteTasksWithRetry(
    final List<DnsRefreshRequest> refreshRequests,
    final Queue queue,
    AsyncFlowMetrics asyncFlowMetrics,
    Retrier retrier,
    OperationResult result) {
  if (refreshRequests.isEmpty()) {
    return;
  }
  final List<TaskHandle> tasks =
      refreshRequests.stream().map(DnsRefreshRequest::task).collect(toImmutableList());
  retrier.callWithRetry(() -> queue.deleteTask(tasks), TransientFailureException.class);
  refreshRequests.forEach(
      r -> asyncFlowMetrics.recordAsyncFlowResult(DNS_REFRESH, result, r.requestedTime()));
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
private static String processTasks(List<TaskHandle> tasks, Queue q) {
  String payload;
  int numberOfDeletedTasks = 0;
  for (TaskHandle task : tasks) {
    payload = new String(task.getPayload());
    output = String.format("Processing: taskName='%s'  payload='%s'", task.getName(), payload);
    log.info(output);
    output = String.format("Deleting taskName='%s'", task.getName());
    log.info(output);
    // [START delete_task]
    q.deleteTask(task);
    // [END delete_task]
    numberOfDeletedTasks++;
  }
  if (numberOfDeletedTasks > 0) {
    message = "Processed and deleted " + numberOfTasksToLease + " tasks from the "
        + " task queue.";
  } else {
    message = "Task Queue has no tasks available for lease.";
  }
  return message;
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
private static String processTasks(List<TaskHandle> tasks, Queue q) {
  String payload;
  int numberOfDeletedTasks = 0;
  for (TaskHandle task : tasks) {
    payload = new String(task.getPayload());
    output =
        String.format(
            "Processing: taskName='%s'  payload='%s'",
            task.getName().toString(), payload.toString());
    log.info(output.toString());
    output = String.format("Deleting taskName='%s'", task.getName().toString());
    log.info(output.toString());
    // [START delete_task]
    q.deleteTask(task);
    // [END delete_task]
    numberOfDeletedTasks++;
  }
  if (numberOfDeletedTasks > 0) {
    message =
        "Processed and deleted " + numberOfTasksToLease + " tasks from the " + " task queue.";
  } else {
    message = "Task Queue has no tasks available for lease.";
  }
  return message;
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
/**
 * @param name
 * @param id
 */
public static void queueToIndex (String name, Long id) {
	Queue queue = QueueFactory.getDefaultQueue();

	TaskOptions options = TaskOptions.Builder.withMethod(Method.POST)
			.url(INDEX_SEARCH_URL).param(ENTITY_NAME_KEY, name)
			.param(ENTITY_ID_KEY, id.toString());

	int retry = RETRY_COUNT;
	do {
		try {
			queue.add(options);

			// success no need to retry
			retry = 0;
		} catch (TransientFailureException ex) {
			retry--;
		}
	} while (retry > 0);
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
/**
 * Reset reservations in datastore to match those in RTDB. Reservations in RTDB are used
 * as the source of truth, corresponding reservations in datastore are updated to match
 * those in RTDB. Reservations in RTDB that do not exist in datastore are added to datastore.
 * Reservations that exist in datastore and do not exist in RTDB are updated in datastore
 * with status DELETED.
 *
 * Use of this endpoint should be followed by a user data sync.
 *
 * @param user User making request (injected by Endpoints)
 */
@ApiMethod(name = "reset", path = "reset")
public void reset(User user)
    throws UnauthorizedException {
  if (user == null) {
    throw new UnauthorizedException("Invalid credentials");
  }

  // Add Sync Reservations worker to queue.
  Queue queue = QueueFactory.getQueue("SyncReservationsQueue");

  TaskOptions taskOptions = TaskOptions.Builder
      .withUrl("/queue/syncres")
      .method(Method.GET);
  queue.add(taskOptions);
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
@Override
public void enqueueTask(String taskName, Map<String, String[]> paramMap) {

  checkNotNull(taskName);

  final Queue queue = QueueFactory.getDefaultQueue();
  final TaskOptions options = TaskOptions.Builder.withUrl(String.format(PATH_ADMIN_TASK, taskName));

  for (Map.Entry<String, String[]> param : paramMap.entrySet()) {
    for (String value : param.getValue()) {
      options.param(param.getKey(), value);
    }
  }

  try {
    queue.add(options);
    LOGGER.info("Added admin task to queue {}", taskName);
  } catch (TransientFailureException tfe) {
    LOGGER.error("Run admin task fail {} ", tfe.getMessage());
  }

}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
  String channelKey = getChannelKey();
  String filterText = req.getParameter("filterText");
  filterText = (filterText == null) ? "" : filterText;
  String tag = req.getParameter("tag");
  String requestId = req.getParameter("reqId");
  String userId = userService.getCurrentUser().getUserId();

  Queue queue = QueueFactory.getDefaultQueue();
  TaskOptions taskOptions = withUrl("/fetch")
      .param("displayStyle", req.getParameter("displayStyle"))
      .param("filterText", filterText)
      .param("key", channelKey)
      .param("networkCode", req.getParameter("networkCode"))
      .param("userId", userId)
      .param("tag", tag)
      .param("reqId", requestId)
      .param("typeOverride", req.getParameter("typeOverride"));

  queue.add(taskOptions.method(Method.GET));
  resp.getWriter().print(channelKey);
}
 

import com.google.appengine.api.taskqueue.Queue; //導入依賴的package包/類
List<TaskHandle> addToQueue(final Collection<Task> tasks) {
  List<TaskHandle> handles = new ArrayList<>();
  Map<String, List<TaskOptions>> queueNameToTaskOptions = new HashMap<>();
  for (Task task : tasks) {
    logger.finest("Enqueueing: " + task);
    String queueName = task.getQueueSettings().getOnQueue();
    TaskOptions taskOptions = toTaskOptions(task);
    List<TaskOptions> taskOptionsList = queueNameToTaskOptions.get(queueName);
    if (taskOptionsList == null) {
      taskOptionsList = new ArrayList<>();
      queueNameToTaskOptions.put(queueName, taskOptionsList);
    }
    taskOptionsList.add(taskOptions);
  }
  for (Map.Entry<String, List<TaskOptions>> entry : queueNameToTaskOptions.entrySet()) {
    Queue queue = getQueue(entry.getKey());
    handles.addAll(addToQueue(queue, entry.getValue()));
  }
  return handles;
}