private Response search(final String table, final String key) throws IOException { try (XContentBuilder builder = jsonBuilder()) { builder.startObject(); builder.startObject("query"); builder.startObject("term"); builder.field(KEY, key); builder.endObject(); builder.endObject(); builder.endObject(); return search(table, builder); } }
private Response search(final String table, final XContentBuilder builder) throws IOException { refreshIfNeeded(); final Map<String, String> params = emptyMap(); final StringEntity entity = new StringEntity(builder.string()); final Header header = new BasicHeader("content-type", ContentType.APPLICATION_JSON.toString()); return restClient.performRequest("GET", "/" + indexKey + "/" + table + "/_search", params, entity, header); }
private void list(RestRequest request, RestChannel channel, Client esClient) { try { Map<String, Object> rivers = getRivers(request.paramAsInt("page", 1), request.paramAsInt("count", 10), esClient); XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder.value(rivers); channel.sendResponse(new BytesRestResponse(RestStatus.OK, builder)); } catch (Throwable e) { errorResponse(request, channel, e); } }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject("whoami"); builder.field("dn", dn); builder.field("is_admin", isAdmin); builder.field("is_authenticated", isAuthenticated); builder.field("is_node_certificate_request", isNodeCertificateRequest); builder.endObject(); return builder; }
private void writeMappings(ImmutableOpenMap<String, MappingMetaData> mappings, XContentBuilder builder, ToXContent.Params params) throws IOException { builder.startObject(Fields.MAPPINGS); if (mappings != null) { for (ObjectObjectCursor<String, MappingMetaData> typeEntry : mappings) { builder.field(typeEntry.key); builder.map(typeEntry.value.sourceAsMap()); } } builder.endObject(); }
/** * Insert a record in the database. Any field/value pairs in the specified * values HashMap will be written into the record with the specified record * key. * * @param table * The name of the table * @param key * The record key of the record to insert. * @param values * A HashMap of field/value pairs to insert in the record * @return Zero on success, a non-zero error code on error. See this class's * description for a discussion of error codes. */ @Override public Status insert(String table, String key, Map<String, ByteIterator> values) { try { final XContentBuilder doc = jsonBuilder().startObject(); for (Entry<String, String> entry : StringByteIterator.getStringMap(values).entrySet()) { doc.field(entry.getKey(), entry.getValue()); } doc.endObject(); client.prepareIndex(indexKey, table, key).setSource(doc).execute().actionGet(); return Status.OK; } catch (Exception e) { e.printStackTrace(); return Status.ERROR; } }
@Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); builder.startArray("scroll_id"); for (String scrollId : scrollIds) { builder.value(scrollId); } builder.endArray(); builder.endObject(); return builder; }
private static class StreamingPropertyString { private final String propertyValue; public StreamingPropertyString(String propertyValue) { this.propertyValue = propertyValue; } public String getPropertyValue() { return propertyValue; } }
public void registerPercolateQuery(String indexName, String queryName, QueryBuilder queryBuilder) { try { client.prepareIndex(indexName, PERCOLATOR_TYPE, queryName) .setSource(XContentFactory.jsonBuilder() .startObject() .field("query", queryBuilder) .endObject()) .setRefresh(true) .execute().actionGet(); } catch (IOException e) { DTThrowable.rethrow(e); } }
private void respondError(RestRequest request, RestChannel channel, String error, RestStatus status) { try { XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder.startObject(); builder.field("success", false); builder.field("error", error); builder.endObject(); channel.sendResponse(new BytesRestResponse(status, builder)); } catch (IOException e) { errorResponse(request, channel, e); } }
@Override public void accept(RestChannel channel) throws Exception { XContentBuilder builder = channel.newBuilder(); RestStatus restStatus = RestStatus.OK; BytesRestResponse response = null; try { String status = "UP"; String message = null; builder.startObject(); if ("strict".equalsIgnoreCase(mode) && registry.isInitialized() == false) { status = "DOWN"; message = "Not initialized"; restStatus = RestStatus.SERVICE_UNAVAILABLE; } builder.field("message", message); builder.field("mode", mode); builder.field("status", status); builder.endObject(); response = new BytesRestResponse(restStatus, builder); } finally { builder.close(); } channel.sendResponse(response); }
mapping = XContentFactory.jsonBuilder(). startObject(). startObject(store). field(TTL_FIELD, new HashMap<String, Object>() {{ put("enabled", true); }}). startObject("properties"). startObject(key); mapping.field("type", "string"); switch (map) { case STRING: mapping.field("index","not_analyzed"); break; case TEXT: mapping.endObject(); mapping.startObject(getDualMappingName(key)); mapping.field("type", "string"); mapping.field("index","not_analyzed"); break; default: throw new AssertionError("Unexpected mapping: "+map); mapping.field("type", "float"); } else if (dataType == Double.class) { log.debug("Registering double type for {}", key); mapping.field("type", "double"); } else if (dataType == Byte.class) {
@Override public boolean indexWord(String word) { if (bulk == null) { bulk = client.prepareBulk(); } try { bulk.add(client.prepareIndex(INDEX_NAME, INDEX_TYPE) .setSource(XContentFactory.jsonBuilder() .startObject() .field(FIELD_NAME, word) .endObject())); } catch (IOException e) { // should never happen throw new RuntimeException(e); } return true; }
parser = XContentFactory.xContent(contentType).createParser(data); while (parser.nextToken() != null) {}; parser = XContentFactory.xContent(contentType).createParser(data); builder.field(fieldName); builder.copyCurrentStructure(parser); } catch (JsonParseException ex) { } finally { if (parser != null) { parser.close();
@Override public String toString() { try { XContentBuilder builder = XContentFactory.jsonBuilder().prettyPrint(); builder.startObject(); toXContent(builder, EMPTY_PARAMS); builder.endObject(); return builder.string(); } catch (IOException e) { return "{ \"error\" : \"" + e.getMessage() + "\"}"; } }
private XContentBuilder createPublishMessage(RestRequest request) { try { Map<String, Object> map = null; String message = request.content().toUtf8(); XContentParser parser = null; try { parser = XContentFactory.xContent(message).createParser(message); map = parser.map(); } catch (Exception e) { logger.warn("unable to parse {}", message); } finally { parser = null; } return jsonBuilder().startObject() .field("timestamp", request.param("timestamp", Long.toString(System.currentTimeMillis()))) .field("message", map) .endObject(); } catch (IOException e) { return null; } } }
public void store(HttpArticle article, Map<String, Object> fields) throws IOException { XContentBuilder jsonBuilder = jsonBuilder(); jsonBuilder.startObject(); applyFields(jsonBuilder, article, fields); jsonBuilder.endObject(); IndexRequestBuilder insert = getConnection().getClient() .prepareIndex(getIndex(), getType(), article.getUrl()) .setSource(jsonBuilder); getConnection().getProcessor().add(insert.request()); }
public void memStatus() throws IOException { NodeStats[] nodeStats = client.admin().cluster().prepareNodesStats() .setJvm(true).setIndices(true).setTransport(true) .execute().actionGet().getNodes(); log("==== MEMORY ===="); log("Committed heap size: [0]=" + nodeStats[0].getJvm().getMem().getHeapCommitted() + ", [1]=" + nodeStats[1].getJvm().getMem().getHeapCommitted()); log("Used heap size: [0]=" + nodeStats[0].getJvm().getMem().getHeapUsed() + ", [1]=" + nodeStats[1].getJvm().getMem().getHeapUsed()); log("FieldData cache size: [0]=" + nodeStats[0].getIndices().getFieldData().getMemorySize() + ", [1]=" + nodeStats[1].getIndices().getFieldData().getMemorySize()); log("Query cache size: [0]=" + nodeStats[0].getIndices().getQueryCache().getMemorySize() + ", [1]=" + nodeStats[1].getIndices().getQueryCache().getMemorySize()); log(""); log("==== NETWORK ===="); log("Transport: [0]=" + nodeStats[0].getTransport().toXContent(jsonBuilder(), ToXContent.EMPTY_PARAMS).string() + ", [1]=" + nodeStats[1].getTransport().toXContent(jsonBuilder(), ToXContent.EMPTY_PARAMS).string()); log(""); }
public static RestResponse buildXContentBuilder(Table table, RestChannel channel) throws Exception { RestRequest request = channel.request(); XContentBuilder builder = channel.newBuilder(); List<DisplayHeader> displayHeaders = buildDisplayHeaders(table, request); builder.startArray(); List<Integer> rowOrder = getRowOrder(table, request); for (Integer row : rowOrder) { builder.startObject(); for (DisplayHeader header : displayHeaders) { builder.field(header.display, renderValue(request, table.getAsMap().get(header.name).get(row).value)); } builder.endObject(); } builder.endArray(); return new BytesRestResponse(RestStatus.OK, builder); }
public static String convertToJson(byte[] data, int offset, int length, boolean reformatJson, boolean prettyPrint) throws IOException { XContentType xContentType = XContentFactory.xContentType(data, offset, length); if (xContentType == XContentType.JSON && !reformatJson) { return new String(data, offset, length, Charsets.UTF_8); } try (XContentParser parser = XContentFactory.xContent(xContentType).createParser(data, offset, length)) { parser.nextToken(); XContentBuilder builder = XContentFactory.jsonBuilder(); if (prettyPrint) { builder.prettyPrint(); } builder.copyCurrentStructure(parser); return builder.string(); } }