Ejemplo n.º 1
0
 @Override
 public void log(LogMessage request, StreamObserver<EmptyMessage> responseObserver) {
   try {
     // FIXME put these in Cassandra and render in central UI
     LogEvent logEvent = request.getLogEvent();
     Proto.Throwable t = logEvent.getThrowable();
     if (t == null) {
       logger.warn(
           "{} -- {} -- {} -- {}",
           request.getServerId(),
           logEvent.getLevel(),
           logEvent.getLoggerName(),
           logEvent.getFormattedMessage());
     } else {
       logger.warn(
           "{} -- {} -- {} -- {}\n{}",
           request.getServerId(),
           logEvent.getLevel(),
           logEvent.getLoggerName(),
           logEvent.getFormattedMessage(),
           t);
     }
   } catch (Throwable t) {
     responseObserver.onError(t);
     return;
   }
   responseObserver.onNext(EmptyMessage.getDefaultInstance());
   responseObserver.onCompleted();
 }
Ejemplo n.º 2
0
  public void cancelAfterFirstResponse() throws Exception {
    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
    request.responseParameters = new Messages.ResponseParameters[1];
    request.responseParameters[0] = new ResponseParameters();
    request.responseParameters[0].size = 31415;
    request.payload = new Payload();
    request.payload.body = new byte[27182];
    final StreamingOutputCallResponse goldenResponse = new StreamingOutputCallResponse();
    goldenResponse.payload = new Payload();
    goldenResponse.payload.type = Messages.COMPRESSABLE;
    goldenResponse.payload.body = new byte[31415];

    ResponseObserver responseObserver = new ResponseObserver();
    StreamObserver<StreamingOutputCallRequest> requestObserver =
        asyncStub.fullDuplexCall(responseObserver);
    requestObserver.onNext(request);
    Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    if (!(response instanceof Messages.StreamingOutputCallResponse)) {
      fail("Unexpected: " + response);
    }
    assertMessageEquals(goldenResponse, (Messages.StreamingOutputCallResponse) response);

    requestObserver.onError(new RuntimeException());
    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    if (!(response instanceof Throwable)) {
      fail("Unexpected: " + response);
    }
    assertCodeEquals(io.grpc.Status.CANCELLED, io.grpc.Status.fromThrowable((Throwable) response));
  }
Ejemplo n.º 3
0
  public void halfDuplexCallShouldSucceed() throws Exception {
    // Build the request.
    Integer[] responseSizes = {50, 100, 150, 200};
    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
    request.responseParameters = new ResponseParameters[responseSizes.length];
    request.responseType = Messages.COMPRESSABLE;
    for (int i = 0; i < responseSizes.length; ++i) {
      request.responseParameters[i] = new ResponseParameters();
      request.responseParameters[i].size = responseSizes[i];
      request.responseParameters[i].intervalUs = 0;
    }

    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
    StreamObserver<StreamingOutputCallRequest> requestStream = asyncStub.halfDuplexCall(recorder);

    final int numRequests = 10;
    for (int ix = numRequests; ix > 0; --ix) {
      requestStream.onNext(request);
    }
    requestStream.onCompleted();
    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
    assertSuccess(recorder);
    assertEquals(responseSizes.length * numRequests, recorder.getValues().size());
    for (int ix = 0; ix < recorder.getValues().size(); ++ix) {
      StreamingOutputCallResponse response = recorder.getValues().get(ix);
      assertEquals(Messages.COMPRESSABLE, response.payload.type);
      int length = response.payload.body.length;
      int expectedSize = responseSizes[ix % responseSizes.length];
      assertEquals("comparison failed at index " + ix, expectedSize, length);
    }
  }
