private static <T> Response<ByteString> serialize(ObjectWriter objectWriter, Response<T> response){ if(!response.payload().isPresent()){ // Same as in com.spotify.apollo.route.Middlewares.serializePayload() // no payload, so this cast is safe to do //noinspection unchecked return (Response<ByteString>) response; } else { return response.withPayload(serialize(objectWriter, response.payload().get())); } }
private static <T> Response<ByteString> serializePayload( Serializer serializer, Request request, Response<T> response) { if (!response.payload().isPresent()) { // no payload, so this cast is safe to do //noinspection unchecked return (Response<ByteString>) response; } final T payloadObject = response.payload().get(); final Serializer.Payload payload = serializer.serialize(request, payloadObject); if (payload.contentType().isPresent()) { response = response.withHeader(CONTENT_TYPE, payload.contentType().get()); } return response.withPayload(payload.byteString()); }
/** * Async middleware for a Response object. * * @param templateName The template name, respective to the "resources" folder * @param <T> The Type of the parameters * @return the middlware */ public static <T> Middleware<AsyncHandler<Response<T>>, AsyncHandler<Response<ByteString>>> htmlSerializeResponse(final String templateName) { return handler -> requestContext -> handler.invoke(requestContext) .thenApply(response -> response .withPayload(serialize(templateName, response.payload().orElse(null))) .withHeader(CONTENT_TYPE, HTML)); }
static Response<ByteString> transformResponse(com.squareup.okhttp.Response response) throws IOException { final StatusType status = transformStatus(response.code(), Optional.ofNullable(response.message())); Response<ByteString> apolloResponse = Response.forStatus(status); for (Map.Entry<String, List<String>> entry : response.headers().toMultimap().entrySet()) { apolloResponse = apolloResponse.withHeader( entry.getKey(), HEADER_JOINER.join(entry.getValue())); } final byte[] bytes = response.body().bytes(); if (bytes.length > 0) { apolloResponse = apolloResponse.withPayload(ByteString.of(bytes)); } return apolloResponse; }
private <R> Function<Response<R>, Response<ByteString>> serialize( RequestContext rc, Class<? extends R> entityClass) { return response -> { final Optional<R> entityOpt = response.payload(); if (!entityOpt.isPresent()) { //noinspection unchecked return (Response<ByteString>) response; } final EncodedResponse encoded; try { encoded = codec.write(entityOpt.get(), entityClass, rc); } catch (Throwable e) { LOG.error("error", e); return Response.forStatus( Status.INTERNAL_SERVER_ERROR .withReasonPhrase("Payload serialization failed: " + e.getMessage())); } final Response<ByteString> result = response.withPayload(encoded.data()); return contentType != null ? result.withHeader(CONTENT_TYPE, contentType) : encoded.contentType().isPresent() ? result.withHeader(CONTENT_TYPE, encoded.contentType().get()) : result; }; } }
private static Response<ByteString> applyHttpPayloadSemantics( Request request, Response<ByteString> response) { Response<ByteString> result = response; Optional<ByteString> payload = response.payload(); if (setContentLengthForStatus(response.status())) { int payloadSize = payload.isPresent() ? payload.get().size() : 0; result = result.withHeader("Content-Length", String.valueOf(payloadSize)); } if (!setPayloadForMethod(request.method()) || !setPayloadForStatus(response.status())) { result = result.withPayload(null); } return result; }
private Response<Resource> updateResource(String id, Resource resource) { if (!resource.id().equals(id)) { return Response.forStatus( Status.BAD_REQUEST.withReasonPhrase("ID of payload does not match ID in uri.")); } try { storage.storeResource(resource); } catch (IOException e) { throw new RuntimeException(e); } return Response.forStatus(Status.OK).withPayload(resource); } }
public static Middleware<AsyncHandler<? extends Response<?>>, AsyncHandler<Response<ByteString>>> jsonAsync() { return innerHandler -> innerHandler.map(response -> { if (!response.payload().isPresent()) { // noinspection unchecked return (Response<ByteString>) response; } final Object tPayload = response.payload().get(); try { final byte[] bytes = OBJECT_MAPPER.writeValueAsBytes(tPayload); final ByteString payload = ByteString.of(bytes); return response.withPayload(payload) .withHeader("Content-Type", "application/json"); } catch (JsonProcessingException e) { return Response.forStatus( INTERNAL_SERVER_ERROR.withReasonPhrase( "Failed to serialize response " + e.getMessage())); } }); }
private <R> Function<Response<R>, Response<ByteString>> serialize( RequestContext rc, Class<? extends R> entityClass) { return response -> { final Optional<R> entityOpt = response.payload(); if (!entityOpt.isPresent()) { //noinspection unchecked return (Response<ByteString>) response; } final EncodedResponse encoded; try { encoded = codec.write(entityOpt.get(), entityClass, rc); } catch (Throwable e) { LOG.error("error", e); return Response.forStatus( Status.INTERNAL_SERVER_ERROR .withReasonPhrase("Payload serialization failed: " + e.getMessage())); } final Response<ByteString> result = response.withPayload(encoded.data()); return contentType != null ? result.withHeader(CONTENT_TYPE, contentType) : encoded.contentType().isPresent() ? result.withHeader(CONTENT_TYPE, encoded.contentType().get()) : result; }; } }
private Response<WorkflowInstance> haltWorkflowInstance(AuthContext ac, WorkflowInstance workflowInstance) { workflowActionAuthorizer.authorizeWorkflowAction(ac, workflowInstance.workflowId()); final Event event = Event.halt(workflowInstance); return Response.forStatus(eventInjectorHelper(event)).withPayload(workflowInstance); }
private Response<WorkflowInstance> retryWorkflowInstanceAfter(AuthContext ac, RequestContext rc, WorkflowInstance workflowInstance) { workflowActionAuthorizer.authorizeWorkflowAction(ac, workflowInstance.workflowId()); final long delay; try { delay = Long.parseLong(rc.request().parameter("delay").orElse("0")); } catch (NumberFormatException e) { return Response.forStatus(BAD_REQUEST.withReasonPhrase( "Delay parameter could not be parsed")); } final Event event = Event.retryAfter(workflowInstance, delay); return Response.forStatus(eventInjectorHelper(event)).withPayload(workflowInstance); }
private Response<Event> injectEvent(AuthContext ac, Event event) { workflowActionAuthorizer.authorizeWorkflowAction(ac, event.workflowInstance().workflowId()); if ("dequeue".equals(EventUtil.name(event))) { // For backwards compatibility return Response.forStatus(eventInjectorHelper( Event.retryAfter(event.workflowInstance(), 0L))).withPayload(event); } else if ("halt".equals(EventUtil.name(event))) { // For backwards compatibility return Response.forStatus(eventInjectorHelper(event)); } else if ("timeout".equals(EventUtil.name(event))) { // This is for manually getting out of a stale state return Response.forStatus(eventInjectorHelper(event)); } else { return Response.forStatus(BAD_REQUEST.withReasonPhrase( "This API for injecting generic events is deprecated, refer to the specific API for the " + "event you want to send to the scheduler")); } }
private Response<Backfill> updateBackfill(AuthContext ac, String id, EditableBackfillInput backfillInput) { if (!backfillInput.id().equals(id)) { return Response.forStatus( Status.BAD_REQUEST.withReasonPhrase("ID of payload does not match ID in uri.")); } final Backfill backfill; try { backfill = storage.runInTransaction(tx -> { final Backfill oldBackfill = tx.backfill(id) .orElseThrow(() -> new ResourceNotFoundException(String.format("Backfill %s not found.", id))); workflowActionAuthorizer.authorizeWorkflowAction(ac, oldBackfill.workflowId()); final BackfillBuilder backfillBuilder = oldBackfill.builder(); backfillInput.concurrency().ifPresent(backfillBuilder::concurrency); backfillInput.description().ifPresent(backfillBuilder::description); return tx.store(backfillBuilder.build()); }); } catch (ResourceNotFoundException e) { return Response.forStatus(Status.NOT_FOUND.withReasonPhrase(e.getMessage())); } catch (IOException e) { return Response.forStatus( Status.INTERNAL_SERVER_ERROR.withReasonPhrase("Failed to store backfill.")); } return Response.forStatus(Status.OK).withPayload(backfill); }