private String[] setStandardTime(String requestUid, String time, User user) { final ZonedDateTime proposedDateTime; final String dateTimePrompt = getMessage(thisSection, "confirm", "time." + time, user); ZonedDateTime zonedNow = Instant.now().atZone(DateTimeUtil.getSAST()); switch (time) { case "instant": proposedDateTime = zonedNow.plusMinutes(7L).truncatedTo(ChronoUnit.SECONDS); break; case "hour": proposedDateTime = zonedNow.plusHours(1L); break; case "day": proposedDateTime = zonedNow.plusDays(1L); break; case "week": proposedDateTime = zonedNow.plusWeeks(1L); break; default: // this should never be called, but need it else Java throws error -- defaulting to instant proposedDateTime = zonedNow.plusMinutes(7L); break; } eventRequestBroker.updateEventDateTime( user.getUid(), requestUid, proposedDateTime.toLocalDateTime()); EventRequest voteRequest = eventRequestBroker.load(requestUid); return new String[] {voteRequest.getName(), dateTimePrompt}; }
/** The 'refType' is known to match, return the EventRequest. */ EventRequest resolveEventRequest(ReferenceType refType) throws NoSuchFieldException { Field field = refType.fieldByName(fieldId); EventRequestManager em = refType.virtualMachine().eventRequestManager(); EventRequest wp = em.createAccessWatchpointRequest(field); wp.setSuspendPolicy(suspendPolicy); wp.enable(); return wp; }
/* Final menu asks for confirmation, then sends out */ @RequestMapping(value = path + "confirm") @ResponseBody public Request voteConfirm( @RequestParam(value = phoneNumber) String inputNumber, @RequestParam(value = entityUidParam) String requestUid, @RequestParam(value = userInputParam) String userInput, @RequestParam(value = "time", required = false) String time, @RequestParam(value = "field", required = false) String field, @RequestParam(value = interruptedFlag, required = false) boolean interrupted) throws URISyntaxException { User user = userManager.findByInputNumber(inputNumber, saveVoteMenu("confirm", requestUid)); String[] promptFields; if (!interrupted) { switch (field) { case "standard": promptFields = setStandardTime(requestUid, time, user); break; case "custom": promptFields = setCustomTime(requestUid, userInput, user); break; case "issue": promptFields = adjustSubject(requestUid, userInput, user); break; default: promptFields = new String[] {"Error!", "Error occurred!"}; break; } } else { EventRequest vote = eventRequestBroker.load(requestUid); promptFields = new String[] { vote.getName(), "at " + vote.getEventDateTimeAtSAST().format(dateTimeFormat) }; } USSDMenu menu = new USSDMenu(getMessage(thisSection, "confirm", promptKey, promptFields, user)); menu.addMenuOption( voteMenus + "send" + entityUidUrlSuffix + requestUid, getMessage(thisSection, "confirm", optionsKey + "yes", user)); menu.addMenuOption( backVoteUrl("issue", requestUid), getMessage(thisSection, "confirm", optionsKey + "topic", user)); menu.addMenuOption( backVoteUrl("time", requestUid), getMessage(thisSection, "confirm", optionsKey + "time", user)); return menuBuilder(menu); }
/** * Requests monitoring of an event. * * <p>The debugger registers for event notification through an event filter. If no event filter is * specified for an event in the VM, it is assumed that the debugger is not interested in * receiving notifications of this event. * * <p>The virtual machine will be notified of the request. * * @param request the request to monitor * @throws InvalidEventTypeException for invalid event kind * @throws JdwpException for other errors involving request */ public void requestEvent(EventRequest request) throws JdwpException { // Add request to request list Hashtable requests; Byte kind = new Byte(request.getEventKind()); requests = (Hashtable) _requests.get(kind); if (requests == null) { // Did not get a valid event type throw new InvalidEventTypeException(request.getEventKind()); } // Register the event with the VM VMVirtualMachine.registerEvent(request); requests.put(new Integer(request.getId()), request); }
public void run() { Event event = request.getEvent(); if (logger.isDebugEnabled()) logger.debug("Processing event: " + event.getClass().getSimpleName()); EventStatus status = null; try { if (request.isCancelRequested()) { // If the event is cancelled note it. status = new EventStatus(false, true, null); if (logger.isDebugEnabled()) logger.debug("Skipped cancelled event: " + event.getClass().getSimpleName()); } else { // Mark the request as started and submit to state machine. request.started(); sm.applyEvent(event); status = new EventStatus(true, false, null); if (logger.isDebugEnabled()) logger.debug("Applied event: " + event.getClass().getSimpleName()); } } catch (InterruptedException e) { // Handle an interruption, which could happen if we are cancelled // while executing. status = new EventStatus(false, true, e); logger.debug( String.format("Failed to apply event %s, reason=%s", event, e.getLocalizedMessage())); } catch (Throwable e) { // Handle a failure. status = new EventStatus(false, false, e); logger.debug( String.format("Failed to apply event %s, reason=%s", event, e.getLocalizedMessage())); } finally { // We need to store the status and call the completion // listener, if any. This must happen regardless of any // exception that occurs. try { if (listener != null) request.setAnnotation(listener.onCompletion(event, status)); } catch (InterruptedException e) { // Do nothing; this is the end of the road for this task. } catch (Throwable e) { logger.error("Unexpected failure while calling listener", e); } finally { // Make sure we record the request state no matter what to // prevent hangs. request.setStatus(status); } } }
private String[] adjustSubject(String requestUid, String userInput, User user) { String dateTime; eventRequestBroker.updateName(user.getUid(), requestUid, userInput); EventRequest vote = eventRequestBroker.load(requestUid); if (vote.getEventStartDateTime().isBefore(Instant.now().plus(7, ChronoUnit.MINUTES))) { // user is manipulating an "instant" vote so need to reset the counter, else may expire before // send eventRequestBroker.updateEventDateTime( user.getUid(), requestUid, LocalDateTime.now().plusMinutes(7L)); dateTime = getMessage(thisSection, "confirm", "time.instant", user); } else { // need a quick way to do "at" in i18n dateTime = "at " + vote.getEventDateTimeAtSAST().format(dateTimeFormat); } return new String[] {userInput, dateTime}; }
/** * Returns a request for the given event. This method will only be used if the <code>EventManager * </code> is handling event filtering. * * @param event the event * @return request that was interested in this event or <code>null</code> if none (and event * should not be sent) * @throws IllegalArgumentException for invalid event kind */ public EventRequest getEventRequest(Event event) { EventRequest interestedRequest = null; Hashtable requests; Byte kind = new Byte(event.getEventKind()); requests = (Hashtable) _requests.get(kind); if (requests == null) { // Did not get a valid event type throw new IllegalArgumentException("invalid event kind: " + kind); } boolean match = false; // Loop through the requests. Must look at ALL requests in order // to evaluate all filters (think count filter). // TODO: What if multiple matches? Spec isn't so clear on this. Iterator rIter = requests.values().iterator(); while (rIter.hasNext()) { EventRequest request = (EventRequest) rIter.next(); if (request.matches(event)) interestedRequest = request; } return interestedRequest; }
EventDestination destination() { /* * We need to decide if this event is for * 1. an internal request * 2. a client request that is no longer available, ie * it has been deleted, or disabled and re-enabled * which gives it a new ID. * 3. a current client request that is disabled * 4. a current enabled client request. * * We will filter this set into a set * that contains only 1s for our internal queue * and a set that contains only 4s for our client queue. * If we get an EventSet that contains only 2 and 3 * then we have to resume it if it is not SUSPEND_NONE * because no one else will. */ if (requestID == 0) { /* An unsolicited event. These have traditionally * been treated as client events. */ return EventDestination.CLIENT_EVENT; } // Is this an event for a current client request? if (request == null) { // Nope. Is it an event for an internal request? EventRequestManagerImpl ermi = this.vm.getInternalEventRequestManager(); if (ermi.request(eventCmd, requestID) != null) { // Yep return EventDestination.INTERNAL_EVENT; } return EventDestination.UNKNOWN_EVENT; } // We found a client request if (request.isEnabled()) { return EventDestination.CLIENT_EVENT; } return EventDestination.UNKNOWN_EVENT; }