code: public void call(final T request, final Functor<String, RemoteService.Response> process, final Functor<Void, RemoteService.Response> confirm) {
          try {
              String message = process.invoke(RemoteService.call(location, endpoint, true, request));
              if (message != null) {
                  // clean failure
                  throw new RuntimeException(message);
              }
          } catch (RuntimeException x) {
              if (confirm == null) {
                  executor.execute(new VitalTask<Reporting, Void>(reporting) {
                      protected Void execute() throws Exception {
                          if (getAge() > DEFAULT_RETRY_LIMIT) {
                              try { process.invoke(null); } catch (Exception x) {}
                          } else {
                              process.invoke(RemoteService.call(location, recovery, repacker.invoke(request)));
                          }
                          return null;
                      }
                  });
                  // positive!
              } else {
                  executor.execute(new VitalTask<Reporting, Void>(reporting) {
                      protected Void execute() throws Exception {
                          if (getAge() > DEFAULT_RETRY_LIMIT) {
                              return null;
                          } else {
                              confirm.invoke(RemoteService.call(location, recovery, repacker.invoke(request)));
                          }
                          return null;
                      }
                  });
                  // negative!
                  throw x;
              }
          }
      }
docs: Starts a critical call and automatically manages uncertain outcomes.
  
  @param request - the request packet
  @param process - a functor that processes an invocation/retransmission response. This functor's invoke method must
  <ol>
  <li>return null if the call is successful</li>
  <li>return a non-null message if the call ends in a clean failure</li>
  <li>throw a RuntimeException if the outcome is uncertain</li>
  </ol>
  If the retransmission limit has been reached, this functor is invoked for the last time with a null argument to allow any fallback
  processing deemed necessary. Any exception thrown during this invocation is silently ignored.
  @param confirm - a functor to confirm that a rollback response is positive, and to throw an exception otherwise. This functor can be null
  to indicate that the remote call should be retransmissted rather than rolled back.