How to use

io.swagger.annotations.ApiOperation

constructor

@PUT
@Produces(MediaType.APPLICATION_JSON)
@Path("/schemas/{schemaName}")
@ApiOperation(value = "Update a schema", notes = "Updates a schema")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Successfully updated schema"), @ApiResponse(code = 404, message = "Schema not found"), @ApiResponse(code = 400, message = "Missing or invalid request body"), @ApiResponse(code = 500, message = "Internal error")})
public SuccessResponse updateSchema(
  @ApiParam(value = "Name of the schema", required = true) @PathParam("schemaName") String schemaName,
  FormDataMultiPart multiPart) {
 return addOrUpdateSchema(schemaName, multiPart);
}

 @GET
 @Path("/")
 @ApiOperation(value = "Check controller health")
 @ApiResponses(value = {@ApiResponse(code = 200, message = "Good")})
 @Produces(MediaType.TEXT_PLAIN)
 public String checkHealth() {
  if (StringUtils.isNotBlank(controllerConf.generateVipUrl())) {
   return "GOOD";
  }
  return "";
 }
}

@GET
@Path("tables/{tableName}/segments/crc")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Gets crc of all segments of a table", notes = "Gets crc of all segments")
public String getCrcForAllSegments(
  @ApiParam(value = "Name of the table", required = true) @PathParam("tableName") String tableName) {
 return getAllCrcMetadataForTable(tableName);
}

@GET
@Path("/{streamRuleId}")
@Timed
@ApiOperation(value = "Get a single stream rules")
@Produces(MediaType.APPLICATION_JSON)
public StreamRule get(@ApiParam(name = "streamid", value = "The id of the stream whose stream rule we want.", required = true) @PathParam("streamid") String streamid,
           @ApiParam(name = "streamRuleId", value = "The stream rule id we are getting", required = true) @PathParam("streamRuleId") String streamRuleId) throws NotFoundException {
  checkPermission(RestPermissions.STREAMS_READ, streamid);
  return streamRuleService.load(streamRuleId);
}

 @GET
 @Produces(MediaType.APPLICATION_JSON)
 @Path("/table/{tableName}/size")
 @ApiOperation(value = "Show table storage size", notes = "Lists size of all the segments of the table")
 @ApiResponses(value = {@ApiResponse(code = 200, message = "Success"), @ApiResponse(code = 500, message = "Internal server error"), @ApiResponse(code = 404, message = "Table not found")})
 @Deprecated
 public String getTableSizeOld(
   @ApiParam(value = "Table Name with type", required = true) @PathParam("tableName") String tableName,
   @ApiParam(value = "Provide detailed information") @DefaultValue("true") @QueryParam("detailed") boolean detailed)
   throws WebApplicationException {
  return this.getTableSize(tableName, detailed);
 }
}

 @GET
 @Path("memory/offheap")
 @ApiOperation(value = "View current off-heap allocations", notes = "Lists all off-heap allocations and their associated sizes")
 @ApiResponses(value = {@ApiResponse(code = 200, message = "Success")})
 @Produces(MediaType.APPLICATION_JSON)
 public List<String> getOffHeapSizes() {
  return PinotDataBuffer.getBufferInfo();
 }
}

@GET
@Path("/available")
@Timed
@ApiOperation(value = "Get a list of all alarm callback types")
@Produces(MediaType.APPLICATION_JSON)
@Deprecated
public AvailableAlarmCallbacksResponse available(@ApiParam(name = "streamid", value = "The id of the stream whose alarm callbacks we want.", required = true)
                         @PathParam("streamid") String streamid) {
  checkPermission(RestPermissions.STREAMS_READ, streamid);
  return alarmCallbacksResource.available();
}

@DELETE
@Produces(MediaType.APPLICATION_JSON)
@Path("/schemas/{schemaName}")
@ApiOperation(value = "Delete a schema", notes = "Deletes a schema by name")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Successfully deleted schema"), @ApiResponse(code = 404, message = "Schema not found"), @ApiResponse(code = 409, message = "Schema is in use"), @ApiResponse(code = 500, message = "Error deleting schema")})
public SuccessResponse deleteSchema(
  @ApiParam(value = "Schema name", required = true) @PathParam("schemaName") String schemaName) {
 deleteSchemaInternal(schemaName);
 return new SuccessResponse("Schema " + schemaName + " deleted");
}

@POST
@Produces(MediaType.APPLICATION_JSON)
@Path("/schemas")
@ApiOperation(value = "Add a new schema", notes = "Adds a new schema")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Successfully deleted schema"), @ApiResponse(code = 404, message = "Schema not found"), @ApiResponse(code = 400, message = "Missing or invalid request body"), @ApiResponse(code = 500, message = "Internal error")})
public SuccessResponse addSchema(FormDataMultiPart multiPart) {
 return addOrUpdateSchema(null, multiPart);
}

@Deprecated
@GET
@Path("tables/{tableName}/segments/reload")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Reloads all segments of a table", notes = "Reloads all segments")
public SuccessResponse reloadAllSegmentsDeprecated(
  @ApiParam(value = "Name of the table", required = true) @PathParam("tableName") String tableName,
  @ApiParam(value = "realtime|offline") @QueryParam("type") String tableTypeStr) {
 CommonConstants.Helix.TableType tableType = Constants.validateTableType(tableTypeStr);
 return reloadAllSegmentsForTable(tableName, tableType);
}

