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;
}