Ejemplo n.º 4
0
  public void gracefulShutdown() throws Exception {
    StreamingOutputCallRequest[] requests = new StreamingOutputCallRequest[3];
    requests[0] = new StreamingOutputCallRequest();
    requests[0].responseParameters = new ResponseParameters[1];
    requests[0].responseParameters[0] = new ResponseParameters();
    requests[0].responseParameters[0].size = 3;
    requests[0].payload = new Payload();
    requests[0].payload.body = new byte[2];
    requests[1] = new StreamingOutputCallRequest();
    requests[1].responseParameters = new ResponseParameters[1];
    requests[1].responseParameters[0] = new ResponseParameters();
    requests[1].responseParameters[0].size = 1;
    requests[1].payload = new Payload();
    requests[1].payload.body = new byte[7];
    requests[2] = new StreamingOutputCallRequest();
    requests[2].responseParameters = new ResponseParameters[1];
    requests[2].responseParameters[0] = new ResponseParameters();
    requests[2].responseParameters[0].size = 4;
    requests[2].payload = new Payload();
    requests[2].payload.body = new byte[1];

    StreamingOutputCallResponse[] goldenResponses = new StreamingOutputCallResponse[3];
    goldenResponses[0] = new StreamingOutputCallResponse();
    goldenResponses[0].payload = new Payload();
    goldenResponses[0].payload.type = Messages.COMPRESSABLE;
    goldenResponses[0].payload.body = new byte[3];
    goldenResponses[1] = new StreamingOutputCallResponse();
    goldenResponses[1].payload = new Payload();
    goldenResponses[1].payload.type = Messages.COMPRESSABLE;
    goldenResponses[1].payload.body = new byte[1];
    goldenResponses[2] = new StreamingOutputCallResponse();
    goldenResponses[2].payload = new Payload();
    goldenResponses[2].payload.type = Messages.COMPRESSABLE;
    goldenResponses[2].payload.body = new byte[4];

    ResponseObserver responseObserver = new ResponseObserver();
    StreamObserver<StreamingOutputCallRequest> requestObserver =
        asyncStub.fullDuplexCall(responseObserver);
    requestObserver.onNext(requests[0]);
    Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
    assertMessageEquals(goldenResponses[0], (Messages.StreamingOutputCallResponse) response);
    // Initiate graceful shutdown.
    channel.shutdown();
    // The previous ping-pong could have raced with the shutdown, but this one certainly shouldn't.
    requestObserver.onNext(requests[1]);
    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
    assertMessageEquals(goldenResponses[1], (Messages.StreamingOutputCallResponse) response);
    requestObserver.onNext(requests[2]);
    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
    assertMessageEquals(goldenResponses[2], (Messages.StreamingOutputCallResponse) response);
    requestObserver.onCompleted();
    assertEquals(
        responseObserver.magicTailResponse,
        responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
  }
Ejemplo n.º 5
0
 public void emptyStream() throws Exception {
   @SuppressWarnings("unchecked")
   ResponseObserver responseObserver = new ResponseObserver();
   StreamObserver<StreamingOutputCallRequest> requestObserver =
       asyncStub.fullDuplexCall(responseObserver);
   requestObserver.onCompleted();
   assertEquals(
       responseObserver.magicTailResponse,
       responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
 }
Ejemplo n.º 6
0
 public void cancelAfterBegin() throws Exception {
   StreamRecorder<StreamingInputCallResponse> responseObserver = StreamRecorder.create();
   StreamObserver<StreamingInputCallRequest> requestObserver =
       asyncStub.streamingInputCall(responseObserver);
   requestObserver.onError(new RuntimeException());
   assertTrue(responseObserver.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
   assertEquals(Arrays.<StreamingInputCallResponse>asList(), responseObserver.getValues());
   assertCodeEquals(
       io.grpc.Status.CANCELLED, io.grpc.Status.fromThrowable(responseObserver.getError()));
 }
Ejemplo n.º 7
0
 @Override
 public void collectTrace(TraceMessage request, StreamObserver<EmptyMessage> responseObserver) {
   try {
     traceRepository.collect(request.getServerId(), request.getTrace());
   } catch (Throwable t) {
     logger.error(t.getMessage(), t);
     responseObserver.onError(t);
     return;
   }
   responseObserver.onNext(EmptyMessage.getDefaultInstance());
   responseObserver.onCompleted();
 }
Ejemplo n.º 8
0
 @Override
 public void collectInit(InitMessage request, StreamObserver<EmptyMessage> responseObserver) {
   // FIXME store request.getConfig()
   try {
     serverRepository.storeProcessInfo(request.getServerId(), request.getProcessInfo());
   } catch (Throwable t) {
     logger.error(t.getMessage(), t);
     responseObserver.onError(t);
     return;
   }
   responseObserver.onNext(EmptyMessage.getDefaultInstance());
   responseObserver.onCompleted();
 }
Ejemplo n.º 9
0
 @Override
 public void asyncRecognize(
     AsyncRecognizeRequest request, StreamObserver<Operation> responseObserver) {
   Object response = responses.remove();
   if (response instanceof Operation) {
     requests.add(request);
     responseObserver.onNext((Operation) response);
     responseObserver.onCompleted();
   } else if (response instanceof Exception) {
     responseObserver.onError((Exception) response);
   } else {
     responseObserver.onError(new IllegalArgumentException("Unrecognized response type"));
   }
 }
Ejemplo n.º 10
0
 @Override
 public void collectAggregates(
     AggregateMessage request, StreamObserver<EmptyMessage> responseObserver) {
   try {
     aggregateRepository.store(
         request.getServerId(), request.getCaptureTime(), request.getAggregatesByTypeList());
   } catch (Throwable t) {
     logger.error(t.getMessage(), t);
     responseObserver.onError(t);
     return;
   }
   responseObserver.onNext(EmptyMessage.getDefaultInstance());
   responseObserver.onCompleted();
 }
Ejemplo n.º 11
0
  public void pingPong() throws Exception {
    final Messages.StreamingOutputCallRequest[] requests =
        new Messages.StreamingOutputCallRequest[4];
    for (int i = 0; i < 4; i++) {
      requests[i] = new Messages.StreamingOutputCallRequest();
      requests[i].responseParameters = new Messages.ResponseParameters[1];
      requests[i].responseParameters[0] = new Messages.ResponseParameters();
      requests[i].payload = new Payload();
    }
    requests[0].responseParameters[0].size = 31415;
    requests[0].payload.body = new byte[27182];
    requests[1].responseParameters[0].size = 9;
    requests[1].payload.body = new byte[8];
    requests[2].responseParameters[0].size = 2653;
    requests[2].payload.body = new byte[1828];
    requests[3].responseParameters[0].size = 58979;
    requests[3].payload.body = new byte[45904];

    final Messages.StreamingOutputCallResponse[] goldenResponses =
        new Messages.StreamingOutputCallResponse[4];
    for (int i = 0; i < 4; i++) {
      goldenResponses[i] = new Messages.StreamingOutputCallResponse();
      goldenResponses[i].payload = new Payload();
      goldenResponses[i].payload.type = Messages.COMPRESSABLE;
    }
    goldenResponses[0].payload.body = new byte[31415];
    goldenResponses[1].payload.body = new byte[9];
    goldenResponses[2].payload.body = new byte[2653];
    goldenResponses[3].payload.body = new byte[58979];

    @SuppressWarnings("unchecked")
    ResponseObserver responseObserver = new ResponseObserver();
    StreamObserver<Messages.StreamingOutputCallRequest> requestObserver =
        asyncStub.fullDuplexCall(responseObserver);
    for (int i = 0; i < requests.length; i++) {
      requestObserver.onNext(requests[i]);
      Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
      if (!(response instanceof Messages.StreamingOutputCallResponse)) {
        fail("Unexpected: " + response);
      }
      assertMessageEquals(goldenResponses[i], (Messages.StreamingOutputCallResponse) response);
      assertTrue(
          "More than 1 responses received for ping pong test.",
          responseObserver.responses.isEmpty());
    }
    requestObserver.onCompleted();
    assertEquals(
        responseObserver.magicTailResponse,
        responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
  }
Ejemplo n.º 12
0
  @Override
  public void executeSynchronously(
      RemoteWorkRequest request, StreamObserver<RemoteWorkResponse> responseObserver) {
    Path tempRoot = workPath.getRelative("build-" + UUID.randomUUID().toString());
    try {
      FileSystemUtils.createDirectoryAndParents(tempRoot);
      final ConcurrentMapActionCache actionCache = new ConcurrentMapActionCache(tempRoot, cache);
      final MemcacheWorkExecutor workExecutor =
          MemcacheWorkExecutor.createLocalWorkExecutor(actionCache, tempRoot);
      if (LOG_FINER) {
        LOG.fine(
            "Work received has "
                + request.getInputFilesCount()
                + " input files and "
                + request.getOutputFilesCount()
                + " output files.");
      }
      RemoteWorkResponse response = workExecutor.executeLocally(request);
      responseObserver.onNext(response);
      if (options.debug) {
        if (!response.getSuccess()) {
          LOG.warning("Work failed. Request: " + request.toString() + ".");

        } else if (LOG_FINER) {
          LOG.fine("Work completed.");
        }
      }
      if (!options.debug || response.getSuccess()) {
        FileSystemUtils.deleteTree(tempRoot);
      } else {
        LOG.warning("Preserving work directory " + tempRoot.toString() + ".");
      }
    } catch (IOException | InterruptedException e) {
      RemoteWorkResponse.Builder response = RemoteWorkResponse.newBuilder();
      response.setSuccess(false).setOut("").setErr("").setException(e.toString());
      responseObserver.onNext(response.build());
      if (e instanceof InterruptedException) {
        Thread.currentThread().interrupt();
      }
    } finally {
      responseObserver.onCompleted();
    }
  }
Ejemplo n.º 13
0
  /** Start a fullDuplexCall which the server will not respond, and verify the deadline expires. */
  public void timeoutOnSleepingServer() throws Exception {
    TestServiceGrpc.TestService stub =
        TestServiceGrpc.newStub(channel).withDeadlineAfter(1, TimeUnit.MILLISECONDS);
    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
    StreamObserver<StreamingOutputCallRequest> requestObserver = stub.fullDuplexCall(recorder);

    try {
      StreamingOutputCallRequest request = new StreamingOutputCallRequest();
      request.payload = new Messages.Payload();
      request.payload.body = new byte[27182];
      requestObserver.onNext(request);
    } catch (IllegalStateException expected) {
      // This can happen if the stream has already been terminated due to deadline exceeded.
    }

    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
    assertCodeEquals(
        io.grpc.Status.DEADLINE_EXCEEDED, io.grpc.Status.fromThrowable(recorder.getError()));
  }
Ejemplo n.º 14
0
  public void clientStreaming() throws Exception {
    final Messages.StreamingInputCallRequest[] requests = new Messages.StreamingInputCallRequest[4];
    for (int i = 0; i < 4; i++) {
      requests[i] = new Messages.StreamingInputCallRequest();
      requests[i].payload = new Payload();
    }
    requests[0].payload.body = new byte[27182];
    requests[1].payload.body = new byte[8];
    requests[2].payload.body = new byte[1828];
    requests[3].payload.body = new byte[45904];

    final Messages.StreamingInputCallResponse goldenResponse =
        new Messages.StreamingInputCallResponse();
    goldenResponse.aggregatedPayloadSize = 74922;

    StreamRecorder<Messages.StreamingInputCallResponse> responseObserver = StreamRecorder.create();
    StreamObserver<Messages.StreamingInputCallRequest> requestObserver =
        asyncStub.streamingInputCall(responseObserver);
    for (Messages.StreamingInputCallRequest request : requests) {
      requestObserver.onNext(request);
    }
    requestObserver.onCompleted();
    assertMessageEquals(goldenResponse, responseObserver.firstValue().get());
  }
Ejemplo n.º 15
0
 private ClientResponse sendRequest(ServerRequest request) throws Exception {
   ResponseHolder responseHolder = new ResponseHolder();
   responseHolders.put(request.getRequestId(), responseHolder);
   requestObserver.onNext(request);
   // timeout is in case agent never responds
   // passing ClientResponse.getDefaultInstance() is just dummy (non-null) value
   ClientResponse response =
       responseHolder.response.exchange(ClientResponse.getDefaultInstance(), 1, HOURS);
   if (response.getMessageCase() == MessageCase.UNKNOWN_REQUEST_RESPONSE) {
     throw new OutdatedAgentException();
   }
   if (response.getMessageCase() == MessageCase.EXCEPTION_RESPONSE) {
     throw new AgentException();
   }
   return response;
 }
Ejemplo n.º 16
0
 @Override
 public void onFailure(final Throwable throwable) {
   responseObserver.onValue(
       AddDataPointResponse.newBuilder().setMessage(throwable.getMessage()).build());
   responseObserver.onCompleted();
 }
Ejemplo n.º 17
0
 @Override
 public void onSuccess(@Nullable final Void result) {
   responseObserver.onValue(AddDataPointResponse.newBuilder().setMessage("OK").build());
   responseObserver.onCompleted();
 }
Ejemplo n.º 18
0
 @Override
 public void sayHello(HelloRequest req, StreamObserver<HelloResponse> responseObserver) {
   HelloResponse reply = HelloResponse.newBuilder().setMessage("Hello " + req.getName()).build();
   responseObserver.onValue(reply);
   responseObserver.onCompleted();
 }