How to use

of

method

in

com.hotels.styx.api.Eventual

private static Eventual<LiveHttpResponse> handleErrors(Throwable e, HttpInterceptor.Context context) {
  if (e instanceof PluginNotFoundException) {
    return Eventual.of(responseWith(NOT_FOUND, e.getMessage()));
  }
  if (e instanceof BadPluginToggleRequestException) {
    return Eventual.of(responseWith(BAD_REQUEST, e.getMessage()));
  }
  LOGGER.error("Plugin toggle error", e);
  return Eventual.of(responseWith(INTERNAL_SERVER_ERROR, ""));
}

@Override
public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
  return Eventual.of(doHandle(request));
}

@Override
public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
  return Eventual.of(generateResponse());
}

private Eventual<LiveHttpResponse> putNewState(LiveHttpRequest request, HttpInterceptor.Context context) {
  return Eventual.of(request)
      .flatMap(this::requestedUpdate)
      .map(this::applyUpdate);
}

@Override
public Map<String, HttpHandler> adminInterfaceHandlers() {
  return ImmutableMap.of("status", (request, context) -> Eventual.of(
      response(OK)
          .addHeader(CONTENT_TYPE, APPLICATION_JSON)
          .body(format("{ name: \"%s\" status: \"%s\" }", name, status), UTF_8)
          .build()
          .stream()));
}

@Override
public Eventual<LiveHttpResponse> intercept(LiveHttpRequest request, Chain chain) {
  if (CONNECT.equals(request.method())) {
    return Eventual.of(response(METHOD_NOT_ALLOWED).build());
  } else {
    return chain.proceed(request);
  }
}

  static ImmutableMap<String, HttpHandler> adminHandlers(String endpoint, String responseContent) {
    return ImmutableMap.of(endpoint, (request, context) -> Eventual.of(response(OK)
        .body(responseContent, UTF_8)
        .build().stream()));
  }
}

  static ImmutableMap<String, HttpHandler> adminHandlers(String endpoint, String responseContent) {
    return ImmutableMap.of(endpoint, (request, context) -> Eventual.of(response(OK)
        .body(responseContent, UTF_8)
        .build()
        .stream()
    ));
  }
}

private Eventual<LiveHttpResponse> getCurrentOrPutNewState(LiveHttpRequest request, HttpInterceptor.Context context) {
  if (GET.equals(request.method())) {
    return getCurrentState(request, context);
  } else if (PUT.equals(request.method())) {
    return putNewState(request, context);
  } else {
    return Eventual.of(response(METHOD_NOT_ALLOWED).build());
  }
}

@Override
public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
  Stream<NamedPlugin> enabled = plugins.stream().filter(NamedPlugin::enabled);
  Stream<NamedPlugin> disabled = plugins.stream().filter(plugin -> !plugin.enabled());
  String output = section("Enabled", enabled)
      + section("Disabled", disabled);
  return Eventual.of(response(OK)
      .body(output, UTF_8)
      .addHeader(CONTENT_TYPE, HTML_UTF_8.toString())
      .build()
      .stream());
}

private static HttpHandler buildFallbackHandler(List<String> parents, RouteHandlerFactory routeHandlerFactory, ConditionRouterConfig config) {
  if (config.fallback == null) {
    return (request, context) -> Eventual.of(LiveHttpResponse.response(BAD_GATEWAY).build());
  } else {
    return routeHandlerFactory.build(append(parents, "fallback"), config.fallback);
  }
}

@Test
public void flatMapsValues() {
  Eventual<String> eventual = Eventual.of("hello")
      .flatMap(it -> Eventual.of(it + " world"));
  StepVerifier.create(eventual)
      .expectNext("hello world")
      .verifyComplete();
}

  @Override
  public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
    if (!method.equals(request.method())) {
      return Eventual.of(
          HttpResponse.response(METHOD_NOT_ALLOWED)
              .body(errorBody, StandardCharsets.UTF_8)
              .build()
              .stream()
      );
    }

    return httpHandler.handle(request, context);
  }
}

private Eventual<LiveHttpResponse> getCurrentState(LiveHttpRequest request, HttpInterceptor.Context context) {
  return Eventual.of(request)
      .map(this::plugin)
      .map(this::currentState)
      .map(state -> responseWith(OK, state.toString()));
}

@Test
public void createFromValue() {
  StepVerifier.create(Eventual.of("x"))
      .expectNext("x")
      .verifyComplete();
}

  @Test
  public void mapsErrors() {
    Eventual<String> eventual = Eventual.<String>error(new RuntimeException("ouch"))
        .onError(it -> Eventual.of("mapped error: " + it.getMessage()));

    StepVerifier.create(eventual)
        .expectNext("mapped error: ouch")
        .verifyComplete();
  }
}

@Override
public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
  MetricRequest metricRequest = new MetricRequest(request);
  return metricRequest.fullMetrics()
      ? super.handle(request, context)
      : Eventual.of(restrictedMetricsResponse(metricRequest).build().stream());
}

private static HttpHandler newHandler(String originId, RequestHandler wireMockHandler) {
  return (httpRequest, ctx) ->
      httpRequest.aggregate(MAX_CONTENT_LENGTH)
          .map(fullRequest -> {
            LOGGER.info("{} received: {}\n{}", new Object[]{originId, fullRequest.url(), fullRequest.body()});
            return fullRequest;
          })
          .flatMap(fullRequest -> {
            Request wmRequest = new WiremockStyxRequestAdapter(fullRequest);
            com.github.tomakehurst.wiremock.http.Response wmResponse = wireMockHandler.handle(wmRequest);
            return Eventual.of(toStyxResponse(wmResponse).stream());
          });
}

  private static HttpHandler newHandler(RequestHandler wireMockHandler) {
    return (httpRequest, ctx) ->
        httpRequest.aggregate(MAX_CONTENT_LENGTH)
            .map(fullRequest -> {
              LOGGER.info("Received: {}\n{}", new Object[]{fullRequest.url(), fullRequest.body()});
              return fullRequest;
            })
            .flatMap(fullRequest -> {
              Request wmRequest = new WiremockStyxRequestAdapter(fullRequest);
              com.github.tomakehurst.wiremock.http.Response wmResponse = wireMockHandler.handle(wmRequest);
              return Eventual.of(toStyxResponse(wmResponse).stream());
            });
  }
}

@Override
public Eventual<LiveHttpResponse> handle(LiveHttpRequest request, HttpInterceptor.Context context) {
  return Eventual.of(response(statusWithCode(status)).body(new ByteStream(Flux.just(new Buffer(text, UTF_8)))).build());
}