+ maxVersions + " Batch Size => " + batchSize); Table hTable = RESTServlet.getInstance().getTable(this.table); tableScan.setBatch(batchSize); tableScan.setMaxVersions(maxVersions); int fetchSize = this.servlet.getConfiguration().getInt(Constants.SCAN_FETCH_SIZE, 10); tableScan.setCaching(fetchSize); tableScan.setReversed(reversed); return new TableScanResource(hTable.getScanner(tableScan), userRequestedLimit); } catch (IOException exp) { servlet.getMetrics().incrementFailedScanRequests(1); processException(exp); LOG.warn(exp.toString(), exp);
/** * @param conf Existing configuration to use in rest servlet * @param userProvider the login user provider * @return the RESTServlet singleton instance * @throws IOException */ public synchronized static RESTServlet getInstance(Configuration conf, UserProvider userProvider) throws IOException { if (INSTANCE == null) { INSTANCE = new RESTServlet(conf, userProvider); } return INSTANCE; }
private Response processUpdate(final NamespacesInstanceModel model, final boolean updateExisting, final UriInfo uriInfo) { if (servlet.isReadOnly()) { servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.FORBIDDEN).type(MIMETYPE_TEXT) .entity("Forbidden" + CRLF).build(); boolean namespaceExists = false; try { admin = servlet.getAdmin(); namespaceExists = doesNamespaceExist(admin, namespace); }catch (IOException e) { servlet.getMetrics().incrementFailedPutRequests(1); return processException(e); servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.FORBIDDEN).type(MIMETYPE_TEXT). entity("Namespace '" + namespace + "' already exists. Use REST PUT " + servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.FORBIDDEN).type(MIMETYPE_TEXT). entity("Namespace '" + namespace + "' does not exist. Use " +
@DELETE public Response delete(final @Context UriInfo uriInfo) { if (LOG.isTraceEnabled()) { LOG.trace("DELETE " + uriInfo.getAbsolutePath()); } servlet.getMetrics().incrementRequests(1); if (servlet.isReadOnly()) { return Response.status(Response.Status.FORBIDDEN) .type(MIMETYPE_TEXT).entity("Forbidden" + CRLF) .build(); } if (ScannerResource.delete(id)) { servlet.getMetrics().incrementSucessfulDeleteRequests(1); } else { servlet.getMetrics().incrementFailedDeleteRequests(1); } return Response.ok().build(); } }
/** * Build a response for a list of all namespaces request. * @param context servlet context * @param uriInfo (JAX-RS context variable) request URL * @return a response for a version request */ @GET @Produces({MIMETYPE_TEXT, MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF}) public Response get(final @Context ServletContext context, final @Context UriInfo uriInfo) { if (LOG.isTraceEnabled()) { LOG.trace("GET " + uriInfo.getAbsolutePath()); } servlet.getMetrics().incrementRequests(1); try { NamespacesModel rowModel = null; rowModel = new NamespacesModel(servlet.getAdmin()); servlet.getMetrics().incrementSucessfulGetRequests(1); return Response.ok(rowModel).build(); } catch (IOException e) { servlet.getMetrics().incrementFailedGetRequests(1); throw new RuntimeException("Cannot retrieve list of namespaces."); } }
final HttpServletResponse response) throws ServletException, IOException { final String doAsUserFromQuery = request.getParameter("doAs"); RESTServlet servlet = RESTServlet.getInstance(); if (doAsUserFromQuery != null) { Configuration conf = servlet.getConfiguration(); if (!servlet.supportsProxyuser()) { throw new ServletException("Support for proxyuser is not configured"); throw new ServletException(e.getMessage()); servlet.setEffectiveUser(doAsUserFromQuery); } else { String effectiveUser = request.getRemoteUser(); servlet.setEffectiveUser(effectiveUser);
LOG.trace("DELETE " + uriInfo.getAbsolutePath()); servlet.getMetrics().incrementRequests(1); if (servlet.isReadOnly()) { servlet.getMetrics().incrementFailedDeleteRequests(1); return Response.status(Response.Status.FORBIDDEN) .type(MIMETYPE_TEXT).entity("Forbidden" + CRLF) table = servlet.getTable(tableResource.getName()); table.delete(delete); servlet.getMetrics().incrementSucessfulDeleteRequests(1); if (LOG.isTraceEnabled()) { LOG.trace("DELETE " + delete.toString()); servlet.getMetrics().incrementFailedDeleteRequests(1); return processException(e); } finally {
@GET @Produces({ Constants.MIMETYPE_PROTOBUF, Constants.MIMETYPE_PROTOBUF_IETF }) public Response getProtobuf( final @Context UriInfo uriInfo, final @HeaderParam("Accept") String contentType) { if (LOG.isTraceEnabled()) { LOG.trace("GET " + uriInfo.getAbsolutePath() + " as " + MIMETYPE_BINARY); } servlet.getMetrics().incrementRequests(1); try { int fetchSize = this.servlet.getConfiguration().getInt(Constants.SCAN_FETCH_SIZE, 10); StreamingOutput stream = new ProtobufStreamingOutput(this.results, contentType, userRequestedLimit, fetchSize); servlet.getMetrics().incrementSucessfulScanRequests(1); ResponseBuilder response = Response.ok(stream); response.header("content-type", contentType); return response.build(); } catch (Exception exp) { servlet.getMetrics().incrementFailedScanRequests(1); processException(exp); LOG.warn(exp.toString(), exp); return null; } }
public ScannerResultGenerator(final String tableName, final RowSpec rowspec, final Filter filter, final int caching, final boolean cacheBlocks) throws IllegalArgumentException, IOException { Table table = RESTServlet.getInstance().getTable(tableName); try { Scan scan;
@Path("{scanner: .+}") public ScannerInstanceResource getScannerInstanceResource( final @PathParam("scanner") String id) throws IOException { ScannerInstanceResource instance = scanners.get(id); if (instance == null) { servlet.getMetrics().incrementFailedGetRequests(1); return new ScannerInstanceResource(); } else { servlet.getMetrics().incrementSucessfulGetRequests(1); } return instance; } }
@Test public void testMetrics() throws IOException, JAXBException { final String path = "/" + TABLE + "/" + ROW_4 + "/" + COLUMN_1; Response response = client.put(path, Constants.MIMETYPE_BINARY, Bytes.toBytes(VALUE_4)); assertEquals(200, response.getCode()); Thread.yield(); response = client.get(path, Constants.MIMETYPE_JSON); assertEquals(200, response.getCode()); assertEquals(Constants.MIMETYPE_JSON, response.getHeader("content-type")); response = deleteRow(TABLE, ROW_4); assertEquals(200, response.getCode()); UserProvider userProvider = UserProvider.instantiate(conf); METRICS_ASSERT.assertCounterGt("requests", 2l, RESTServlet.getInstance(conf, userProvider).getMetrics().getSource()); METRICS_ASSERT.assertCounterGt("successfulGet", 0l, RESTServlet.getInstance(conf, userProvider).getMetrics().getSource()); METRICS_ASSERT.assertCounterGt("successfulPut", 0l, RESTServlet.getInstance(conf, userProvider).getMetrics().getSource()); METRICS_ASSERT.assertCounterGt("successfulDelete", 0l, RESTServlet.getInstance(conf, userProvider).getMetrics().getSource()); }
public ResourceBase() throws IOException { servlet = RESTServlet.getInstance(); try { accessDeniedClazz = Class.forName("org.apache.hadoop.hbase.security.AccessDeniedException"); } catch (ClassNotFoundException e) { } }
Table table = null; try { table = servlet.getTable(tableResource.getName()); if (model.getRows().size() != 1) { servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.BAD_REQUEST).type(MIMETYPE_TEXT) .entity("Bad request: Number of rows specified is not 1." + CRLF).build(); int cellModelCount = cellModels.size(); if (key == null || cellModelCount <= 1) { servlet.getMetrics().incrementFailedPutRequests(1); return Response .status(Response.Status.BAD_REQUEST) servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.BAD_REQUEST) .type(MIMETYPE_TEXT).entity("Bad request: Column found to be null." + CRLF) servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.BAD_REQUEST).type(MIMETYPE_TEXT) .entity("Bad request: The column to put and check do not match." + CRLF).build(); servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.BAD_REQUEST) .type(MIMETYPE_TEXT).entity("Bad request: Column incorrectly specified." + CRLF) servlet.getMetrics().incrementFailedPutRequests(1); return Response.status(Response.Status.NOT_MODIFIED) .type(MIMETYPE_TEXT).entity("Value not Modified" + CRLF)
userProvider, conf); FilterHolder authFilter = pair.getFirst(); RESTServlet servlet = RESTServlet.getInstance(conf, userProvider); int maxThreads = servlet.getConfiguration().getInt(REST_THREAD_POOL_THREADS_MAX, 100); int minThreads = servlet.getConfiguration().getInt(REST_THREAD_POOL_THREADS_MIN, 2); int queueSize = servlet.getConfiguration().getInt(REST_THREAD_POOL_TASK_QUEUE_SIZE, -1); int idleTimeout = servlet.getConfiguration().getInt(REST_THREAD_POOL_THREAD_IDLE_TIMEOUT, 60000); QueuedThreadPool threadPool = queueSize > 0 ? new QueuedThreadPool(maxThreads, minThreads, idleTimeout, new ArrayBlockingQueue<>(queueSize)) : String host = servlet.getConfiguration().get("hbase.rest.host", "0.0.0.0"); int servicePort = servlet.getConfiguration().getInt("hbase.rest.port", 8080); HttpConfiguration httpConfig = new HttpConfiguration(); httpConfig.setSecureScheme("https"); String[] excludeCiphers = servlet.getConfiguration().getStrings( REST_SSL_EXCLUDE_CIPHER_SUITES, ArrayUtils.EMPTY_STRING_ARRAY); if (excludeCiphers.length != 0) { sslCtxFactory.setExcludeCipherSuites(excludeCiphers); String[] includeCiphers = servlet.getConfiguration().getStrings( REST_SSL_INCLUDE_CIPHER_SUITES, ArrayUtils.EMPTY_STRING_ARRAY); if (includeCiphers.length != 0) { String[] excludeProtocols = servlet.getConfiguration().getStrings( REST_SSL_EXCLUDE_PROTOCOLS, ArrayUtils.EMPTY_STRING_ARRAY); if (excludeProtocols.length != 0) {
public ScannerResultGenerator(final String tableName, final RowSpec rowspec, final Filter filter) throws IllegalArgumentException, IOException { HTablePool pool = RESTServlet.getInstance().getTablePool(); HTableInterface table = pool.getTable(tableName); try {
/** * @return true if the table exists * @throws IOException */ boolean exists() throws IOException { return servlet.getAdmin().tableExists(TableName.valueOf(table)); }
/** * Helper method to determine if server should * only respond to GET HTTP method requests. * @return boolean for server read-only state */ boolean isReadOnly() { return getConfiguration().getBoolean("hbase.rest.readonly", false); }
/** * Constructor with existing configuration * @param conf existing configuration * @param userProvider the login user provider * @throws IOException */ RESTServlet(final Configuration conf, final UserProvider userProvider) throws IOException { this.realUser = userProvider.getCurrent().getUGI(); this.conf = conf; registerCustomFilter(conf); int cleanInterval = conf.getInt(CLEANUP_INTERVAL, 10 * 1000); int maxIdleTime = conf.getInt(MAX_IDLETIME, 10 * 60 * 1000); connectionCache = new ConnectionCache( conf, userProvider, cleanInterval, maxIdleTime); if (supportsProxyuser()) { ProxyUsers.refreshSuperUserGroupsConfiguration(conf); } metrics = new MetricsREST(); pauseMonitor = new JvmPauseMonitor(conf, metrics.getSource()); pauseMonitor.start(); }
private HTableDescriptor getTableSchema() throws IOException, TableNotFoundException { Table table = servlet.getTable(tableResource.getName()); try { return table.getTableDescriptor(); } finally { table.close(); } }
@GET @Produces({MIMETYPE_TEXT, MIMETYPE_XML, MIMETYPE_JSON}) public Response get(final @Context UriInfo uriInfo) { if (LOG.isTraceEnabled()) { LOG.trace("GET " + uriInfo.getAbsolutePath()); } servlet.getMetrics().incrementRequests(1); try { StorageClusterVersionModel model = new StorageClusterVersionModel(); model.setVersion( servlet.getAdmin().getClusterMetrics(EnumSet.of(Option.HBASE_VERSION)) .getHBaseVersion()); ResponseBuilder response = Response.ok(model); response.cacheControl(cacheControl); servlet.getMetrics().incrementSucessfulGetRequests(1); return response.build(); } catch (IOException e) { servlet.getMetrics().incrementFailedGetRequests(1); return Response.status(Response.Status.SERVICE_UNAVAILABLE) .type(MIMETYPE_TEXT).entity("Unavailable" + CRLF) .build(); } } }