/**
 * Generate the report with the data recorded this LB stream since the last report.
 */
ClientStats generateLoadReport() {
  ClientStats.Builder statsBuilder =
      ClientStats.newBuilder()
      .setTimestamp(Timestamps.fromNanos(time.currentTimeNanos()))
      .setNumCallsStarted(callsStartedUpdater.getAndSet(this, 0))
      .setNumCallsFinished(callsFinishedUpdater.getAndSet(this, 0))
      .setNumCallsFinishedWithClientFailedToSend(callsFailedToSendUpdater.getAndSet(this, 0))
      .setNumCallsFinishedKnownReceived(callsFinishedKnownReceivedUpdater.getAndSet(this, 0));

  Map<String, LongHolder> localCallsDroppedPerToken = Collections.emptyMap();
  synchronized (this) {
    if (!callsDroppedPerToken.isEmpty()) {
      localCallsDroppedPerToken = callsDroppedPerToken;
      callsDroppedPerToken = new HashMap<String, LongHolder>(localCallsDroppedPerToken.size());
    }
  }
  for (Entry<String, LongHolder> entry : localCallsDroppedPerToken.entrySet()) {
    statsBuilder.addCallsFinishedWithDrop(
        ClientStatsPerToken.newBuilder()
            .setLoadBalanceToken(entry.getKey())
            .setNumCalls(entry.getValue().num)
            .build());
  }
  return statsBuilder.build();
}
 

private static List<ChannelTraceEvent> toChannelTraceEvents(List<Event> events) {
  List<ChannelTraceEvent> channelTraceEvents = new ArrayList<>();
  for (Event event : events) {
    ChannelTraceEvent.Builder builder = ChannelTraceEvent.newBuilder()
        .setDescription(event.description)
        .setSeverity(Severity.valueOf(event.severity.name()))
        .setTimestamp(Timestamps.fromNanos(event.timestampNanos));
    if (event.channelRef != null) {
      builder.setChannelRef(toChannelRef(event.channelRef));
    }
    if (event.subchannelRef != null) {
      builder.setSubchannelRef(toSubchannelRef(event.subchannelRef));
    }
    channelTraceEvents.add(builder.build());
  }
  return Collections.unmodifiableList(channelTraceEvents);
}
 

private Span fromProto(Model.Span protoSpan) {
  Span span = new Span();
  span.traceId = asHexString(protoSpan.getTraceId());
  span.spanId = asHexString(protoSpan.getSpanId());
  span.operationName = protoSpan.getOperationName();
  span.serviceName = protoSpan.getProcess().getServiceName();
  span.startTimeMicros = Timestamps.toMicros(protoSpan.getStartTime());
  span.durationMicros = Durations.toMicros(protoSpan.getDuration());
  addTags(span, protoSpan.getTagsList());
  addTags(span, protoSpan.getProcess().getTagsList());
  if (protoSpan.getReferencesList().size() > 0) {
    SpanRef reference = protoSpan.getReferences(0);
    if (asHexString(reference.getTraceId()).equals(span.traceId)) {
      span.parentId = asHexString(protoSpan.getReferences(0).getSpanId());
    }
  }
  return span;
}
 

@Benchmark
@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime})
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public boolean createUser() throws Exception {
    final int count = counter.getAndIncrement();

    final PagePB.User.Builder user = PagePB.User.newBuilder();
    user.setId(count);
    user.setName(new String("Doug Lea"));
    user.setSex(1);
    user.setBirthday(Timestamps.fromMillis(System.currentTimeMillis()));
    user.setEmail(new String("[email protected]"));
    user.setMobile(new String("18612345678"));
    user.setAddress(new String("北京市 中关村 中关村大街1号 鼎好大厦 1605"));
    user.setIcon(new String("https://www.baidu.com/img/bd_logo1.png"));
    user.setStatus(1);
    user.setCreateTime(Timestamps.fromMillis(System.currentTimeMillis()));
    user.setUpdateTime(user.getCreateTime());
    List<Integer> permissions = new ArrayList<Integer>(
            Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 19, 88, 86, 89, 90, 91, 92));
    user.addAllPermissions(permissions);
    final PagePB.Request.Builder builder = PagePB.Request.newBuilder();
    return userService.createUser(builder.setUser(user.build()).build()).getState();

}
 

