Difference between revisions of "E4/EAS/Status Handling"

Revision as of 15:41, 29 October 2009

(Status: in progress)

Something unexpected happened in a component, for example:

• an operation requested by the user could not be performed at all
• an operation could only be performed partially
• an exception happened, but there is no immediate consequence for the user

Typically, in these situation, some or all of the following are known:

• how severe the situation is
• if the user needs to be informed
• if the user can do anything about it
• a string describing the unexpected situation
• an exception
• an application-specific object that should be made available to application-level error handling code

Eclipse 3.x API

public void foo() {
  try {
    // some operation
  } catch (SomeException ex) {
    Status failStatus = new Status(IStatus.ERROR, "myPluginId", "Error Message", ex);
    StatusManager.getManager().handle(failStatus, StatusManager.SHOW| StatusManager.LOG);
  }
}

Critique:

• The API does not separate the client API (notifying about a problem) from the service provider API (acting on a problem).
  • The calling code has to know how the info is presented (BLOCK, SHOW, LOG)
  • There is no way to hook in and override or augment the error info between the time the client reports it and the time the service provider shows it.
• The API is currently defined in a UI bundle and as such is not available to lower level bundles.
• We use the Singleton Pattern and thus each client must provide information about itself (like e.g. the plugin id) that could be computed automatically.
• There is no relationship between global error reporting schemes (log, error dialog) and local error reporting schemes (status dialogs, wizard pages, etc.). If the user opens a wizard that triggers some background work, they expect the status to be reported in the wizard rather than be interrupted by a dialog.
• Some asynchronous errors are expected by the calling code and there is no easy way to specify what actions are suggested or could be taken by the user when the error is reported (Bug 273137).

e4 (Java)

Clients should be able to write something like:

@Inject Provider<StatusHandler> statusHandler;
@Inject Provider<StatusReportingService> statusReportingService;
 
public void foo() {
  try {
    // some operation
  } catch (SomeException ex) {
    statusHandler.get().handle(ex, IStatus.ERROR, "some message", statusReportingService.get());
  }
}

The calling code should be dead simple. The only thing the client should have to care about is what they know (if anything) about the error when it happens. Any complexity in how the error surfaces is handled in the injected services.

Client code

• The calling code expects some errors and has predefined user messages to describe it
• Unexpected exceptions percolate to a global handler as today

StatusHandler

• StatusHandler consults with registered interpreters
• Status may surface as originally reported or get augmented or reinterpreted depending on configuration.
• Status finally gets surfaced via the reporting service

StatusReportingService

• The StatusReportingService decides how the error is shown (in a wizard, in an error dialog, etc.)
• A smart status reporting service may be able to offer assistance to the user (quick fixes, take the user back to where they launched the asynch op that failed, help)
• Do we want the ability to chain these? (report to the user and log to the help desk)