private void leaveGroup(long time) {
   if (Timing.isEnabled() && currentGroup != null) {
     Timing.stop(requestTimer, time);
     requestTimer = null;
     currentGroup = null;
     Timing.exitScope();
   }
 }
 private void enterGroup(String group, long time) {
   if (Timing.isEnabled()) {
     Timing.enterScope();
     requestTimer = Timing.startRequest(GWT_PREFIX + group);
     requestTimer.start(time);
     currentGroup = group;
   }
 }
Exemplo n.º 3
0
 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
     throws IOException, ServletException {
   HttpServletRequest req = (HttpServletRequest) request;
   Timer timer = Timing.startRequest(req.getRequestURI());
   try {
     chain.doFilter(req, response);
   } finally {
     Timing.stop(timer);
   }
 }
Exemplo n.º 4
0
 private void loadStageOne(final StageZero zero) {
   final Timer timer = Timing.start("Stage One");
   createStageOneLoader(zero)
       .call(
           new Accessor<StageOne>() {
             @Override
             public void use(StageOne x) {
               Timing.stop(timer);
               loadStageTwo(x);
             }
           });
 }
Exemplo n.º 5
0
 private void loadStageZero() {
   final Timer timer = Timing.start("Stage Zero");
   createStageZeroLoader()
       .call(
           new Accessor<StageZero>() {
             @Override
             public void use(StageZero x) {
               Timing.stop(timer);
               loadStageOne(x);
             }
           });
 }
 @Override
 public void onStatisticsEvent(StatisticsEvent event) {
   String group = event.getEventGroupKey();
   String type = (String) event.getExtraParameter(PARAM_TYPE);
   if (TYPE_BEGIN.equals(type)) {
     enterGroup(group, (long) event.getMillis());
   } else {
     if (TYPE_END.equals(type)) {
       leaveGroup((long) event.getMillis());
     } else {
       if (!group.equals(currentGroup)) {
         leaveGroup((long) event.getMillis());
         enterGroup(group, (long) event.getMillis());
       }
       Timing.record(GWT_PREFIX + type, (int) ((long) event.getMillis() - previousCallTimestamp));
     }
   }
   previousCallTimestamp = (long) event.getMillis();
 }
Exemplo n.º 7
0
  private void loadStageTwo(final StageOne one) {
    final Timer timer = Timing.start("Stage Two");
    SchedulerInstance.getHighPriorityTimer()
        .schedule(
            new Scheduler.Task() {

              @Override
              public void execute() {
                createStageTwoLoader(one)
                    .call(
                        new Accessor<StageTwo>() {
                          @Override
                          public void use(StageTwo x) {
                            Timing.stop(timer);
                            loadStageThree(x);
                          }
                        });
              }
            });
  }
Exemplo n.º 8
0
  private void loadStageThree(final StageTwo two) {
    final Timer timer = Timing.start("Stage Tree");
    SchedulerInstance.getHighPriorityTimer()
        .schedule(
            new Scheduler.Task() {

              @Override
              public void execute() {
                createStageThreeLoader(two)
                    .call(
                        new Accessor<StageThree>() {
                          @Override
                          public void use(StageThree x) {
                            Timing.stop(timer);
                            finish();
                          }
                        });
              }
            });
  }
Exemplo n.º 9
0
    @Override
    public void message(final int sequenceNo, Message message) {
      final String messageName = "/" + message.getClass().getSimpleName();
      final Timer profilingTimer = Timing.startRequest(messageName);
      if (message instanceof Rpc.CancelRpc) {
        final ServerRpcController controller = activeRpcs.get(sequenceNo);
        if (controller == null) {
          throw new IllegalStateException("Trying to cancel an RPC that is not active!");
        } else {
          LOG.info("Cancelling open RPC " + sequenceNo);
          controller.cancel();
        }
      } else if (message instanceof ProtocolAuthenticate) {
        // Workaround for bug: http://codereview.waveprotocol.org/224001/

        // When we get this message, either the connection will not be logged in
        // (loggedInUser == null) or the connection will have been authenticated
        // via cookies
        // (in which case loggedInUser must match the authenticated user, and
        // this message has no
        // effect).

        ProtocolAuthenticate authMessage = (ProtocolAuthenticate) message;
        ParticipantId authenticatedAs = authenticate(authMessage.getToken());

        Preconditions.checkArgument(authenticatedAs != null, "Auth token invalid");
        Preconditions.checkState(
            loggedInUser == null || loggedInUser.equals(authenticatedAs),
            "Session already authenticated as a different user");

        loggedInUser = authenticatedAs;
        LOG.info("Session authenticated as " + loggedInUser);
        sendMessage(sequenceNo, ProtocolAuthenticationResult.getDefaultInstance());
      } else if (provider.registeredServices.containsKey(message.getDescriptorForType())) {
        if (activeRpcs.containsKey(sequenceNo)) {
          throw new IllegalStateException(
              "Can't invoke a new RPC with a sequence number already in use.");
        } else {
          final RegisteredServiceMethod serviceMethod =
              provider.registeredServices.get(message.getDescriptorForType());

          // Create the internal ServerRpcController used to invoke the call.
          final ServerRpcController controller =
              new ServerRpcControllerImpl(
                  message,
                  serviceMethod.service,
                  serviceMethod.method,
                  loggedInUser,
                  new RpcCallback<Message>() {
                    @Override
                    public synchronized void run(Message message) {
                      if (message instanceof Rpc.RpcFinished
                          || !serviceMethod.method.getOptions().getExtension(Rpc.isStreamingRpc)) {
                        // This RPC is over - remove it from the map.
                        boolean failed =
                            message instanceof Rpc.RpcFinished
                                ? ((Rpc.RpcFinished) message).getFailed()
                                : false;
                        LOG.fine("RPC " + sequenceNo + " is now finished, failed = " + failed);
                        if (failed) {
                          LOG.info("error = " + ((Rpc.RpcFinished) message).getErrorText());
                        }
                        activeRpcs.remove(sequenceNo);
                      }
                      sendMessage(sequenceNo, message);
                      if (profilingTimer != null) {
                        Timing.stop(profilingTimer);
                      }
                    }
                  });

          // Kick off a new thread specific to this RPC.
          activeRpcs.put(sequenceNo, controller);
          provider.threadPool.execute(controller);
        }
      } else {
        // Sent a message type we understand, but don't expect - erronous case!
        throw new IllegalStateException(
            "Got expected but unknown message  (" + message + ") for sequence: " + sequenceNo);
      }
    }