@Override
public PagePB.Response getUser(PagePB.Request request) {
    final long id = request.getId();
    final PagePB.User.Builder user = PagePB.User.newBuilder();
    user.setId(id);
    user.setName(new String("Doug Lea"));
    user.setSex(1);
    user.setBirthday(Timestamps.fromMillis(System.currentTimeMillis()));
    user.setEmail(new String("[email protected]"));
    user.setMobile(new String("18612345678"));
    user.setAddress(new String("北京市 中关村 中关村大街1号 鼎好大厦 1605"));
    user.setIcon(new String("https://www.baidu.com/img/bd_logo1.png"));
    user.setStatus(1);
    user.setCreateTime(Timestamps.fromMillis(System.currentTimeMillis()));
    user.setUpdateTime(user.getCreateTime());
    List<Integer> permissions = new ArrayList<Integer>(
            Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 19, 88, 86, 89, 90, 91, 92));
    user.addAllPermissions(permissions);

    return PagePB.Response.newBuilder().setUser(user.build()).build();
}
 

private static List<ChannelTraceEvent> toChannelTraceEvents(List<Event> events) {
  List<ChannelTraceEvent> channelTraceEvents = new ArrayList<>();
  for (Event event : events) {
    ChannelTraceEvent.Builder builder = ChannelTraceEvent.newBuilder()
        .setDescription(event.description)
        .setSeverity(Severity.valueOf(event.severity.name()))
        .setTimestamp(Timestamps.fromNanos(event.timestampNanos));
    if (event.channelRef != null) {
      builder.setChannelRef(toChannelRef(event.channelRef));
    }
    if (event.subchannelRef != null) {
      builder.setSubchannelRef(toSubchannelRef(event.subchannelRef));
    }
    channelTraceEvents.add(builder.build());
  }
  return Collections.unmodifiableList(channelTraceEvents);
}
 

private Span fromProto(Model.Span protoSpan) {
    Span span = new Span();
    span.traceId = asHexString(protoSpan.getTraceId());
    span.spanId = asHexString(protoSpan.getSpanId());
    span.operationName = protoSpan.getOperationName();
    span.serviceName = protoSpan.getProcess().getServiceName();
    span.startTimeMicros = Timestamps.toMicros(protoSpan.getStartTime());
    span.tags = new HashMap<>();
    for (Model.KeyValue kv : protoSpan.getTagsList()) {
        if (!Model.ValueType.STRING.equals(kv.getVType())) {
            continue;
        }
        String value = kv.getVStr();
        if (value != null) {
            span.tags.put(kv.getKey(), value);
        }
    }
    return span;
}
 

JobStats getJobStats(JobStatsRequest request) {
  final long startDate = Timestamps.toMillis(request.getStartDate());
  final long endDate = Timestamps.toMillis(request.getEndDate());

  final List<Integer> counts = store.getCounts(JOBS_STATS_TYPE_TO_SEARCH_QUERY_MAPPING.stream()
      .map(SimpleEntry::getValue)
      .map(searchQuery -> SearchQueryUtils.and(
          SearchQueryUtils.newRangeLong(JobIndexKeys.START_TIME.getIndexFieldName(), startDate, endDate, true, true),
          searchQuery))
      .toArray(SearchQuery[]::new));

  // same order as above
  final JobStats.Builder jobStats = JobStats.newBuilder();
  for (int i = 0; i < counts.size(); i++) {
    jobStats.addCounts(JobStats.JobCountWithType.newBuilder()
        .setType(JOBS_STATS_TYPE_TO_SEARCH_QUERY_MAPPING.get(i).getKey())
        .setCount(counts.get(i)));
  }
  return jobStats.build();
}
 

private void removeStaleData(Timestamp now) {
  // currentSlot != lastUsedSlot means stepping over to a new bucket.
  // The data in the new bucket should be thrown away before storing new data.
  int currentSlot = getCurrentSlot(now);
  if (lastOperationCompleteTime != null && lastUsedSlot >= 0) {
    Duration duration = Timestamps.between(lastOperationCompleteTime, now);
    // if 1) duration between the new added operation and last added one is longer than period
    // or 2) the duration is shorter than period but longer than time range of a single bucket
    //       and at the same time currentSlot == lastUsedSlot
    if ((Durations.toMillis(duration) >= Durations.toMillis(period))
        || (lastUsedSlot == currentSlot
            && Durations.toMillis(duration) > (Durations.toMillis(period) / buckets.length))) {
      for (OperationStageDurations bucket : buckets) {
        bucket.reset();
      }
    } else if (lastUsedSlot != currentSlot) {
      // currentSlot < lastUsedSlot means wrap around happened
      currentSlot = currentSlot < lastUsedSlot ? currentSlot + NumOfSlots : currentSlot;
      for (int i = lastUsedSlot + 1; i <= currentSlot; i++) {
        buckets[i % buckets.length].reset();
      }
    }
  }
}
 

