@Override protected void handleRequest( final RestRequest request, final RestChannel channel, final Client client) throws Exception { BytesRestResponse response = null; final XContentBuilder builder = channel.newBuilder(); try { builder.startObject(); final User user = ((User) request.getFromContext("_shield_user")); if (user != null) { builder.field("principal", user.principal()); builder.field("roles", user.roles()); } else { builder.nullField("principal"); } builder.field("remote_address", request.getFromContext("_rest_remote_address")); builder.endObject(); response = new BytesRestResponse(RestStatus.OK, builder); } catch (final Exception e1) { builder.startObject(); builder.field("error", e1.toString()); builder.endObject(); response = new BytesRestResponse(RestStatus.INTERNAL_SERVER_ERROR, builder); } channel.sendResponse(response); }
private static String renderValue(RestRequest request, Object value) { if (value == null) { return null; } if (value instanceof ByteSizeValue) { ByteSizeValue v = (ByteSizeValue) value; String resolution = request.param("bytes"); if ("b".equals(resolution)) { return Long.toString(v.bytes()); } else if ("k".equals(resolution)) { return Long.toString(v.kb()); } else if ("m".equals(resolution)) { return Long.toString(v.mb()); } else if ("g".equals(resolution)) { return Long.toString(v.gb()); } else if ("t".equals(resolution)) { return Long.toString(v.tb()); } else if ("p".equals(resolution)) { return Long.toString(v.pb()); } else { return v.toString(); } } if (value instanceof SizeValue) { SizeValue v = (SizeValue) value; String resolution = request.param("size"); if ("b".equals(resolution)) { return Long.toString(v.singles()); } else if ("k".equals(resolution)) { return Long.toString(v.kilo()); } else if ("m".equals(resolution)) { return Long.toString(v.mega()); } else if ("g".equals(resolution)) { return Long.toString(v.giga()); } else if ("t".equals(resolution)) { return Long.toString(v.tera()); } else if ("p".equals(resolution)) { return Long.toString(v.peta()); } else { return v.toString(); } } if (value instanceof TimeValue) { TimeValue v = (TimeValue) value; String resolution = request.param("time"); if ("ms".equals(resolution)) { return Long.toString(v.millis()); } else if ("s".equals(resolution)) { return Long.toString(v.seconds()); } else if ("m".equals(resolution)) { return Long.toString(v.minutes()); } else if ("h".equals(resolution)) { return Long.toString(v.hours()); } else { return v.toString(); } } // Add additional built in data points we can render based on request parameters? return value.toString(); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final NodeClient client) { GetIndexTemplatesRequest getIndexTemplatesRequest = new GetIndexTemplatesRequest(request.param("name")); getIndexTemplatesRequest.local( request.paramAsBoolean("local", getIndexTemplatesRequest.local())); getIndexTemplatesRequest.masterNodeTimeout( request.paramAsTime("master_timeout", getIndexTemplatesRequest.masterNodeTimeout())); client .admin() .indices() .getTemplates( getIndexTemplatesRequest, new RestResponseListener<GetIndexTemplatesResponse>(channel) { @Override public RestResponse buildResponse( GetIndexTemplatesResponse getIndexTemplatesResponse) { boolean templateExists = getIndexTemplatesResponse.getIndexTemplates().size() > 0; if (templateExists) { return new BytesRestResponse( OK, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY); } else { return new BytesRestResponse( NOT_FOUND, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY); } } }); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final NodeClient client) { ForceMergeRequest mergeRequest = new ForceMergeRequest(Strings.splitStringByCommaToArray(request.param("index"))); mergeRequest.indicesOptions(IndicesOptions.fromRequest(request, mergeRequest.indicesOptions())); mergeRequest.maxNumSegments( request.paramAsInt("max_num_segments", mergeRequest.maxNumSegments())); mergeRequest.onlyExpungeDeletes( request.paramAsBoolean("only_expunge_deletes", mergeRequest.onlyExpungeDeletes())); mergeRequest.flush(request.paramAsBoolean("flush", mergeRequest.flush())); client .admin() .indices() .forceMerge( mergeRequest, new RestBuilderListener<ForceMergeResponse>(channel) { @Override public RestResponse buildResponse( ForceMergeResponse response, XContentBuilder builder) throws Exception { builder.startObject(); buildBroadcastShardsHeader(builder, request, response); builder.endObject(); return new BytesRestResponse(OK, builder); } }); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { final String[] names = Strings.splitStringByCommaToArray(request.param("name")); GetIndexTemplatesRequest getIndexTemplatesRequest = new GetIndexTemplatesRequest(names); getIndexTemplatesRequest.local( request.paramAsBoolean("local", getIndexTemplatesRequest.local())); getIndexTemplatesRequest.masterNodeTimeout( request.paramAsTime("master_timeout", getIndexTemplatesRequest.masterNodeTimeout())); final boolean implicitAll = getIndexTemplatesRequest.names().length == 0; return channel -> client .admin() .indices() .getTemplates( getIndexTemplatesRequest, new RestToXContentListener<GetIndexTemplatesResponse>(channel) { @Override protected RestStatus getStatus(GetIndexTemplatesResponse response) { boolean templateExists = false == response.getIndexTemplates().isEmpty(); return (templateExists || implicitAll) ? OK : NOT_FOUND; } }); }
@Override public void handleRequest(final RestRequest request, final RestChannel channel, Client client) { DeleteIndexedScriptRequest deleteIndexedScriptRequest = new DeleteIndexedScriptRequest(getScriptLang(request), request.param("id")); deleteIndexedScriptRequest.version( request.paramAsLong("version", deleteIndexedScriptRequest.version())); deleteIndexedScriptRequest.versionType( VersionType.fromString( request.param("version_type"), deleteIndexedScriptRequest.versionType())); client.deleteIndexedScript( deleteIndexedScriptRequest, new RestBuilderListener<DeleteIndexedScriptResponse>(channel) { @Override public RestResponse buildResponse( DeleteIndexedScriptResponse result, XContentBuilder builder) throws Exception { builder .startObject() .field(Fields.FOUND, result.isFound()) .field(Fields._INDEX, result.getIndex()) .field(Fields._TYPE, result.getType()) .field(Fields._ID, result.getId()) .field(Fields._VERSION, result.getVersion()) .endObject(); RestStatus status = OK; if (!result.isFound()) { status = NOT_FOUND; } return new BytesRestResponse(status, builder); } }); }
@Override public void handleRequest(final RestRequest request, final RestChannel channel) { DeleteMappingRequest deleteMappingRequest = deleteMappingRequest(splitIndices(request.param("index"))); deleteMappingRequest.type(request.param("type")); client .admin() .indices() .deleteMapping( deleteMappingRequest, new ActionListener<DeleteMappingResponse>() { @Override public void onResponse(DeleteMappingResponse response) { try { XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder.startObject().field("ok", true); builder.endObject(); channel.sendResponse(new XContentRestResponse(request, OK, builder)); } catch (IOException e) { onFailure(e); } } @Override public void onFailure(Throwable e) { try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); } catch (IOException e1) { logger.error("Failed to send failure response", e1); } } }); }
@Override public void login(final RestRequest request, final ActionListener<String[]> listener) { String username = request.param(usernameKey); String password = request.param(passwordKey); final BytesReference content = request.content(); final XContentType xContentType = XContentFactory.xContentType(content); XContentParser parser = null; try { parser = XContentFactory.xContent(xContentType).createParser(content); final XContentParser.Token t = parser.nextToken(); if (t != null) { final Map<String, Object> contentMap = parser.map(); username = MapUtil.getAsString(contentMap, usernameKey, username); password = MapUtil.getAsString(contentMap, passwordKey, password); } } catch (final Exception e) { listener.onFailure(e); return; } finally { if (parser != null) { parser.close(); } } if (username == null) { listener.onResponse(new String[0]); return; } processLogin(username, password, listener); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, NodeClient client) { PutStoredScriptRequest putRequest = new PutStoredScriptRequest(getScriptLang(request), request.param("id")); putRequest.script(request.content()); client.admin().cluster().putStoredScript(putRequest, new AcknowledgedRestListener<>(channel)); }
protected AbstractRestChannel(RestRequest request, boolean detailedErrorsEnabled) { this.request = request; this.detailedErrorsEnabled = detailedErrorsEnabled; this.format = request.param("format", request.header("Accept")); this.filterPath = request.param("filter_path", null); this.pretty = request.paramAsBoolean("pretty", false); this.human = request.paramAsBoolean("human", false); }
@Override public void doRequest(final RestRequest request, final RestChannel channel, final Client client) { final ClusterStateRequest clusterStateRequest = new ClusterStateRequest(); clusterStateRequest.clear().nodes(true); clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local())); clusterStateRequest.masterNodeTimeout( request.paramAsTime("master_timeout", clusterStateRequest.masterNodeTimeout())); client .admin() .cluster() .state( clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) { @Override public void processResponse(final ClusterStateResponse clusterStateResponse) { NodesInfoRequest nodesInfoRequest = new NodesInfoRequest(); nodesInfoRequest.clear().jvm(true).os(true).process(true); client .admin() .cluster() .nodesInfo( nodesInfoRequest, new RestActionListener<NodesInfoResponse>(channel) { @Override public void processResponse(final NodesInfoResponse nodesInfoResponse) { NodesStatsRequest nodesStatsRequest = new NodesStatsRequest(); nodesStatsRequest .clear() .jvm(true) .os(true) .fs(true) .indices(true) .process(true) .script(true); client .admin() .cluster() .nodesStats( nodesStatsRequest, new RestResponseListener<NodesStatsResponse>(channel) { @Override public RestResponse buildResponse( NodesStatsResponse nodesStatsResponse) throws Exception { return RestTable.buildResponse( buildTable( request, clusterStateResponse, nodesInfoResponse, nodesStatsResponse), channel); } }); } }); } }); }
public static RestResponse buildResponse(Table table, RestChannel channel) throws Exception { RestRequest request = channel.request(); XContentType xContentType = XContentType.fromMediaTypeOrFormat(request.param("format", request.header("Accept"))); if (xContentType != null) { return buildXContentBuilder(table, channel); } return buildTextPlainResponse(table, channel); }
public static RestResponse buildResponse(Table table, RestRequest request, RestChannel channel) throws Exception { XContentType xContentType = XContentType.fromRestContentType(request.param("format", request.header("Content-Type"))); if (xContentType != null) { return buildXContentBuilder(table, request, channel); } return buildTextPlainResponse(table, request, channel); }
private static String getXForwardedForHeader(RestRequest request) { if (!ConfigurationHelper.isNullOrEmpty(request.header("X-Forwarded-For"))) { String[] parts = request.header("X-Forwarded-For").split(","); if (!ConfigurationHelper.isNullOrEmpty(parts[0])) { return parts[0]; } } return null; }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final Client client) { ClusterStatsRequest clusterStatsRequest = new ClusterStatsRequest().nodesIds(request.paramAsStringArray("nodeId", null)); clusterStatsRequest.timeout(request.param("timeout")); client .admin() .cluster() .clusterStats(clusterStatsRequest, new RestToXContentListener<>(channel)); }
static List<DisplayHeader> buildDisplayHeaders(Table table, RestRequest request) { List<DisplayHeader> display = new ArrayList<>(); if (request.hasParam("h")) { Set<String> headers = expandHeadersFromRequest(table, request); for (String possibility : headers) { DisplayHeader dispHeader = null; if (table.getAsMap().containsKey(possibility)) { dispHeader = new DisplayHeader(possibility, possibility); } else { for (Table.Cell headerCell : table.getHeaders()) { String aliases = headerCell.attr.get("alias"); if (aliases != null) { for (String alias : Strings.splitStringByCommaToArray(aliases)) { if (possibility.equals(alias)) { dispHeader = new DisplayHeader(headerCell.value.toString(), alias); break; } } } } } if (dispHeader != null && checkOutputTimestamp(dispHeader, request)) { // We know we need the header asked for: display.add(dispHeader); // Look for accompanying sibling column Table.Cell hcell = table.getHeaderMap().get(dispHeader.name); String siblingFlag = hcell.attr.get("sibling"); if (siblingFlag != null) { // ...link the sibling and check that its flag is set String sibling = siblingFlag + "." + dispHeader.name; Table.Cell c = table.getHeaderMap().get(sibling); if (c != null && request.paramAsBoolean(siblingFlag, false)) { display.add( new DisplayHeader(c.value.toString(), siblingFlag + "." + dispHeader.display)); } } } } } else { for (Table.Cell cell : table.getHeaders()) { String d = cell.attr.get("default"); if (Booleans.parseBoolean(d, true) && checkOutputTimestamp(cell.value.toString(), request)) { display.add(new DisplayHeader(cell.value.toString(), cell.value.toString())); } } } return display; }
private RestChannelConsumer parseDocPercolate( PercolateRequest percolateRequest, RestRequest restRequest, NodeClient client) { percolateRequest.indices(Strings.splitStringByCommaToArray(restRequest.param("index"))); percolateRequest.documentType(restRequest.param("type")); percolateRequest.routing(restRequest.param("routing")); percolateRequest.preference(restRequest.param("preference")); percolateRequest.source(restRequest.contentOrSourceParam()); percolateRequest.indicesOptions( IndicesOptions.fromRequest(restRequest, percolateRequest.indicesOptions())); return channel -> executePercolate(client, percolateRequest, channel); }
public JsonContent( final Client client, final RestRequest request, final RestChannel channel, final SearchType searchType) { super(client, request, searchType); nettyChannel = NettyUtils.getChannel(channel); bulkIndex = request.param("bulk.index"); bulkType = request.param("bulk.type"); }
@Override public void handleRequest(final RestRequest request, final RestChannel channel) { final String[] aliases = request.paramAsStringArrayOrEmptyIfAll("name"); final String[] indices = Strings.splitStringByCommaToArray(request.param("index")); final GetAliasesRequest getAliasesRequest = new GetAliasesRequest(aliases); getAliasesRequest.indices(indices); getAliasesRequest.indicesOptions( IndicesOptions.fromRequest(request, getAliasesRequest.indicesOptions())); getAliasesRequest.local(request.paramAsBoolean("local", getAliasesRequest.local())); client .admin() .indices() .getAliases( getAliasesRequest, new RestBuilderListener<GetAliasesResponse>(channel) { @Override public RestResponse buildResponse( GetAliasesResponse response, XContentBuilder builder) throws Exception { // empty body, if indices were specified but no aliases were if (indices.length > 0 && response.getAliases().isEmpty()) { return new BytesRestResponse(OK, builder.startObject().endObject()); } else if (response.getAliases().isEmpty()) { String message = String.format( Locale.ROOT, "alias [%s] missing", toNamesString(getAliasesRequest.aliases())); builder .startObject() .field("error", message) .field("status", RestStatus.NOT_FOUND.getStatus()) .endObject(); return new BytesRestResponse(RestStatus.NOT_FOUND, builder); } builder.startObject(); for (ObjectObjectCursor<String, List<AliasMetaData>> entry : response.getAliases()) { builder.startObject(entry.key, XContentBuilder.FieldCaseConversion.NONE); builder.startObject(Fields.ALIASES); for (AliasMetaData alias : entry.value) { AliasMetaData.Builder.toXContent(alias, builder, ToXContent.EMPTY_PARAMS); } builder.endObject(); builder.endObject(); } builder.endObject(); return new BytesRestResponse(OK, builder); } }); }
@Override public void handleRequest(final RestRequest request, final RestChannel channel) { final ClusterUpdateSettingsRequest clusterUpdateSettingsRequest = Requests.clusterUpdateSettingsRequest(); clusterUpdateSettingsRequest.listenerThreaded(false); try { Map<String, Object> source = XContentFactory.xContent(request.content()).createParser(request.content()).mapAndClose(); if (source.containsKey("transient")) { clusterUpdateSettingsRequest.transientSettings((Map) source.get("transient")); } if (source.containsKey("persistent")) { clusterUpdateSettingsRequest.persistentSettings((Map) source.get("persistent")); } } catch (Exception e) { try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); } catch (IOException e1) { logger.warn("Failed to send response", e1); } return; } client .admin() .cluster() .updateSettings( clusterUpdateSettingsRequest, new ActionListener<ClusterUpdateSettingsResponse>() { @Override public void onResponse(ClusterUpdateSettingsResponse response) { try { channel.sendResponse(new StringRestResponse(RestStatus.OK)); } catch (Throwable e) { onFailure(e); } } @Override public void onFailure(Throwable e) { if (logger.isDebugEnabled()) { logger.debug("failed to handle cluster state", e); } try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); } catch (IOException e1) { logger.error("Failed to send failure response", e1); } } }); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final Client client) { final GetRequest getRequest = new GetRequest(request.param("index"), request.param("type"), request.param("id")); getRequest.operationThreaded(true); getRequest.refresh(request.paramAsBoolean("refresh", getRequest.refresh())); getRequest.routing( request.param( "routing")); // order is important, set it after routing, so it will set the routing getRequest.parent(request.param("parent")); getRequest.preference(request.param("preference")); getRequest.realtime(request.paramAsBoolean("realtime", getRequest.realtime())); // don't get any fields back... getRequest.fields(Strings.EMPTY_ARRAY); // TODO we can also just return the document size as Content-Length client.get( getRequest, new RestResponseListener<GetResponse>(channel) { @Override public RestResponse buildResponse(GetResponse response) { if (!response.isExists()) { return new BytesRestResponse(NOT_FOUND); } else { return new BytesRestResponse(OK); } } }); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final Client client) throws IOException { final SearchRequest searchRequest = new SearchRequest( Strings.splitStringByCommaToArray(request.param("index")), new SearchSourceBuilder()); searchRequest.indicesOptions( IndicesOptions.fromRequest(request, searchRequest.indicesOptions())); if (RestActions.hasBodyContent(request)) { final BytesReference sourceBytes = RestActions.getRestContent(request); try (XContentParser parser = XContentFactory.xContent(sourceBytes).createParser(sourceBytes)) { final QueryParseContext context = new QueryParseContext(queryRegistry, parser, parseFieldMatcher); searchRequest.source().suggest(SuggestBuilder.fromXContent(context, suggesters)); } } else { throw new IllegalArgumentException("no content or source provided to execute suggestion"); } searchRequest.routing(request.param("routing")); searchRequest.preference(request.param("preference")); client.search( searchRequest, new RestBuilderListener<SearchResponse>(channel) { @Override public RestResponse buildResponse(SearchResponse response, XContentBuilder builder) throws Exception { RestStatus restStatus = RestStatus.status( response.getSuccessfulShards(), response.getTotalShards(), response.getShardFailures()); builder.startObject(); buildBroadcastShardsHeader( builder, request, response.getTotalShards(), response.getSuccessfulShards(), response.getFailedShards(), response.getShardFailures()); Suggest suggest = response.getSuggest(); if (suggest != null) { suggest.toInnerXContent(builder, request); } builder.endObject(); return new BytesRestResponse(restStatus, builder); } }); }
@SuppressWarnings({"unchecked"}) @Override public void handleRequest(final RestRequest request, final RestChannel channel) { PutIndexTemplateRequest putRequest = new PutIndexTemplateRequest(request.param("name")); try { putRequest.create(request.paramAsBoolean("create", false)); putRequest.cause(request.param("cause", "")); putRequest.timeout(request.paramAsTime("timeout", timeValueSeconds(10))); putRequest.source( request.contentByteArray(), request.contentByteArrayOffset(), request.contentLength()); } catch (Exception e) { try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); } catch (IOException e1) { logger.warn("Failed to send response", e1); } return; } putRequest.template(request.param("template", putRequest.template())); putRequest.order(request.paramAsInt("order", putRequest.order())); client .admin() .indices() .putTemplate( putRequest, new ActionListener<PutIndexTemplateResponse>() { @Override public void onResponse(PutIndexTemplateResponse response) { try { XContentBuilder builder = RestXContentBuilder.restContentBuilder(request); builder .startObject() .field(Fields.OK, true) .field(Fields.ACKNOWLEDGED, response.acknowledged()) .endObject(); channel.sendResponse(new XContentRestResponse(request, OK, builder)); } catch (IOException e) { onFailure(e); } } @Override public void onFailure(Throwable e) { try { channel.sendResponse(new XContentThrowableRestResponse(request, e)); } catch (IOException e1) { logger.error("Failed to send failure response", e1); } } }); }
public static RestResponse buildTextPlainResponse( Table table, RestRequest request, RestChannel channel) { boolean verbose = request.paramAsBoolean("v", false); boolean help = request.paramAsBoolean("h", false); if (help) { int[] width = buildHelpWidths(table, request, verbose); StringBuilder out = new StringBuilder(); for (Table.Cell cell : table.getHeaders()) { // need to do left-align always, so create new cells pad(new Table.Cell(cell.value), width[0], request, out); out.append(" "); pad( new Table.Cell(cell.attr.containsKey("desc") ? cell.attr.get("desc") : "not available"), width[1], request, out); out.append("\n"); } return new StringRestResponse(RestStatus.OK, out.toString()); } int[] width = buildWidths(table, request, verbose); Set<String> displayHeaders = buildDisplayHeaders(table, request); StringBuilder out = new StringBuilder(); if (verbose) { // print the headers for (int i = 0; i < width.length; i++) { String headerName = table.getHeaders().get(i).value.toString(); if (displayHeaders.contains(headerName)) { pad(table.getHeaders().get(i), width[i], request, out); out.append(" "); } } out.append("\n"); } for (List<Table.Cell> row : table.getRows()) { for (int i = 0; i < width.length; i++) { String headerName = table.getHeaders().get(i).value.toString(); if (displayHeaders.contains(headerName)) { pad(row.get(i), width[i], request, out); out.append(" "); } } out.append("\n"); } return new StringRestResponse(RestStatus.OK, out.toString()); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final Client client) { PutRepositoryRequest putRepositoryRequest = putRepositoryRequest(request.param("repository")); putRepositoryRequest.source(request.content().toUtf8()); putRepositoryRequest.verify(request.paramAsBoolean("verify", true)); putRepositoryRequest.masterNodeTimeout( request.paramAsTime("master_timeout", putRepositoryRequest.masterNodeTimeout())); putRepositoryRequest.timeout(request.paramAsTime("timeout", putRepositoryRequest.timeout())); client .admin() .cluster() .putRepository( putRepositoryRequest, new AcknowledgedRestListener<PutRepositoryResponse>(channel)); }
void parseDocPercolate( PercolateRequest percolateRequest, RestRequest restRequest, RestChannel restChannel, final Client client) { percolateRequest.indices(Strings.splitStringByCommaToArray(restRequest.param("index"))); percolateRequest.documentType(restRequest.param("type")); percolateRequest.routing(restRequest.param("routing")); percolateRequest.preference(restRequest.param("preference")); percolateRequest.source(RestActions.getRestContent(restRequest)); percolateRequest.indicesOptions( IndicesOptions.fromRequest(restRequest, percolateRequest.indicesOptions())); executePercolate(percolateRequest, restChannel, client); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final NodeClient client) { RestoreSnapshotRequest restoreSnapshotRequest = restoreSnapshotRequest(request.param("repository"), request.param("snapshot")); restoreSnapshotRequest.masterNodeTimeout( request.paramAsTime("master_timeout", restoreSnapshotRequest.masterNodeTimeout())); restoreSnapshotRequest.waitForCompletion(request.paramAsBoolean("wait_for_completion", false)); restoreSnapshotRequest.source(request.content().utf8ToString()); client .admin() .cluster() .restoreSnapshot( restoreSnapshotRequest, new RestToXContentListener<RestoreSnapshotResponse>(channel)); }
@Override public void handleRequest( final RestRequest request, final RestChannel channel, final NodeClient client) throws Exception { boolean helpWanted = request.paramAsBoolean("help", false); if (helpWanted) { Table table = getTableWithHeader(request); int[] width = buildHelpWidths(table, request); BytesStreamOutput bytesOutput = channel.bytesOutput(); UTF8StreamWriter out = new UTF8StreamWriter().setOutput(bytesOutput); for (Table.Cell cell : table.getHeaders()) { // need to do left-align always, so create new cells pad(new Table.Cell(cell.value), width[0], request, out); out.append(" | "); pad( new Table.Cell(cell.attr.containsKey("alias") ? cell.attr.get("alias") : ""), width[1], request, out); out.append(" | "); pad( new Table.Cell(cell.attr.containsKey("desc") ? cell.attr.get("desc") : "not available"), width[2], request, out); out.append("\n"); } out.close(); channel.sendResponse( new BytesRestResponse( RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOutput.bytes())); } else { doRequest(request, channel, client); } }
public static RestResponse buildTextPlainResponse( Table table, RestRequest request, RestChannel channel) { boolean verbose = request.paramAsBoolean("v", false); List<DisplayHeader> headers = buildDisplayHeaders(table, request); int[] width = buildWidths(table, request, verbose, headers); StringBuilder out = new StringBuilder(); if (verbose) { for (int col = 0; col < headers.size(); col++) { DisplayHeader header = headers.get(col); pad( new Table.Cell(header.display, table.findHeaderByName(header.name)), width[col], request, out); out.append(" "); } out.append("\n"); } for (int row = 0; row < table.getRows().size(); row++) { for (int col = 0; col < headers.size(); col++) { DisplayHeader header = headers.get(col); pad(table.getAsMap().get(header.name).get(row), width[col], request, out); out.append(" "); } out.append("\n"); } return new StringRestResponse(RestStatus.OK, out.toString()); }
public static RestResponse buildTextPlainResponse( Table table, RestRequest request, RestChannel channel) { boolean verbose = request.paramAsBoolean("v", true); int[] width = buildWidths(table, request, verbose); Set<String> displayHeaders = buildDisplayHeaders(table, request); StringBuilder out = new StringBuilder(); if (verbose) { // print the headers for (int i = 0; i < width.length; i++) { String headerName = table.getHeaders().get(i).value.toString(); if (displayHeaders.contains(headerName)) { pad(table.getHeaders().get(i), width[i], request, out); out.append(" "); } } out.append("\n"); } for (List<Table.Cell> row : table.getRows()) { for (int i = 0; i < width.length; i++) { String headerName = table.getHeaders().get(i).value.toString(); if (displayHeaders.contains(headerName)) { pad(row.get(i), width[i], request, out); out.append(" "); } } out.append("\n"); } return new StringRestResponse(RestStatus.OK, out.toString()); }