/**
 * This method expects a tenant name and will return a list of tables tagged on that tenant. It assumes that the
 * tagname is for server tenants only.
 * @param tenantName
 * @return
 */
@GET
@Path("/tenants/{tenantName}/tables")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "List tables on a a server tenant")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Success"), @ApiResponse(code = 500, message = "Error reading list")})
public String getTablesOnTenant(
  @ApiParam(value = "Tenant name", required = true) @PathParam("tenantName") String tenantName) {
 return getTablesServedFromTenant(tenantName);
}

@GET
@Path("/instances")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "List all instances")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Success"), @ApiResponse(code = 500, message = "Internal error")})
public Instances getAllInstances() {
 return new Instances(pinotHelixResourceManager.getAllInstances());
}

@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/tables/{tableName}/externalview")
@ApiOperation(value = "Get table external view", notes = "Get table external view")
public TableView getExternalView(
  @ApiParam(value = "Name of the table", required = true) @PathParam("tableName") String tableName,
  @ApiParam(value = "realtime|offline", required = false) @QueryParam("tableType") String tableTypeStr
) {
 CommonConstants.Helix.TableType tableType = validateTableType(tableTypeStr);
 return getTableState(tableName, EXTERNALVIEW, tableType);
}

@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/routingTable/{tableName}")
@ApiOperation(value = "Debugging routing table")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Routing table information of a table"), @ApiResponse(code = 500, message = "Internal server error")})
public String debugRoutingTable(@ApiParam(value = "Name of the table") @PathParam("tableName") String tableName) {
 try {
  return _routingTable.dumpSnapshot(tableName);
 } catch (Exception e) {
  LOGGER.error("Caught exception while processing GET request", e);
  _brokerMetrics.addMeteredGlobalValue(BrokerMeter.UNCAUGHT_GET_EXCEPTIONS, 1);
  throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
 }
}

@GET
@Path("/tables")
@Produces(MediaType.APPLICATION_JSON)
//swagger annotations
@ApiOperation(value = "List tables", notes = "List all the tables on this server")
@ApiResponses(value = {@ApiResponse(code = 200, message = "Success", response = TablesList.class), @ApiResponse(code = 500, message = "Server initialization error", response = ErrorInfo.class)})
public String listTables() {
 InstanceDataManager instanceDataManager = checkGetInstanceDataManager();
 List<String> tables = new ArrayList<>(instanceDataManager.getAllTables());
 return ResourceUtils.convertToJsonString(new TablesList(tables));
}

@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/tables/{tableName}/idealstate")
@ApiOperation(value = "Get table ideal state", notes = "Get table ideal state")
public TableView getIdealState(
  @ApiParam(value = "Name of the table", required = true) @PathParam("tableName") String tableName,
  @ApiParam(value = "realtime|offline", required = false) @QueryParam("tableType") String tableTypeStr) {
 CommonConstants.Helix.TableType tableType = validateTableType(tableTypeStr);
 return getTableState(tableName, IDEALSTATE, tableType);
}

@GET
@Timed
@ApiOperation(value = "Get a single dashboards and all configurations of its widgets.")
@Path("/{dashboardId}")
@ApiResponses(value = {
    @ApiResponse(code = 404, message = "Dashboard not found."),
})
@Produces(MediaType.APPLICATION_JSON)
public Map<String, Object> get(@ApiParam(name = "dashboardId", required = true)
                @PathParam("dashboardId") String dashboardId) throws NotFoundException {
  checkPermission(RestPermissions.DASHBOARDS_READ, dashboardId);
  return dashboardService.load(dashboardId).asMap();
}

@GET
@Path("/{id}/configurations")
@RequiresPermissions(SidecarRestPermissions.CONFIGURATIONS_READ)
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Show configurations using this variable")
public List<Configuration> getConfigurationVariablesConfigurations(@ApiParam(name = "id", required = true)
                                  @PathParam("id") String id) {
  final ConfigurationVariable configurationVariable = findVariableOrFail(id);
  final List<Configuration> configurations = this.configurationService.findByConfigurationVariable(configurationVariable);
  return configurations;
}

@GET
@Timed
@Path("/nodes/{nodeId}")
@ApiOperation(value = "Information about a node.",
    notes = "This is returning information of a node in context to its state in the cluster. " +
        "Use the system API of the node itself to get system information.")
@ApiResponses(value = {
    @ApiResponse(code = 404, message = "Node not found.")
})
public NodeSummary node(@ApiParam(name = "nodeId", required = true) @PathParam("nodeId") @NotEmpty String nodeId) throws NodeNotFoundException {
  return nodeSummary(nodeService.byNodeId(nodeId));
}

@POST
@Path("tables/{tableName}/segments/reload")
@Produces(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Reloads all segments of a table", notes = "Reloads all segments")
public SuccessResponse reloadAllSegments(
  @ApiParam(value = "Name of the table", required = true) @PathParam("tableName") String tableName,
  @ApiParam(value = "realtime|offline") @QueryParam("type") String tableTypeStr) {
 CommonConstants.Helix.TableType tableType = Constants.validateTableType(tableTypeStr);
 return reloadAllSegmentsForTable(tableName, tableType);
}