void set(ExecutedActionMetadata metadata) {
  queuedToMatch =
      Timestamps.between(metadata.getQueuedTimestamp(), metadata.getWorkerStartTimestamp());
  matchToInputFetchStart =
      Timestamps.between(
          metadata.getWorkerStartTimestamp(), metadata.getInputFetchStartTimestamp());
  inputFetchStartToComplete =
      Timestamps.between(
          metadata.getInputFetchStartTimestamp(), metadata.getInputFetchCompletedTimestamp());
  inputFetchCompleteToExecutionStart =
      Timestamps.between(
          metadata.getInputFetchCompletedTimestamp(), metadata.getExecutionStartTimestamp());
  executionStartToComplete =
      Timestamps.between(
          metadata.getExecutionStartTimestamp(), metadata.getExecutionCompletedTimestamp());
  executionCompleteToOutputUploadStart =
      Timestamps.between(
          metadata.getExecutionCompletedTimestamp(), metadata.getOutputUploadStartTimestamp());
  outputUploadStartToComplete =
      Timestamps.between(
          metadata.getOutputUploadStartTimestamp(),
          metadata.getOutputUploadCompletedTimestamp());
  operationCount = 1;
}
 

private TimeSeries prepareMetric(MetricDescriptor requiredMetric, long metricValue) {
  TimeInterval interval =
      TimeInterval.newBuilder()
          .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))
          .build();
  TypedValue value = TypedValue.newBuilder().setInt64Value(metricValue).build();

  Point point = Point.newBuilder().setInterval(interval).setValue(value).build();

  List<Point> pointList = Lists.newArrayList();
  pointList.add(point);

  Metric metric = Metric.newBuilder().setType(requiredMetric.getName()).build();

  return TimeSeries.newBuilder().setMetric(metric).addAllPoints(pointList).build();
}
 

/**
 * Generate the report with the data recorded this LB stream since the last report.
 */
ClientStats generateLoadReport() {
  ClientStats.Builder statsBuilder =
      ClientStats.newBuilder()
      .setTimestamp(Timestamps.fromNanos(time.currentTimeNanos()))
      .setNumCallsStarted(callsStartedUpdater.getAndSet(this, 0))
      .setNumCallsFinished(callsFinishedUpdater.getAndSet(this, 0))
      .setNumCallsFinishedWithClientFailedToSend(callsFailedToSendUpdater.getAndSet(this, 0))
      .setNumCallsFinishedKnownReceived(callsFinishedKnownReceivedUpdater.getAndSet(this, 0));

  Map<String, LongHolder> localCallsDroppedPerToken = Collections.emptyMap();
  synchronized (this) {
    if (!callsDroppedPerToken.isEmpty()) {
      localCallsDroppedPerToken = callsDroppedPerToken;
      callsDroppedPerToken = new HashMap<>(localCallsDroppedPerToken.size());
    }
  }
  for (Entry<String, LongHolder> entry : localCallsDroppedPerToken.entrySet()) {
    statsBuilder.addCallsFinishedWithDrop(
        ClientStatsPerToken.newBuilder()
            .setLoadBalanceToken(entry.getKey())
            .setNumCalls(entry.getValue().num)
            .build());
  }
  return statsBuilder.build();
}
 

