Example usage for io.vertx.core.buffer Buffer appendString

List of usage examples for io.vertx.core.buffer Buffer appendString

Introduction

In this page you can find the example usage for io.vertx.core.buffer Buffer appendString.

Prototype

@Fluent
Buffer appendString(String str, String enc);

Source Link

Document

Appends the specified String to the end of the Buffer with the encoding as specified by enc .

The buffer will expand as necessary to accommodate any bytes written.

Returns a reference to this so multiple operations can be appended together.

Usage

From source file:org.etourdot.vertx.marklogic.http.impl.request.DefaultMultiPartRequest.java

License:Open Source License

private static List<HttpPart> constructMultipartHttpPart(Document document) {
    List<HttpPart> partList = new ArrayList<>();
    try {// w ww  . jav  a2s .c om
        if (document.hasMetadata()) {
            Buffer metadata = Buffer.buffer(document.getMetadata().encode().getBytes("UTF-8"));
            partList.add(constructHttpPart(document, metadata, null));
        }
        if (document.hasContent()) {
            final Format format = Format.valueOf(document.getFormat());
            Buffer body = Buffer.buffer();
            final String mimeType = format.getDefaultMimetype();
            if (Format.JSON == format) {
                body.appendString(((JsonObject) document.getContent()).encode(), "UTF-8");
            } else if (Format.XML == format || Format.TEXT == format || Format.BINARY == format) {
                body.appendString((String) document.getContent(), "UTF-8");
            }
            partList.add(constructHttpPart(document, body, mimeType));
        }
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    return partList;
}

From source file:org.sfs.nodes.compute.account.GetAccount.java

License:Apache License

@Override
public void handle(final SfsRequest httpServerRequest) {

    aVoid().flatMap(new Authenticate(httpServerRequest))
            .flatMap(new ValidateActionAuthenticated(httpServerRequest))
            .map(aVoid -> fromSfsRequest(httpServerRequest)).map(new ValidateAccountPath())
            .map(objectPath -> objectPath.accountPath().get())
            .flatMap(new LoadAccount(httpServerRequest.vertxContext()))
            .map(new ValidatePersistentAccountExists()).flatMap(new ListContainers(httpServerRequest))
            .flatMap(containerList -> {
                HttpServerResponse httpServerResponse = httpServerRequest.response();
                MultiMap headerParams = httpServerRequest.headers();
                MultiMap queryParams = httpServerRequest.params();
                String format = queryParams.get(FORMAT);

                String accept = headerParams.get(ACCEPT);

                Account account = containerList.getAccount();

                Metadata metadata = account.getMetadata();

                for (String key : metadata.keySet()) {
                    SortedSet<String> values = metadata.get(key);
                    if (values != null && !values.isEmpty()) {
                        httpServerResponse.putHeader(format("%s%s", X_ADD_ACCOUNT_META_PREFIX, key), values);
                    }//  w  ww .  jav a 2 s.  c  o m
                }

                httpServerResponse.putHeader(X_ACCOUNT_OBJECT_COUNT, valueOf(containerList.getObjectCount()));
                httpServerResponse.putHeader(X_ACCOUNT_CONTAINER_COUNT,
                        valueOf(containerList.getContainerCount()));
                httpServerResponse.putHeader(X_ACCOUNT_BYTES_USED,
                        BigDecimal.valueOf(containerList.getBytesUsed()).setScale(0, ROUND_HALF_UP).toString());

                MediaType parsedAccept = null;
                if (!isNullOrEmpty(accept)) {
                    parsedAccept = parse(accept);
                }

                if (equalsIgnoreCase("xml", format)) {
                    parsedAccept = APPLICATION_XML_UTF_8;
                } else if (equalsIgnoreCase("json", format)) {
                    parsedAccept = JSON_UTF_8;
                }

                httpServerResponse.setStatusCode(HTTP_OK);

                if (parsedAccept != null && JSON_UTF_8.is(parsedAccept)) {
                    String charset = UTF_8.toString();

                    JsonArray array = new JsonArray();

                    for (SparseContainer container : ordered(containerList.getContainers())) {

                        array.add(new JsonObject().put("name", container.getContainerName())
                                .put("count", container.getObjectCount())
                                .put("bytes", BigDecimal.valueOf(container.getByteCount())
                                        .setScale(0, ROUND_HALF_UP).longValue()));

                    }

                    Buffer buffer = buffer(array.encode(), charset);
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_TYPE, JSON_UTF_8.toString());
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_LENGTH, valueOf(buffer.length()));
                    return AsyncIO.append(buffer, httpServerResponse);

                } else if (parsedAccept != null && APPLICATION_XML_UTF_8.is(parsedAccept)) {

                    BufferOutputStream bufferOutputStream = new BufferOutputStream();
                    String charset = UTF_8.toString();
                    XMLStreamWriter writer = null;
                    try {
                        writer = newFactory().createXMLStreamWriter(bufferOutputStream, charset);

                        writer.writeStartDocument(charset, "1.0");

                        writer.writeStartElement("account");

                        writer.writeAttribute("name", fromPaths(account.getId()).accountName().get());

                        for (SparseContainer container : ordered(containerList.getContainers())) {

                            writer.writeStartElement("container");

                            writer.writeStartElement("name");
                            writer.writeCharacters(container.getContainerName());
                            writer.writeEndElement();

                            writer.writeStartElement("count");
                            writer.writeCharacters(valueOf(container.getObjectCount()));
                            writer.writeEndElement();

                            writer.writeStartElement("bytes");
                            writer.writeCharacters(BigDecimal.valueOf(container.getByteCount())
                                    .setScale(0, ROUND_HALF_UP).toString());
                            writer.writeEndElement();

                            writer.writeEndElement();
                        }

                        writer.writeEndElement();

                        writer.writeEndDocument();

                    } catch (XMLStreamException e) {
                        throw new RuntimeException(e);
                    } finally {
                        try {
                            if (writer != null) {
                                writer.close();
                            }
                        } catch (XMLStreamException e) {
                            LOGGER.warn(e.getLocalizedMessage(), e);
                        }
                    }

                    Buffer buffer = bufferOutputStream.toBuffer();
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_TYPE,
                            APPLICATION_XML_UTF_8.toString());
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_LENGTH, valueOf(buffer.length()));
                    return AsyncIO.append(buffer, httpServerResponse);

                } else {
                    String charset = UTF_8.toString();
                    Buffer buffer = buffer();
                    for (SparseContainer container : ordered(containerList.getContainers())) {
                        buffer.appendString(container.getContainerName(), charset);
                        buffer.appendString("\n", charset);
                    }
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_TYPE,
                            PLAIN_TEXT_UTF_8.toString());
                    httpServerResponse = httpServerResponse.putHeader(CONTENT_LENGTH, valueOf(buffer.length()));
                    return AsyncIO.append(buffer, httpServerResponse);
                }
            }).single().subscribe(new ConnectionCloseTerminus<Void>(httpServerRequest) {

                @Override
                public void onNext(Void aVoid) {

                }

            });

}