@Test
public void testExtractNestedTimestampMillis() throws Exception {
    Map<String, String> classPerTopic = new HashMap<String, String>();
    classPerTopic.put("*", TimestampedMessages.UnitTestTimestamp2.class.getName());
    Mockito.when(mConfig.getMessageTimestampName()).thenReturn("internal.timestamp");
    Mockito.when(mConfig.getProtobufMessageClassPerTopic()).thenReturn(classPerTopic);

    ProtobufMessageParser parser = new ProtobufMessageParser(mConfig);

    Timestamp timestamp = Timestamps.fromMillis(1405970352000L);

    TimestampedMessages.UnitTestTimestamp2 message = TimestampedMessages.UnitTestTimestamp2.newBuilder()
            .setInternal(TimestampedMessages.UnitTestTimestamp2.Internal.newBuilder().setTimestamp(timestamp).build()).build();
    assertEquals(1405970352000l,
            parser.extractTimestampMillis(new Message("test", 0, 0, null, message.toByteArray(), timestamp.getSeconds(), null)));

    timestamp = Timestamps.fromMillis(1405970352123l);
    message = TimestampedMessages.UnitTestTimestamp2.newBuilder()
            .setInternal(TimestampedMessages.UnitTestTimestamp2.Internal.newBuilder().setTimestamp(timestamp).build()).build();
    assertEquals(1405970352123l,
            parser.extractTimestampMillis(new Message("test", 0, 0, null, message.toByteArray(), timestamp.getSeconds(), null)));
}
 

@Test
public void testBuildEnqueued() {
  Timestamp expected = Timestamps.fromMillis(clock.advanceMillis(100));
  assertThat(BES_PROTO_UTIL.buildEnqueued(expected))
      .isEqualTo(
          PublishLifecycleEventRequest.newBuilder()
              .setServiceLevel(ServiceLevel.INTERACTIVE)
              .setProjectId(PROJECT_ID)
              .setBuildEvent(
                  OrderedBuildEvent.newBuilder()
                      .setStreamId(
                          StreamId.newBuilder()
                              .setBuildId(BUILD_REQUEST_ID)
                              .setComponent(BuildComponent.CONTROLLER))
                      .setSequenceNumber(1)
                      .setEvent(
                          BuildEvent.newBuilder()
                              .setEventTime(expected)
                              .setBuildEnqueued(BuildEnqueued.newBuilder())))
              .build());
}
 

@Test
public void testInvocationAttemptStarted() {
  Timestamp expected = Timestamps.fromMillis(clock.advanceMillis(100));
  assertThat(BES_PROTO_UTIL.invocationStarted(expected))
      .isEqualTo(
          PublishLifecycleEventRequest.newBuilder()
              .setServiceLevel(ServiceLevel.INTERACTIVE)
              .setProjectId(PROJECT_ID)
              .setBuildEvent(
                  OrderedBuildEvent.newBuilder()
                      .setStreamId(
                          StreamId.newBuilder()
                              .setBuildId(BUILD_REQUEST_ID)
                              .setInvocationId(BUILD_INVOCATION_ID)
                              .setComponent(BuildComponent.CONTROLLER))
                      .setSequenceNumber(1)
                      .setEvent(
                          BuildEvent.newBuilder()
                              .setEventTime(expected)
                              .setInvocationAttemptStarted(
                                  InvocationAttemptStarted.newBuilder().setAttemptNumber(1))))
              .build());
}
 

@Test
public void testInvocationAttemptFinished() {
  Timestamp expected = Timestamps.fromMillis(clock.advanceMillis(100));
  assertThat(BES_PROTO_UTIL.invocationFinished(expected, Result.COMMAND_SUCCEEDED))
      .isEqualTo(
          PublishLifecycleEventRequest.newBuilder()
              .setServiceLevel(ServiceLevel.INTERACTIVE)
              .setProjectId(PROJECT_ID)
              .setBuildEvent(
                  OrderedBuildEvent.newBuilder()
                      .setStreamId(
                          StreamId.newBuilder()
                              .setBuildId(BUILD_REQUEST_ID)
                              .setInvocationId(BUILD_INVOCATION_ID)
                              .setComponent(BuildComponent.CONTROLLER))
                      .setSequenceNumber(2)
                      .setEvent(
                          BuildEvent.newBuilder()
                              .setEventTime(expected)
                              .setInvocationAttemptFinished(
                                  InvocationAttemptFinished.newBuilder()
                                      .setInvocationStatus(
                                          BuildStatus.newBuilder()
                                              .setResult(Result.COMMAND_SUCCEEDED)))))
              .build());
}
 

@Test
public void testBuildFinished() {
  Timestamp expected = Timestamps.fromMillis(clock.advanceMillis(100));
  assertThat(BES_PROTO_UTIL.buildFinished(expected, Result.COMMAND_SUCCEEDED))
      .isEqualTo(
          PublishLifecycleEventRequest.newBuilder()
              .setServiceLevel(ServiceLevel.INTERACTIVE)
              .setProjectId(PROJECT_ID)
              .setBuildEvent(
                  OrderedBuildEvent.newBuilder()
                      .setStreamId(
                          StreamId.newBuilder()
                              .setBuildId(BUILD_REQUEST_ID)
                              .setComponent(BuildComponent.CONTROLLER))
                      .setSequenceNumber(2)
                      .setEvent(
                          BuildEvent.newBuilder()
                              .setEventTime(expected)
                              .setBuildFinished(
                                  BuildFinished.newBuilder()
                                      .setStatus(
                                          BuildStatus.newBuilder()
                                              .setResult(Result.COMMAND_SUCCEEDED)))))
              .build());
}
 

private void assertNextReport(
    InOrder inOrder, StreamObserver<LoadBalanceRequest> lbRequestObserver,
    long loadReportIntervalMillis, ClientStats expectedReport) {
  assertEquals(0, fakeClock.forwardTime(loadReportIntervalMillis - 1, TimeUnit.MILLISECONDS));
  inOrder.verifyNoMoreInteractions();
  assertEquals(1, fakeClock.forwardTime(1, TimeUnit.MILLISECONDS));
  assertEquals(1, fakeClock.numPendingTasks());
  inOrder.verify(lbRequestObserver).onNext(
      eq(LoadBalanceRequest.newBuilder()
          .setClientStats(
              ClientStats.newBuilder(expectedReport)
              .setTimestamp(Timestamps.fromNanos(fakeClock.getTicker().read()))
              .build())
          .build()));
}
 

static ServerData toServerData(ServerStats stats) {
  return ServerData
      .newBuilder()
      .setCallsStarted(stats.callsStarted)
      .setCallsSucceeded(stats.callsSucceeded)
      .setCallsFailed(stats.callsFailed)
      .setLastCallStartedTimestamp(Timestamps.fromNanos(stats.lastCallStartedNanos))
      .build();
}
 

static SocketData extractSocketData(SocketStats socketStats) {
  SocketData.Builder builder = SocketData.newBuilder();
  if (socketStats.data != null) {
    TransportStats s = socketStats.data;
    builder
        .setStreamsStarted(s.streamsStarted)
        .setStreamsSucceeded(s.streamsSucceeded)
        .setStreamsFailed(s.streamsFailed)
        .setMessagesSent(s.messagesSent)
        .setMessagesReceived(s.messagesReceived)
        .setKeepAlivesSent(s.keepAlivesSent)
        .setLastLocalStreamCreatedTimestamp(
            Timestamps.fromNanos(s.lastLocalStreamCreatedTimeNanos))
        .setLastRemoteStreamCreatedTimestamp(
            Timestamps.fromNanos(s.lastRemoteStreamCreatedTimeNanos))
        .setLastMessageSentTimestamp(
            Timestamps.fromNanos(s.lastMessageSentTimeNanos))
        .setLastMessageReceivedTimestamp(
            Timestamps.fromNanos(s.lastMessageReceivedTimeNanos))
        .setLocalFlowControlWindow(
            Int64Value.of(s.localFlowControlWindow))
        .setRemoteFlowControlWindow(
            Int64Value.of(s.remoteFlowControlWindow));
  }
  builder.addAllOption(toSocketOptionsList(socketStats.socketOptions));
  return builder.build();
}
 

static ChannelData extractChannelData(InternalChannelz.ChannelStats stats) {
  ChannelData.Builder builder = ChannelData.newBuilder();
  builder.setTarget(stats.target)
      .setState(toChannelConnectivityState(stats.state))
      .setCallsStarted(stats.callsStarted)
      .setCallsSucceeded(stats.callsSucceeded)
      .setCallsFailed(stats.callsFailed)
      .setLastCallStartedTimestamp(Timestamps.fromNanos(stats.lastCallStartedNanos));
  if (stats.channelTrace != null) {
    builder.setTrace(toChannelTrace(stats.channelTrace));
  }
  return builder.build();
}
 

private static ChannelTrace toChannelTrace(InternalChannelz.ChannelTrace channelTrace) {
  return ChannelTrace.newBuilder()
      .setNumEventsLogged(channelTrace.numEventsLogged)
      .setCreationTimestamp(Timestamps.fromNanos(channelTrace.creationTimeNanos))
      .addAllEvents(toChannelTraceEvents(channelTrace.events))
      .build();
}
 

/**
 * Converts a {@link Event} into Jaeger's {@link Model.Log}.
 *
 * @param event the timed event to be converted
 * @return a Jaeger log
 */
@VisibleForTesting
static Model.Log toJaegerLog(Event event) {
  Model.Log.Builder builder = Model.Log.newBuilder();
  builder.setTimestamp(Timestamps.fromNanos(event.getEpochNanos()));

  // name is a top-level property in OpenTelemetry
  builder.addFields(
      Model.KeyValue.newBuilder().setKey(KEY_LOG_MESSAGE).setVStr(event.getName()).build());
  builder.addAllFields(toKeyValues(event.getAttributes()));

  return builder.build();
}
 

@Override
public PagePB.Response listUser(PagePB.Request request) {

    final PagePB.Page.Builder page = PagePB.Page.newBuilder();
    List<PagePB.User> userList = new ArrayList<>(15);

    for (int i = 0; i < 15; i++) {
        final PagePB.User.Builder user = PagePB.User.newBuilder();

        user.setId(i);
        user.setName(new String("Doug Lea"));
        user.setSex(1);
        user.setBirthday(Timestamps.fromMillis(System.currentTimeMillis()));
        user.setEmail(new String("[email protected]"));
        user.setMobile(new String("18612345678"));
        user.setAddress(new String("北京市 中关村 中关村大街1号 鼎好大厦 1605"));
        user.setIcon(new String("https://www.baidu.com/img/bd_logo1.png"));
        user.setStatus(1);
        user.setCreateTime(Timestamps.fromMillis(System.currentTimeMillis()));
        user.setUpdateTime(user.getCreateTime());
        List<Integer> permissions = new ArrayList<Integer>(
                Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 19, 88, 86, 89, 90, 91, 92));
        user.addAllPermissions(permissions);
        userList.add(user.build());
    }

    page.setPageNo(request.getPage());
    page.setTotal(1000);
    page.addAllUsers(userList);

    return PagePB.Response.newBuilder().setPage(page.build()).build();
}
 

public ArrayList<FeatureProtos> spatialTemporalQuery() throws ParseException {
  LOGGER.info("Performing Spatial Temporal Query...");
  final VectorStoreParametersProtos baseParams =
      VectorStoreParametersProtos.newBuilder().setStoreName(
          GeoWaveGrpcTestUtils.storeName).build();

  final TimeZone tz = TimeZone.getTimeZone("UTC");
  final DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm'Z'"); // Quoted "Z" to indicate
  // UTC,
  // no timezone offset
  df.setTimeZone(tz);

  final SpatialQueryParametersProtos spatialQuery =
      SpatialQueryParametersProtos.newBuilder().setBaseParams(baseParams).setGeometry(
          copyFrom(GeoWaveGrpcTestUtils.wkbSpatialQuery)).build();
  final TemporalConstraintsProtos t =
      TemporalConstraintsProtos.newBuilder().setStartTime(
          Timestamps.fromMillis(
              df.parse(GeoWaveGrpcTestUtils.temporalQueryStartTime).getTime())).setEndTime(
                  Timestamps.fromMillis(
                      df.parse(GeoWaveGrpcTestUtils.temporalQueryEndTime).getTime())).build();
  final SpatialTemporalQueryParametersProtos request =
      SpatialTemporalQueryParametersProtos.newBuilder().setSpatialParams(
          spatialQuery).addTemporalConstraints(0, t).setCompareOperation("CONTAINS").build();

  Iterator<FeatureProtos> features;
  final ArrayList<FeatureProtos> feature_list = new ArrayList<>();
  features = vectorBlockingStub.spatialTemporalQuery(request);

  // iterate over features
  while (features.hasNext()) {
    final FeatureProtos feature = features.next();
    feature_list.add(feature);
  }
  return feature_list;
}
 

@Override
public void listUser(PagePB.Request request, StreamObserver<PagePB.Response> responseObserver) {
    final PagePB.Page.Builder page = PagePB.Page.newBuilder();
    List<PagePB.User> userList = new ArrayList<>(15);

    for (int i = 0; i < 15; i++) {
        final PagePB.User.Builder user = PagePB.User.newBuilder();

        user.setId(i);
        user.setName(new String("Doug Lea"));
        user.setSex(1);
        user.setBirthday(Timestamps.fromMillis(System.currentTimeMillis()));
        user.setEmail(new String("[email protected]"));
        user.setMobile(new String("18612345678"));
        user.setAddress(new String("北京市 中关村 中关村大街1号 鼎好大厦 1605"));
        user.setIcon(new String("https://www.baidu.com/img/bd_logo1.png"));
        user.setStatus(1);
        user.setCreateTime(Timestamps.fromMillis(System.currentTimeMillis()));
        user.setUpdateTime(user.getCreateTime());
        List<Integer> permissions = new ArrayList<Integer>(
                Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 19, 88, 86, 89, 90, 91, 92));
        user.addAllPermissions(permissions);
        userList.add(user.build());
    }

    page.setPageNo(request.getPage());
    page.setTotal(1000);
    page.addAllUsers(userList);

    PagePB.Response response = PagePB.Response.newBuilder().setPage(page.build()).build();
    responseObserver.onNext(response);
    responseObserver.onCompleted();
}
 

/**
 * Create a Feature Row with random value according to the FeatureSet.
 *
 * <p>The Feature Row created contains fields according to the entities and features defined in
 * FeatureSet, matching the value type of the field, with randomized value for testing.
 *
 * @param featureSetSpec {@link FeatureSetSpec}
 * @param randomStringSize number of characters for the generated random string
 * @return {@link FeatureRow}
 */
public static FeatureRow createRandomFeatureRow(
    FeatureSetSpec featureSetSpec, int randomStringSize) {
  Builder builder =
      FeatureRow.newBuilder()
          .setFeatureSet(getFeatureSetStringRef(featureSetSpec))
          .setEventTimestamp(Timestamps.fromMillis(System.currentTimeMillis()));

  featureSetSpec
      .getEntitiesList()
      .forEach(
          field -> {
            builder.addFields(
                Field.newBuilder()
                    .setName(field.getName())
                    .setValue(createRandomValue(field.getValueType(), randomStringSize))
                    .build());
          });

  featureSetSpec
      .getFeaturesList()
      .forEach(
          field -> {
            builder.addFields(
                Field.newBuilder()
                    .setName(field.getName())
                    .setValue(createRandomValue(field.getValueType(), randomStringSize))
                    .build());
          });

  return builder.build();
}
 

public static Row create() {
  Row row = new Row();
  row.entity_timestamp = Timestamps.fromMillis(System.currentTimeMillis());
  row.fields = new HashMap<>();
  row.fieldStatuses = new HashMap<>();
  return row;
}
 

/**
 * Create a Feature Row with random value according to the FeatureSet.
 *
 * <p>The Feature Row created contains fields according to the entities and features defined in
 * FeatureSet, matching the value type of the field, with randomized value for testing.
 *
 * @param featureSet {@link FeatureSet}
 * @param randomStringSize number of characters for the generated random string
 * @return {@link FeatureRow}
 */
public static FeatureRow createRandomFeatureRow(FeatureSet featureSet, int randomStringSize) {
  Builder builder =
      FeatureRow.newBuilder()
          .setFeatureSet(getFeatureSetReference(featureSet))
          .setEventTimestamp(Timestamps.fromMillis(System.currentTimeMillis()));

  featureSet
      .getSpec()
      .getEntitiesList()
      .forEach(
          field -> {
            builder.addFields(
                Field.newBuilder()
                    .setName(field.getName())
                    .setValue(createRandomValue(field.getValueType(), randomStringSize))
                    .build());
          });

  featureSet
      .getSpec()
      .getFeaturesList()
      .forEach(
          field -> {
            builder.addFields(
                Field.newBuilder()
                    .setName(field.getName())
                    .setValue(createRandomValue(field.getValueType(), randomStringSize))
                    .build());
          });

  return builder.build();
}
 

/**
 * Tests that BigQueryConverters.columnToValue() returns a Timestamp {@link Value} when the
 * BigQuery column is a valid TIMESTAMP.
 */
@Test
public void testColumnToValueTimestampValid() {
  TableFieldSchema column =
      new TableFieldSchema().setName(validTimestampField).setType("TIMESTAMP");
  Record record =
      generateSingleFieldAvroRecord(
          validTimestampField, "long", validTimestampFieldDesc, validTimestampFieldValueMicros);
  Value value = BigQueryConverters.columnToValue(column, record.get(validTimestampField));
  assertEquals(Timestamps.fromMillis(validTimestampFieldValueMillis), value.getTimestampValue());
}