src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
AsyncProcess { public <CResult> AsyncRequestFuture submitAll(TableName tableName, List<? extends Row> rows, Batch.Callback<CResult> callback, Object[] results) { return submitAll(null, tableName, rows, callback, results); } AsyncProcess(ClusterConnection hc, Configuration conf, ExecutorService pool,
RpcRetryingCallerFactory rpcCaller, boolean useGlobalErrors, RpcControllerFactory rpcFactory); AsyncRequestFuture submit(TableName tableName, List<? extends Row> rows,
boolean atLeastOne, Batch.Callback<CResult> callback, boolean needResults); AsyncRequestFuture submit(ExecutorService pool, TableName tableName,
List<? extends Row> rows, boolean atLeastOne, Batch.Callback<CResult> callback,
boolean needResults); AsyncRequestFuture submitAll(TableName tableName,
List<? extends Row> rows, Batch.Callback<CResult> callback, Object[] results); AsyncRequestFuture submitAll(ExecutorService pool, TableName tableName,
List<? extends Row> rows, Batch.Callback<CResult> callback, Object[] results); boolean hasError(); RetriesExhaustedWithDetailsException waitForAllPreviousOpsAndReset(
List<Row> failedRows); static final String PRIMARY_CALL_TIMEOUT_KEY; static final String START_LOG_ERRORS_AFTER_COUNT_KEY; static final int DEFAULT_START_LOG_ERRORS_AFTER_COUNT; } | @Test public void testReplicaReplicaSuccess() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(10, 1000, 0); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2, DUMMY_BYTES_3); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[3]); verifyReplicaResult(ars, RR.TRUE, RR.TRUE, RR.FALSE); Assert.assertEquals(2, ap.getReplicaCallCount()); }
@Test public void testReplicaPrimarySuccessWoReplicaCalls() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(1000, 10, 0); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2, DUMMY_BYTES_3); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[3]); verifyReplicaResult(ars, RR.FALSE, RR.FALSE, RR.FALSE); Assert.assertEquals(0, ap.getReplicaCallCount()); }
@Test public void testReplicaParallelCallsSucceed() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(0, 0, 0); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[2]); verifyReplicaResult(ars, RR.DONT_CARE, RR.DONT_CARE); long replicaCalls = ap.getReplicaCallCount(); Assert.assertTrue(replicaCalls >= 0); Assert.assertTrue(replicaCalls <= 2); }
@Test public void testReplicaPartialReplicaCall() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(1000, 0, 0); ap.setPrimaryCallDelay(sn2, 2000); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[2]); verifyReplicaResult(ars, RR.FALSE, RR.TRUE); Assert.assertEquals(1, ap.getReplicaCallCount()); }
@Test public void testReplicaMainFailsBeforeReplicaCalls() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(1000, 0, 0, 1); ap.addFailures(hri1, hri2); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[2]); verifyReplicaResult(ars, RR.FAILED, RR.FAILED); Assert.assertEquals(0, ap.getReplicaCallCount()); }
@Test public void testReplicaReplicaSuccessWithParallelFailures() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(0, 1000, 1000, 1); ap.addFailures(hri1, hri1r2, hri2); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[2]); verifyReplicaResult(ars, RR.TRUE, RR.TRUE); Assert.assertEquals(2, ap.getReplicaCallCount()); }
@Test public void testReplicaAllCallsFailForOneRegion() throws Exception { MyAsyncProcessWithReplicas ap = createReplicaAp(500, 1000, 0, 1); ap.addFailures(hri1, hri1r1, hri1r2, hri2r1); List<Get> rows = makeTimelineGets(DUMMY_BYTES_1, DUMMY_BYTES_2); AsyncRequestFuture ars = ap.submitAll(DUMMY_TABLE, rows, null, new Object[2]); verifyReplicaResult(ars, RR.FAILED, RR.FALSE); Assert.assertEquals(3, ars.getErrors().getNumExceptions()); for (int i = 0; i < ars.getErrors().getNumExceptions(); ++i) { Assert.assertArrayEquals(DUMMY_BYTES_1, ars.getErrors().getRow(i).getRow()); } } |
Get extends Query implements Row, Comparable<Row> { public Get(byte [] row) { Mutation.checkRow(row); this.row = row; } Get(byte [] row); Get(Get get); boolean isCheckExistenceOnly(); Get setCheckExistenceOnly(boolean checkExistenceOnly); boolean isClosestRowBefore(); Get setClosestRowBefore(boolean closestRowBefore); Get addFamily(byte [] family); Get addColumn(byte [] family, byte [] qualifier); Get setTimeRange(long minStamp, long maxStamp); Get setTimeStamp(long timestamp); @Override Get setColumnFamilyTimeRange(byte[] cf, long minStamp, long maxStamp); Get setMaxVersions(); Get setMaxVersions(int maxVersions); Get setMaxResultsPerColumnFamily(int limit); Get setRowOffsetPerColumnFamily(int offset); @Override Get setFilter(Filter filter); Get setCacheBlocks(boolean cacheBlocks); boolean getCacheBlocks(); @Override byte [] getRow(); int getMaxVersions(); int getMaxResultsPerColumnFamily(); int getRowOffsetPerColumnFamily(); TimeRange getTimeRange(); Set<byte[]> familySet(); int numFamilies(); boolean hasFamilies(); Map<byte[],NavigableSet<byte[]>> getFamilyMap(); @Override Map<String, Object> getFingerprint(); @Override Map<String, Object> toMap(int maxCols); @Override int compareTo(Row other); @Override int hashCode(); @Override boolean equals(Object obj); @Override Get setAttribute(String name, byte[] value); @Override Get setId(String id); @Override Get setAuthorizations(Authorizations authorizations); @Override Get setACL(Map<String, Permission> perms); @Override Get setACL(String user, Permission perms); @Override Get setConsistency(Consistency consistency); @Override Get setReplicaId(int Id); @Override Get setIsolationLevel(IsolationLevel level); } | @Test public void testDynamicFilter() throws Exception { Configuration conf = HBaseConfiguration.create(); String localPath = conf.get("hbase.local.dir") + File.separator + "jars" + File.separator; File jarFile = new File(localPath, "MockFilter.jar"); jarFile.delete(); assertFalse("Should be deleted: " + jarFile.getPath(), jarFile.exists()); ClientProtos.Get getProto1 = ClientProtos.Get.parseFrom(Base64.decode(PB_GET)); ClientProtos.Get getProto2 = ClientProtos.Get.parseFrom(Base64.decode(PB_GET_WITH_FILTER_LIST)); try { ProtobufUtil.toGet(getProto1); fail("Should not be able to load the filter class"); } catch (IOException ioe) { assertTrue(ioe.getCause() instanceof ClassNotFoundException); } try { ProtobufUtil.toGet(getProto2); fail("Should not be able to load the filter class"); } catch (IOException ioe) { assertTrue(ioe.getCause() instanceof InvocationTargetException); InvocationTargetException ite = (InvocationTargetException)ioe.getCause(); assertTrue(ite.getTargetException() instanceof DeserializationException); } FileOutputStream fos = new FileOutputStream(jarFile); fos.write(Base64.decode(MOCK_FILTER_JAR)); fos.close(); Get get1 = ProtobufUtil.toGet(getProto1); assertEquals("test.MockFilter", get1.getFilter().getClass().getName()); Get get2 = ProtobufUtil.toGet(getProto2); assertTrue(get2.getFilter() instanceof FilterList); List<Filter> filters = ((FilterList)get2.getFilter()).getFilters(); assertEquals(3, filters.size()); assertEquals("test.MockFilter", filters.get(0).getClass().getName()); assertEquals("my.MockFilter", filters.get(1).getClass().getName()); assertTrue(filters.get(2) instanceof KeyOnlyFilter); } |
Operation { public String toJSON(int maxCols) throws IOException { return JsonMapper.writeMapAsString(toMap(maxCols)); } abstract Map<String, Object> getFingerprint(); abstract Map<String, Object> toMap(int maxCols); Map<String, Object> toMap(); String toJSON(int maxCols); String toJSON(); String toString(int maxCols); @Override String toString(); } | @Test public void testOperationJSON() throws IOException { Scan scan = new Scan(ROW); scan.addColumn(FAMILY, QUALIFIER); String json = scan.toJSON(); Map<String, Object> parsedJSON = mapper.readValue(json, HashMap.class); assertEquals("startRow incorrect in Scan.toJSON()", Bytes.toStringBinary(ROW), parsedJSON.get("startRow")); List familyInfo = (List) ((Map) parsedJSON.get("families")).get( Bytes.toStringBinary(FAMILY)); assertNotNull("Family absent in Scan.toJSON()", familyInfo); assertEquals("Qualifier absent in Scan.toJSON()", 1, familyInfo.size()); assertEquals("Qualifier incorrect in Scan.toJSON()", Bytes.toStringBinary(QUALIFIER), familyInfo.get(0)); Get get = new Get(ROW); get.addColumn(FAMILY, QUALIFIER); json = get.toJSON(); parsedJSON = mapper.readValue(json, HashMap.class); assertEquals("row incorrect in Get.toJSON()", Bytes.toStringBinary(ROW), parsedJSON.get("row")); familyInfo = (List) ((Map) parsedJSON.get("families")).get( Bytes.toStringBinary(FAMILY)); assertNotNull("Family absent in Get.toJSON()", familyInfo); assertEquals("Qualifier absent in Get.toJSON()", 1, familyInfo.size()); assertEquals("Qualifier incorrect in Get.toJSON()", Bytes.toStringBinary(QUALIFIER), familyInfo.get(0)); Put put = new Put(ROW); put.add(FAMILY, QUALIFIER, VALUE); json = put.toJSON(); parsedJSON = mapper.readValue(json, HashMap.class); assertEquals("row absent in Put.toJSON()", Bytes.toStringBinary(ROW), parsedJSON.get("row")); familyInfo = (List) ((Map) parsedJSON.get("families")).get( Bytes.toStringBinary(FAMILY)); assertNotNull("Family absent in Put.toJSON()", familyInfo); assertEquals("KeyValue absent in Put.toJSON()", 1, familyInfo.size()); Map kvMap = (Map) familyInfo.get(0); assertEquals("Qualifier incorrect in Put.toJSON()", Bytes.toStringBinary(QUALIFIER), kvMap.get("qualifier")); assertEquals("Value length incorrect in Put.toJSON()", VALUE.length, kvMap.get("vlen")); Delete delete = new Delete(ROW); delete.deleteColumn(FAMILY, QUALIFIER); json = delete.toJSON(); parsedJSON = mapper.readValue(json, HashMap.class); assertEquals("row absent in Delete.toJSON()", Bytes.toStringBinary(ROW), parsedJSON.get("row")); familyInfo = (List) ((Map) parsedJSON.get("families")).get( Bytes.toStringBinary(FAMILY)); assertNotNull("Family absent in Delete.toJSON()", familyInfo); assertEquals("KeyValue absent in Delete.toJSON()", 1, familyInfo.size()); kvMap = (Map) familyInfo.get(0); assertEquals("Qualifier incorrect in Delete.toJSON()", Bytes.toStringBinary(QUALIFIER), kvMap.get("qualifier")); } |
DelayingRunner implements Runnable { public DelayingRunner(long sleepTime, Map.Entry<byte[], List<Action<T>>> e) { this.sleepTime = sleepTime; add(e); } DelayingRunner(long sleepTime, Map.Entry<byte[], List<Action<T>>> e); void setRunner(Runnable runner); @Override void run(); void add(Map.Entry<byte[], List<Action<T>>> e); MultiAction<T> getActions(); long getSleepTime(); } | @SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testDelayingRunner() throws Exception{ MultiAction<Row> ma = new MultiAction<Row>(); ma.add(hri1.getRegionName(), new Action<Row>(new Put(DUMMY_BYTES_1), 0)); final AtomicLong endTime = new AtomicLong(); final long sleepTime = 1000; DelayingRunner runner = new DelayingRunner(sleepTime, ma.actions.entrySet().iterator().next()); runner.setRunner(new Runnable() { @Override public void run() { endTime.set(EnvironmentEdgeManager.currentTime()); } }); long startTime = EnvironmentEdgeManager.currentTime(); runner.run(); long delay = endTime.get() - startTime; assertTrue("DelayingRunner did not delay long enough", delay >= sleepTime); assertFalse("DelayingRunner delayed too long", delay > sleepTime + sleepTime*0.2); } |
Scan extends Query { @Override public Scan setAttribute(String name, byte[] value) { return (Scan) super.setAttribute(name, value); } Scan(); Scan(byte [] startRow, Filter filter); Scan(byte [] startRow); Scan(byte [] startRow, byte [] stopRow); Scan(Scan scan); Scan(Get get); boolean isGetScan(); Scan addFamily(byte [] family); Scan addColumn(byte [] family, byte [] qualifier); Scan setTimeRange(long minStamp, long maxStamp); Scan setTimeStamp(long timestamp); @Override Scan setColumnFamilyTimeRange(byte[] cf, long minStamp, long maxStamp); Scan setStartRow(byte [] startRow); Scan setStopRow(byte [] stopRow); Scan setRowPrefixFilter(byte[] rowPrefix); Scan setMaxVersions(); Scan setMaxVersions(int maxVersions); Scan setBatch(int batch); Scan setMaxResultsPerColumnFamily(int limit); Scan setRowOffsetPerColumnFamily(int offset); Scan setCaching(int caching); long getMaxResultSize(); Scan setMaxResultSize(long maxResultSize); @Override Scan setFilter(Filter filter); Scan setFamilyMap(Map<byte [], NavigableSet<byte []>> familyMap); Map<byte [], NavigableSet<byte []>> getFamilyMap(); int numFamilies(); boolean hasFamilies(); byte[][] getFamilies(); byte [] getStartRow(); byte [] getStopRow(); int getMaxVersions(); int getBatch(); int getMaxResultsPerColumnFamily(); int getRowOffsetPerColumnFamily(); int getCaching(); TimeRange getTimeRange(); @Override Filter getFilter(); boolean hasFilter(); Scan setCacheBlocks(boolean cacheBlocks); boolean getCacheBlocks(); Scan setReversed(boolean reversed); boolean isReversed(); Scan setAllowPartialResults(final boolean allowPartialResults); boolean getAllowPartialResults(); Scan setLoadColumnFamiliesOnDemand(boolean value); Boolean getLoadColumnFamiliesOnDemandValue(); boolean doLoadColumnFamiliesOnDemand(); @Override Map<String, Object> getFingerprint(); @Override Map<String, Object> toMap(int maxCols); Scan setRaw(boolean raw); boolean isRaw(); Scan setSmall(boolean small); boolean isSmall(); @Override Scan setAttribute(String name, byte[] value); @Override Scan setId(String id); @Override Scan setAuthorizations(Authorizations authorizations); @Override Scan setACL(Map<String, Permission> perms); @Override Scan setACL(String user, Permission perms); @Override Scan setConsistency(Consistency consistency); @Override Scan setReplicaId(int Id); @Override Scan setIsolationLevel(IsolationLevel level); Scan setScanMetricsEnabled(final boolean enabled); boolean isScanMetricsEnabled(); ScanMetrics getScanMetrics(); @Deprecated
static final String SCAN_ATTRIBUTES_METRICS_ENABLE; @Deprecated
static final String SCAN_ATTRIBUTES_METRICS_DATA; static final String SCAN_ATTRIBUTES_TABLE_NAME; @Deprecated
static final String HINT_LOOKAHEAD; } | @Test public void testAttributesSerialization() throws IOException { Scan scan = new Scan(); scan.setAttribute("attribute1", Bytes.toBytes("value1")); scan.setAttribute("attribute2", Bytes.toBytes("value2")); scan.setAttribute("attribute3", Bytes.toBytes("value3")); ClientProtos.Scan scanProto = ProtobufUtil.toScan(scan); Scan scan2 = ProtobufUtil.toScan(scanProto); Assert.assertNull(scan2.getAttribute("absent")); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value1"), scan2.getAttribute("attribute1"))); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value2"), scan2.getAttribute("attribute2"))); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value3"), scan2.getAttribute("attribute3"))); Assert.assertEquals(3, scan2.getAttributesMap().size()); }
@Test public void testScanAttributes() { Scan scan = new Scan(); Assert.assertTrue(scan.getAttributesMap().isEmpty()); Assert.assertNull(scan.getAttribute("absent")); scan.setAttribute("absent", null); Assert.assertTrue(scan.getAttributesMap().isEmpty()); Assert.assertNull(scan.getAttribute("absent")); scan.setAttribute("attribute1", Bytes.toBytes("value1")); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value1"), scan.getAttribute("attribute1"))); Assert.assertEquals(1, scan.getAttributesMap().size()); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value1"), scan.getAttributesMap().get("attribute1"))); scan.setAttribute("attribute1", Bytes.toBytes("value12")); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value12"), scan.getAttribute("attribute1"))); Assert.assertEquals(1, scan.getAttributesMap().size()); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value12"), scan.getAttributesMap().get("attribute1"))); scan.setAttribute("attribute2", Bytes.toBytes("value2")); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value2"), scan.getAttribute("attribute2"))); Assert.assertEquals(2, scan.getAttributesMap().size()); Assert.assertTrue(Arrays.equals(Bytes.toBytes("value2"), scan.getAttributesMap().get("attribute2"))); scan.setAttribute("attribute2", null); Assert.assertNull(scan.getAttribute("attribute2")); Assert.assertEquals(1, scan.getAttributesMap().size()); Assert.assertNull(scan.getAttributesMap().get("attribute2")); scan.setAttribute("attribute2", null); Assert.assertNull(scan.getAttribute("attribute2")); Assert.assertEquals(1, scan.getAttributesMap().size()); Assert.assertNull(scan.getAttributesMap().get("attribute2")); scan.setAttribute("attribute1", null); Assert.assertNull(scan.getAttribute("attribute1")); Assert.assertTrue(scan.getAttributesMap().isEmpty()); Assert.assertNull(scan.getAttributesMap().get("attribute1")); } |
Scan extends Query { @Override public Scan setAuthorizations(Authorizations authorizations) { return (Scan) super.setAuthorizations(authorizations); } Scan(); Scan(byte [] startRow, Filter filter); Scan(byte [] startRow); Scan(byte [] startRow, byte [] stopRow); Scan(Scan scan); Scan(Get get); boolean isGetScan(); Scan addFamily(byte [] family); Scan addColumn(byte [] family, byte [] qualifier); Scan setTimeRange(long minStamp, long maxStamp); Scan setTimeStamp(long timestamp); @Override Scan setColumnFamilyTimeRange(byte[] cf, long minStamp, long maxStamp); Scan setStartRow(byte [] startRow); Scan setStopRow(byte [] stopRow); Scan setRowPrefixFilter(byte[] rowPrefix); Scan setMaxVersions(); Scan setMaxVersions(int maxVersions); Scan setBatch(int batch); Scan setMaxResultsPerColumnFamily(int limit); Scan setRowOffsetPerColumnFamily(int offset); Scan setCaching(int caching); long getMaxResultSize(); Scan setMaxResultSize(long maxResultSize); @Override Scan setFilter(Filter filter); Scan setFamilyMap(Map<byte [], NavigableSet<byte []>> familyMap); Map<byte [], NavigableSet<byte []>> getFamilyMap(); int numFamilies(); boolean hasFamilies(); byte[][] getFamilies(); byte [] getStartRow(); byte [] getStopRow(); int getMaxVersions(); int getBatch(); int getMaxResultsPerColumnFamily(); int getRowOffsetPerColumnFamily(); int getCaching(); TimeRange getTimeRange(); @Override Filter getFilter(); boolean hasFilter(); Scan setCacheBlocks(boolean cacheBlocks); boolean getCacheBlocks(); Scan setReversed(boolean reversed); boolean isReversed(); Scan setAllowPartialResults(final boolean allowPartialResults); boolean getAllowPartialResults(); Scan setLoadColumnFamiliesOnDemand(boolean value); Boolean getLoadColumnFamiliesOnDemandValue(); boolean doLoadColumnFamiliesOnDemand(); @Override Map<String, Object> getFingerprint(); @Override Map<String, Object> toMap(int maxCols); Scan setRaw(boolean raw); boolean isRaw(); Scan setSmall(boolean small); boolean isSmall(); @Override Scan setAttribute(String name, byte[] value); @Override Scan setId(String id); @Override Scan setAuthorizations(Authorizations authorizations); @Override Scan setACL(Map<String, Permission> perms); @Override Scan setACL(String user, Permission perms); @Override Scan setConsistency(Consistency consistency); @Override Scan setReplicaId(int Id); @Override Scan setIsolationLevel(IsolationLevel level); Scan setScanMetricsEnabled(final boolean enabled); boolean isScanMetricsEnabled(); ScanMetrics getScanMetrics(); @Deprecated
static final String SCAN_ATTRIBUTES_METRICS_ENABLE; @Deprecated
static final String SCAN_ATTRIBUTES_METRICS_DATA; static final String SCAN_ATTRIBUTES_TABLE_NAME; @Deprecated
static final String HINT_LOOKAHEAD; } | @Test public void testSetAuthorizations() { Scan scan = new Scan(); try { scan.setAuthorizations(new Authorizations("\u002b|\u0029")); scan.setAuthorizations(new Authorizations("A", "B", "0123", "A0", "1A1", "_a")); scan.setAuthorizations(new Authorizations("A|B")); scan.setAuthorizations(new Authorizations("A&B")); scan.setAuthorizations(new Authorizations("!B")); scan.setAuthorizations(new Authorizations("A", "(A)")); scan.setAuthorizations(new Authorizations("A", "{A")); scan.setAuthorizations(new Authorizations(" ")); scan.setAuthorizations(new Authorizations(":B")); scan.setAuthorizations(new Authorizations("-B")); scan.setAuthorizations(new Authorizations(".B")); scan.setAuthorizations(new Authorizations("/B")); } catch (IllegalArgumentException e) { fail("should not throw exception"); } } |
Put extends Mutation implements HeapSize, Comparable<Row> { public Put addColumn(byte [] family, byte [] qualifier, byte [] value) { return addColumn(family, qualifier, this.ts, value); } Put(byte [] row); Put(byte[] row, long ts); Put(byte [] rowArray, int rowOffset, int rowLength); Put(ByteBuffer row, long ts); Put(ByteBuffer row); Put(byte [] rowArray, int rowOffset, int rowLength, long ts); Put(Put putToCopy); @Deprecated Put add(byte [] family, byte [] qualifier, byte [] value); Put addColumn(byte [] family, byte [] qualifier, byte [] value); Put addImmutable(byte [] family, byte [] qualifier, byte [] value); @InterfaceAudience.Private Put addImmutable(byte[] family, byte [] qualifier, byte [] value, Tag[] tag); @Deprecated Put add(byte [] family, byte [] qualifier, long ts, byte [] value); Put addColumn(byte [] family, byte [] qualifier, long ts, byte [] value); Put addImmutable(byte [] family, byte [] qualifier, long ts, byte [] value); @InterfaceAudience.Private Put addImmutable(byte[] family, byte[] qualifier, long ts, byte[] value, Tag[] tag); @InterfaceAudience.Private Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value,
Tag[] tag); @Deprecated Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value); Put addColumn(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value); Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value); Put add(Cell kv); boolean has(byte [] family, byte [] qualifier); boolean has(byte [] family, byte [] qualifier, long ts); boolean has(byte [] family, byte [] qualifier, byte [] value); boolean has(byte [] family, byte [] qualifier, long ts, byte [] value); List<Cell> get(byte[] family, byte[] qualifier); @Override Put setAttribute(String name, byte[] value); @Override Put setId(String id); @Override @Deprecated Put setWriteToWAL(boolean write); @Override Put setDurability(Durability d); @Override Put setFamilyCellMap(NavigableMap<byte[], List<Cell>> map); @Override @Deprecated Put setFamilyMap(NavigableMap<byte[], List<KeyValue>> map); @Override Put setClusterIds(List<UUID> clusterIds); @Override Put setCellVisibility(CellVisibility expression); @Override Put setACL(String user, Permission perms); @Override Put setACL(Map<String, Permission> perms); @Override Put setTTL(long ttl); } | @Test public void testCopyConstructor() { Put origin = new Put(Bytes.toBytes("ROW-01")); byte[] family = Bytes.toBytes("CF-01"); byte[] qualifier = Bytes.toBytes("Q-01"); origin.addColumn(family, qualifier, Bytes.toBytes("V-01")); Put clone = new Put(origin); assertEquals(origin.getCellList(family), clone.getCellList(family)); origin.addColumn(family, qualifier, Bytes.toBytes("V-02")); assertNotEquals(origin.getCellList(family), clone.getCellList(family)); } |
ClientScanner extends AbstractClientScanner { protected void loadCache() throws IOException { Result[] values = null; long remainingResultSize = maxScannerResultSize; int countdown = this.caching; callable.setCaching(this.caching); boolean retryAfterOutOfOrderException = true; boolean serverHasMoreResults = false; boolean allResultsSkipped = false; do { allResultsSkipped = false; try { values = call(callable, caller, scannerTimeout); if (values == null && callable.switchedToADifferentReplica()) { clearPartialResults(); this.currentRegion = callable.getHRegionInfo(); continue; } retryAfterOutOfOrderException = true; } catch (DoNotRetryIOException | NeedUnmanagedConnectionException e) { clearPartialResults(); if (e instanceof UnknownScannerException) { long timeout = lastNext + scannerTimeout; if (timeout < System.currentTimeMillis()) { LOG.info("For hints related to the following exception, please try taking a look at: " + "https: long elapsed = System.currentTimeMillis() - lastNext; ScannerTimeoutException ex = new ScannerTimeoutException(elapsed + "ms passed since the last invocation, " + "timeout is currently set to " + scannerTimeout); ex.initCause(e); throw ex; } } else { Throwable cause = e.getCause(); if ((cause != null && cause instanceof NotServingRegionException) || (cause != null && cause instanceof RegionServerStoppedException) || e instanceof OutOfOrderScannerNextException) { } else { throw e; } } if (this.lastResult != null) { if (!this.lastResult.isPartial() && scan.getBatch() < 0 ) { if (scan.isReversed()) { scan.setStartRow(createClosestRowBefore(lastResult.getRow())); } else { scan.setStartRow(Bytes.add(lastResult.getRow(), new byte[1])); } } else { scan.setStartRow(lastResult.getRow()); } } if (e instanceof OutOfOrderScannerNextException) { if (retryAfterOutOfOrderException) { retryAfterOutOfOrderException = false; } else { throw new DoNotRetryIOException("Failed after retry of " + "OutOfOrderScannerNextException: was there a rpc timeout?", e); } } this.currentRegion = null; callable = null; continue; } long currentTime = System.currentTimeMillis(); if (this.scanMetrics != null) { this.scanMetrics.sumOfMillisSecBetweenNexts.addAndGet(currentTime - lastNext); } lastNext = currentTime; List<Result> resultsToAddToCache = getResultsToAddToCache(values, callable.isHeartbeatMessage()); if (!resultsToAddToCache.isEmpty()) { for (Result rs : resultsToAddToCache) { rs = filterLoadedCell(rs); if (rs == null) { continue; } cache.add(rs); for (Cell cell : rs.rawCells()) { remainingResultSize -= CellUtil.estimatedHeapSizeOf(cell); } countdown--; this.lastResult = rs; if (this.lastResult.isPartial() || scan.getBatch() > 0 ) { updateLastCellLoadedToCache(this.lastResult); } else { this.lastCellLoadedToCache = null; } } if (cache.isEmpty()) { allResultsSkipped = true; continue; } } if (callable.isHeartbeatMessage()) { if (cache.size() > 0) { if (LOG.isTraceEnabled()) { LOG.trace("Heartbeat message received and cache contains Results." + " Breaking out of scan loop"); } break; } continue; } if (null != values && values.length > 0 && callable.hasMoreResultsContext()) { serverHasMoreResults = callable.getServerHasMoreResults() && partialResults.isEmpty(); } } while (allResultsSkipped || (callable != null && callable.isHeartbeatMessage()) || (doneWithRegion(remainingResultSize, countdown, serverHasMoreResults) && (!partialResults.isEmpty() || possiblyNextScanner(countdown, values == null)))); } ClientScanner(final Configuration conf, final Scan scan, final TableName tableName,
ClusterConnection connection, RpcRetryingCallerFactory rpcFactory,
RpcControllerFactory controllerFactory, ExecutorService pool, int primaryOperationTimeout); @Override Result next(); @VisibleForTesting int getCacheSize(); @Override void close(); @Override boolean renewLease(); } | @Test @SuppressWarnings("unchecked") public void testNoResultsHint() throws IOException { final Result[] results = new Result[1]; KeyValue kv1 = new KeyValue("row".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); results[0] = Result.create(new Cell[] {kv1}); RpcRetryingCaller<Result[]> caller = Mockito.mock(RpcRetryingCaller.class); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); Mockito.when(caller.callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt())).thenAnswer(new Answer<Result[]>() { private int count = 0; @Override public Result[] answer(InvocationOnMock invocation) throws Throwable { ScannerCallableWithReplicas callable = invocation.getArgumentAt(0, ScannerCallableWithReplicas.class); switch (count) { case 0: case 2: count++; return null; case 1: count++; callable.setHasMoreResultsContext(false); return results; default: throw new RuntimeException("Expected only 2 invocations"); } } }); scan.setCaching(100); scan.setMaxResultSize(1000*1000); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { scanner.setRpcFinished(true); InOrder inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(2)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); assertEquals(1, scanner.cache.size()); Result r = scanner.cache.poll(); assertNotNull(r); CellScanner cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv1, cs.current()); assertFalse(cs.advance()); } }
@Test @SuppressWarnings("unchecked") public void testSizeLimit() throws IOException { final Result[] results = new Result[1]; KeyValue kv1 = new KeyValue("row".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); results[0] = Result.create(new Cell[] {kv1}); RpcRetryingCaller<Result[]> caller = Mockito.mock(RpcRetryingCaller.class); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); Mockito.when(caller.callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt())).thenAnswer(new Answer<Result[]>() { private int count = 0; @Override public Result[] answer(InvocationOnMock invocation) throws Throwable { ScannerCallableWithReplicas callable = invocation.getArgumentAt(0, ScannerCallableWithReplicas.class); switch (count) { case 0: case 2: count++; return null; case 1: count++; callable.setHasMoreResultsContext(true); callable.setServerHasMoreResults(false); return results; default: throw new RuntimeException("Expected only 2 invocations"); } } }); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); scan.setCaching(100); scan.setMaxResultSize(1); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { Mockito.verify(caller).callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt()); InOrder inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(2)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); assertEquals(1, scanner.cache.size()); Result r = scanner.cache.poll(); assertNotNull(r); CellScanner cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv1, cs.current()); assertFalse(cs.advance()); } }
@Test @SuppressWarnings("unchecked") public void testCacheLimit() throws IOException { KeyValue kv1 = new KeyValue("row1".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum), kv2 = new KeyValue("row2".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum), kv3 = new KeyValue("row3".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); final Result[] results = new Result[] {Result.create(new Cell[] {kv1}), Result.create(new Cell[] {kv2}), Result.create(new Cell[] {kv3})}; RpcRetryingCaller<Result[]> caller = Mockito.mock(RpcRetryingCaller.class); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); Mockito.when(caller.callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt())).thenAnswer(new Answer<Result[]>() { private int count = 0; @Override public Result[] answer(InvocationOnMock invocation) throws Throwable { ScannerCallableWithReplicas callable = invocation.getArgumentAt(0, ScannerCallableWithReplicas.class); switch (count) { case 0: case 2: count++; return null; case 1: count++; callable.setHasMoreResultsContext(true); callable.setServerHasMoreResults(false); return results; default: throw new RuntimeException("Expected only 2 invocations"); } } }); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); scan.setCaching(1); scan.setMaxResultSize(1000*1000); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { Mockito.verify(caller).callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt()); InOrder inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(2)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); assertEquals(3, scanner.cache.size()); Result r = scanner.cache.poll(); assertNotNull(r); CellScanner cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv1, cs.current()); assertFalse(cs.advance()); r = scanner.cache.poll(); assertNotNull(r); cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv2, cs.current()); assertFalse(cs.advance()); r = scanner.cache.poll(); assertNotNull(r); cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv3, cs.current()); assertFalse(cs.advance()); } }
@Test @SuppressWarnings("unchecked") public void testNoMoreResults() throws IOException { final Result[] results = new Result[1]; KeyValue kv1 = new KeyValue("row".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); results[0] = Result.create(new Cell[] {kv1}); RpcRetryingCaller<Result[]> caller = Mockito.mock(RpcRetryingCaller.class); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); Mockito.when(caller.callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt())).thenAnswer(new Answer<Result[]>() { private int count = 0; @Override public Result[] answer(InvocationOnMock invocation) throws Throwable { ScannerCallableWithReplicas callable = invocation.getArgumentAt(0, ScannerCallableWithReplicas.class); switch (count) { case 0: case 2: count++; return null; case 1: count++; callable.setHasMoreResultsContext(true); callable.setServerHasMoreResults(false); return results; default: throw new RuntimeException("Expected only 2 invocations"); } } }); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); scan.setCaching(100); scan.setMaxResultSize(1000*1000); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { Mockito.verify(caller).callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt()); scanner.setRpcFinished(true); InOrder inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(2)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); assertEquals(1, scanner.cache.size()); Result r = scanner.cache.poll(); assertNotNull(r); CellScanner cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv1, cs.current()); assertFalse(cs.advance()); } }
@Test @SuppressWarnings("unchecked") public void testMoreResults() throws IOException { final Result[] results1 = new Result[1]; KeyValue kv1 = new KeyValue("row".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); results1[0] = Result.create(new Cell[] {kv1}); final Result[] results2 = new Result[1]; KeyValue kv2 = new KeyValue("row2".getBytes(), "cf".getBytes(), "cq".getBytes(), 1, Type.Maximum); results2[0] = Result.create(new Cell[] {kv2}); RpcRetryingCaller<Result[]> caller = Mockito.mock(RpcRetryingCaller.class); Mockito.when(rpcFactory.<Result[]> newCaller()).thenReturn(caller); Mockito.when(caller.callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt())).thenAnswer(new Answer<Result[]>() { private int count = 0; @Override public Result[] answer(InvocationOnMock invocation) throws Throwable { ScannerCallableWithReplicas callable = invocation.getArgumentAt(0, ScannerCallableWithReplicas.class); switch (count) { case 0: case 3: count++; return null; case 1: count++; callable.setHasMoreResultsContext(true); callable.setServerHasMoreResults(true); return results1; case 2: count++; callable.setHasMoreResultsContext(true); callable.setServerHasMoreResults(false); return results2; default: throw new RuntimeException("Expected only 2 invocations"); } } }); scan.setCaching(100); scan.setMaxResultSize(1000*1000); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { Mockito.verify(caller).callWithoutRetries(Mockito.any(RetryingCallable.class), Mockito.anyInt()); InOrder inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(2)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); assertEquals(1, scanner.cache.size()); Result r = scanner.cache.poll(); assertNotNull(r); CellScanner cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv1, cs.current()); assertFalse(cs.advance()); scanner.setRpcFinished(true); inOrder = Mockito.inOrder(caller); scanner.loadCache(); inOrder.verify(caller, Mockito.times(3)).callWithoutRetries( Mockito.any(RetryingCallable.class), Mockito.anyInt()); r = scanner.cache.poll(); assertNotNull(r); cs = r.cellScanner(); assertTrue(cs.advance()); assertEquals(kv2, cs.current()); assertFalse(cs.advance()); } } |
ClientScanner extends AbstractClientScanner { @Override public Result next() throws IOException { if (cache.size() == 0 && this.closed) { return null; } if (cache.size() == 0) { loadCache(); } if (cache.size() > 0) { return cache.poll(); } writeScanMetrics(); return null; } ClientScanner(final Configuration conf, final Scan scan, final TableName tableName,
ClusterConnection connection, RpcRetryingCallerFactory rpcFactory,
RpcControllerFactory controllerFactory, ExecutorService pool, int primaryOperationTimeout); @Override Result next(); @VisibleForTesting int getCacheSize(); @Override void close(); @Override boolean renewLease(); } | @Test (timeout = 30000) public void testExceptionsFromReplicasArePropagated() throws IOException { scan.setConsistency(Consistency.TIMELINE); rpcFactory = new MockRpcRetryingCallerFactory(conf); conf.set(RpcRetryingCallerFactory.CUSTOM_CALLER_CONF_KEY, MockRpcRetryingCallerFactory.class.getName()); when(clusterConn.locateRegion((TableName)any(), (byte[])any(), anyBoolean(), anyBoolean(), anyInt())).thenReturn(new RegionLocations(null, null, null)); try (MockClientScanner scanner = new MockClientScanner(conf, scan, TableName.valueOf("table"), clusterConn, rpcFactory, controllerFactory, pool, Integer.MAX_VALUE)) { Iterator<Result> iter = scanner.iterator(); while (iter.hasNext()) { iter.next(); } fail("Should have failed with RetriesExhaustedException"); } catch (RetriesExhaustedException expected) { } } |
ZKUtil { private static ArrayList<ACL> createACL(ZooKeeperWatcher zkw, String node) { return createACL(zkw, node, isSecureZooKeeper(zkw.getConfiguration())); } static RecoverableZooKeeper connect(Configuration conf, Watcher watcher); static RecoverableZooKeeper connect(Configuration conf, String ensemble,
Watcher watcher); static RecoverableZooKeeper connect(Configuration conf, String ensemble,
Watcher watcher, final String identifier); static void loginServer(Configuration conf, String keytabFileKey,
String userNameKey, String hostname); static void loginClient(Configuration conf, String keytabFileKey,
String userNameKey, String hostname); static String joinZNode(String prefix, String suffix); static String getParent(String node); static String getNodeName(String path); static boolean watchAndCheckExists(ZooKeeperWatcher zkw, String znode); static boolean setWatchIfNodeExists(ZooKeeperWatcher zkw, String znode); static int checkExists(ZooKeeperWatcher zkw, String znode); static List<String> listChildrenAndWatchForNewChildren(
ZooKeeperWatcher zkw, String znode); static List<String> listChildrenAndWatchThem(ZooKeeperWatcher zkw,
String znode); static List<String> listChildrenNoWatch(ZooKeeperWatcher zkw, String znode); static boolean nodeHasChildren(ZooKeeperWatcher zkw, String znode); static int getNumberOfChildren(ZooKeeperWatcher zkw, String znode); static byte [] getData(ZooKeeperWatcher zkw, String znode); static byte [] getDataAndWatch(ZooKeeperWatcher zkw, String znode); static byte[] getDataAndWatch(ZooKeeperWatcher zkw, String znode,
Stat stat); static byte [] getDataNoWatch(ZooKeeperWatcher zkw, String znode,
Stat stat); static List<NodeAndData> getChildDataAndWatchForNewChildren(
ZooKeeperWatcher zkw, String baseNode); static void updateExistingNodeData(ZooKeeperWatcher zkw, String znode,
byte [] data, int expectedVersion); static boolean setData(ZooKeeperWatcher zkw, String znode,
byte [] data, int expectedVersion); static void createSetData(final ZooKeeperWatcher zkw, final String znode,
final byte [] data); static void setData(ZooKeeperWatcher zkw, String znode, byte [] data); static boolean isSecureZooKeeper(Configuration conf); static ArrayList<ACL> createACL(ZooKeeperWatcher zkw, String node,
boolean isSecureZooKeeper); static boolean createEphemeralNodeAndWatch(ZooKeeperWatcher zkw,
String znode, byte [] data); static boolean createNodeIfNotExistsAndWatch(
ZooKeeperWatcher zkw, String znode, byte [] data); static String createNodeIfNotExistsNoWatch(ZooKeeperWatcher zkw, String znode,
byte[] data, CreateMode createMode); static int createAndWatch(ZooKeeperWatcher zkw,
String znode, byte [] data); static void asyncCreate(ZooKeeperWatcher zkw,
String znode, byte [] data, final AsyncCallback.StringCallback cb,
final Object ctx); static void createAndFailSilent(ZooKeeperWatcher zkw,
String znode); static void createAndFailSilent(ZooKeeperWatcher zkw,
String znode, byte[] data); static void createWithParents(ZooKeeperWatcher zkw, String znode); static void createWithParents(ZooKeeperWatcher zkw, String znode, byte[] data); static void deleteNode(ZooKeeperWatcher zkw, String node); static boolean deleteNode(ZooKeeperWatcher zkw, String node,
int version); static void deleteNodeFailSilent(ZooKeeperWatcher zkw, String node); static void deleteNodeRecursively(ZooKeeperWatcher zkw, String node); static void deleteChildrenRecursively(ZooKeeperWatcher zkw, String node); static void deleteChildrenRecursivelyMultiOrSequential(
ZooKeeperWatcher zkw, boolean runSequentialOnMultiFailure,
String... pathRoots); static void deleteNodeRecursivelyMultiOrSequential(ZooKeeperWatcher zkw,
boolean runSequentialOnMultiFailure, String... pathRoots); static void multiOrSequential(ZooKeeperWatcher zkw, List<ZKUtilOp> ops,
boolean runSequentialOnMultiFailure); static String dump(ZooKeeperWatcher zkw); static String[] getServerStats(String server, int timeout); static void waitForBaseZNode(Configuration conf); static byte[] blockUntilAvailable(
final ZooKeeperWatcher zkw, final String znode, final long timeout); static KeeperException convert(final DeserializationException e); static void logZKTree(ZooKeeperWatcher zkw, String root); static byte[] positionToByteArray(final long position); static long parseWALPositionFrom(final byte[] bytes); static byte[] regionSequenceIdsToByteArray(final Long regionLastFlushedSequenceId,
final Map<byte[], Long> storeSequenceIds); static RegionStoreSequenceIds parseRegionStoreSequenceIds(final byte[] bytes); static final char ZNODE_PATH_SEPARATOR; } | @Test public void testCreateACL() throws ZooKeeperConnectionException, IOException { Configuration conf = HBaseConfiguration.create(); conf.set(Superusers.SUPERUSER_CONF_KEY, "user1,@group1,user2,@group2,user3"); String node = "/hbase/testCreateACL"; ZooKeeperWatcher watcher = new ZooKeeperWatcher(conf, node, null, false); List<ACL> aclList = ZKUtil.createACL(watcher, node, true); Assert.assertEquals(aclList.size(), 4); Assert.assertTrue(!aclList.contains(new ACL(Perms.ALL, new Id("auth", "@group1"))) && !aclList.contains(new ACL(Perms.ALL, new Id("auth", "@group2")))); Assert.assertTrue(aclList.contains(new ACL(Perms.ALL, new Id("auth", "user1"))) && aclList.contains(new ACL(Perms.ALL, new Id("auth", "user2"))) && aclList.contains(new ACL(Perms.ALL, new Id("auth", "user3")))); } |
ZooKeeperWatcher implements Watcher, Abortable, Closeable { public boolean isClientReadable(String node) { return node.equals(baseZNode) || isAnyMetaReplicaZnode(node) || node.equals(getMasterAddressZNode()) || node.equals(clusterIdZNode)|| node.equals(rsZNode) || node.equals(tableZNode) || node.startsWith(tableZNode + "/"); } ZooKeeperWatcher(Configuration conf, String identifier,
Abortable abortable); ZooKeeperWatcher(Configuration conf, String identifier,
Abortable abortable, boolean canCreateBaseZNode); boolean isClientReadable(String node); void checkAndSetZNodeAcls(); static boolean isSuperUserId(String[] superUsers, Id id); @Override String toString(); String prefix(final String str); boolean isAnyMetaReplicaZnode(String node); boolean isDefaultMetaReplicaZnode(String node); List<String> getMetaReplicaNodes(); String getZNodeForReplica(int replicaId); int getMetaReplicaIdFromZnode(String znode); void registerListener(ZooKeeperListener listener); void registerListenerFirst(ZooKeeperListener listener); void unregisterListener(ZooKeeperListener listener); void unregisterAllListeners(); List<ZooKeeperListener> getListeners(); int getNumberOfListeners(); RecoverableZooKeeper getRecoverableZooKeeper(); void reconnectAfterExpiration(); String getQuorum(); String getBaseZNode(); @Override void process(WatchedEvent event); void sync(String path); void keeperException(KeeperException ke); void interruptedException(InterruptedException ie); @Override void close(); Configuration getConfiguration(); @Override void abort(String why, Throwable e); @Override boolean isAborted(); String getMasterAddressZNode(); String getRegionNormalizerZNode(); public CountDownLatch saslLatch; public String baseZNode; public String rsZNode; public String drainingZNode; public String backupMasterAddressesZNode; public String clusterStateZNode; public String assignmentZNode; public String tableZNode; public String clusterIdZNode; public String splitLogZNode; public String balancerZNode; public String tableLockZNode; public String recoveringRegionsZNode; static String namespaceZNode; static final ArrayList<ACL> CREATOR_ALL_AND_WORLD_READABLE; final static String META_ZNODE_PREFIX; } | @Test public void testIsClientReadable() throws ZooKeeperConnectionException, IOException { ZooKeeperWatcher watcher = new ZooKeeperWatcher(HBaseConfiguration.create(), "testIsClientReadable", null, false); assertTrue(watcher.isClientReadable(watcher.baseZNode)); assertTrue(watcher.isClientReadable(watcher.getZNodeForReplica(0))); assertTrue(watcher.isClientReadable(watcher.getMasterAddressZNode())); assertTrue(watcher.isClientReadable(watcher.clusterIdZNode)); assertTrue(watcher.isClientReadable(watcher.tableZNode)); assertTrue(watcher.isClientReadable(ZKUtil.joinZNode(watcher.tableZNode, "foo"))); assertTrue(watcher.isClientReadable(watcher.rsZNode)); assertFalse(watcher.isClientReadable(watcher.tableLockZNode)); assertFalse(watcher.isClientReadable(watcher.balancerZNode)); assertFalse(watcher.isClientReadable(watcher.getRegionNormalizerZNode())); assertFalse(watcher.isClientReadable(watcher.clusterStateZNode)); assertFalse(watcher.isClientReadable(watcher.drainingZNode)); assertFalse(watcher.isClientReadable(watcher.recoveringRegionsZNode)); assertFalse(watcher.isClientReadable(watcher.splitLogZNode)); assertFalse(watcher.isClientReadable(watcher.backupMasterAddressesZNode)); watcher.close(); } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public HTableDescriptor addCoprocessor(String className) throws IOException { addCoprocessor(className, null, Coprocessor.PRIORITY_USER, null); return this; } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test (expected=IOException.class) public void testAddCoprocessorTwice() throws IOException { HTableDescriptor htd = new HTableDescriptor(TableName.META_TABLE_NAME); String cpName = "a.b.c.d"; htd.addCoprocessor(cpName); htd.addCoprocessor(cpName); } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public HTableDescriptor addCoprocessorWithSpec(final String specStr) throws IOException { String className = getCoprocessorClassNameFromSpecStr(specStr); if (className == null) { throw new IllegalArgumentException("Format does not match " + HConstants.CP_HTD_ATTR_VALUE_PATTERN + ": " + specStr); } checkHasCoprocessor(className); return addCoprocessorToMap(specStr); } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test public void testAddCoprocessorWithSpecStr() throws IOException { HTableDescriptor htd = new HTableDescriptor(TableName.META_TABLE_NAME); String cpName = "a.b.c.d"; boolean expected = false; try { htd.addCoprocessorWithSpec(cpName); } catch (IllegalArgumentException iae) { expected = true; } if (!expected) fail(); try { htd.addCoprocessorWithSpec("file: } catch (IllegalArgumentException iae) { expected = false; } if (expected) fail(); String spec = "hdfs: try { htd.addCoprocessorWithSpec(spec); } catch (IllegalArgumentException iae) { expected = false; } if (expected) fail(); try { htd.addCoprocessorWithSpec(spec); } catch (IOException ioe) { expected = true; } if (!expected) fail(); } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public String getNameAsString() { return name.getNameAsString(); } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test public void testLegalHTableNamesRegex() { for (String tn : legalTableNames) { TableName tName = TableName.valueOf(tn); assertTrue("Testing: '" + tn + "'", Pattern.matches(TableName.VALID_USER_TABLE_REGEX, tName.getNameAsString())); } } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public long getMaxFileSize() { byte [] value = getValue(MAX_FILESIZE_KEY); if (value != null) { return Long.parseLong(Bytes.toString(value)); } return -1; } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test public void testGetMaxFileSize() { HTableDescriptor desc = new HTableDescriptor(TableName.valueOf("table")); assertEquals(-1, desc.getMaxFileSize()); desc.setMaxFileSize(1111L); assertEquals(1111L, desc.getMaxFileSize()); } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public long getMemStoreFlushSize() { byte [] value = getValue(MEMSTORE_FLUSHSIZE_KEY); if (value != null) { return Long.parseLong(Bytes.toString(value)); } return -1; } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test public void testGetMemStoreFlushSize() { HTableDescriptor desc = new HTableDescriptor(TableName.valueOf("table")); assertEquals(-1, desc.getMemStoreFlushSize()); desc.setMemStoreFlushSize(1111L); assertEquals(1111L, desc.getMemStoreFlushSize()); } |
HTableDescriptor implements WritableComparable<HTableDescriptor> { public HTableDescriptor modifyFamily(final HColumnDescriptor family) { if (family.getName() == null || family.getName().length <= 0) { throw new IllegalArgumentException("Family name cannot be null or empty"); } if (!hasFamily(family.getName())) { throw new IllegalArgumentException("Column family '" + family.getNameAsString() + "' does not exist"); } this.families.put(family.getName(), family); return this; } @InterfaceAudience.Private protected HTableDescriptor(final TableName name, HColumnDescriptor[] families); protected HTableDescriptor(final TableName name, HColumnDescriptor[] families,
Map<ImmutableBytesWritable,ImmutableBytesWritable> values); @Deprecated HTableDescriptor(); HTableDescriptor(final TableName name); @Deprecated HTableDescriptor(final byte[] name); @Deprecated HTableDescriptor(final String name); HTableDescriptor(final HTableDescriptor desc); HTableDescriptor(final TableName name, final HTableDescriptor desc); boolean isRootRegion(); boolean isMetaRegion(); boolean isMetaTable(); byte[] getValue(byte[] key); String getValue(String key); Map<ImmutableBytesWritable,ImmutableBytesWritable> getValues(); HTableDescriptor setValue(byte[] key, byte[] value); HTableDescriptor setValue(final ImmutableBytesWritable key,
final ImmutableBytesWritable value); HTableDescriptor setValue(String key, String value); void remove(final String key); void remove(ImmutableBytesWritable key); void remove(final byte [] key); boolean isReadOnly(); HTableDescriptor setReadOnly(final boolean readOnly); boolean isCompactionEnabled(); HTableDescriptor setCompactionEnabled(final boolean isEnable); boolean isNormalizationEnabled(); HTableDescriptor setNormalizationEnabled(final boolean isEnable); HTableDescriptor setDurability(Durability durability); Durability getDurability(); TableName getTableName(); @Deprecated byte[] getName(); String getNameAsString(); HTableDescriptor setRegionSplitPolicyClassName(String clazz); String getRegionSplitPolicyClassName(); @Deprecated HTableDescriptor setName(byte[] name); @Deprecated HTableDescriptor setName(TableName name); long getMaxFileSize(); HTableDescriptor setMaxFileSize(long maxFileSize); long getMemStoreFlushSize(); HTableDescriptor setMemStoreFlushSize(long memstoreFlushSize); HTableDescriptor setFlushPolicyClassName(String clazz); String getFlushPolicyClassName(); HTableDescriptor addFamily(final HColumnDescriptor family); HTableDescriptor modifyFamily(final HColumnDescriptor family); boolean hasFamily(final byte [] familyName); @Override String toString(); String toStringCustomizedValues(); String toStringTableAttributes(); @Override boolean equals(Object obj); @Override int hashCode(); @Deprecated @Override void readFields(DataInput in); @Deprecated @Override void write(DataOutput out); @Override int compareTo(final HTableDescriptor other); Collection<HColumnDescriptor> getFamilies(); int getRegionReplication(); HTableDescriptor setRegionReplication(int regionReplication); boolean hasRegionMemstoreReplication(); HTableDescriptor setRegionMemstoreReplication(boolean memstoreReplication); Set<byte[]> getFamiliesKeys(); HColumnDescriptor[] getColumnFamilies(); HColumnDescriptor getFamily(final byte [] column); HColumnDescriptor removeFamily(final byte [] column); HTableDescriptor addCoprocessor(String className); HTableDescriptor addCoprocessor(String className, Path jarFilePath,
int priority, final Map<String, String> kvs); HTableDescriptor addCoprocessorWithSpec(final String specStr); boolean hasCoprocessor(String classNameToMatch); List<String> getCoprocessors(); void removeCoprocessor(String className); @Deprecated static Path getTableDir(Path rootdir, final byte [] tableName); @Deprecated HTableDescriptor setOwner(User owner); @Deprecated HTableDescriptor setOwnerString(String ownerString); @Deprecated String getOwnerString(); byte [] toByteArray(); static HTableDescriptor parseFrom(final byte [] bytes); TableSchema convert(); static HTableDescriptor convert(final TableSchema ts); String getConfigurationValue(String key); Map<String, String> getConfiguration(); HTableDescriptor setConfiguration(String key, String value); void removeConfiguration(final String key); static HTableDescriptor metaTableDescriptor(final Configuration conf); static final String SPLIT_POLICY; static final String MAX_FILESIZE; static final String OWNER; static final ImmutableBytesWritable OWNER_KEY; static final String READONLY; static final String COMPACTION_ENABLED; static final String MEMSTORE_FLUSHSIZE; static final String FLUSH_POLICY; static final String IS_ROOT; static final String IS_META; @Deprecated
static final String DEFERRED_LOG_FLUSH; static final String DURABILITY; static final String REGION_REPLICATION; static final String REGION_MEMSTORE_REPLICATION; static final String NORMALIZATION_ENABLED; static final boolean DEFAULT_READONLY; static final boolean DEFAULT_COMPACTION_ENABLED; static final boolean DEFAULT_NORMALIZATION_ENABLED; static final long DEFAULT_MEMSTORE_FLUSH_SIZE; static final int DEFAULT_REGION_REPLICATION; static final boolean DEFAULT_REGION_MEMSTORE_REPLICATION; @Deprecated
static final HTableDescriptor META_TABLEDESC; final static String NAMESPACE_FAMILY_INFO; final static byte[] NAMESPACE_FAMILY_INFO_BYTES; final static byte[] NAMESPACE_COL_DESC_BYTES; static final HTableDescriptor NAMESPACE_TABLEDESC; } | @Test public void testModifyFamily() { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("table")); byte[] familyName = Bytes.toBytes("cf"); HColumnDescriptor hcd = new HColumnDescriptor(familyName); hcd.setBlocksize(1000); hcd.setDFSReplication((short) 3); htd.addFamily(hcd); assertEquals(1000, htd.getFamily(familyName).getBlocksize()); assertEquals(3, htd.getFamily(familyName).getDFSReplication()); hcd = new HColumnDescriptor(familyName); hcd.setBlocksize(2000); hcd.setDFSReplication((short) 1); htd.modifyFamily(hcd); assertEquals(2000, htd.getFamily(familyName).getBlocksize()); assertEquals(1, htd.getFamily(familyName).getDFSReplication()); }
@Test(expected=IllegalArgumentException.class) public void testModifyInexistentFamily() { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("table")); byte[] familyName = Bytes.toBytes("cf"); HColumnDescriptor hcd = new HColumnDescriptor(familyName); htd.modifyFamily(hcd); } |
NamespacesResource extends ResourceBase { @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.isDebugEnabled()) { LOG.debug("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."); } } NamespacesResource(); @GET @Produces({MIMETYPE_TEXT, MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF}) Response get(final @Context ServletContext context, final @Context UriInfo uriInfo); @Path("{namespace}") NamespacesInstanceResource getNamespaceInstanceResource(
final @PathParam("namespace") String namespace); } | @Test public void testNamespaceListXMLandJSON() throws IOException, JAXBException { String namespacePath = "/namespaces/"; NamespacesModel model; Response response; Admin admin = TEST_UTIL.getHBaseAdmin(); assertFalse(doesNamespaceExist(admin, NAMESPACE1)); model = testNamespacesModel.buildTestModel(); testNamespacesModel.checkModel(model); response = client.get(namespacePath, Constants.MIMETYPE_XML); assertEquals(200, response.getCode()); model = fromXML(response.getBody()); testNamespacesModel.checkModel(model, "hbase", "default"); response = client.get(namespacePath, Constants.MIMETYPE_JSON); assertEquals(200, response.getCode()); model = testNamespacesModel.fromJSON(Bytes.toString(response.getBody())); testNamespacesModel.checkModel(model, "hbase", "default"); createNamespaceViaAdmin(admin, NAMESPACE1); response = client.get(namespacePath, Constants.MIMETYPE_XML); assertEquals(200, response.getCode()); model = fromXML(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE1, "hbase", "default"); response = client.get(namespacePath, Constants.MIMETYPE_JSON); assertEquals(200, response.getCode()); model = testNamespacesModel.fromJSON(Bytes.toString(response.getBody())); testNamespacesModel.checkModel(model, NAMESPACE1, "hbase", "default"); createNamespaceViaAdmin(admin, NAMESPACE2); response = client.get(namespacePath, Constants.MIMETYPE_XML); assertEquals(200, response.getCode()); model = fromXML(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE1, NAMESPACE2, "hbase", "default"); response = client.get(namespacePath, Constants.MIMETYPE_JSON); assertEquals(200, response.getCode()); model = testNamespacesModel.fromJSON(Bytes.toString(response.getBody())); testNamespacesModel.checkModel(model, NAMESPACE1, NAMESPACE2, "hbase", "default"); admin.deleteNamespace(NAMESPACE1); response = client.get(namespacePath, Constants.MIMETYPE_XML); assertEquals(200, response.getCode()); model = fromXML(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE2, "hbase", "default"); response = client.get(namespacePath, Constants.MIMETYPE_JSON); assertEquals(200, response.getCode()); model = testNamespacesModel.fromJSON(Bytes.toString(response.getBody())); testNamespacesModel.checkModel(model, NAMESPACE2, "hbase", "default"); admin.deleteNamespace(NAMESPACE2); }
@Test public void testNamespaceListPBandDefault() throws IOException, JAXBException { String schemaPath = "/namespaces/"; NamespacesModel model; Response response; Admin admin = TEST_UTIL.getHBaseAdmin(); assertFalse(doesNamespaceExist(admin, NAMESPACE1)); model = testNamespacesModel.buildTestModel(); testNamespacesModel.checkModel(model); response = client.get(schemaPath, Constants.MIMETYPE_PROTOBUF); assertEquals(200, response.getCode()); model.getObjectFromMessage(response.getBody()); testNamespacesModel.checkModel(model, "hbase", "default"); response = client.get(schemaPath); assertEquals(200, response.getCode()); createNamespaceViaAdmin(admin, NAMESPACE1); response = client.get(schemaPath, Constants.MIMETYPE_PROTOBUF); assertEquals(200, response.getCode()); model.getObjectFromMessage(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE1, "hbase", "default"); response = client.get(schemaPath); assertEquals(200, response.getCode()); createNamespaceViaAdmin(admin, NAMESPACE2); response = client.get(schemaPath, Constants.MIMETYPE_PROTOBUF); assertEquals(200, response.getCode()); model.getObjectFromMessage(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE1, NAMESPACE2, "hbase", "default"); response = client.get(schemaPath); assertEquals(200, response.getCode()); admin.deleteNamespace(NAMESPACE1); response = client.get(schemaPath, Constants.MIMETYPE_PROTOBUF); assertEquals(200, response.getCode()); model.getObjectFromMessage(response.getBody()); testNamespacesModel.checkModel(model, NAMESPACE2, "hbase", "default"); response = client.get(schemaPath); assertEquals(200, response.getCode()); admin.deleteNamespace(NAMESPACE2); } |
HBaseFsck extends Configured implements Closeable { public ErrorReporter getErrors() { return errors; } HBaseFsck(Configuration conf); HBaseFsck(Configuration conf, ExecutorService exec); void connect(); void offlineHdfsIntegrityRepair(); int onlineConsistencyRepair(); int onlineHbck(); static byte[] keyOnly(byte[] b); @Override void close(); void checkRegionBoundaries(); ErrorReporter getErrors(); void fixEmptyMetaCells(); void fixOrphanTables(); boolean rebuildMeta(boolean fix); void loadHdfsRegionDirs(); int mergeRegionDirs(Path targetRegionDir, HbckInfo contained); void dumpOverlapProblems(Multimap<byte[], HbckInfo> regions); void dumpSidelinedRegions(Map<Path, HbckInfo> regions); Multimap<byte[], HbckInfo> getOverlapGroups(
TableName table); static void setDisplayFullReport(); static void setForceExclusive(); boolean isExclusive(); static void setDisableBalancer(); boolean shouldDisableBalancer(); void setFixTableLocks(boolean shouldFix); void setFixTableZNodes(boolean shouldFix); void setFixAssignments(boolean shouldFix); void setFixMeta(boolean shouldFix); void setFixEmptyMetaCells(boolean shouldFix); void setCheckHdfs(boolean checking); void setFixHdfsHoles(boolean shouldFix); void setFixTableOrphans(boolean shouldFix); void setFixHdfsOverlaps(boolean shouldFix); void setFixHdfsOrphans(boolean shouldFix); void setFixVersionFile(boolean shouldFix); boolean shouldFixVersionFile(); void setSidelineBigOverlaps(boolean sbo); boolean shouldSidelineBigOverlaps(); void setFixSplitParents(boolean shouldFix); void setFixReferenceFiles(boolean shouldFix); boolean shouldIgnorePreCheckPermission(); void setIgnorePreCheckPermission(boolean ignorePreCheckPermission); void setMaxMerge(int mm); int getMaxMerge(); void setMaxOverlapsToSideline(int mo); int getMaxOverlapsToSideline(); void includeTable(TableName table); void setTimeLag(long seconds); void setSidelineDir(String sidelineDir); HFileCorruptionChecker getHFilecorruptionChecker(); void setHFileCorruptionChecker(HFileCorruptionChecker hfcc); void setRetCode(int code); int getRetCode(); static void main(String[] args); HBaseFsck exec(ExecutorService exec, String[] args); static void debugLsr(Configuration conf,
Path p); static void debugLsr(Configuration conf,
Path p, ErrorReporter errors); static final long DEFAULT_TIME_LAG; static final long DEFAULT_SLEEP_BEFORE_RERUN; } | @Test public void testOrphanedTableZNode() throws Exception { TableName table = TableName.valueOf("testOrphanedZKTableEntry"); try { TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager().getTableStateManager() .setTableState(table, ZooKeeperProtos.Table.State.ENABLING); try { setupTable(table); Assert.fail( "Create table should fail when its ZNode has already existed with ENABLING state."); } catch(TableExistsException t) { } try { cleanupTable(table); } catch (IOException e) { } HBaseFsck hbck = doFsck(conf, false); assertTrue(hbck.getErrors().getErrorList().contains(ERROR_CODE.ORPHANED_ZK_TABLE_ENTRY)); hbck = doFsck(conf, true); hbck = doFsck(conf, false); assertFalse(hbck.getErrors().getErrorList().contains(ERROR_CODE.ORPHANED_ZK_TABLE_ENTRY)); setupTable(table); } finally { try { cleanupTable(table); } catch (IOException e) { } } } |
HBaseFsck extends Configured implements Closeable { private void deleteMetaRegion(HbckInfo hi) throws IOException { deleteMetaRegion(hi.metaEntry.getRegionName()); } HBaseFsck(Configuration conf); HBaseFsck(Configuration conf, ExecutorService exec); void connect(); void offlineHdfsIntegrityRepair(); int onlineConsistencyRepair(); int onlineHbck(); static byte[] keyOnly(byte[] b); @Override void close(); void checkRegionBoundaries(); ErrorReporter getErrors(); void fixEmptyMetaCells(); void fixOrphanTables(); boolean rebuildMeta(boolean fix); void loadHdfsRegionDirs(); int mergeRegionDirs(Path targetRegionDir, HbckInfo contained); void dumpOverlapProblems(Multimap<byte[], HbckInfo> regions); void dumpSidelinedRegions(Map<Path, HbckInfo> regions); Multimap<byte[], HbckInfo> getOverlapGroups(
TableName table); static void setDisplayFullReport(); static void setForceExclusive(); boolean isExclusive(); static void setDisableBalancer(); boolean shouldDisableBalancer(); void setFixTableLocks(boolean shouldFix); void setFixTableZNodes(boolean shouldFix); void setFixAssignments(boolean shouldFix); void setFixMeta(boolean shouldFix); void setFixEmptyMetaCells(boolean shouldFix); void setCheckHdfs(boolean checking); void setFixHdfsHoles(boolean shouldFix); void setFixTableOrphans(boolean shouldFix); void setFixHdfsOverlaps(boolean shouldFix); void setFixHdfsOrphans(boolean shouldFix); void setFixVersionFile(boolean shouldFix); boolean shouldFixVersionFile(); void setSidelineBigOverlaps(boolean sbo); boolean shouldSidelineBigOverlaps(); void setFixSplitParents(boolean shouldFix); void setFixReferenceFiles(boolean shouldFix); boolean shouldIgnorePreCheckPermission(); void setIgnorePreCheckPermission(boolean ignorePreCheckPermission); void setMaxMerge(int mm); int getMaxMerge(); void setMaxOverlapsToSideline(int mo); int getMaxOverlapsToSideline(); void includeTable(TableName table); void setTimeLag(long seconds); void setSidelineDir(String sidelineDir); HFileCorruptionChecker getHFilecorruptionChecker(); void setHFileCorruptionChecker(HFileCorruptionChecker hfcc); void setRetCode(int code); int getRetCode(); static void main(String[] args); HBaseFsck exec(ExecutorService exec, String[] args); static void debugLsr(Configuration conf,
Path p); static void debugLsr(Configuration conf,
Path p, ErrorReporter errors); static final long DEFAULT_TIME_LAG; static final long DEFAULT_SLEEP_BEFORE_RERUN; } | @Test (timeout=180000) public void testMetaOffline() throws Exception { HBaseFsck hbck = doFsck(conf, false); assertNoErrors(hbck); deleteMetaRegion(conf, true, false, false); hbck = doFsck(conf, false); assertErrors(hbck, new ERROR_CODE[] { ERROR_CODE.NO_META_REGION, ERROR_CODE.UNKNOWN }); hbck = doFsck(conf, true); assertErrors(hbck, new ERROR_CODE[] { ERROR_CODE.NO_META_REGION, ERROR_CODE.UNKNOWN }); hbck = doFsck(conf, false); assertNoErrors(hbck); } |
HBaseFsck extends Configured implements Closeable { public void checkRegionBoundaries() { try { ByteArrayComparator comparator = new ByteArrayComparator(); List<HRegionInfo> regions = MetaScanner.listAllRegions(getConf(), connection, false); final RegionBoundariesInformation currentRegionBoundariesInformation = new RegionBoundariesInformation(); Path hbaseRoot = FSUtils.getRootDir(getConf()); for (HRegionInfo regionInfo : regions) { Path tableDir = FSUtils.getTableDir(hbaseRoot, regionInfo.getTable()); currentRegionBoundariesInformation.regionName = regionInfo.getRegionName(); Path path = new Path(tableDir, regionInfo.getEncodedName()); FileSystem fs = path.getFileSystem(getConf()); FileStatus[] files = fs.listStatus(path); byte[] storeFirstKey = null; byte[] storeLastKey = null; for (FileStatus file : files) { String fileName = file.getPath().toString(); fileName = fileName.substring(fileName.lastIndexOf("/") + 1); if (!fileName.startsWith(".") && !fileName.endsWith("recovered.edits")) { FileStatus[] storeFiles = fs.listStatus(file.getPath()); for (FileStatus storeFile : storeFiles) { HFile.Reader reader = HFile.createReader(fs, storeFile.getPath(), new CacheConfig( getConf()), getConf()); if ((reader.getFirstKey() != null) && ((storeFirstKey == null) || (comparator.compare(storeFirstKey, reader.getFirstKey()) > 0))) { storeFirstKey = reader.getFirstKey(); } if ((reader.getLastKey() != null) && ((storeLastKey == null) || (comparator.compare(storeLastKey, reader.getLastKey())) < 0)) { storeLastKey = reader.getLastKey(); } reader.close(); } } } currentRegionBoundariesInformation.metaFirstKey = regionInfo.getStartKey(); currentRegionBoundariesInformation.metaLastKey = regionInfo.getEndKey(); currentRegionBoundariesInformation.storesFirstKey = keyOnly(storeFirstKey); currentRegionBoundariesInformation.storesLastKey = keyOnly(storeLastKey); if (currentRegionBoundariesInformation.metaFirstKey.length == 0) currentRegionBoundariesInformation.metaFirstKey = null; if (currentRegionBoundariesInformation.metaLastKey.length == 0) currentRegionBoundariesInformation.metaLastKey = null; boolean valid = true; if ((currentRegionBoundariesInformation.storesFirstKey != null) && (currentRegionBoundariesInformation.metaFirstKey != null)) { valid = valid && comparator.compare(currentRegionBoundariesInformation.storesFirstKey, currentRegionBoundariesInformation.metaFirstKey) >= 0; } if ((currentRegionBoundariesInformation.storesLastKey != null) && (currentRegionBoundariesInformation.metaLastKey != null)) { valid = valid && comparator.compare(currentRegionBoundariesInformation.storesLastKey, currentRegionBoundariesInformation.metaLastKey) < 0; } if (!valid) { errors.reportError(ERROR_CODE.BOUNDARIES_ERROR, "Found issues with regions boundaries", tablesInfo.get(regionInfo.getTable())); LOG.warn("Region's boundaries not alligned between stores and META for:"); LOG.warn(currentRegionBoundariesInformation); } } } catch (IOException e) { LOG.error(e); } } HBaseFsck(Configuration conf); HBaseFsck(Configuration conf, ExecutorService exec); void connect(); void offlineHdfsIntegrityRepair(); int onlineConsistencyRepair(); int onlineHbck(); static byte[] keyOnly(byte[] b); @Override void close(); void checkRegionBoundaries(); ErrorReporter getErrors(); void fixEmptyMetaCells(); void fixOrphanTables(); boolean rebuildMeta(boolean fix); void loadHdfsRegionDirs(); int mergeRegionDirs(Path targetRegionDir, HbckInfo contained); void dumpOverlapProblems(Multimap<byte[], HbckInfo> regions); void dumpSidelinedRegions(Map<Path, HbckInfo> regions); Multimap<byte[], HbckInfo> getOverlapGroups(
TableName table); static void setDisplayFullReport(); static void setForceExclusive(); boolean isExclusive(); static void setDisableBalancer(); boolean shouldDisableBalancer(); void setFixTableLocks(boolean shouldFix); void setFixTableZNodes(boolean shouldFix); void setFixAssignments(boolean shouldFix); void setFixMeta(boolean shouldFix); void setFixEmptyMetaCells(boolean shouldFix); void setCheckHdfs(boolean checking); void setFixHdfsHoles(boolean shouldFix); void setFixTableOrphans(boolean shouldFix); void setFixHdfsOverlaps(boolean shouldFix); void setFixHdfsOrphans(boolean shouldFix); void setFixVersionFile(boolean shouldFix); boolean shouldFixVersionFile(); void setSidelineBigOverlaps(boolean sbo); boolean shouldSidelineBigOverlaps(); void setFixSplitParents(boolean shouldFix); void setFixReferenceFiles(boolean shouldFix); boolean shouldIgnorePreCheckPermission(); void setIgnorePreCheckPermission(boolean ignorePreCheckPermission); void setMaxMerge(int mm); int getMaxMerge(); void setMaxOverlapsToSideline(int mo); int getMaxOverlapsToSideline(); void includeTable(TableName table); void setTimeLag(long seconds); void setSidelineDir(String sidelineDir); HFileCorruptionChecker getHFilecorruptionChecker(); void setHFileCorruptionChecker(HFileCorruptionChecker hfcc); void setRetCode(int code); int getRetCode(); static void main(String[] args); HBaseFsck exec(ExecutorService exec, String[] args); static void debugLsr(Configuration conf,
Path p); static void debugLsr(Configuration conf,
Path p, ErrorReporter errors); static final long DEFAULT_TIME_LAG; static final long DEFAULT_SLEEP_BEFORE_RERUN; } | @Test (timeout = 180000) public void testRegionBoundariesCheck() throws Exception { HBaseFsck hbck = doFsck(conf, false); assertNoErrors(hbck); try { hbck.checkRegionBoundaries(); } catch (IllegalArgumentException e) { if (e.getMessage().endsWith("not a valid DFS filename.")) { fail("Table directory path is not valid." + e.getMessage()); } } } |
IdReadWriteLock { @VisibleForTesting int purgeAndGetEntryPoolSize() { gc(); Threads.sleep(200); lockPool.purge(); return lockPool.size(); } ReentrantReadWriteLock getLock(long id); @VisibleForTesting void waitForWaiters(long id, int numWaiters); } | @Test(timeout = 60000) public void testMultipleClients() throws Exception { ExecutorService exec = Executors.newFixedThreadPool(NUM_THREADS); try { ExecutorCompletionService<Boolean> ecs = new ExecutorCompletionService<Boolean>(exec); for (int i = 0; i < NUM_THREADS; ++i) ecs.submit(new IdLockTestThread("client_" + i)); for (int i = 0; i < NUM_THREADS; ++i) { Future<Boolean> result = ecs.take(); assertTrue(result.get()); } int entryPoolSize = idLock.purgeAndGetEntryPoolSize(); LOG.debug("Size of entry pool after gc and purge: " + entryPoolSize); assertEquals(0, entryPoolSize); } finally { exec.shutdown(); exec.awaitTermination(5000, TimeUnit.MILLISECONDS); } } |
ConnectionCache { ConnectionInfo getCurrentConnection() throws IOException { String userName = getEffectiveUser(); ConnectionInfo connInfo = connections.get(userName); if (connInfo == null || !connInfo.updateAccessTime()) { Lock lock = locker.acquireLock(userName); try { connInfo = connections.get(userName); if (connInfo == null) { UserGroupInformation ugi = realUser; if (!userName.equals(realUserName)) { ugi = UserGroupInformation.createProxyUser(userName, realUser); } User user = userProvider.create(ugi); Connection conn = ConnectionFactory.createConnection(conf, user); connInfo = new ConnectionInfo(conn, userName); connections.put(userName, connInfo); } } finally { lock.unlock(); } } return connInfo; } ConnectionCache(final Configuration conf,
final UserProvider userProvider,
final int cleanInterval, final int maxIdleTime); void setEffectiveUser(String user); String getEffectiveUser(); void shutdown(); Admin getAdmin(); Table getTable(String tableName); RegionLocator getRegionLocator(byte[] tableName); } | @Test public void testConnectionChore() throws Exception { UTIL.startMiniCluster(); ConnectionCache cache = new ConnectionCache(UTIL.getConfiguration(), UserProvider.instantiate(UTIL.getConfiguration()), 1000, 5000); ConnectionCache.ConnectionInfo info = cache.getCurrentConnection(); assertEquals(false, info.connection.isClosed()); Thread.sleep(7000); assertEquals(true, info.connection.isClosed()); UTIL.shutdownMiniCluster(); } |
RegionSizeCalculator { public long getRegionSize(byte[] regionId) { Long size = sizeMap.get(regionId); if (size == null) { LOG.debug("Unknown region:" + Arrays.toString(regionId)); return 0; } else { return size; } } @Deprecated RegionSizeCalculator(HTable table); RegionSizeCalculator(RegionLocator regionLocator, Admin admin); long getRegionSize(byte[] regionId); Map<byte[], Long> getRegionSizeMap(); } | @Test public void testLargeRegion() throws Exception { RegionLocator regionLocator = mockRegionLocator("largeRegion"); Admin admin = mockAdmin( mockServer( mockRegion("largeRegion", Integer.MAX_VALUE) ) ); RegionSizeCalculator calculator = new RegionSizeCalculator(regionLocator, admin); assertEquals(((long) Integer.MAX_VALUE) * megabyte, calculator.getRegionSize("largeRegion".getBytes())); } |
FSVisitor { public static void visitTableStoreFiles(final FileSystem fs, final Path tableDir, final StoreFileVisitor visitor) throws IOException { FileStatus[] regions = FSUtils.listStatus(fs, tableDir, new FSUtils.RegionDirFilter(fs)); if (regions == null) { if (LOG.isTraceEnabled()) { LOG.trace("No regions under directory:" + tableDir); } return; } for (FileStatus region: regions) { visitRegionStoreFiles(fs, region.getPath(), visitor); } } private FSVisitor(); static void visitRegions(final FileSystem fs, final Path tableDir,
final RegionVisitor visitor); static void visitTableStoreFiles(final FileSystem fs, final Path tableDir,
final StoreFileVisitor visitor); static void visitRegionStoreFiles(final FileSystem fs, final Path regionDir,
final StoreFileVisitor visitor); static void visitTableRecoveredEdits(final FileSystem fs, final Path tableDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitRegionRecoveredEdits(final FileSystem fs, final Path regionDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitLogFiles(final FileSystem fs, final Path rootDir,
final LogFileVisitor visitor); } | @Test public void testVisitStoreFiles() throws IOException { final Set<String> regions = new HashSet<String>(); final Set<String> families = new HashSet<String>(); final Set<String> hfiles = new HashSet<String>(); FSVisitor.visitTableStoreFiles(fs, tableDir, new FSVisitor.StoreFileVisitor() { public void storeFile(final String region, final String family, final String hfileName) throws IOException { regions.add(region); families.add(family); hfiles.add(hfileName); } }); assertEquals(tableRegions, regions); assertEquals(tableFamilies, families); assertEquals(tableHFiles, hfiles); } |
FSVisitor { public static void visitTableRecoveredEdits(final FileSystem fs, final Path tableDir, final FSVisitor.RecoveredEditsVisitor visitor) throws IOException { FileStatus[] regions = FSUtils.listStatus(fs, tableDir, new FSUtils.RegionDirFilter(fs)); if (regions == null) { if (LOG.isTraceEnabled()) { LOG.trace("No recoveredEdits regions under directory:" + tableDir); } return; } for (FileStatus region: regions) { visitRegionRecoveredEdits(fs, region.getPath(), visitor); } } private FSVisitor(); static void visitRegions(final FileSystem fs, final Path tableDir,
final RegionVisitor visitor); static void visitTableStoreFiles(final FileSystem fs, final Path tableDir,
final StoreFileVisitor visitor); static void visitRegionStoreFiles(final FileSystem fs, final Path regionDir,
final StoreFileVisitor visitor); static void visitTableRecoveredEdits(final FileSystem fs, final Path tableDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitRegionRecoveredEdits(final FileSystem fs, final Path regionDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitLogFiles(final FileSystem fs, final Path rootDir,
final LogFileVisitor visitor); } | @Test public void testVisitRecoveredEdits() throws IOException { final Set<String> regions = new HashSet<String>(); final Set<String> edits = new HashSet<String>(); FSVisitor.visitTableRecoveredEdits(fs, tableDir, new FSVisitor.RecoveredEditsVisitor() { public void recoveredEdits (final String region, final String logfile) throws IOException { regions.add(region); edits.add(logfile); } }); assertEquals(tableRegions, regions); assertEquals(recoveredEdits, edits); } |
FSVisitor { public static void visitLogFiles(final FileSystem fs, final Path rootDir, final LogFileVisitor visitor) throws IOException { Path logsDir = new Path(rootDir, HConstants.HREGION_LOGDIR_NAME); FileStatus[] logServerDirs = FSUtils.listStatus(fs, logsDir); if (logServerDirs == null) { if (LOG.isTraceEnabled()) { LOG.trace("No logs under directory:" + logsDir); } return; } for (FileStatus serverLogs: logServerDirs) { String serverName = serverLogs.getPath().getName(); FileStatus[] wals = FSUtils.listStatus(fs, serverLogs.getPath()); if (wals == null) { if (LOG.isTraceEnabled()) { LOG.trace("No wals found for server: " + serverName + ", skipping."); } continue; } for (FileStatus walRef: wals) { visitor.logFile(serverName, walRef.getPath().getName()); } } } private FSVisitor(); static void visitRegions(final FileSystem fs, final Path tableDir,
final RegionVisitor visitor); static void visitTableStoreFiles(final FileSystem fs, final Path tableDir,
final StoreFileVisitor visitor); static void visitRegionStoreFiles(final FileSystem fs, final Path regionDir,
final StoreFileVisitor visitor); static void visitTableRecoveredEdits(final FileSystem fs, final Path tableDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitRegionRecoveredEdits(final FileSystem fs, final Path regionDir,
final FSVisitor.RecoveredEditsVisitor visitor); static void visitLogFiles(final FileSystem fs, final Path rootDir,
final LogFileVisitor visitor); } | @Test public void testVisitLogFiles() throws IOException { final Set<String> servers = new HashSet<String>(); final Set<String> logs = new HashSet<String>(); FSVisitor.visitLogFiles(fs, rootDir, new FSVisitor.LogFileVisitor() { public void logFile (final String server, final String logfile) throws IOException { servers.add(server); logs.add(logfile); } }); assertEquals(regionServers, servers); assertEquals(serverLogs, logs); } |
FSUtils { public static boolean isHDFS(final Configuration conf) throws IOException { FileSystem fs = FileSystem.get(conf); String scheme = fs.getUri().getScheme(); return scheme.equalsIgnoreCase("hdfs"); } protected FSUtils(); static void setStoragePolicy(final FileSystem fs, final Configuration conf,
final Path path, final String policyKey, final String defaultPolicy); static boolean isStartingWithPath(final Path rootPath, final String path); static boolean isMatchingTail(final Path pathToSearch, String pathTail); static boolean isMatchingTail(final Path pathToSearch, final Path pathTail); static FSUtils getInstance(FileSystem fs, Configuration conf); static boolean deleteDirectory(final FileSystem fs, final Path dir); static boolean deleteRegionDir(final Configuration conf, final HRegionInfo hri); static long getDefaultBlockSize(final FileSystem fs, final Path path); static short getDefaultReplication(final FileSystem fs, final Path path); static int getDefaultBufferSize(final FileSystem fs); static FSDataOutputStream create(Configuration conf, FileSystem fs, Path path,
FsPermission perm, InetSocketAddress[] favoredNodes); static FSDataOutputStream create(FileSystem fs, Path path,
FsPermission perm, boolean overwrite); static FsPermission getFilePermissions(final FileSystem fs,
final Configuration conf, final String permssionConfKey); static void checkFileSystemAvailable(final FileSystem fs); static void checkDfsSafeMode(final Configuration conf); static String getVersion(FileSystem fs, Path rootdir); static void checkVersion(FileSystem fs, Path rootdir, boolean message); static void checkVersion(FileSystem fs, Path rootdir,
boolean message, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir); static void setVersion(FileSystem fs, Path rootdir, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir, String version,
int wait, int retries); static boolean checkClusterIdExists(FileSystem fs, Path rootdir,
int wait); static ClusterId getClusterId(FileSystem fs, Path rootdir); static void setClusterId(FileSystem fs, Path rootdir, ClusterId clusterId,
int wait); static Path validateRootPath(Path root); static String removeRootPath(Path path, final Configuration conf); static void waitOnSafeMode(final Configuration conf,
final long wait); static String getPath(Path p); static Path getRootDir(final Configuration c); static void setRootDir(final Configuration c, final Path root); static void setFsDefault(final Configuration c, final Path root); @SuppressWarnings("deprecation") static boolean metaRegionExists(FileSystem fs, Path rootdir); static HDFSBlocksDistribution computeHDFSBlocksDistribution(
final FileSystem fs, FileStatus status, long start, long length); static boolean isMajorCompacted(final FileSystem fs,
final Path hbaseRootDir); static int getTotalTableFragmentation(final HMaster master); static Map<String, Integer> getTableFragmentation(
final HMaster master); static Map<String, Integer> getTableFragmentation(
final FileSystem fs, final Path hbaseRootDir); static Path getTableDir(Path rootdir, final TableName tableName); static TableName getTableName(Path tablePath); static Path getNamespaceDir(Path rootdir, final String namespace); static boolean isAppendSupported(final Configuration conf); static boolean isHDFS(final Configuration conf); abstract void recoverFileLease(final FileSystem fs, final Path p,
Configuration conf, CancelableProgressable reporter); static List<Path> getTableDirs(final FileSystem fs, final Path rootdir); static List<Path> getLocalTableDirs(final FileSystem fs, final Path rootdir); static boolean isRecoveredEdits(Path path); static List<Path> getRegionDirs(final FileSystem fs, final Path tableDir); static List<Path> getFamilyDirs(final FileSystem fs, final Path regionDir); static List<Path> getReferenceFilePaths(final FileSystem fs, final Path familyDir); static FileSystem getCurrentFileSystem(Configuration conf); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName, ErrorReporter errors); static int getRegionReferenceFileCount(final FileSystem fs, final Path p); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir, ErrorReporter errors); static FileStatus [] listStatus(final FileSystem fs,
final Path dir, final PathFilter filter); static FileStatus[] listStatus(final FileSystem fs, final Path dir); static boolean delete(final FileSystem fs, final Path path, final boolean recursive); static boolean isExists(final FileSystem fs, final Path path); static void checkAccess(UserGroupInformation ugi, FileStatus file,
FsAction action); static void logFileSystemState(final FileSystem fs, final Path root, Log LOG); static boolean renameAndSetModifyTime(final FileSystem fs, final Path src, final Path dest); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf, final String desiredTable, int threadPoolSize); static void setupShortCircuitRead(final Configuration conf); static void checkShortCircuitReadBufferSize(final Configuration conf); static final String FULL_RWX_PERMISSIONS; static final boolean WINDOWS; } | @Test public void testIsHDFS() throws Exception { HBaseTestingUtility htu = new HBaseTestingUtility(); htu.getConfiguration().setBoolean("dfs.support.append", false); assertFalse(FSUtils.isHDFS(htu.getConfiguration())); htu.getConfiguration().setBoolean("dfs.support.append", true); MiniDFSCluster cluster = null; try { cluster = htu.startMiniDFSCluster(1); assertTrue(FSUtils.isHDFS(htu.getConfiguration())); assertTrue(FSUtils.isAppendSupported(htu.getConfiguration())); } finally { if (cluster != null) cluster.shutdown(); } } |
FSUtils { static public HDFSBlocksDistribution computeHDFSBlocksDistribution( final FileSystem fs, FileStatus status, long start, long length) throws IOException { HDFSBlocksDistribution blocksDistribution = new HDFSBlocksDistribution(); BlockLocation [] blockLocations = fs.getFileBlockLocations(status, start, length); for(BlockLocation bl : blockLocations) { String [] hosts = bl.getHosts(); long len = bl.getLength(); blocksDistribution.addHostsAndBlockWeight(hosts, len); } return blocksDistribution; } protected FSUtils(); static void setStoragePolicy(final FileSystem fs, final Configuration conf,
final Path path, final String policyKey, final String defaultPolicy); static boolean isStartingWithPath(final Path rootPath, final String path); static boolean isMatchingTail(final Path pathToSearch, String pathTail); static boolean isMatchingTail(final Path pathToSearch, final Path pathTail); static FSUtils getInstance(FileSystem fs, Configuration conf); static boolean deleteDirectory(final FileSystem fs, final Path dir); static boolean deleteRegionDir(final Configuration conf, final HRegionInfo hri); static long getDefaultBlockSize(final FileSystem fs, final Path path); static short getDefaultReplication(final FileSystem fs, final Path path); static int getDefaultBufferSize(final FileSystem fs); static FSDataOutputStream create(Configuration conf, FileSystem fs, Path path,
FsPermission perm, InetSocketAddress[] favoredNodes); static FSDataOutputStream create(FileSystem fs, Path path,
FsPermission perm, boolean overwrite); static FsPermission getFilePermissions(final FileSystem fs,
final Configuration conf, final String permssionConfKey); static void checkFileSystemAvailable(final FileSystem fs); static void checkDfsSafeMode(final Configuration conf); static String getVersion(FileSystem fs, Path rootdir); static void checkVersion(FileSystem fs, Path rootdir, boolean message); static void checkVersion(FileSystem fs, Path rootdir,
boolean message, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir); static void setVersion(FileSystem fs, Path rootdir, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir, String version,
int wait, int retries); static boolean checkClusterIdExists(FileSystem fs, Path rootdir,
int wait); static ClusterId getClusterId(FileSystem fs, Path rootdir); static void setClusterId(FileSystem fs, Path rootdir, ClusterId clusterId,
int wait); static Path validateRootPath(Path root); static String removeRootPath(Path path, final Configuration conf); static void waitOnSafeMode(final Configuration conf,
final long wait); static String getPath(Path p); static Path getRootDir(final Configuration c); static void setRootDir(final Configuration c, final Path root); static void setFsDefault(final Configuration c, final Path root); @SuppressWarnings("deprecation") static boolean metaRegionExists(FileSystem fs, Path rootdir); static HDFSBlocksDistribution computeHDFSBlocksDistribution(
final FileSystem fs, FileStatus status, long start, long length); static boolean isMajorCompacted(final FileSystem fs,
final Path hbaseRootDir); static int getTotalTableFragmentation(final HMaster master); static Map<String, Integer> getTableFragmentation(
final HMaster master); static Map<String, Integer> getTableFragmentation(
final FileSystem fs, final Path hbaseRootDir); static Path getTableDir(Path rootdir, final TableName tableName); static TableName getTableName(Path tablePath); static Path getNamespaceDir(Path rootdir, final String namespace); static boolean isAppendSupported(final Configuration conf); static boolean isHDFS(final Configuration conf); abstract void recoverFileLease(final FileSystem fs, final Path p,
Configuration conf, CancelableProgressable reporter); static List<Path> getTableDirs(final FileSystem fs, final Path rootdir); static List<Path> getLocalTableDirs(final FileSystem fs, final Path rootdir); static boolean isRecoveredEdits(Path path); static List<Path> getRegionDirs(final FileSystem fs, final Path tableDir); static List<Path> getFamilyDirs(final FileSystem fs, final Path regionDir); static List<Path> getReferenceFilePaths(final FileSystem fs, final Path familyDir); static FileSystem getCurrentFileSystem(Configuration conf); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName, ErrorReporter errors); static int getRegionReferenceFileCount(final FileSystem fs, final Path p); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir, ErrorReporter errors); static FileStatus [] listStatus(final FileSystem fs,
final Path dir, final PathFilter filter); static FileStatus[] listStatus(final FileSystem fs, final Path dir); static boolean delete(final FileSystem fs, final Path path, final boolean recursive); static boolean isExists(final FileSystem fs, final Path path); static void checkAccess(UserGroupInformation ugi, FileStatus file,
FsAction action); static void logFileSystemState(final FileSystem fs, final Path root, Log LOG); static boolean renameAndSetModifyTime(final FileSystem fs, final Path src, final Path dest); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf, final String desiredTable, int threadPoolSize); static void setupShortCircuitRead(final Configuration conf); static void checkShortCircuitReadBufferSize(final Configuration conf); static final String FULL_RWX_PERMISSIONS; static final boolean WINDOWS; } | @Test public void testcomputeHDFSBlocksDistribution() throws Exception { HBaseTestingUtility htu = new HBaseTestingUtility(); final int DEFAULT_BLOCK_SIZE = 1024; htu.getConfiguration().setLong("dfs.blocksize", DEFAULT_BLOCK_SIZE); MiniDFSCluster cluster = null; Path testFile = null; try { String hosts[] = new String[] { "host1", "host2", "host3" }; cluster = htu.startMiniDFSCluster(hosts); cluster.waitActive(); FileSystem fs = cluster.getFileSystem(); testFile = new Path("/test1.txt"); WriteDataToHDFS(fs, testFile, 2*DEFAULT_BLOCK_SIZE); final long maxTime = System.currentTimeMillis() + 2000; boolean ok; do { ok = true; FileStatus status = fs.getFileStatus(testFile); HDFSBlocksDistribution blocksDistribution = FSUtils.computeHDFSBlocksDistribution(fs, status, 0, status.getLen()); long uniqueBlocksTotalWeight = blocksDistribution.getUniqueBlocksTotalWeight(); for (String host : hosts) { long weight = blocksDistribution.getWeight(host); ok = (ok && uniqueBlocksTotalWeight == weight); } } while (!ok && System.currentTimeMillis() < maxTime); assertTrue(ok); } finally { htu.shutdownMiniDFSCluster(); } try { String hosts[] = new String[] { "host1", "host2", "host3", "host4" }; cluster = htu.startMiniDFSCluster(hosts); cluster.waitActive(); FileSystem fs = cluster.getFileSystem(); testFile = new Path("/test2.txt"); WriteDataToHDFS(fs, testFile, 3*DEFAULT_BLOCK_SIZE); final long maxTime = System.currentTimeMillis() + 2000; long weight; long uniqueBlocksTotalWeight; do { FileStatus status = fs.getFileStatus(testFile); HDFSBlocksDistribution blocksDistribution = FSUtils.computeHDFSBlocksDistribution(fs, status, 0, status.getLen()); uniqueBlocksTotalWeight = blocksDistribution.getUniqueBlocksTotalWeight(); String tophost = blocksDistribution.getTopHosts().get(0); weight = blocksDistribution.getWeight(tophost); } while (uniqueBlocksTotalWeight != weight && System.currentTimeMillis() < maxTime); assertTrue(uniqueBlocksTotalWeight == weight); } finally { htu.shutdownMiniDFSCluster(); } try { String hosts[] = new String[] { "host1", "host2", "host3", "host4" }; cluster = htu.startMiniDFSCluster(hosts); cluster.waitActive(); FileSystem fs = cluster.getFileSystem(); testFile = new Path("/test3.txt"); WriteDataToHDFS(fs, testFile, DEFAULT_BLOCK_SIZE); final long maxTime = System.currentTimeMillis() + 2000; HDFSBlocksDistribution blocksDistribution; do { FileStatus status = fs.getFileStatus(testFile); blocksDistribution = FSUtils.computeHDFSBlocksDistribution(fs, status, 0, status.getLen()); } while (blocksDistribution.getTopHosts().size() != 3 && System.currentTimeMillis() < maxTime); assertEquals("Wrong number of hosts distributing blocks.", 3, blocksDistribution.getTopHosts().size()); } finally { htu.shutdownMiniDFSCluster(); } } |
FSUtils { public static boolean renameAndSetModifyTime(final FileSystem fs, final Path src, final Path dest) throws IOException { fs.setTimes(src, EnvironmentEdgeManager.currentTime(), -1); return fs.rename(src, dest); } protected FSUtils(); static void setStoragePolicy(final FileSystem fs, final Configuration conf,
final Path path, final String policyKey, final String defaultPolicy); static boolean isStartingWithPath(final Path rootPath, final String path); static boolean isMatchingTail(final Path pathToSearch, String pathTail); static boolean isMatchingTail(final Path pathToSearch, final Path pathTail); static FSUtils getInstance(FileSystem fs, Configuration conf); static boolean deleteDirectory(final FileSystem fs, final Path dir); static boolean deleteRegionDir(final Configuration conf, final HRegionInfo hri); static long getDefaultBlockSize(final FileSystem fs, final Path path); static short getDefaultReplication(final FileSystem fs, final Path path); static int getDefaultBufferSize(final FileSystem fs); static FSDataOutputStream create(Configuration conf, FileSystem fs, Path path,
FsPermission perm, InetSocketAddress[] favoredNodes); static FSDataOutputStream create(FileSystem fs, Path path,
FsPermission perm, boolean overwrite); static FsPermission getFilePermissions(final FileSystem fs,
final Configuration conf, final String permssionConfKey); static void checkFileSystemAvailable(final FileSystem fs); static void checkDfsSafeMode(final Configuration conf); static String getVersion(FileSystem fs, Path rootdir); static void checkVersion(FileSystem fs, Path rootdir, boolean message); static void checkVersion(FileSystem fs, Path rootdir,
boolean message, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir); static void setVersion(FileSystem fs, Path rootdir, int wait, int retries); static void setVersion(FileSystem fs, Path rootdir, String version,
int wait, int retries); static boolean checkClusterIdExists(FileSystem fs, Path rootdir,
int wait); static ClusterId getClusterId(FileSystem fs, Path rootdir); static void setClusterId(FileSystem fs, Path rootdir, ClusterId clusterId,
int wait); static Path validateRootPath(Path root); static String removeRootPath(Path path, final Configuration conf); static void waitOnSafeMode(final Configuration conf,
final long wait); static String getPath(Path p); static Path getRootDir(final Configuration c); static void setRootDir(final Configuration c, final Path root); static void setFsDefault(final Configuration c, final Path root); @SuppressWarnings("deprecation") static boolean metaRegionExists(FileSystem fs, Path rootdir); static HDFSBlocksDistribution computeHDFSBlocksDistribution(
final FileSystem fs, FileStatus status, long start, long length); static boolean isMajorCompacted(final FileSystem fs,
final Path hbaseRootDir); static int getTotalTableFragmentation(final HMaster master); static Map<String, Integer> getTableFragmentation(
final HMaster master); static Map<String, Integer> getTableFragmentation(
final FileSystem fs, final Path hbaseRootDir); static Path getTableDir(Path rootdir, final TableName tableName); static TableName getTableName(Path tablePath); static Path getNamespaceDir(Path rootdir, final String namespace); static boolean isAppendSupported(final Configuration conf); static boolean isHDFS(final Configuration conf); abstract void recoverFileLease(final FileSystem fs, final Path p,
Configuration conf, CancelableProgressable reporter); static List<Path> getTableDirs(final FileSystem fs, final Path rootdir); static List<Path> getLocalTableDirs(final FileSystem fs, final Path rootdir); static boolean isRecoveredEdits(Path path); static List<Path> getRegionDirs(final FileSystem fs, final Path tableDir); static List<Path> getFamilyDirs(final FileSystem fs, final Path regionDir); static List<Path> getReferenceFilePaths(final FileSystem fs, final Path familyDir); static FileSystem getCurrentFileSystem(Configuration conf); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName); static Map<String, Path> getTableStoreFilePathMap(Map<String, Path> map,
final FileSystem fs, final Path hbaseRootDir, TableName tableName, ErrorReporter errors); static int getRegionReferenceFileCount(final FileSystem fs, final Path p); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir); static Map<String, Path> getTableStoreFilePathMap(
final FileSystem fs, final Path hbaseRootDir, ErrorReporter errors); static FileStatus [] listStatus(final FileSystem fs,
final Path dir, final PathFilter filter); static FileStatus[] listStatus(final FileSystem fs, final Path dir); static boolean delete(final FileSystem fs, final Path path, final boolean recursive); static boolean isExists(final FileSystem fs, final Path path); static void checkAccess(UserGroupInformation ugi, FileStatus file,
FsAction action); static void logFileSystemState(final FileSystem fs, final Path root, Log LOG); static boolean renameAndSetModifyTime(final FileSystem fs, final Path src, final Path dest); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf); static Map<String, Map<String, Float>> getRegionDegreeLocalityMappingFromFS(
final Configuration conf, final String desiredTable, int threadPoolSize); static void setupShortCircuitRead(final Configuration conf); static void checkShortCircuitReadBufferSize(final Configuration conf); static final String FULL_RWX_PERMISSIONS; static final boolean WINDOWS; } | @Test public void testRenameAndSetModifyTime() throws Exception { HBaseTestingUtility htu = new HBaseTestingUtility(); Configuration conf = htu.getConfiguration(); MiniDFSCluster cluster = htu.startMiniDFSCluster(1); assertTrue(FSUtils.isHDFS(conf)); FileSystem fs = FileSystem.get(conf); Path testDir = htu.getDataTestDirOnTestFS("testArchiveFile"); String file = UUID.randomUUID().toString(); Path p = new Path(testDir, file); FSDataOutputStream out = fs.create(p); out.close(); assertTrue("The created file should be present", FSUtils.isExists(fs, p)); long expect = System.currentTimeMillis() + 1000; assertNotEquals(expect, fs.getFileStatus(p).getModificationTime()); ManualEnvironmentEdge mockEnv = new ManualEnvironmentEdge(); mockEnv.setValue(expect); EnvironmentEdgeManager.injectEdge(mockEnv); try { String dstFile = UUID.randomUUID().toString(); Path dst = new Path(testDir , dstFile); assertTrue(FSUtils.renameAndSetModifyTime(fs, p, dst)); assertFalse("The moved file should not be present", FSUtils.isExists(fs, p)); assertTrue("The dst file should be present", FSUtils.isExists(fs, dst)); assertEquals(expect, fs.getFileStatus(dst).getModificationTime()); cluster.shutdown(); } finally { EnvironmentEdgeManager.reset(); } } |
FileLink { @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (this.getClass().equals(obj.getClass())) { return Arrays.equals(this.locations, ((FileLink) obj).locations); } return false; } protected FileLink(); FileLink(Path originPath, Path... alternativePaths); FileLink(final Collection<Path> locations); Path[] getLocations(); @Override String toString(); boolean exists(final FileSystem fs); Path getAvailablePath(FileSystem fs); FileStatus getFileStatus(FileSystem fs); FSDataInputStream open(final FileSystem fs); FSDataInputStream open(final FileSystem fs, int bufferSize); static Path getBackReferencesDir(final Path storeDir, final String fileName); static String getBackReferenceFileName(final Path dirPath); static boolean isBackReferencesDir(final Path dirPath); @Override boolean equals(Object obj); @Override int hashCode(); static final String BACK_REFERENCES_DIRECTORY_PREFIX; } | @Test public void testEquals() { Path p1 = new Path("/p1"); Path p2 = new Path("/p2"); Path p3 = new Path("/p3"); assertEquals(new FileLink(), new FileLink()); assertEquals(new FileLink(p1), new FileLink(p1)); assertEquals(new FileLink(p1, p2), new FileLink(p1, p2)); assertEquals(new FileLink(p1, p2, p3), new FileLink(p1, p2, p3)); assertNotEquals(new FileLink(p1), new FileLink(p3)); assertNotEquals(new FileLink(p1, p2), new FileLink(p1)); assertNotEquals(new FileLink(p1, p2), new FileLink(p2)); assertNotEquals(new FileLink(p1, p2), new FileLink(p2, p1)); } |
FileLink { @Override public int hashCode() { return Arrays.hashCode(locations); } protected FileLink(); FileLink(Path originPath, Path... alternativePaths); FileLink(final Collection<Path> locations); Path[] getLocations(); @Override String toString(); boolean exists(final FileSystem fs); Path getAvailablePath(FileSystem fs); FileStatus getFileStatus(FileSystem fs); FSDataInputStream open(final FileSystem fs); FSDataInputStream open(final FileSystem fs, int bufferSize); static Path getBackReferencesDir(final Path storeDir, final String fileName); static String getBackReferenceFileName(final Path dirPath); static boolean isBackReferencesDir(final Path dirPath); @Override boolean equals(Object obj); @Override int hashCode(); static final String BACK_REFERENCES_DIRECTORY_PREFIX; } | @Test public void testHashCode() { Path p1 = new Path("/p1"); Path p2 = new Path("/p2"); Path p3 = new Path("/p3"); assertEquals(new FileLink().hashCode(), new FileLink().hashCode()); assertEquals(new FileLink(p1).hashCode(), new FileLink(p1).hashCode()); assertEquals(new FileLink(p1, p2).hashCode(), new FileLink(p1, p2).hashCode()); assertEquals(new FileLink(p1, p2, p3).hashCode(), new FileLink(p1, p2, p3).hashCode()); assertNotEquals(new FileLink(p1).hashCode(), new FileLink(p3).hashCode()); assertNotEquals(new FileLink(p1, p2).hashCode(), new FileLink(p1).hashCode()); assertNotEquals(new FileLink(p1, p2).hashCode(), new FileLink(p2).hashCode()); assertNotEquals(new FileLink(p1, p2).hashCode(), new FileLink(p2, p1).hashCode()); } |
FileLink { public FSDataInputStream open(final FileSystem fs) throws IOException { return new FSDataInputStream(new FileLinkInputStream(fs, this)); } protected FileLink(); FileLink(Path originPath, Path... alternativePaths); FileLink(final Collection<Path> locations); Path[] getLocations(); @Override String toString(); boolean exists(final FileSystem fs); Path getAvailablePath(FileSystem fs); FileStatus getFileStatus(FileSystem fs); FSDataInputStream open(final FileSystem fs); FSDataInputStream open(final FileSystem fs, int bufferSize); static Path getBackReferencesDir(final Path storeDir, final String fileName); static String getBackReferenceFileName(final Path dirPath); static boolean isBackReferencesDir(final Path dirPath); @Override boolean equals(Object obj); @Override int hashCode(); static final String BACK_REFERENCES_DIRECTORY_PREFIX; } | @Test public void testHDFSLinkReadDuringDelete() throws Exception { HBaseTestingUtility testUtil = new HBaseTestingUtility(); Configuration conf = testUtil.getConfiguration(); conf.setInt("dfs.blocksize", 1024 * 1024); conf.setInt("dfs.client.read.prefetch.size", 2 * 1024 * 1024); testUtil.startMiniDFSCluster(1); MiniDFSCluster cluster = testUtil.getDFSCluster(); FileSystem fs = cluster.getFileSystem(); assertEquals("hdfs", fs.getUri().getScheme()); try { List<Path> files = new ArrayList<Path>(); for (int i = 0; i < 3; i++) { Path path = new Path(String.format("test-data-%d", i)); writeSomeData(fs, path, 1 << 20, (byte)i); files.add(path); } FileLink link = new FileLink(files); FSDataInputStream in = link.open(fs); try { byte[] data = new byte[8192]; int n; n = in.read(data); dataVerify(data, n, (byte)0); fs.delete(files.get(0), true); skipBuffer(in, (byte)0); n = in.read(data); dataVerify(data, n, (byte)1); fs.delete(files.get(1), true); skipBuffer(in, (byte)1); n = in.read(data); dataVerify(data, n, (byte)2); fs.delete(files.get(2), true); skipBuffer(in, (byte)2); try { n = in.read(data); assert(n <= 0); } catch (FileNotFoundException e) { assertTrue(true); } } finally { in.close(); } } finally { testUtil.shutdownMiniCluster(); } } |
LruCachedBlock implements HeapSize, Comparable<LruCachedBlock> { @Override public int hashCode() { return (int)(accessTime ^ (accessTime >>> 32)); } LruCachedBlock(BlockCacheKey cacheKey, Cacheable buf, long accessTime); LruCachedBlock(BlockCacheKey cacheKey, Cacheable buf, long accessTime,
boolean inMemory); void access(long accessTime); long getCachedTime(); long heapSize(); @Override int compareTo(LruCachedBlock that); @Override int hashCode(); @Override boolean equals(Object obj); Cacheable getBuffer(); BlockCacheKey getCacheKey(); BlockPriority getPriority(); final static long PER_BLOCK_OVERHEAD; } | @Test public void testEquality() { assertEquals(block.hashCode(), blockEqual.hashCode()); assertNotEquals(block.hashCode(), blockNotEqual.hashCode()); assertEquals(block, blockEqual); assertNotEquals(block, blockNotEqual); } |
BucketCache implements BlockCache, HeapSize { public BucketAllocator getAllocator() { return this.bucketAllocator; } BucketCache(String ioEngineName, long capacity, int blockSize, int[] bucketSizes,
int writerThreadNum, int writerQLen, String persistencePath); BucketCache(String ioEngineName, long capacity, int blockSize, int[] bucketSizes,
int writerThreadNum, int writerQLen, String persistencePath, int ioErrorsTolerationDuration); long getMaxSize(); String getIoEngine(); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable buf); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory,
final boolean cacheDataInL1); void cacheBlockWithWait(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory,
boolean wait); @Override Cacheable getBlock(BlockCacheKey key, boolean caching, boolean repeat,
boolean updateCacheMetrics); @Override boolean evictBlock(BlockCacheKey cacheKey); void logStats(); long getRealCacheSize(); @Override void shutdown(); @Override CacheStats getStats(); BucketAllocator getAllocator(); @Override long heapSize(); @Override long size(); @Override long getFreeSize(); @Override long getBlockCount(); @Override long getCurrentSize(); @Override int evictBlocksByHfileName(String hfileName); @Override Iterator<CachedBlock> iterator(); @Override BlockCache[] getBlockCaches(); static final int DEFAULT_ERROR_TOLERATION_DURATION; } | @Test public void testBucketAllocator() throws BucketAllocatorException { BucketAllocator mAllocator = cache.getAllocator(); final List<Integer> BLOCKSIZES = Arrays.asList(4 * 1024, 8 * 1024, 64 * 1024, 96 * 1024); boolean full = false; ArrayList<Long> allocations = new ArrayList<Long>(); List<Integer> tmp = new ArrayList<Integer>(BLOCKSIZES); while (!full) { Integer blockSize = null; try { blockSize = randFrom(tmp); allocations.add(mAllocator.allocateBlock(blockSize)); } catch (CacheFullException cfe) { tmp.remove(blockSize); if (tmp.isEmpty()) full = true; } } for (Integer blockSize : BLOCKSIZES) { BucketSizeInfo bucketSizeInfo = mAllocator.roundUpToBucketSizeInfo(blockSize); IndexStatistics indexStatistics = bucketSizeInfo.statistics(); assertEquals("unexpected freeCount for " + bucketSizeInfo, 0, indexStatistics.freeCount()); } for (long offset : allocations) { assertEquals(mAllocator.sizeOfAllocation(offset), mAllocator.freeBlock(offset)); } assertEquals(0, mAllocator.getUsedSize()); } |
BucketCache implements BlockCache, HeapSize { void stopWriterThreads() throws InterruptedException { for (WriterThread writerThread : writerThreads) { writerThread.disableWriter(); writerThread.interrupt(); writerThread.join(); } } BucketCache(String ioEngineName, long capacity, int blockSize, int[] bucketSizes,
int writerThreadNum, int writerQLen, String persistencePath); BucketCache(String ioEngineName, long capacity, int blockSize, int[] bucketSizes,
int writerThreadNum, int writerQLen, String persistencePath, int ioErrorsTolerationDuration); long getMaxSize(); String getIoEngine(); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable buf); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory,
final boolean cacheDataInL1); void cacheBlockWithWait(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory,
boolean wait); @Override Cacheable getBlock(BlockCacheKey key, boolean caching, boolean repeat,
boolean updateCacheMetrics); @Override boolean evictBlock(BlockCacheKey cacheKey); void logStats(); long getRealCacheSize(); @Override void shutdown(); @Override CacheStats getStats(); BucketAllocator getAllocator(); @Override long heapSize(); @Override long size(); @Override long getFreeSize(); @Override long getBlockCount(); @Override long getCurrentSize(); @Override int evictBlocksByHfileName(String hfileName); @Override Iterator<CachedBlock> iterator(); @Override BlockCache[] getBlockCaches(); static final int DEFAULT_ERROR_TOLERATION_DURATION; } | @Test public void testHeapSizeChanges() throws Exception { cache.stopWriterThreads(); CacheTestUtils.testHeapSizeChanges(cache, BLOCK_SIZE); } |
Reference { public static Reference read(final FileSystem fs, final Path p) throws IOException { InputStream in = fs.open(p); try { in = in.markSupported()? in: new BufferedInputStream(in); int pblen = ProtobufUtil.lengthOfPBMagic(); in.mark(pblen); byte [] pbuf = new byte[pblen]; int read = in.read(pbuf); if (read != pblen) throw new IOException("read=" + read + ", wanted=" + pblen); if (ProtobufUtil.isPBMagicPrefix(pbuf)) return convert(FSProtos.Reference.parseFrom(in)); in.reset(); Reference r = new Reference(); DataInputStream dis = new DataInputStream(in); in = dis; r.readFields(dis); return r; } finally { in.close(); } } Reference(final byte [] splitRow, final Range fr); @Deprecated // Make this private when it comes time to let go of this constructor. // Needed by pb serialization. Reference(); static Reference createTopReference(final byte [] splitRow); static Reference createBottomReference(final byte [] splitRow); Range getFileRegion(); byte [] getSplitKey(); @Override String toString(); static boolean isTopFileRegion(final Range r); @Deprecated void readFields(DataInput in); Path write(final FileSystem fs, final Path p); static Reference read(final FileSystem fs, final Path p); FSProtos.Reference convert(); static Reference convert(final FSProtos.Reference r); @Override int hashCode(); boolean equals(Object o); } | @Test public void testParsingWritableReference() throws IOException { final String datafile = System.getProperty("test.build.classes", "target/test-classes") + File.separator + "a6a6562b777440fd9c34885428f5cb61.21e75333ada3d5bafb34bb918f29576c"; FileSystem fs = FileSystem.get(HTU.getConfiguration()); Reference.read(fs, new Path(datafile)); } |
MetaMigrationConvertingToPB { static boolean isMetaTableUpdated(final HConnection hConnection) throws IOException { List<Result> results = MetaTableAccessor.fullScanOfMeta(hConnection); if (results == null || results.isEmpty()) { LOG.info("hbase:meta doesn't have any entries to update."); return true; } for (Result r : results) { byte[] value = r.getValue(HConstants.CATALOG_FAMILY, HConstants.REGIONINFO_QUALIFIER); if (!isMigrated(value)) { return false; } } return true; } static long updateMetaIfNecessary(final MasterServices services); } | @Test public void testMetaUpdatedFlagInROOT() throws Exception { HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster(); boolean metaUpdated = MetaMigrationConvertingToPB. isMetaTableUpdated(master.getConnection()); assertEquals(true, metaUpdated); verifyMetaRowsAreUpdated(master.getConnection()); } |
LocalHBaseCluster { public LocalHBaseCluster(final Configuration conf) throws IOException { this(conf, DEFAULT_NO); } LocalHBaseCluster(final Configuration conf); LocalHBaseCluster(final Configuration conf, final int noRegionServers); LocalHBaseCluster(final Configuration conf, final int noMasters,
final int noRegionServers); @SuppressWarnings("unchecked") LocalHBaseCluster(final Configuration conf, final int noMasters,
final int noRegionServers, final Class<? extends HMaster> masterClass,
final Class<? extends HRegionServer> regionServerClass); JVMClusterUtil.RegionServerThread addRegionServer(); @SuppressWarnings("unchecked") JVMClusterUtil.RegionServerThread addRegionServer(
Configuration config, final int index); JVMClusterUtil.RegionServerThread addRegionServer(
final Configuration config, final int index, User user); JVMClusterUtil.MasterThread addMaster(); JVMClusterUtil.MasterThread addMaster(Configuration c, final int index); JVMClusterUtil.MasterThread addMaster(
final Configuration c, final int index, User user); HRegionServer getRegionServer(int serverNumber); List<JVMClusterUtil.RegionServerThread> getRegionServers(); List<JVMClusterUtil.RegionServerThread> getLiveRegionServers(); Configuration getConfiguration(); String waitOnRegionServer(int serverNumber); String waitOnRegionServer(JVMClusterUtil.RegionServerThread rst); HMaster getMaster(int serverNumber); HMaster getActiveMaster(); List<JVMClusterUtil.MasterThread> getMasters(); List<JVMClusterUtil.MasterThread> getLiveMasters(); String waitOnMaster(int serverNumber); String waitOnMaster(JVMClusterUtil.MasterThread masterThread); void join(); void startup(); void shutdown(); static boolean isLocal(final Configuration c); static void main(String[] args); static final String LOCAL; static final String LOCAL_COLON; } | @Test public void testLocalHBaseCluster() throws Exception { TEST_UTIL.startMiniCluster(1, 1, null, MyHMaster.class, MyHRegionServer.class); try { int val = ((MyHMaster)TEST_UTIL.getHBaseCluster().getMaster(0)).echo(42); assertEquals(42, val); } catch (ClassCastException e) { fail("Could not cast master to our class"); } try { int val = ((MyHRegionServer)TEST_UTIL.getHBaseCluster().getRegionServer(0)).echo(42); assertEquals(42, val); } catch (ClassCastException e) { fail("Could not cast regionserver to our class"); } TEST_UTIL.shutdownMiniCluster(); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions) throws IOException { Set<byte[]> families = desc.getFamiliesKeys(); Map<byte[], Set<byte[]>> familyMap = new TreeMap<byte[], Set<byte[]>>(Bytes.BYTES_COMPARATOR); for (byte[] family: families) { familyMap.put(family, null); } requireNamespacePermission("createTable", desc.getTableName().getNamespaceAsString(), desc.getTableName(), familyMap, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableCreate() throws Exception { AccessTestAction createTable = new AccessTestAction() { @Override public Object run() throws Exception { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf("testnewtable")); htd.addFamily(new HColumnDescriptor(TEST_FAMILY)); ACCESS_CONTROLLER.preCreateTable(ObserverContext.createAndPrepare(CP_ENV, null), htd, null); return null; } }; verifyAllowed(createTable, SUPERUSER, USER_ADMIN, USER_GROUP_CREATE); verifyDenied(createTable, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_GROUP_ADMIN, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd) throws IOException { requirePermission("modifyTable", tableName, null, null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableModify() throws Exception { AccessTestAction modifyTable = new AccessTestAction() { @Override public Object run() throws Exception { HTableDescriptor htd = new HTableDescriptor(TEST_TABLE); htd.addFamily(new HColumnDescriptor(TEST_FAMILY)); htd.addFamily(new HColumnDescriptor("fam_" + User.getCurrent().getShortName())); ACCESS_CONTROLLER.preModifyTable(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE, htd); return null; } }; verifyAllowed(modifyTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(modifyTable, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName) throws IOException { requirePermission("deleteTable", tableName, null, null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableDelete() throws Exception { AccessTestAction deleteTable = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER .preDeleteTable(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE); return null; } }; verifyAllowed(deleteTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(deleteTable, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, final TableName tableName) throws IOException { requirePermission("truncateTable", tableName, null, null, Action.ADMIN, Action.CREATE); final Configuration conf = c.getEnvironment().getConfiguration(); User.runAsLoginUser(new PrivilegedExceptionAction<Void>() { @Override public Void run() throws Exception { List<UserPermission> acls = AccessControlLists.getUserTablePermissions(conf, tableName); if (acls != null) { tableAcls.put(tableName, acls); } return null; } }); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableTruncate() throws Exception { AccessTestAction truncateTable = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER .preTruncateTable(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE); return null; } }; verifyAllowed(truncateTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(truncateTable, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column) throws IOException { requireTablePermission("addColumn", tableName, column.getName(), null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testAddColumn() throws Exception { final HColumnDescriptor hcd = new HColumnDescriptor("fam_new"); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preAddColumn(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE, hcd); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(action, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor) throws IOException { requirePermission("modifyColumn", tableName, descriptor.getName(), null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testModifyColumn() throws Exception { final HColumnDescriptor hcd = new HColumnDescriptor(TEST_FAMILY); hcd.setMaxVersions(10); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preModifyColumn(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE, hcd); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_ADMIN_CF, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(action, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
LogLevel { public static void main(String[] args) { if (args.length == 3 && "-getlevel".equals(args[0])) { process("http: return; } else if (args.length == 4 && "-setlevel".equals(args[0])) { process("http: + "&level=" + args[3]); return; } System.err.println(USAGES); System.exit(-1); } static void main(String[] args); static final String USAGES; } | @Test (timeout=60000) @SuppressWarnings("deprecation") public void testDynamicLogLevel() throws Exception { String logName = TestLogLevel.class.getName(); Log testlog = LogFactory.getLog(logName); if (testlog instanceof Log4JLogger) { Logger log = ((Log4JLogger)testlog).getLogger(); log.debug("log.debug1"); log.info("log.info1"); log.error("log.error1"); assertTrue(!Level.ERROR.equals(log.getEffectiveLevel())); HttpServer server = null; try { server = new HttpServer.Builder().setName("..") .addEndpoint(new URI("http: .build(); server.start(); String authority = NetUtils.getHostPortString(server .getConnectorAddress(0)); URL url = new URL("http: + "&level=" + Level.ERROR); out.println("*** Connecting to " + url); HttpURLConnection connection = (HttpURLConnection)url.openConnection(); connection.connect(); BufferedReader in = new BufferedReader(new InputStreamReader( connection.getInputStream())); for(String line; (line = in.readLine()) != null; out.println(line)); in.close(); connection.disconnect(); log.debug("log.debug2"); log.info("log.info2"); log.error("log.error2"); assertTrue(Level.ERROR.equals(log.getEffectiveLevel())); String[] args = {"-setlevel", authority, logName, Level.DEBUG.toString()}; LogLevel.main(args); log.debug("log.debug3"); log.info("log.info3"); log.error("log.error3"); assertTrue(Level.DEBUG.equals(log.getEffectiveLevel())); } finally { if (server != null) { server.stop(); } } } else { out.println(testlog.getClass() + " not tested."); } } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col) throws IOException { requirePermission("deleteColumn", tableName, col, null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testDeleteColumn() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preDeleteColumn(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE, TEST_FAMILY); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_ADMIN_CF, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(action, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName) throws IOException { if (Bytes.equals(tableName.getName(), AccessControlLists.ACL_GLOBAL_NAME)) { throw new AccessDeniedException("Not allowed to disable " + AccessControlLists.ACL_TABLE_NAME + " table with AccessController installed"); } requirePermission("disableTable", tableName, null, null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableDisable() throws Exception { AccessTestAction disableTable = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preDisableTable(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE); return null; } }; AccessTestAction disableAclTable = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preDisableTable(ObserverContext.createAndPrepare(CP_ENV, null), AccessControlLists.ACL_TABLE_NAME); return null; } }; verifyAllowed(disableTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(disableTable, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); verifyDenied(disableAclTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_GROUP_CREATE, USER_GROUP_ADMIN, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName) throws IOException { requirePermission("enableTable", tableName, null, null, Action.ADMIN, Action.CREATE); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testTableEnable() throws Exception { AccessTestAction enableTable = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER .preEnableTable(ObserverContext.createAndPrepare(CP_ENV, null), TEST_TABLE); return null; } }; verifyAllowed(enableTable, SUPERUSER, USER_ADMIN, USER_CREATE, USER_OWNER, USER_GROUP_CREATE, USER_GROUP_ADMIN); verifyDenied(enableTable, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preAbortProcedure( ObserverContext<MasterCoprocessorEnvironment> ctx, final ProcedureExecutor<MasterProcedureEnv> procEnv, final long procId) throws IOException { if (!procEnv.isProcedureOwner(procId, getActiveUser())) { requirePermission("abortProcedure", Action.ADMIN); } } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test public void testAbortProcedure() throws Exception { final TableName tableName = TableName.valueOf("testAbortProcedure"); final ProcedureExecutor<MasterProcedureEnv> procExec = TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(); Procedure proc = new TestTableDDLProcedure(procExec.getEnvironment(), tableName); proc.setOwner(USER_OWNER.getShortName()); final long procId = procExec.submitProcedure(proc); AccessTestAction abortProcedureAction = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER .preAbortProcedure(ObserverContext.createAndPrepare(CP_ENV, null), procExec, procId); return null; } }; verifyAllowed(abortProcedureAction, SUPERUSER, USER_ADMIN, USER_GROUP_ADMIN); verifyAllowed(abortProcedureAction, USER_OWNER); verifyDenied( abortProcedureAction, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void postListProcedures( ObserverContext<MasterCoprocessorEnvironment> ctx, List<ProcedureInfo> procInfoList) throws IOException { if (procInfoList.isEmpty()) { return; } Iterator<ProcedureInfo> itr = procInfoList.iterator(); User user = getActiveUser(); while (itr.hasNext()) { ProcedureInfo procInfo = itr.next(); try { if (!ProcedureInfo.isProcedureOwner(procInfo, user)) { requirePermission("listProcedures", Action.ADMIN); } } catch (AccessDeniedException e) { itr.remove(); } } } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test public void testListProcedures() throws Exception { final TableName tableName = TableName.valueOf("testAbortProcedure"); final ProcedureExecutor<MasterProcedureEnv> procExec = TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(); Procedure proc = new TestTableDDLProcedure(procExec.getEnvironment(), tableName); proc.setOwner(USER_OWNER.getShortName()); final long procId = procExec.submitProcedure(proc); final List<ProcedureInfo> procInfoList = procExec.listProcedures(); AccessTestAction listProceduresAction = new AccessTestAction() { @Override public Object run() throws Exception { List<ProcedureInfo> procInfoListClone = new ArrayList<ProcedureInfo>(procInfoList.size()); for(ProcedureInfo pi : procInfoList) { procInfoListClone.add(pi.clone()); } ACCESS_CONTROLLER .postListProcedures(ObserverContext.createAndPrepare(CP_ENV, null), procInfoListClone); return null; } }; verifyAllowed(listProceduresAction, SUPERUSER, USER_ADMIN, USER_GROUP_ADMIN); verifyAllowed(listProceduresAction, USER_OWNER); verifyIfNull( listProceduresAction, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer) throws IOException { requirePermission("move", region.getTable(), null, null, Action.ADMIN); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testMove() throws Exception { List<HRegionLocation> regions; try (RegionLocator locator = systemUserConnection.getRegionLocator(TEST_TABLE)) { regions = locator.getAllRegionLocations(); } HRegionLocation location = regions.get(0); final HRegionInfo hri = location.getRegionInfo(); final ServerName server = location.getServerName(); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preMove(ObserverContext.createAndPrepare(CP_ENV, null), hri, server, server); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_GROUP_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE, USER_GROUP_CREATE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo) throws IOException { requirePermission("assign", regionInfo.getTable(), null, null, Action.ADMIN); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testAssign() throws Exception { List<HRegionLocation> regions; try (RegionLocator locator = systemUserConnection.getRegionLocator(TEST_TABLE)) { regions = locator.getAllRegionLocations(); } HRegionLocation location = regions.get(0); final HRegionInfo hri = location.getRegionInfo(); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preAssign(ObserverContext.createAndPrepare(CP_ENV, null), hri); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_GROUP_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE, USER_GROUP_CREATE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force) throws IOException { requirePermission("unassign", regionInfo.getTable(), null, null, Action.ADMIN); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testUnassign() throws Exception { List<HRegionLocation> regions; try (RegionLocator locator = systemUserConnection.getRegionLocator(TEST_TABLE)) { regions = locator.getAllRegionLocations(); } HRegionLocation location = regions.get(0); final HRegionInfo hri = location.getRegionInfo(); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preUnassign(ObserverContext.createAndPrepare(CP_ENV, null), hri, false); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_GROUP_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE, USER_GROUP_CREATE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo) throws IOException { requirePermission("regionOffline", regionInfo.getTable(), null, null, Action.ADMIN); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testRegionOffline() throws Exception { List<HRegionLocation> regions; try (RegionLocator locator = systemUserConnection.getRegionLocator(TEST_TABLE)) { regions = locator.getAllRegionLocations(); } HRegionLocation location = regions.get(0); final HRegionInfo hri = location.getRegionInfo(); AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preRegionOffline(ObserverContext.createAndPrepare(CP_ENV, null), hri); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_GROUP_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE, USER_GROUP_CREATE); } |
AccessController extends BaseMasterAndRegionObserver implements RegionServerObserver,
AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver { @Override public void preBalance(ObserverContext<MasterCoprocessorEnvironment> c) throws IOException { requirePermission("balance", Action.ADMIN); } static boolean isAuthorizationSupported(Configuration conf); static boolean isCellAuthorizationSupported(Configuration conf); Region getRegion(); TableAuthManager getAuthManager(); void requireNamespacePermission(String request, String namespace,
Action... permissions); void requireNamespacePermission(String request, String namespace, TableName tableName,
Map<byte[], ? extends Collection<byte[]>> familyMap, Action... permissions); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> c,
HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
TableName tableName, final HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
final TableName tableName, final byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preAbortProcedure(
ObserverContext<MasterCoprocessorEnvironment> ctx,
final ProcedureExecutor<MasterProcedureEnv> procEnv,
final long procId); @Override void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void postListProcedures(
ObserverContext<MasterCoprocessorEnvironment> ctx,
List<ProcedureInfo> procInfoList); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region,
ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo,
boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
NamespaceDescriptor ns); @Override void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<NamespaceDescriptor> descriptors); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName); @Override void preOpen(ObserverContext<RegionCoprocessorEnvironment> e); @Override void postOpen(ObserverContext<RegionCoprocessorEnvironment> c); @Override void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c); @Override void preFlush(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e); @Override void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
byte[] splitRow); @Override InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
final Store store, final InternalScanner scanner, final ScanType scanType); @Override void preGetClosestRowBefore(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final Result result); @Override void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final List<Cell> result); @Override boolean preExists(final ObserverContext<RegionCoprocessorEnvironment> c,
final Get get, final boolean exists); @Override void prePut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void postPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final Put put, final WALEdit edit, final Durability durability); @Override void preDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
MiniBatchOperationInProgress<Mutation> miniBatchOp); @Override void postDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final Delete delete, final WALEdit edit, final Durability durability); @Override boolean preCheckAndPut(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndPutAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte[] row, final byte[] family, final byte[] qualifier,
final CompareFilter.CompareOp compareOp, final ByteArrayComparable comparator, final Put put,
final boolean result); @Override boolean preCheckAndDelete(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete,
final boolean result); @Override boolean preCheckAndDeleteAfterRowLock(
final ObserverContext<RegionCoprocessorEnvironment> c, final byte[] row, final byte[] family,
final byte[] qualifier, final CompareFilter.CompareOp compareOp,
final ByteArrayComparable comparator, final Delete delete, final boolean result); @Override long preIncrementColumnValue(final ObserverContext<RegionCoprocessorEnvironment> c,
final byte [] row, final byte [] family, final byte [] qualifier,
final long amount, final boolean writeToWAL); @Override Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append); @Override Result preAppendAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Append append); @Override Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Result preIncrementAfterRowLock(final ObserverContext<RegionCoprocessorEnvironment> c,
final Increment increment); @Override Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
MutationType opType, Mutation mutation, Cell oldCell, Cell newCell); @Override RegionScanner preScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override RegionScanner postScannerOpen(final ObserverContext<RegionCoprocessorEnvironment> c,
final Scan scan, final RegionScanner s); @Override boolean preScannerNext(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s, final List<Result> result,
final int limit, final boolean hasNext); @Override void preScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void postScannerClose(final ObserverContext<RegionCoprocessorEnvironment> c,
final InternalScanner s); @Override void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
List<Pair<byte[], String>> familyPaths); @Override void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
PrepareBulkLoadRequest request); @Override void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
CleanupBulkLoadRequest request); @Override Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request); @Override void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
Service service, String methodName, Message request, Message.Builder responseBuilder); @Override void grant(RpcController controller,
AccessControlProtos.GrantRequest request,
RpcCallback<AccessControlProtos.GrantResponse> done); @Override void revoke(RpcController controller,
AccessControlProtos.RevokeRequest request,
RpcCallback<AccessControlProtos.RevokeResponse> done); @Override void getUserPermissions(RpcController controller,
AccessControlProtos.GetUserPermissionsRequest request,
RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done); @Override void checkPermissions(RpcController controller,
AccessControlProtos.CheckPermissionsRequest request,
RpcCallback<AccessControlProtos.CheckPermissionsResponse> done); @Override Service getService(); @Override void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested); @Override void preStopRegionServer(
ObserverContext<RegionServerCoprocessorEnvironment> env); @Override void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<TableName> tableNamesList, List<HTableDescriptor> descriptors,
String regex); @Override void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
List<HTableDescriptor> descriptors, String regex); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA,
Region regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA,
Region regionB, Region mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB, Region mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
Region regionA, Region regionB); @Override void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx); @Override ReplicationEndpoint postCreateReplicationEndPoint(
ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint); @Override void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
List<WALEntry> entries, CellScanner cells); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final TableName tableName, final Quotas quotas); @Override void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String userName, final String namespace, final Quotas quotas); @Override void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final TableName tableName, final Quotas quotas); @Override void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx,
final String namespace, final Quotas quotas); } | @Test (timeout=180000) public void testBalance() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preBalance(ObserverContext.createAndPrepare(CP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_GROUP_ADMIN); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE, USER_GROUP_READ, USER_GROUP_WRITE, USER_GROUP_CREATE); } |
WsImportMojo extends AbstractJaxwsMojo { static String getActiveHttpProxy(Settings s) { String retVal = null; for (Proxy p : s.getProxies()) { if (p.isActive() && "http".equals(p.getProtocol())) { StringBuilder sb = new StringBuilder(); String user = p.getUsername(); String pwd = p.getPassword(); if (user != null) { sb.append(user); if (pwd != null) { sb.append(":"); sb.append(pwd); } sb.append("@"); } sb.append(p.getHost()); sb.append(":"); sb.append(p.getPort()); retVal = sb.toString().trim(); break; } } return retVal; } @Override void execute(); final File[] getBindingFiles(); } | @Test public void testGetActiveHttpProxy() throws IOException, XmlPullParserException { SettingsXpp3Reader r = new SettingsXpp3Reader(); Settings s = r.read(WsImportMojoTest.class.getResourceAsStream("proxy1.xml")); String proxyString = WsImportMojo.getActiveHttpProxy(s); Assert.assertEquals(proxyString, "proxyActive:8099"); s = r.read(WsImportMojoTest.class.getResourceAsStream("proxy2.xml")); proxyString = WsImportMojo.getActiveHttpProxy(s); Assert.assertNull(proxyString, proxyString); s = r.read(WsImportMojoTest.class.getResourceAsStream("proxy3.xml")); proxyString = WsImportMojo.getActiveHttpProxy(s); Assert.assertEquals(proxyString, "proxyuser:proxypwd@proxy1-auth:8080"); s = r.read(WsImportMojoTest.class.getResourceAsStream("proxy4.xml")); proxyString = WsImportMojo.getActiveHttpProxy(s); Assert.assertEquals(proxyString, "proxyuser2@proxy1-auth2:7777"); } |
TracingHttpClientBuilder extends HttpClientBuilder { public TracingHttpClientBuilder disableInjection() { this.injectDisabled = true; return this; } TracingHttpClientBuilder(); TracingHttpClientBuilder(
RedirectStrategy redirectStrategy,
boolean redirectHandlingDisabled); TracingHttpClientBuilder(
RedirectStrategy redirectStrategy,
boolean redirectHandlingDisabled,
Tracer tracer,
List<ApacheClientSpanDecorator> spanDecorators); static TracingHttpClientBuilder create(); TracingHttpClientBuilder withTracer(Tracer tracer); TracingHttpClientBuilder withSpanDecorators(List<ApacheClientSpanDecorator> decorators); TracingHttpClientBuilder disableInjection(); } | @Test public void testDisablePropagation() throws IOException { { HttpClient client = ((TracingHttpClientBuilder)clientBuilder).disableInjection().build(); client.execute(new HttpGet(serverUrl(RedirectHandler.MAPPING))); } List<MockSpan> mockSpans = mockTracer.finishedSpans(); Assert.assertEquals(3, mockSpans.size()); MockSpan mockSpan = mockSpans.get(1); Assert.assertEquals(PropagationHandler.lastRequest.getFirstHeader("traceId"), null); Assert.assertEquals(PropagationHandler.lastRequest.getFirstHeader("spanId"), null); assertLocalSpan(mockSpans.get(2)); } |
WXBizMsgCrypt { public String encrypt(String randomStr, String text) throws AesException { ByteGroup byteCollector = new ByteGroup(); byte[] randomStrBytes = randomStr.getBytes(CHARSET); byte[] textBytes = text.getBytes(CHARSET); byte[] networkBytesOrder = getNetworkBytesOrder(textBytes.length); byte[] appidBytes = appId.getBytes(CHARSET); byteCollector.addBytes(randomStrBytes); byteCollector.addBytes(networkBytesOrder); byteCollector.addBytes(textBytes); byteCollector.addBytes(appidBytes); byte[] padBytes = PKCS7Encoder.encode(byteCollector.size()); byteCollector.addBytes(padBytes); byte[] unencrypted = byteCollector.toBytes(); try { Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding"); SecretKeySpec keySpec = new SecretKeySpec(aesKey, "AES"); IvParameterSpec iv = new IvParameterSpec(aesKey, 0, 16); cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv); byte[] encrypted = cipher.doFinal(unencrypted); String base64Encrypted = base64.encodeToString(encrypted); return base64Encrypted; } catch (Exception e) { e.printStackTrace(); throw new AesException(AesException.EncryptAESError); } } WXBizMsgCrypt(String token, String encodingAesKey, String appId); String getRandomStr(); String encrypt(String randomStr, String text); String decrypt(String text); String encryptMsg(String replyMsg, String timeStamp, String nonce); String decryptMsg(String msgSignature, String timeStamp, String nonce, String encrypt); String verifyUrl(String msgSignature, String timeStamp, String nonce, String echoStr); } | @Test public void testAesEncrypt() { try { WXBizMsgCrypt pc = new WXBizMsgCrypt(token, encodingAesKey, appId); assertEquals(afterAesEncrypt, pc.encrypt(randomStr, replyMsg)); } catch (AesException e) { e.printStackTrace(); fail("no异常"); } }
@Test public void testAesEncrypt2() { try { WXBizMsgCrypt pc = new WXBizMsgCrypt(token, encodingAesKey, appId); assertEquals(afterAesEncrypt2, pc.encrypt(randomStr, replyMsg2)); } catch (AesException e) { e.printStackTrace(); fail("no异常"); } } |
WXBizMsgCrypt { public String verifyUrl(String msgSignature, String timeStamp, String nonce, String echoStr) throws AesException { String signature = SHA1.getSHA1(token, timeStamp, nonce, echoStr); if (!signature.equals(msgSignature)) { throw new AesException(AesException.ValidateSignatureError); } String result = decrypt(echoStr); return result; } WXBizMsgCrypt(String token, String encodingAesKey, String appId); String getRandomStr(); String encrypt(String randomStr, String text); String decrypt(String text); String encryptMsg(String replyMsg, String timeStamp, String nonce); String decryptMsg(String msgSignature, String timeStamp, String nonce, String encrypt); String verifyUrl(String msgSignature, String timeStamp, String nonce, String echoStr); } | @Test public void testVerifyUrl() throws AesException { WXBizMsgCrypt wxcpt = new WXBizMsgCrypt("QDG6eK", "jWmYm7qr5nMoAUwZRjGtBxmz3KA1tkAj3ykkR6q2B2C", "wx5823bf96d3bd56c7"); String verifyMsgSig = "5c45ff5e21c57e6ad56bac8758b79b1d9ac89fd3"; String timeStamp = "1409659589"; String nonce = "263014780"; String echoStr = "P9nAzCzyDtyTWESHep1vC5X9xho/qYX3Zpb4yKa9SKld1DsH3Iyt3tP3zNdtp+4RPcs8TgAE7OaBO+FZXvnaqQ=="; wxcpt.verifyUrl(verifyMsgSig, timeStamp, nonce, echoStr); } |
MainActivityPresenter implements MainActivityContract.Presenter { @VisibleForTesting void checkAndroidVersionCompatibility() { if (!supportedByArtist()) { mView.showIncompatibleAndroidVersionDialog(); } } MainActivityPresenter(MainActivityContract.View view,
SettingsManager settingsManager, Context context); @Override void start(); @Override void checkCompatibility(); static boolean isDeviceCompatible(Context context); @Override void openDex2OatHelpPage(); @Override void selectFragment(@selectableFragment int id); @Override void saveInstanceState(Bundle outState); @Override void restoreSavedInstanceState(Bundle savedInstanceState,
FragmentManager fragmentManager); } | @Test public void incompatibilityTest() throws Exception { setFinalStatic(Build.VERSION.class.getField("SDK_INT"), Build.VERSION_CODES.LOLLIPOP); mPresenter.checkAndroidVersionCompatibility(); verify(mView).showIncompatibleAndroidVersionDialog(); }
@Test public void compatibilityTest() throws Exception { setFinalStatic(Build.VERSION.class.getField("SDK_INT"), Build.VERSION_CODES.N); mPresenter.checkAndroidVersionCompatibility(); verify(mView, never()).showIncompatibleAndroidVersionDialog(); } |
MainActivityPresenter implements MainActivityContract.Presenter { @Override public void selectFragment(@selectableFragment int id) { Fragment selectedFragment = null; switch (id) { case INFO_FRAGMENT: if (mInfoFragment == null) { mInfoFragment = new InfoFragment(); } selectedFragment = mInfoFragment; break; case INSTRUMENTATION_FRAGMENT: if (mAppListFragment == null) { mAppListFragment = new AppListFragment(); } selectedFragment = mAppListFragment; break; case MODULES_FRAGMENT: if (mModuleFragment == null) { mModuleFragment = new ModuleFragment(); new ModulePresenter(mContext, mModuleFragment); } selectedFragment = mModuleFragment; break; } mSelectedFragmentId = id; mView.showSelectedFragment(selectedFragment); } MainActivityPresenter(MainActivityContract.View view,
SettingsManager settingsManager, Context context); @Override void start(); @Override void checkCompatibility(); static boolean isDeviceCompatible(Context context); @Override void openDex2OatHelpPage(); @Override void selectFragment(@selectableFragment int id); @Override void saveInstanceState(Bundle outState); @Override void restoreSavedInstanceState(Bundle savedInstanceState,
FragmentManager fragmentManager); } | @Test public void selectInfoFragment() throws Exception { mPresenter.selectFragment(MainActivityPresenter.INFO_FRAGMENT); verify(mView).showSelectedFragment(mArgumentCaptor.capture()); assertTrue(mArgumentCaptor.getValue() instanceof InfoFragment); }
@Test public void selectAppListFragment() throws Exception { mPresenter.selectFragment(MainActivityPresenter.INSTRUMENTATION_FRAGMENT); verify(mView).showSelectedFragment(mArgumentCaptor.capture()); assertTrue(mArgumentCaptor.getValue() instanceof AppListFragment); } |
POP3Store extends Store { @Override public synchronized boolean isConnected() { if (!super.isConnected()) return false; try { if (port == null) port = getPort(null); else if (!port.noop()) throw new IOException("NOOP failed"); return true; } catch (IOException ioex) { try { super.close(); } catch (MessagingException mex) { } return false; } } POP3Store(Session session, URLName url); POP3Store(Session session, URLName url,
String name, boolean isSSL); @Override synchronized boolean isConnected(); @Override synchronized void close(); @Override Folder getDefaultFolder(); @Override Folder getFolder(String name); @Override Folder getFolder(URLName url); Map<String, String> capabilities(); synchronized boolean isSSL(); } | @Test public void testIsConnected() { TestServer server = null; try { final POP3Handler handler = new POP3HandlerNoopErr(); server = new TestServer(handler); server.start(); final Properties properties = new Properties(); properties.setProperty("mail.pop3.host", "localhost"); properties.setProperty("mail.pop3.port", "" + server.getPort()); final Session session = Session.getInstance(properties); final Store store = session.getStore("pop3"); try { store.connect("test", "test"); final Folder folder = store.getFolder("INBOX"); folder.open(Folder.READ_ONLY); assertFalse(folder.isOpen()); } finally { store.close(); } } catch (final Exception e) { e.printStackTrace(); fail(e.getMessage()); } finally { if (server != null) { server.quit(); } } } |
SeverityComparator implements Comparator<LogRecord>, Serializable { private static String toString(final Object o1, final Object o2) { return o1 + ", " + o2; } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); } | @Test public void testByNullAndFrameworkInterrupted() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(this.headWidChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(this.headWidChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(this.headWidChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(this.headWidChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndInterrupted() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headIeChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIeChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIeChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIeChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndInterruptedSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headSubIeChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIeChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIeChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIeChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndInterruptedIo() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headIioeChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIioeChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIioeChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headIioeChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndInterruptedIoSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headSubIioeChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIioeChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIioeChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubIioeChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndThreadDeath() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headTdChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headTdChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headTdChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headTdChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndThreadDeathSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertEquals(r1.getLevel(), r2.getLevel()); r1.setThrown(headSubTdChain(null)); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubTdChain(new Error())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubTdChain(new RuntimeException())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); r1.setThrown(headSubTdChain(new Exception())); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndThrown() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); r1.setSequenceNumber(r2.getSequenceNumber()); setEpochMilli(r2, System.currentTimeMillis()); setEpochMilli(r1, r2.getMillis()); assertEquals(r1.getLevel(), r2.getLevel()); assertEquals(r1.getSequenceNumber(), r2.getSequenceNumber()); assertEquals(r1.getMillis(), r2.getMillis()); assertNull(r1.getThrown()); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertNull(r1.getThrown()); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertNull(r1.getThrown()); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByNullAndNullSeq() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); assertNull(r1.getThrown()); assertNull(r2.getThrown()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndThrownSeq() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); r1.setThrown(new Error()); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); r1.setThrown(new RuntimeException()); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); r1.setThrown(new Exception()); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndInterrupted() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(null)); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(null)); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(null)); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(new Error())); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(new RuntimeException())); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(new Exception())); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndInterruptedSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(null)); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(null)); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(null)); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(new Error())); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(new RuntimeException())); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIeChain(new Exception())); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndInterruptedIoSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIioeChain(null)); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIioeChain(null)); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubIioeChain(null)); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndThreadDeath() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(null)); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(null)); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(null)); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(new Error())); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(new RuntimeException())); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headTdChain(new Exception())); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testByThrownAndThreadDeathSub() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(null)); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(null)); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(null)); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(new Error())); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(new RuntimeException())); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headSubTdChain(new Exception())); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); }
@Test public void testOfClassLoadReadFailed() { Throwable clrf = new NoClassDefFoundError().initCause( new ClassNotFoundException("", new IOException())); Throwable readFailed = new IOException(); LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); r1.setThrown(readFailed); r2.setThrown(clrf); assertRecordLessThan(r1, r2); r1.setThrown(clrf); r2.setThrown(readFailed); assertRecordLessThan(r2, r1); }
@Test public void testOfClassLoadInterrupted() { Throwable cli = new NoClassDefFoundError().initCause( new ClassNotFoundException("", headIioeChain(null))); Throwable iioe = headIioeChain(null); LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); r1.setThrown(iioe); r2.setThrown(cli); assertRecordLessThan(r1, r2); r1.setThrown(cli); r2.setThrown(iioe); assertRecordLessThan(r2, r1); }
@Test public void testOfNpeVsIoe() { Throwable readFailed = new IOException(); Throwable npe = new IOException().initCause(new NullPointerException()); LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); r1.setThrown(readFailed); r2.setThrown(npe); assertRecordLessThan(r1, r2); r1.setThrown(npe); r2.setThrown(readFailed); assertRecordLessThan(r2, r1); }
@Test public void testToString() { final SeverityComparator a = new SeverityComparator(); assertNotNull(a.toString()); assertEquals(a.toString(), a.toString()); }
@Test public void testDeclaredClasses() throws Exception { Class<?>[] declared = SeverityComparator.class.getDeclaredClasses(); assertEquals(Arrays.toString(declared), 0, declared.length); }
@Test public void testLeadingErrorAndInterrupted() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.INFO, Level.INFO.toString()); swapSeq(r1, r2); assertEquals(r1.getLevel(), r2.getLevel()); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); r1.setThrown(headIeChain(new Error())); r2.setThrown(new Error(headIeChain(null))); assertRecordLessThan(r1, r2); r1.setThrown(headIeChain(new RuntimeException())); r2.setThrown(new Error(headIeChain(null))); assertRecordLessThan(r1, r2); r1.setThrown(headIeChain(new Exception())); r2.setThrown(new Error(headIeChain(null))); assertRecordLessThan(r1, r2); }
@Test public void testByLevel() { LogRecord r1 = new LogRecord(Level.INFO, Level.INFO.toString()); LogRecord r2 = new LogRecord(Level.WARNING, Level.WARNING.toString()); assertTrue(r1.getSequenceNumber() < r2.getSequenceNumber()); assertRecordLessThan(r1, r2); r1.setThrown(new Error()); r2.setThrown(null); assertRecordLessThan(r1, r2); assertEquals(Error.class, r1.getThrown().getClass()); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertEquals(Error.class, r1.getThrown().getClass()); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertEquals(Error.class, r1.getThrown().getClass()); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertEquals(Error.class, r1.getThrown().getClass()); r2.setThrown(new InterruptedException()); assertRecordLessThan(r1, r2); r1.setThrown(new RuntimeException()); r2.setThrown(null); assertRecordLessThan(r1, r2); assertEquals(RuntimeException.class, r1.getThrown().getClass()); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertEquals(RuntimeException.class, r1.getThrown().getClass()); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertEquals(RuntimeException.class, r1.getThrown().getClass()); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertEquals(RuntimeException.class, r1.getThrown().getClass()); r2.setThrown(new InterruptedException()); assertRecordLessThan(r1, r2); r1.setThrown(new Exception()); r2.setThrown(null); assertRecordLessThan(r1, r2); assertEquals(Exception.class, r1.getThrown().getClass()); r2.setThrown(new Error()); assertRecordLessThan(r1, r2); assertEquals(Exception.class, r1.getThrown().getClass()); r2.setThrown(new RuntimeException()); assertRecordLessThan(r1, r2); assertEquals(Exception.class, r1.getThrown().getClass()); r2.setThrown(new Exception()); assertRecordLessThan(r1, r2); assertEquals(Exception.class, r1.getThrown().getClass()); r2.setThrown(new InterruptedException()); assertRecordLessThan(r1, r2); swapSeq(r1, r2); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); assertRecordLessThan(r1, r2); r1.setThrown(null); r2.setThrown(null); assertTrue(r1.getSequenceNumber() > r2.getSequenceNumber()); assertRecordLessThan(r1, r2); } |
PropUtil { @Deprecated public static int getIntSessionProperty(Session session, String name, int def) { return getInt(getProp(session.getProperties(), name), def); } private PropUtil(); static int getIntProperty(Properties props, String name, int def); static boolean getBooleanProperty(Properties props,
String name, boolean def); @Deprecated static int getIntSessionProperty(Session session,
String name, int def); @Deprecated static boolean getBooleanSessionProperty(Session session,
String name, boolean def); static boolean getBooleanSystemProperty(String name, boolean def); } | @Test @SuppressWarnings("deprecation") public void testSessionIntDef() throws Exception { Properties props = new Properties(); Session sess = Session.getInstance(props, null); assertEquals(PropUtil.getIntSessionProperty(sess, "test", 1), 1); }
@Test @SuppressWarnings("deprecation") public void testSessionIntDefProp() throws Exception { Properties defprops = new Properties(); defprops.setProperty("test", "2"); Properties props = new Properties(defprops); Session sess = Session.getInstance(props, null); assertEquals(PropUtil.getIntSessionProperty(sess, "test", 1), 2); }
@Test @SuppressWarnings("deprecation") public void testSessionInteger() throws Exception { Properties props = new Properties(); props.put("test", 2); Session sess = Session.getInstance(props, null); assertEquals(PropUtil.getIntSessionProperty(sess, "test", 1), 2); }
@Test @SuppressWarnings("deprecation") public void testSessionInt() throws Exception { Properties props = new Properties(); props.setProperty("test", "2"); Session sess = Session.getInstance(props, null); assertEquals(PropUtil.getIntSessionProperty(sess, "test", 1), 2); } |
SeverityComparator implements Comparator<LogRecord>, Serializable { @Override public boolean equals(final Object o) { return o == null ? false : o.getClass() == getClass(); } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); } | @Test @SuppressWarnings("ObjectEqualsNull") public void testEquals() { final SeverityComparator a = new SeverityComparator(); final SeverityComparator b = new SeverityComparator(); assertNotSame(a, b); assertNotNull(a); assertFalse(a.equals(null)); assertNotNull(b); assertFalse(b.equals(null)); assertTrue(a.equals(a)); assertTrue(b.equals(b)); assertTrue(a.equals(b)); assertTrue(b.equals(a)); } |
SeverityComparator implements Comparator<LogRecord>, Serializable { @Override public int hashCode() { return 31 * getClass().hashCode(); } Throwable apply(final Throwable chain); final int applyThenCompare(Throwable tc1, Throwable tc2); int compareThrowable(final Throwable t1, final Throwable t2); @SuppressWarnings("override") //JDK-6954234 int compare(final LogRecord o1, final LogRecord o2); @Override boolean equals(final Object o); @Override int hashCode(); boolean isNormal(final Throwable t); } | @Test public void testHashCode() { final SeverityComparator a = new SeverityComparator(); final SeverityComparator b = new SeverityComparator(); assertNotSame(a, b); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertEquals(a.hashCode(), b.hashCode()); } |
CompactFormatter extends java.util.logging.Formatter { @Override public String format(final LogRecord record) { ResourceBundle rb = record.getResourceBundle(); Locale l = rb == null ? null : rb.getLocale(); String msg = formatMessage(record); String thrown = formatThrown(record); String err = formatError(record); Object[] params = { formatZonedDateTime(record), formatSource(record), formatLoggerName(record), formatLevel(record), msg, thrown, new Alternate(msg, thrown), new Alternate(thrown, msg), record.getSequenceNumber(), formatThreadID(record), err, new Alternate(msg, err), new Alternate(err, msg), formatBackTrace(record), record.getResourceBundleName(), record.getMessage()}; if (l == null) { return String.format(fmt, params); } else { return String.format(l, fmt, params); } } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormat() throws Exception { final String p = CompactFormatter.class.getName(); Properties props = new Properties(); props.put(p.concat(".format"), "%9$s"); LogManager manager = LogManager.getLogManager(); try { read(manager, props); CompactFormatter cf = new CompactFormatter(); LogRecord first = new LogRecord(Level.SEVERE, Level.INFO.getName()); first.setSequenceNumber(Short.MAX_VALUE); String result = cf.format(first); assertEquals(String.valueOf((int) Short.MAX_VALUE), result); } finally { manager.reset(); } }
@Test public void testNewFormatterWithPattern() { CompactFormatter cf = new CompactFormatter("%4$s"); String result = cf.format(new LogRecord(Level.SEVERE, "")); assertEquals(Level.SEVERE.getLocalizedName(), result); }
@Test public void testFormatWithMessage() { LogRecord record = new LogRecord(Level.SEVERE, "message"); CompactFormatter cf = new CompactFormatter(); String result = cf.format(record); assertTrue(result, result.startsWith(record.getMessage())); assertTrue(result, result.endsWith(LINE_SEP)); }
@Test public void testFormatWithMessagePrecisionOverWidth() { LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("thrown")); CompactFormatter cf = new CompactFormatter("%7$#6.12s"); String result = cf.format(record); assertEquals("mes|Throwable", result); }
@Test public void testFormatWithMessageWidthOverPrecision() { LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("thrown")); CompactFormatter cf = new CompactFormatter("%7$#12.6s"); String result = cf.format(record); assertEquals("mes\u0020\u0020\u0020|Thr\u0020\u0020\u0020", result); }
@Test public void testFormatWithMessageEmpty() { LogRecord record = new LogRecord(Level.SEVERE, ""); CompactFormatter cf = new CompactFormatter(); String result = cf.format(record); assertEquals(result, LINE_SEP); }
@Test public void testFormatMessageSurrogate() { LogRecord record = new LogRecord(Level.SEVERE, "a\ud801\udc00\ud801\udc00\ud801\udc00\ud801\udc00"); record.setThrown(new Throwable("thrown")); CompactFormatter cf = new CompactFormatter("%7$#.6s%n"); String result = cf.format(record); assertTrue(result, result.startsWith("a\ud801\udc00")); assertTrue(result, result.endsWith("|Thr" + LINE_SEP)); }
@Test public void testFormatWithMessageAndThrownLeftToRight() { LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("thrown")); CompactFormatter cf = new CompactFormatter(); String result = cf.format(record); assertTrue(result, result.startsWith(record.getMessage())); assertTrue(result, result.contains("|")); assertTrue(result, result.contains(Throwable.class.getSimpleName())); assertTrue(result, result.contains(CompactFormatterTest.class.getSimpleName())); assertTrue(result, result.contains("testFormatWithMessageAndThrown")); assertTrue(result, result.contains(String.valueOf( record.getThrown().getStackTrace()[0].getLineNumber()))); assertTrue(result, result.endsWith(LINE_SEP)); }
@Test public void testFormatMaxThrowableWidthLeftToRight() { String fmt = LEFT_TO_RIGHT; int width = MAX_PRE; assertTrue(fmt, fmt.contains(Integer.toString(width))); assertTrue(String.valueOf(width), width < Integer.MAX_VALUE / 4); CompactFormatter cf = new CompactFormatter(fmt); LogRecord record = new LogRecord(Level.SEVERE, ""); int padding = LINE_SEP.length(); for (int i = 0; i < width; i++) { record.setThrown(new Throwable(rpad("", i, "A"))); String result = cf.format(record); assertTrue(result, result.length() <= width + padding); assertTrue(result, result.endsWith(LINE_SEP)); } for (int i = width; i <= (width * 4); i++) { record.setThrown(new Throwable(rpad("", i, "A"))); String result = cf.format(record); assertTrue(result.length() + ", " + (width + padding), result.length() == width + padding); assertTrue(result, result.endsWith(LINE_SEP)); } }
@Test public void testFormatThrownClassDotSpace() { String msg = "test"; String prefix = IllegalStateException.class.getName() + ". "; Throwable t = new PrefixException(prefix, null, null); assertEquals(prefix, t.toString()); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; String cns = t.getClass().getSimpleName() + ": " + IllegalStateException.class.getSimpleName(); assertTrue(result, result.startsWith(cns)); assertTrue(result, result.indexOf(cns) == result.lastIndexOf(cns)); assertTrue(result, result.contains(msg)); assertTrue(result, result.indexOf(msg) == result.lastIndexOf(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatThrownSimpleClassNameNullMessage() { String op = "some op"; Throwable t = new PrefixException(PrefixException.class.getSimpleName() + ": " + op, (String) null, null); assertNull(t.getMessage()); assertNotNull(t.toString()); assertTrue(t.toString().startsWith(t.getClass().getSimpleName())); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; String sn = t.getClass().getSimpleName(); assertTrue(result, result.startsWith(sn)); assertTrue(result, result.indexOf(sn) == result.lastIndexOf(sn)); assertTrue(result, result.contains(op)); assertTrue(result, result.indexOf(op) == result.lastIndexOf(op)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatServerSidetMetroException() { String msg = "server error"; NullPointerException npe = new NullPointerException(msg); Throwable t = new PrefixException(npe.getClass().getName(), msg, null); assertEquals(msg, npe.getMessage()); assertEquals(msg, t.getMessage()); assertEquals(npe.toString(), t.toString()); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; String cns = t.getClass().getSimpleName() + ": " + npe.getClass().getSimpleName(); assertTrue(result, result.startsWith(cns)); assertTrue(result, result.indexOf(cns) == result.lastIndexOf(cns)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatThrownPrefixMessageRetainsFqn() { String msg = "java.io.tmpdir"; NullPointerException npe = new NullPointerException(msg); Throwable t = new PrefixException(npe.getClass().getName(), msg, null); assertEquals(msg, npe.getMessage()); assertEquals(msg, t.getMessage()); assertEquals(npe.toString(), t.toString()); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; String cns = t.getClass().getSimpleName() + ": " + npe.getClass().getSimpleName(); assertTrue(result, result.startsWith(cns)); assertTrue(result, result.indexOf(cns) == result.lastIndexOf(cns)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatThrownHiddenMessageRetainsFqn() { String msg = "java.io.tmpdir"; NullPointerException npe = new NullPointerException(msg); Throwable t = new ToStringException(npe.getClass().getName(), msg); assertEquals(msg, npe.getMessage()); assertEquals(msg, t.getMessage()); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; String cns = t.getClass().getSimpleName() + ": " + npe.getClass().getSimpleName(); assertTrue(result, result.startsWith(cns)); assertTrue(result, result.indexOf(cns) == result.lastIndexOf(cns)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatXMLParseXercesException() { String msg = "XML"; String prefix = "1:two:3:four"; Throwable t = new PrefixException(prefix, msg, null); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; assertTrue(prefix, t.toString().startsWith(prefix)); String cn = t.getClass().getSimpleName(); assertTrue(result, result.startsWith(cn)); assertTrue(result, result.indexOf(cn) == result.lastIndexOf(cn)); assertTrue(result, result.contains(prefix)); assertTrue(result, result.indexOf(prefix) == result.lastIndexOf(prefix)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatGSSException() { String msg = "Invalid name provided"; String prefix = PrefixException.class.getSimpleName(); Throwable t = new PrefixException(prefix, msg, null); assertTrue(t.toString().startsWith(t.getClass().getSimpleName())); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; assertTrue(prefix, t.toString().startsWith(prefix)); String cn = t.getClass().getSimpleName(); assertTrue(result, result.startsWith(cn)); assertTrue(result, result.indexOf(cn) == result.lastIndexOf(cn)); assertTrue(result, result.contains(prefix)); assertTrue(result, result.indexOf(prefix) == result.lastIndexOf(prefix)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatMismatchedTreeNodeException() { String prefix = ToStringException.class.getSimpleName() + '(' + String.class.getName() + "!=" + Throwable.class.getName() + ')'; Throwable t = new ToStringException(prefix, (String) null); assertNull(t.getLocalizedMessage()); assertNull(t.getMessage()); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; assertTrue(prefix, t.toString().startsWith(prefix)); String cn = t.getClass().getSimpleName(); assertTrue(result, result.startsWith(cn)); assertTrue(result, result.indexOf(cn) == result.lastIndexOf(cn)); assertTrue(result, result.contains(prefix)); assertTrue(result, result.indexOf(prefix) == result.lastIndexOf(prefix)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatInnerException() { String msg = "inner class"; String prefix = '(' + String.class.getName() + "!=" + Throwable.class.getName() + ')'; Throwable t = new ToStringException(ToStringException.class.getName() + prefix, msg); assertFalse(t.toString().contains(t.getLocalizedMessage())); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(t); CompactFormatter cf = new CompactFormatter("%6$s"); String result = cf.format(record); StackTraceElement[] ste = t.getStackTrace(); String frame = CompactFormatterTest.class.getSimpleName() + '.' + ste[0].getMethodName() + "(:" + ste[0].getLineNumber() + ")"; assertTrue(prefix, t.toString().contains(prefix)); String cn = t.getClass().getSimpleName(); assertTrue(result, result.startsWith(cn)); assertTrue(result, result.indexOf(cn) == result.lastIndexOf(cn)); assertTrue(result, result.contains(prefix)); assertTrue(result, result.indexOf(prefix) == result.lastIndexOf(prefix)); assertTrue(result, result.contains(msg)); assertTrue(result, result.endsWith(frame)); cf = new CompactFormatter("%11$s %14$s"); assertEquals(result, cf.format(record)); }
@Test public void testFormatMillis() { String p = "%1$tc"; CompactFormatter cf = new CompactFormatter(p); LogRecord r = new LogRecord(Level.SEVERE, ""); assertEquals(String.format(p, r.getMillis()), cf.format(r)); }
@Test public void testFormatMillisLocale() throws Exception { String p = "%1$tc"; CompactFormatter cf = new CompactFormatter(p); Properties props = new Properties(); LogRecord r = new LogRecord(Level.SEVERE, ""); r.setResourceBundle(new LocaleResource(props, Locale.ENGLISH)); assertEquals(String.format(Locale.ENGLISH, p, r.getMillis()), cf.format(r)); }
@Test public void testFormatMillisByParts() { String p = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp"; CompactFormatter cf = new CompactFormatter(p); LogRecord r = new LogRecord(Level.SEVERE, ""); assertEquals(String.format(p, r.getMillis()), cf.format(r)); }
@Test public void testFormatMillisByPartsLocale() throws Exception { String p = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS %1$Tp"; CompactFormatter cf = new CompactFormatter(p); Properties props = new Properties(); LogRecord r = new LogRecord(Level.SEVERE, ""); r.setResourceBundle(new LocaleResource(props, Locale.ENGLISH)); assertEquals(String.format(Locale.ENGLISH, p, r.getMillis()), cf.format(r)); }
@Test public void testFormatMillisAsLong() { String p = "%1$tQ"; CompactFormatter cf = new CompactFormatter(p); LogRecord r = new LogRecord(Level.SEVERE, ""); assertEquals(String.format(p, r.getMillis()), cf.format(r)); }
@Test public void testFormatZoneDateTime() throws Exception { LogRecord r = new LogRecord(Level.SEVERE, ""); Object zdt = LogManagerProperties.getZonedDateTime(r); if (zdt != null) { String p = "%1$tb %1$td, %1$tY %1$tl:%1$tM:%1$tS.%1$tN %1$Tp"; CompactFormatter cf = new CompactFormatter(p); assertEquals(String.format(p, zdt), cf.format(r)); } else { try { Method m = LogRecord.class.getMethod("getInstant"); fail(m.toString()); } catch (final NoSuchMethodException expect) { } } }
@Test(expected = NullPointerException.class) public void testFormatNull() { CompactFormatter cf = new CompactFormatter(); cf.format((LogRecord) null); }
@Test public void testFormatResourceBundleName() { CompactFormatter cf = new CompactFormatter("%15$s"); LogRecord r = new LogRecord(Level.SEVERE, ""); r.setResourceBundleName("name"); String output = cf.format(r); assertEquals(r.getResourceBundleName(), output); }
@Test public void testFormatSequence() { CompactFormatter cf = new CompactFormatter("%9$d"); LogRecord record = new LogRecord(Level.SEVERE, ""); String output = cf.format(record); String expect = Long.toString(record.getSequenceNumber()); assertEquals(expect, output); }
@Test public void testFormatErrorNullMessage() { CompactFormatter cf = new CompactFormatter("%11$s"); LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable()); String output = cf.format(record); assertNotNull(output); }
@Test public void testFormatMessageError() { CompactFormatter cf = new CompactFormatter("%12$s"); LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("error")); String output = cf.format(record); int t = output.indexOf(record.getThrown().getClass().getSimpleName()); int f = output.indexOf('|'); int m = output.indexOf(record.getThrown().getMessage()); assertTrue(output, t > -1); assertTrue(output, m > -1); assertTrue(output, f > -1); assertTrue(output, t < m); assertTrue(output, t > f); assertTrue(output, f < m); assertTrue(output, output.startsWith(record.getMessage())); }
@Test public void testFormatErrorMessage() { CompactFormatter cf = new CompactFormatter("%13$s"); LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("error")); String output = cf.format(record); int t = output.indexOf(record.getThrown().getClass().getSimpleName()); int f = output.indexOf('|'); int m = output.indexOf(record.getThrown().getMessage()); assertTrue(output, t > -1); assertTrue(output, m > -1); assertTrue(output, f > -1); assertTrue(output, t < m); assertTrue(output, t < f); assertTrue(output, f > m); assertTrue(output, output.endsWith(record.getMessage())); }
@Test public void testFormatExample1() { String p = "%7$#.160s%n"; LogRecord r = new LogRecord(Level.SEVERE, "Encoding failed."); RuntimeException npe = new NullPointerException(); StackTraceElement frame = new StackTraceElement("java.lang.String", "getBytes", "String.java", 913); npe.setStackTrace(new StackTraceElement[]{frame}); r.setThrown(npe); CompactFormatter cf = new CompactFormatter(p); String output = cf.format(r); assertNotNull(output); }
@Test public void testFormatExample2() { String p = "%7$#.20s%n"; LogRecord r = new LogRecord(Level.SEVERE, "Encoding failed."); RuntimeException npe = new NullPointerException(); StackTraceElement frame = new StackTraceElement("java.lang.String", "getBytes", "String.java", 913); npe.setStackTrace(new StackTraceElement[]{frame}); r.setThrown(npe); CompactFormatter cf = new CompactFormatter(p); String output = cf.format(r); assertNotNull(output); }
@Test public void testFormatExample3() { String p = "%1$tc %2$s%n%4$s: %5$s%6$s%n"; LogRecord r = new LogRecord(Level.SEVERE, "Encoding failed."); r.setSourceClassName("MyClass"); r.setSourceMethodName("fatal"); setEpochMilli(r, 1258723764000L); RuntimeException npe = new NullPointerException(); StackTraceElement frame = new StackTraceElement("java.lang.String", "getBytes", "String.java", 913); npe.setStackTrace(new StackTraceElement[]{frame}); r.setThrown(npe); CompactFormatter cf = new CompactFormatter(p); String output = cf.format(r); assertNotNull(output); }
@Test public void testFormatExample4() { String p = "%4$s: %12$#.160s%n"; LogRecord r = new LogRecord(Level.SEVERE, "Unable to send notification."); r.setSourceClassName("MyClass"); r.setSourceMethodName("fatal"); setEpochMilli(r, 1258723764000L); Exception t = new SocketException("Permission denied: connect"); t = new MessagingException("Couldn't connect to host", t); r.setThrown(t); CompactFormatter cf = new CompactFormatter(p); String output = cf.format(r); assertNotNull(output); }
@Test public void testFormatExample5() { String p = "[%9$d][%1$tT][%10$d][%2$s] %5$s%n%6$s%n"; LogRecord r = new LogRecord(Level.SEVERE, "Unable to send notification."); r.setSequenceNumber(125); r.setThreadID(38); r.setSourceClassName("MyClass"); r.setSourceMethodName("fatal"); setEpochMilli(r, 1248203502449L); Exception t = new SocketException("Permission denied: connect"); StackTraceElement frame = new StackTraceElement( "com.sun.mail.smtp.SMTPTransport", "openServer", "SMTPTransport.java", 1949); t.setStackTrace(new StackTraceElement[]{frame}); t = new MessagingException("Couldn't connect to host", t); r.setThrown(t); CompactFormatter cf = new CompactFormatter(p); String output = cf.format(r); assertNotNull(output); }
@Test public void testFormatIllegalPattern() { CompactFormatter f = new CompactFormatter("%1$#tc"); try { f.format(new LogRecord(Level.SEVERE, "")); fail("Expected format exception."); } catch (java.util.IllegalFormatException expect) { } }
@Test(expected = NullPointerException.class) public void testFormatApplyReturnsNull() { CompactFormatter cf = new ApplyReturnsNull(); LogRecord r = new LogRecord(Level.SEVERE, ""); for (int i = 0; i < 10; i++) { String output = cf.format(r); assertNotNull(output); r.setThrown(new Throwable(Integer.toString(i), r.getThrown())); assertNotNull(cf.format(r)); } } |
CompactFormatter extends java.util.logging.Formatter { @Override public String formatMessage(final LogRecord record) { String msg = super.formatMessage(record); msg = replaceClassName(msg, record.getThrown()); msg = replaceClassName(msg, record.getParameters()); return msg; } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test(expected = NullPointerException.class) public void testFormatMessageNull() { CompactFormatter cf = new CompactFormatter(); cf.formatMessage((LogRecord) null); fail(cf.toString()); }
@Test(timeout = 30000) public void testFormatMessage_LogRecordEvil() { LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(createEvilThrowable()); CompactFormatter cf = new CompactFormatter(); cf.formatMessage(record); }
@Test public void testFormatMessage_Throwable() { Exception e = new IOException(Exception.class.getName()); e = new Exception(e.toString(), e); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter(); String result = cf.formatMessage(e); assertEquals(IOException.class.getSimpleName() + ": " + Exception.class.getSimpleName(), result); }
@Test public void testFormatMessage_ThrowableNull() { CompactFormatter cf = new CompactFormatter(); String result = cf.formatMessage((Throwable) null); assertEquals("", result); }
@Test public void testFormatMessage_ThrowableNullMessage() { CompactFormatter cf = new CompactFormatter(); String result = cf.formatMessage(new Throwable()); String expect = Throwable.class.getSimpleName(); assertEquals(expect, result); }
@Test(timeout = 30000) public void testFormatMessage_ThrowableEvil() { CompactFormatter cf = new CompactFormatter(); cf.formatMessage(createEvilThrowable()); }
@Test(expected = NullPointerException.class) public void testFormatThrownMessageApplyReturnsNull() { CompactFormatter cf = new ApplyReturnsNull(); for (int i = 0; i < 10; i++) { String output = cf.formatMessage(new Throwable()); assertEquals(Throwable.class.getSimpleName(), output); } } |
PropUtil { @Deprecated public static boolean getBooleanSessionProperty(Session session, String name, boolean def) { return getBoolean(getProp(session.getProperties(), name), def); } private PropUtil(); static int getIntProperty(Properties props, String name, int def); static boolean getBooleanProperty(Properties props,
String name, boolean def); @Deprecated static int getIntSessionProperty(Session session,
String name, int def); @Deprecated static boolean getBooleanSessionProperty(Session session,
String name, boolean def); static boolean getBooleanSystemProperty(String name, boolean def); } | @Test @SuppressWarnings("deprecation") public void testSessionBool() throws Exception { Properties props = new Properties(); props.setProperty("test", "true"); Session sess = Session.getInstance(props, null); assertTrue(PropUtil.getBooleanSessionProperty(sess, "test", false)); }
@Test @SuppressWarnings("deprecation") public void testSessionBoolDef() throws Exception { Properties props = new Properties(); Session sess = Session.getInstance(props, null); assertTrue(PropUtil.getBooleanSessionProperty(sess, "test", true)); }
@Test @SuppressWarnings("deprecation") public void testSessionBoolDefProp() throws Exception { Properties defprops = new Properties(); defprops.setProperty("test", "true"); Properties props = new Properties(defprops); Session sess = Session.getInstance(props, null); assertTrue(PropUtil.getBooleanSessionProperty(sess, "test", false)); }
@Test @SuppressWarnings("deprecation") public void testSessionBoolean() throws Exception { Properties props = new Properties(); props.put("test", true); Session sess = Session.getInstance(props, null); assertTrue(PropUtil.getBooleanSessionProperty(sess, "test", false)); } |
CompactFormatter extends java.util.logging.Formatter { public String formatLevel(final LogRecord record) { return record.getLevel().getLocalizedName(); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatLevel() { CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); String result = cf.formatLevel(record); assertEquals(record.getLevel().getLocalizedName(), result); }
@Test(expected = NullPointerException.class) public void testFormatLevelNull() { CompactFormatter cf = new CompactFormatter(); cf.formatLevel((LogRecord) null); fail(cf.toString()); } |
CompactFormatter extends java.util.logging.Formatter { public String formatLoggerName(final LogRecord record) { return simpleClassName(record.getLoggerName()); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatLogger() { CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setSourceMethodName(null); record.setSourceClassName(null); record.setLoggerName(Object.class.getName()); String result = cf.formatLoggerName(record); assertEquals(Object.class.getSimpleName(), result); }
@Test(expected = NullPointerException.class) public void testFormatLoggerNull() { CompactFormatter cf = new CompactFormatter(); cf.formatLoggerName((LogRecord) null); fail(cf.toString()); } |
CompactFormatter extends java.util.logging.Formatter { public String formatSource(final LogRecord record) { String source = record.getSourceClassName(); if (source != null) { if (record.getSourceMethodName() != null) { source = simpleClassName(source) + " " + record.getSourceMethodName(); } else { source = simpleClassName(source); } } else { source = simpleClassName(record.getLoggerName()); } return source; } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatSourceByLogger() { CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setSourceMethodName(null); record.setSourceClassName(null); record.setLoggerName(Object.class.getName()); String result = cf.formatSource(record); assertEquals(Object.class.getSimpleName(), result); }
@Test(expected = NullPointerException.class) public void testFormatSourceNull() { CompactFormatter cf = new CompactFormatter(); cf.formatSource((LogRecord) null); fail(cf.toString()); }
@Test public void testFormatSourceByClass() { CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setSourceMethodName(null); record.setSourceClassName(Object.class.getName()); record.setLoggerName(""); String result = cf.formatSource(record); assertEquals(Object.class.getSimpleName(), result); }
@Test public void testFormatSourceByClassAndMethod() { CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setSourceMethodName("method"); record.setSourceClassName(Object.class.getName()); record.setLoggerName(""); String result = cf.formatSource(record); assertFalse(result, record.getSourceClassName().equals(record.getSourceMethodName())); assertTrue(result, result.startsWith(Object.class.getSimpleName())); assertTrue(result, result.endsWith(record.getSourceMethodName())); } |
CompactFormatter extends java.util.logging.Formatter { public String formatThrown(final LogRecord record) { String msg; final Throwable t = record.getThrown(); if (t != null) { String site = formatBackTrace(record); msg = formatMessage(t) + (isNullOrSpaces(site) ? "" : ' ' + site); } else { msg = ""; } return msg; } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test(timeout = 30000) public void testFormatThrownEvilThrown() { LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(createEvilThrowable()); CompactFormatter cf = new CompactFormatter(); cf.formatThrown(record); }
@Test public void testFormatThrown() { Exception e = new IOException("Fake I/O"); e = new Exception(e.toString(), e); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(e); String result = cf.formatThrown(record); assertTrue(result, result.startsWith(e.getCause().getClass().getSimpleName())); assertTrue(result, result.contains(cf.formatMessage(record.getThrown()))); assertTrue(result, result.endsWith(cf.formatBackTrace(record))); }
@Test public void testFormatThrownLocalized() { CountLocalizedException cle = new CountLocalizedException(); CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(cle); String result = cf.formatThrown(record); assertNotNull(result, result); assertTrue(cle.localizedMessage > 0); }
@Test(expected = NullPointerException.class) public void testFormatThrownNullRecord() { CompactFormatter cf = new CompactFormatter(); cf.formatThrown((LogRecord) null); fail(cf.toString()); } |
CompactFormatter extends java.util.logging.Formatter { public Number formatThreadID(final LogRecord record) { return (((long) record.getThreadID()) & 0xffffffffL); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatThreadID() { CompactFormatter cf = new CompactFormatter("%10$d"); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThreadID(10); String output = cf.format(record); String expect = Long.toString(record.getThreadID()); assertEquals(expect, output); record.setThreadID(-1); output = cf.format(record); expect = Long.toString((1L << 32L) - 1L); assertEquals(expect, output); Number id = cf.formatThreadID(record); assertEquals(record.getThreadID(), id.intValue()); assertEquals(expect, Long.toString(id.longValue())); }
@Test(expected = NullPointerException.class) public void testFormatThreadIDNull() { CompactFormatter cf = new CompactFormatter(); cf.formatThreadID((LogRecord) null); } |
CompactFormatter extends java.util.logging.Formatter { public String formatError(final LogRecord record) { return formatMessage(record.getThrown()); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatError() { CompactFormatter cf = new CompactFormatter("%11$s"); LogRecord record = new LogRecord(Level.SEVERE, "message"); record.setThrown(new Throwable("error")); String output = cf.format(record); assertTrue(output.startsWith(record.getThrown() .getClass().getSimpleName())); assertTrue(output.endsWith(record.getThrown().getMessage())); }
@Test(expected = NullPointerException.class) public void testFormatErrorNull() { CompactFormatter cf = new CompactFormatter(); cf.formatError((LogRecord) null); } |
PropUtil { public static boolean getBooleanSystemProperty(String name, boolean def) { try { return getBoolean(getProp(System.getProperties(), name), def); } catch (SecurityException sex) { } try { String value = System.getProperty(name); if (value == null) return def; if (def) return !value.equalsIgnoreCase("false"); else return value.equalsIgnoreCase("true"); } catch (SecurityException sex) { return def; } } private PropUtil(); static int getIntProperty(Properties props, String name, int def); static boolean getBooleanProperty(Properties props,
String name, boolean def); @Deprecated static int getIntSessionProperty(Session session,
String name, int def); @Deprecated static boolean getBooleanSessionProperty(Session session,
String name, boolean def); static boolean getBooleanSystemProperty(String name, boolean def); } | @Test public void testSystemBool() throws Exception { System.setProperty("test", "true"); assertTrue(PropUtil.getBooleanSystemProperty("test", false)); }
@Test public void testSystemBoolDef() throws Exception { assertTrue(PropUtil.getBooleanSystemProperty("testnotset", true)); }
@Test public void testSystemBoolean() throws Exception { System.getProperties().put("testboolean", true); assertTrue(PropUtil.getBooleanSystemProperty("testboolean", false)); } |
CompactFormatter extends java.util.logging.Formatter { public String formatBackTrace(final LogRecord record) { String site = ""; final Throwable t = record.getThrown(); if (t != null) { final Throwable root = apply(t); StackTraceElement[] trace = root.getStackTrace(); site = findAndFormat(trace); if (isNullOrSpaces(site)) { int limit = 0; for (Throwable c = t; c != null; c = c.getCause()) { StackTraceElement[] ste = c.getStackTrace(); site = findAndFormat(ste); if (!isNullOrSpaces(site)) { break; } else { if (trace.length == 0) { trace = ste; } } if (++limit == (1 << 16)) { break; } } if (isNullOrSpaces(site) && trace.length != 0) { site = formatStackTraceElement(trace[0]); } } } return site; } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testFormatBackTrace() { Exception e = new IOException("Fake I/O"); e = new Exception(e.toString(), e); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter("%14$s"); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(e); String result = cf.formatBackTrace(record); assertTrue(result, result.startsWith("CompactFormatterTest")); assertTrue(result, result.contains("testFormatBackTrace")); assertTrue(result, Character.isDigit(result.charAt(result.length() - 2))); assertFalse(result, result.contains(".java")); assertEquals(result, cf.format(record)); }
@Test public void testFormatBackTraceUnknown() { Exception e = new IOException("Fake I/O"); e.setStackTrace(new StackTraceElement[]{ new StackTraceElement(CompactFormatterTest.class.getName(), "testFormatBackTrace", null, -2)}); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(e); String result = cf.formatBackTrace(record); assertTrue(result, result.startsWith("CompactFormatterTest")); assertTrue(result, result.contains("testFormatBackTrace")); }
@Test public void testFormatBackTracePunt() { final Class<?> k = Collections.class; Exception e = new NullPointerException("Fake NPE"); e.setStackTrace(new StackTraceElement[]{ new StackTraceElement(k.getName(), "newSetFromMap", null, 3878)}); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(e); String result = cf.formatBackTrace(record); assertTrue(result, result.startsWith(k.getSimpleName())); assertTrue(result, result.contains("newSetFromMap")); }
@Test public void testFormatBackTraceChainPunt() { final Class<?> k = Collections.class; Throwable e = new NullPointerException("Fake NPE"); e.setStackTrace(new StackTraceElement[0]); e = new RuntimeException(e); e.setStackTrace(new StackTraceElement[]{ new StackTraceElement(k.getName(), "newSetFromMap", null, 3878)}); assertNotNull(e.getMessage(), e.getMessage()); CompactFormatter cf = new CompactFormatter(); LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(e); String result = cf.formatBackTrace(record); assertTrue(result, result.startsWith(k.getSimpleName())); assertTrue(result, result.contains("newSetFromMap")); }
@Test(expected = NullPointerException.class) public void testFormatBackTraceNull() { CompactFormatter cf = new CompactFormatter(); cf.formatBackTrace((LogRecord) null); fail(cf.toString()); }
@Test(timeout = 30000) public void testFormatBackTraceEvil() { LogRecord record = new LogRecord(Level.SEVERE, ""); record.setThrown(createEvilThrowable()); CompactFormatter cf = new CompactFormatter(); cf.formatBackTrace(record); } |
CompactFormatter extends java.util.logging.Formatter { protected Throwable apply(final Throwable t) { return SeverityComparator.getInstance().apply(t); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testApply() { CompactFormatter cf = new CompactFormatter(); assertNull(cf.apply((Throwable) null)); final Throwable t = new Throwable(); Throwable e = cf.apply(t); assertSame(t, e); }
@Test public void testApplyNull() { assertNull(new CompactFormatter().apply(null)); }
@Test(timeout = 30000) public void testApplyEvil() { CompactFormatter cf = new CompactFormatter(); assertNotNull(cf.apply(createEvilThrowable())); } |
CompactFormatter extends java.util.logging.Formatter { protected boolean ignore(final StackTraceElement s) { return isUnknown(s) || defaultIgnore(s); } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test(expected = NullPointerException.class) public void testIgnoreNull() { CompactFormatter cf = new CompactFormatter(); cf.ignore((StackTraceElement) null); fail(cf.toString()); }
@Test public void testIgnoreKnownClass() { CompactFormatter cf = new CompactFormatter(); String n = cf.getClass().getName(); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "format", f, 20); assertFalse(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreUnknownClass() { CompactFormatter cf = new CompactFormatter(); String n = UNKNOWN_CLASS_NAME; String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "format", f, 20); assertFalse(s.toString(), cf.ignore(s)); }
@Test public void testIgnorePrivateInnerClass() { CompactFormatter cf = new CompactFormatter(); String n = Arrays.asList("foo", "bar", "baz").getClass().getName(); assertTrue(n, n.contains("$")); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "size", f, 20); assertFalse(s.toString(), cf.ignore(s)); }
@Test public void testIgnorePrivateStaticInnerClass() { CompactFormatter cf = new CompactFormatter(); String n = Collections.emptySet().getClass().getName(); assertTrue(n, n.contains("$")); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "size", f, 20); assertFalse(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreStaticUtilityClass() { CompactFormatter cf = new CompactFormatter(); String n = MimeUtility.class.getName(); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "encodeText", f, 400); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreStaticUtilityClass_Util() { CompactFormatter cf = new CompactFormatter(); String n = getClass().getName().concat("MimeUtility"); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "encodeText", f, 400); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreStaticUtilityClass_s() { CompactFormatter cf = new CompactFormatter(); String n = getClass().getName().concat("Collections"); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "nCopies", f, 400); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreStaticUtilityClass_es() { CompactFormatter cf = new CompactFormatter(); String n = getClass().getName().concat("Properties"); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "get", f, 400); assertFalse(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreStaticUtilityClass_Throwables() { CompactFormatter cf = new CompactFormatter(); String n = getClass().getName().concat("Throwables"); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "propagate", f, 400); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreSyntheticMethod() { CompactFormatter cf = new CompactFormatter(); String n = UNKNOWN_CLASS_NAME; String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "access$100", f, 10); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreNativeMethod() { CompactFormatter cf = new CompactFormatter(); String n = UNKNOWN_CLASS_NAME; String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "foo", f, -2); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreReflectMethod() { CompactFormatter cf = new CompactFormatter(); String n = java.lang.reflect.Method.class.getName(); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "invoke", f, 10); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreReflectMethodApiError() { CompactFormatter cf = new CompactFormatter(); String n = "java.lang.reflect.".concat(getClass().getName()); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "invoke", f, 10); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreReflectMethodSunError() { CompactFormatter cf = new CompactFormatter(); String n = "sun.reflect.".concat(getClass().getName()); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "invoke", f, 10); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreReflectConstructor() { CompactFormatter cf = new CompactFormatter(); String n = java.lang.reflect.Constructor.class.getName(); String f = n.concat(".java"); StackTraceElement s = new StackTraceElement(n, "newInstance", f, 10); assertTrue(s.toString(), cf.ignore(s)); }
@Test public void testIgnoreUnknownLine() { CompactFormatter cf = new CompactFormatter(); String n = UNKNOWN_CLASS_NAME; StackTraceElement s = new StackTraceElement(n, "foo", null, -1); assertTrue(s.toString(), cf.ignore(s)); } |
PropUtil { public static int getIntProperty(Properties props, String name, int def) { return getInt(getProp(props, name), def); } private PropUtil(); static int getIntProperty(Properties props, String name, int def); static boolean getBooleanProperty(Properties props,
String name, boolean def); @Deprecated static int getIntSessionProperty(Session session,
String name, int def); @Deprecated static boolean getBooleanSessionProperty(Session session,
String name, boolean def); static boolean getBooleanSystemProperty(String name, boolean def); } | @Test public void testInt() throws Exception { Properties props = new Properties(); props.setProperty("test", "2"); assertEquals(PropUtil.getIntProperty(props, "test", 1), 2); }
@Test public void testIntDef() throws Exception { Properties props = new Properties(); assertEquals(PropUtil.getIntProperty(props, "test", 1), 1); }
@Test public void testIntDefProp() throws Exception { Properties defprops = new Properties(); defprops.setProperty("test", "2"); Properties props = new Properties(defprops); assertEquals(PropUtil.getIntProperty(props, "test", 1), 2); }
@Test public void testInteger() throws Exception { Properties props = new Properties(); props.put("test", 2); assertEquals(PropUtil.getIntProperty(props, "test", 1), 2); } |
CompactFormatter extends java.util.logging.Formatter { protected String toAlternate(final String s) { return s != null ? s.replaceAll("[\\x00-\\x1F\\x7F]+", "") : null; } CompactFormatter(); CompactFormatter(final String format); @Override String format(final LogRecord record); @Override String formatMessage(final LogRecord record); String formatMessage(final Throwable t); String formatLevel(final LogRecord record); String formatSource(final LogRecord record); String formatLoggerName(final LogRecord record); Number formatThreadID(final LogRecord record); String formatThrown(final LogRecord record); String formatError(final LogRecord record); String formatBackTrace(final LogRecord record); } | @Test public void testToAlternate() { CompactFormatter cf = new CompactFormatter(); assertEquals("", cf.toAlternate(LINE_SEP)); }
@Test public void testToAlternateNull() { CompactFormatter cf = new CompactFormatter(); assertNull(cf.toAlternate((String) null)); } |
CollectorFormatter extends Formatter { @Override public String toString() { String result; try { result = formatRecord((Handler) null, false); } catch (final RuntimeException ignore) { result = super.toString(); } return result; } CollectorFormatter(); CollectorFormatter(String format); CollectorFormatter(String format, Formatter f,
Comparator<? super LogRecord> c); @Override String format(final LogRecord record); @Override String getTail(final Handler h); @Override String toString(); } | @Test public void testDeclaredClasses() throws Exception { Class<?>[] declared = CollectorFormatter.class.getDeclaredClasses(); assertEquals(Arrays.toString(declared), 0, declared.length); } |
LogManagerProperties extends Properties { static void checkLogManagerAccess() { boolean checked = false; final Object m = LOG_MANAGER; if (m != null) { try { if (m instanceof LogManager) { checked = true; ((LogManager) m).checkAccess(); } } catch (final SecurityException notAllowed) { if (checked) { throw notAllowed; } } catch (final LinkageError restricted) { } catch (final RuntimeException unexpected) { } } if (!checked) { checkLoggingAccess(); } } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); } | @Test public void testCheckAccessPresent() { LogManager m = LogManager.getLogManager(); m.checkAccess(); LogManagerProperties.checkLogManagerAccess(); LogPermSecurityManager sm = new LogPermSecurityManager(); sm.secure = false; System.setSecurityManager(sm); try { sm.secure = true; try { m.checkAccess(); fail(m.toString()); } catch (SecurityException expect) { } try { LogManagerProperties.checkLogManagerAccess(); fail(LogManagerProperties.class.getName()); } catch (SecurityException expect) { } } finally { sm.secure = false; System.setSecurityManager((SecurityManager) null); } } |
CollectorFormatter extends Formatter { @Override public String format(final LogRecord record) { if (record == null) { throw new NullPointerException(); } boolean accepted; do { final LogRecord peek = peek(); LogRecord update = apply(peek != null ? peek : record, record); if (peek != update) { update.getSourceMethodName(); accepted = acceptAndUpdate(peek, update); } else { accepted = accept(peek, record); } } while (!accepted); return ""; } CollectorFormatter(); CollectorFormatter(String format); CollectorFormatter(String format, Formatter f,
Comparator<? super LogRecord> c); @Override String format(final LogRecord record); @Override String getTail(final Handler h); @Override String toString(); } | @Test(expected = NullPointerException.class) public void testFormatApplyReturnsNull() { CollectorFormatter f = new ApplyReturnsNull(); for (int i = 0; i < 10; i++) { String o = f.format(new LogRecord(Level.INFO, "")); assertNotNull(o); } }
@Test(expected = NullPointerException.class) public void testFormatNull() { CollectorFormatter f = new CollectorFormatter("{1}", (Formatter) null, (Comparator<LogRecord>) null); f.format((LogRecord) null); }
@Test public void testFormat() throws Exception { final String p = CollectorFormatter.class.getName(); Properties props = new Properties(); final String expect = CollectorFormatterTest.class.getName(); props.put(p.concat(".format"), expect); LogManager manager = LogManager.getLogManager(); try { read(manager, props); CollectorFormatter cf = new CollectorFormatter(); LogRecord first = new LogRecord(Level.SEVERE, Level.SEVERE.getName()); assertEquals("", cf.format(first)); String result = cf.getTail((Handler) null); assertEquals(expect, result); } finally { manager.reset(); } } |
CollectorFormatter extends Formatter { @Override public String getTail(final Handler h) { super.getTail(h); return formatRecord(h, true); } CollectorFormatter(); CollectorFormatter(String format); CollectorFormatter(String format, Formatter f,
Comparator<? super LogRecord> c); @Override String format(final LogRecord record); @Override String getTail(final Handler h); @Override String toString(); } | @Test public void testFormatNextMin() throws Exception { CollectorFormatter minF = new CollectorFormatter("{7}", (Formatter) null, (Comparator<LogRecord>) null); tickMilli(); final String min = minF.getTail((Handler) null); NumberFormat.getIntegerInstance().parse(min); tickMilli(); String next = minF.getTail((Handler) null); assertFalse(min + ' ' + next, min.equals(next)); CollectorFormatter initF = new CollectorFormatter("{10}", (Formatter) null, (Comparator<LogRecord>) null); next = initF.getTail((Handler) null); assertEquals(min, next); }
@Test public void testFormatNextMax() throws Exception { CollectorFormatter f = new CollectorFormatter("{8}", (Formatter) null, (Comparator<LogRecord>) null); String now = f.getTail((Handler) null); Number num = NumberFormat.getIntegerInstance().parse(now); assertFalse(Long.MIN_VALUE == num.longValue()); tickMilli(); String next = f.getTail((Handler) null); assertFalse(NumberFormat.getIntegerInstance().parse(now).longValue() == Long.MIN_VALUE); assertFalse(now.equals(next)); }
@Test public void testGetTail() { CollectorFormatter f = new CollectorFormatter( "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}", (Formatter) null, (Comparator<LogRecord>) null); assertTrue(f.getTail((Handler) null).length() != 0); assertTrue(f.getTail((Handler) null).length() != 0); }
@Test public void testFormatInitTimeMillis() throws Exception { CollectorFormatter f = new CollectorFormatter("{10}", (Formatter) null, (Comparator<LogRecord>) null); String init = f.getTail((Handler) null); NumberFormat.getIntegerInstance().parse(init); tickMilli(); assertTrue(init.equals(f.getTail((Handler) null))); }
@Test public void testFormatInitTimeDateTime() throws Exception { CollectorFormatter f = new CollectorFormatter( "{10,date," + DATE_TIME_FMT + "}", (Formatter) null, (Comparator<LogRecord>) null); String init = f.getTail((Handler) null); DateFormat df = new SimpleDateFormat(DATE_TIME_FMT); Date dt = df.parse(init); tickMilli(); assertTrue(init.equals(f.getTail((Handler) null))); assertTrue(dt.equals(df.parse(f.getTail((Handler) null)))); }
@Test public void testFormatCurrentTimeMillis() throws Exception { CollectorFormatter f = new CollectorFormatter("{11}", (Formatter) null, (Comparator<LogRecord>) null); String now = f.getTail((Handler) null); NumberFormat.getIntegerInstance().parse(now); tickMilli(); assertFalse(now.equals(f.getTail((Handler) null))); }
@Test public void testFormatCurrentTimeDateTime() throws Exception { CollectorFormatter f = new CollectorFormatter( "{11,date," + DATE_TIME_FMT + "}", (Formatter) null, (Comparator<LogRecord>) null); String init = f.getTail((Handler) null); DateFormat df = new SimpleDateFormat(DATE_TIME_FMT); Date dt = df.parse(init); tickMilli(); assertFalse(init.equals(f.getTail((Handler) null))); assertFalse(dt.equals(df.parse(f.getTail((Handler) null)))); }
@Test public void testFormatUpTime() throws Exception { CollectorFormatter f = new CollectorFormatter("{12}", (Formatter) null, (Comparator<LogRecord>) null); String up = f.getTail((Handler) null); NumberFormat.getIntegerInstance().parse(up); tickMilli(); assertFalse(up.equals(f.getTail((Handler) null))); } |
LogManagerProperties extends Properties { @Override @SuppressWarnings("CloneDoesntCallSuperClone") public synchronized Object clone() { return exportCopy(defaults); } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); } | @Test public void testClone() throws Exception { String prefix = LogManagerPropertiesTest.class.getName(); Properties parent; LogManagerProperties mp; LogManager manager = LogManager.getLogManager(); try { String key = prefix.concat(".dummy"); parent = new Properties(); parent.put(key, "value"); read(manager, parent); parent = new Properties(); mp = new LogManagerProperties(parent, prefix); assertFalse(contains(mp, key, null)); assertEquals("value", mp.getProperty(key)); assertTrue(contains(mp, key, "value")); } finally { manager.reset(); } Properties clone = (Properties) mp.clone(); assertFalse(clone instanceof LogManagerProperties); assertEquals(Properties.class, clone.getClass()); assertNotSame(clone, parent); assertNotSame(clone, mp); assertEquals(mp.size(), clone.size()); assertTrue(clone.equals(mp)); } |
DurationFilter implements Filter { @Override public String toString() { boolean idle; boolean loggable; synchronized (this) { final long millis = System.currentTimeMillis(); idle = test(0L, millis); loggable = test(records, millis); } return getClass().getName() + "{records=" + records + ", duration=" + duration + ", idle=" + idle + ", loggable=" + loggable + '}'; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); } | @Test public void testDeclaredClasses() throws Exception { Class<?>[] declared = DurationFilter.class.getDeclaredClasses(); assertEquals(Arrays.toString(declared), 0, declared.length); }
@Test public void testToString() { testToString(new DurationFilter()); } |
LogManagerProperties extends Properties { static boolean isReflectionClass(String name) throws Exception { String[] names = REFLECT_NAMES; if (names == null) { REFLECT_NAMES = names = reflectionClassNames(); } for (String rf : names) { if (name.equals(rf)) { return true; } } findClass(name); return false; } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); } | @Test public void testIsReflection() throws Exception { assertTrue(LogManagerProperties.isReflectionClass(Constructor.class.getName())); assertTrue(LogManagerProperties.isReflectionClass(Method.class.getName())); } |
DurationFilter implements Filter { @Override protected DurationFilter clone() throws CloneNotSupportedException { final DurationFilter clone = (DurationFilter) super.clone(); clone.count = 0L; clone.peak = 0L; clone.start = 0L; return clone; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); } | @Test public void testClone() throws Exception { DurationFilterExt source = new DurationFilterExt(); final Filter clone = source.clone(); assertNotNull(clone); assertFalse(source == clone); assertTrue(source.equals(clone)); assertEquals(source.getClass(), clone.getClass()); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(source.isLoggable(r)); assertFalse(source.equals(clone)); assertTrue(((DurationFilterExt) clone).clone().equals(clone)); } |
DurationFilter implements Filter { @SuppressWarnings("override") public boolean isLoggable(final LogRecord record) { return accept(record.getMillis()); } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); } | @Test public void testPredictedOverflow() { int records = 4; int duration = 4; DurationFilter sf = new DurationFilter(records, duration); for (int i = 0; i < records; i++) { LogRecord r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE); assertTrue(sf.isLoggable(r)); } LogRecord r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE); assertFalse(sf.isLoggable(r)); r = new LogRecord(Level.INFO, ""); setEpochMilli(r, Long.MAX_VALUE + duration); assertTrue(sf.isLoggable(r)); }
@Test(expected = NullPointerException.class) public void testIsLoggableNull() { new DurationFilter().isLoggable((LogRecord) null); } |
DurationFilter implements Filter { @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } final DurationFilter other = (DurationFilter) obj; if (this.records != other.records) { return false; } if (this.duration != other.duration) { return false; } final long c; final long p; final long s; synchronized (this) { c = this.count; p = this.peak; s = this.start; } synchronized (other) { if (c != other.count || p != other.peak || s != other.start) { return false; } } return true; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); } | @Test public void testEquals() { DurationFilter one = new DurationFilter(); DurationFilter two = new DurationFilter(); assertTrue(one.equals(one)); assertTrue(two.equals(two)); assertTrue(one.equals(two)); assertTrue(two.equals(one)); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(one.isLoggable(r)); assertTrue(one.equals(one)); assertTrue(two.equals(two)); assertFalse(one.equals(two)); assertFalse(two.equals(one)); assertFalse(one.equals((Object) null)); assertFalse(two.equals((Object) null)); } |
DurationFilter implements Filter { @Override public int hashCode() { int hash = 3; hash = 89 * hash + (int) (this.records ^ (this.records >>> 32)); hash = 89 * hash + (int) (this.duration ^ (this.duration >>> 32)); return hash; } DurationFilter(); DurationFilter(final long records, final long duration); @Override boolean equals(final Object obj); boolean isIdle(); @Override int hashCode(); @SuppressWarnings("override") //JDK-6954234 boolean isLoggable(final LogRecord record); boolean isLoggable(); @Override String toString(); } | @Test public void testHashCode() { DurationFilter one = new DurationFilter(10, 10); DurationFilter two = new DurationFilter(10, 10); DurationFilter three = new DurationFilter(3, 3); assertTrue(one.hashCode() == two.hashCode()); assertFalse(one.hashCode() == three.hashCode()); LogRecord r = new LogRecord(Level.INFO, ""); assertTrue(one.isLoggable(r)); assertTrue(one.hashCode() == two.hashCode()); assertFalse(one.hashCode() == three.hashCode()); } |
LineInputStream extends FilterInputStream { @SuppressWarnings("deprecation") public String readLine() throws IOException { byte[] buf = lineBuffer; if (buf == null) buf = lineBuffer = new byte[128]; int c1; int room = buf.length; int offset = 0; while ((c1 = in.read()) != -1) { if (c1 == '\n') break; else if (c1 == '\r') { boolean twoCRs = false; if (in.markSupported()) in.mark(2); int c2 = in.read(); if (c2 == '\r') { twoCRs = true; c2 = in.read(); } if (c2 != '\n') { if (in.markSupported()) in.reset(); else { if (!(in instanceof PushbackInputStream)) in = new PushbackInputStream(in, 2); if (c2 != -1) ((PushbackInputStream)in).unread(c2); if (twoCRs) ((PushbackInputStream)in).unread('\r'); } } break; } if (--room < 0) { if (buf.length < MAX_INCR) buf = new byte[buf.length * 2]; else buf = new byte[buf.length + MAX_INCR]; room = buf.length - offset - 1; System.arraycopy(lineBuffer, 0, buf, 0, offset); lineBuffer = buf; } buf[offset++] = (byte)c1; } if ((c1 == -1) && (offset == 0)) return null; if (allowutf8) return new String(buf, 0, offset, StandardCharsets.UTF_8); else return new String(buf, 0, 0, offset); } LineInputStream(InputStream in); LineInputStream(InputStream in, boolean allowutf8); @SuppressWarnings("deprecation") // for old String constructor String readLine(); } | @Test public void testLines() throws IOException { for (String s : lines) { LineInputStream is = createStream(s); assertEquals("line1", is.readLine()); assertEquals("line2", is.readLine()); assertEquals("line3", is.readLine()); assertEquals(null, is.readLine()); } }
@Test public void testEmpty() throws IOException { for (String s : empty) { LineInputStream is = createStream(s); assertEquals("", is.readLine()); assertEquals("", is.readLine()); assertEquals("", is.readLine()); assertEquals(null, is.readLine()); } }
@Test public void testMixed() throws IOException { for (String s : mixed) { LineInputStream is = createStream(s); assertEquals("line1", is.readLine()); assertEquals("", is.readLine()); assertEquals("line3", is.readLine()); assertEquals(null, is.readLine()); } } |
WriteTimeoutSocket extends Socket { @Override public String toString() { return socket.toString(); } WriteTimeoutSocket(Socket socket, int timeout); WriteTimeoutSocket(int timeout); WriteTimeoutSocket(InetAddress address, int port, int timeout); WriteTimeoutSocket(InetAddress address, int port,
InetAddress localAddress, int localPort, int timeout); WriteTimeoutSocket(String host, int port, int timeout); WriteTimeoutSocket(String host, int port,
InetAddress localAddress, int localPort, int timeout); @Override void connect(SocketAddress remote); @Override void connect(SocketAddress remote, int timeout); @Override void bind(SocketAddress local); @Override SocketAddress getRemoteSocketAddress(); @Override SocketAddress getLocalSocketAddress(); @Override void setPerformancePreferences(int connectionTime, int latency,
int bandwidth); @Override SocketChannel getChannel(); @Override InetAddress getInetAddress(); @Override InetAddress getLocalAddress(); @Override int getPort(); @Override int getLocalPort(); @Override InputStream getInputStream(); @Override synchronized OutputStream getOutputStream(); @Override void setTcpNoDelay(boolean on); @Override boolean getTcpNoDelay(); @Override void setSoLinger(boolean on, int linger); @Override int getSoLinger(); @Override void sendUrgentData(int data); @Override void setOOBInline(boolean on); @Override boolean getOOBInline(); @Override void setSoTimeout(int timeout); @Override int getSoTimeout(); @Override void setSendBufferSize(int size); @Override int getSendBufferSize(); @Override void setReceiveBufferSize(int size); @Override int getReceiveBufferSize(); @Override void setKeepAlive(boolean on); @Override boolean getKeepAlive(); @Override void setTrafficClass(int tc); @Override int getTrafficClass(); @Override void setReuseAddress(boolean on); @Override boolean getReuseAddress(); @Override void close(); @Override void shutdownInput(); @Override void shutdownOutput(); @Override String toString(); @Override boolean isConnected(); @Override boolean isBound(); @Override boolean isClosed(); @Override boolean isInputShutdown(); @Override boolean isOutputShutdown(); Socket setOption(SocketOption<T> so, T val); T getOption(SocketOption<T> so); Set<SocketOption<?>> supportedOptions(); FileDescriptor getFileDescriptor(); } | @Test public void testOverrides() throws Exception { Set<String> socketMethods = new HashSet<>(); Method[] m = java.net.Socket.class.getDeclaredMethods(); String className = java.net.Socket.class.getName() + "."; for (int i = 0; i < m.length; i++) { if (Modifier.isPublic(m[i].getModifiers()) && !Modifier.isStatic(m[i].getModifiers())) { String name = m[i].toString(). replace("synchronized ", ""). replace(className, ""); socketMethods.add(name); } } Set<String> wtsocketMethods = new HashSet<>(); m = WriteTimeoutSocket.class.getDeclaredMethods(); className = WriteTimeoutSocket.class.getName() + "."; for (int i = 0; i < m.length; i++) { if (Modifier.isPublic(m[i].getModifiers())) { String name = m[i].toString(). replace("synchronized ", ""). replace(className, ""); socketMethods.remove(name); } } for (String s : socketMethods) System.out.println("WriteTimeoutSocket did not override: " + s); assertTrue(socketMethods.isEmpty()); } |
Response { public String readAtom() { return readDelimString(ATOM_CHAR_DELIM); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; } | @Test public void testAtom() throws Exception { for (String s : atomTests) { Response r = new Response("* " + s); assertEquals("atom", r.readAtom()); } for (String s : atomTests) { Response r = new Response("* " + s + " "); assertEquals("atom", r.readAtom()); } } |
Response { public String readAtomString() { return (String)parseString(true, true); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; } | @Test public void testAString() throws Exception { for (String s : astringTests) { Response r = new Response("* " + s); assertEquals("atom", r.readAtomString()); } for (String s : astringTests) { Response r = new Response("* " + s + " "); assertEquals("atom", r.readAtomString()); } }
@Test public void testAStringSpecial() throws Exception { Response r = new Response("* " + "atom] "); assertEquals("atom]", r.readAtomString()); } |
Response { public String[] readAtomStringList() { return readStringList(true); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; } | @Test public void testAStringList() throws Exception { Response r = new Response("* " + "(A B C)"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListInitialSpace() throws Exception { Response r = new Response("* " + "( A B C)"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListTrailingSpace() throws Exception { Response r = new Response("* " + "(A B C )"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListInitialAndTrailingSpace() throws Exception { Response r = new Response("* " + "( A B C )"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListMultipleSpaces() throws Exception { Response r = new Response("* " + "(A B C)"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListQuoted() throws Exception { Response r = new Response("* " + "(A B \"C\")"); assertArrayEquals(new String[] { "A", "B", "C" }, r.readAtomStringList()); }
@Test public void testAStringListEmpty() throws Exception { Response r = new Response("* " + "()"); assertArrayEquals(new String[0], r.readAtomStringList()); } |
LogManagerProperties extends Properties { static String getLocalHost(final Object s) throws Exception { try { final Method m = s.getClass().getMethod("getLocalHost"); if (!Modifier.isStatic(m.getModifiers()) && m.getReturnType() == String.class) { return (String) m.invoke(s); } else { throw new NoSuchMethodException(m.toString()); } } catch (final ExceptionInInitializerError EIIE) { throw wrapOrThrow(EIIE); } catch (final InvocationTargetException ite) { throw paramOrError(ite); } } LogManagerProperties(final Properties parent, final String prefix); @Override @SuppressWarnings("CloneDoesntCallSuperClone") synchronized Object clone(); @Override synchronized String getProperty(final String key); @Override String getProperty(final String key, final String def); @Override synchronized Object get(final Object key); @Override synchronized Object put(final Object key, final Object value); @Override Object setProperty(String key, String value); @Override synchronized boolean containsKey(final Object key); @Override synchronized Object remove(final Object key); @Override Enumeration<?> propertyNames(); @Override boolean equals(final Object o); @Override int hashCode(); } | @Test public void testGetLocalHost() throws Exception { String host = LogManagerPropertiesTest.class.getName(); Properties p = new Properties(); p.setProperty("mail.smtp.localhost", host); Session s = Session.getInstance(p); Transport t = s.getTransport(InternetAddress.getLocalAddress(s)); try { String h = LogManagerProperties.getLocalHost(t); if (h != null || isPrivateSpec(t.getClass())) { Assert.assertEquals(host, h); } } catch (NoSuchMethodException notOfficial) { if (isPrivateSpec(t.getClass())) { fail(t.toString()); } } }
@Test public void testGetLocalHostMissing() throws Exception { Session session = Session.getInstance(new Properties()); Service svc = new NoHostService(session); try { LogManagerProperties.getLocalHost(svc); fail(""); } catch (NoSuchMethodException expect) { } }
@Test public void testGetLocalHostSecure() throws Exception { Session session = Session.getInstance(new Properties()); Service svc = new NotAllowedService(session); try { LogManagerProperties.getLocalHost(svc); } catch (SecurityException allowed) { } catch (InvocationTargetException expect) { Assert.assertTrue(expect.getCause() instanceof SecurityException); } }
@Test public void testGetLocalHostNull() throws Exception { boolean fail = true; try { LogManagerProperties.getLocalHost((Service) null); } catch (NullPointerException expected) { fail = false; } Assert.assertFalse(fail); } |
Response { public String[] readStringList() { return readStringList(false); } Response(String s); Response(String s, boolean supportsUtf8); Response(Protocol p); Response(Response r); static Response byeResponse(Exception ex); boolean supportsUtf8(); void skipSpaces(); boolean isNextNonSpace(char c); void skipToken(); void skip(int count); byte peekByte(); byte readByte(); String readAtom(); String readString(char delim); String[] readStringList(); String[] readAtomStringList(); int readNumber(); long readLong(); String readString(); ByteArrayInputStream readBytes(); ByteArray readByteArray(); String readAtomString(); int getType(); boolean isContinuation(); boolean isTagged(); boolean isUnTagged(); boolean isOK(); boolean isNO(); boolean isBAD(); boolean isBYE(); boolean isSynthetic(); String getTag(); String getRest(); Exception getException(); void reset(); @Override String toString(); final static int TAG_MASK; final static int CONTINUATION; final static int TAGGED; final static int UNTAGGED; final static int TYPE_MASK; final static int OK; final static int NO; final static int BAD; final static int BYE; final static int SYNTHETIC; } | @Test public void testBadStringList() throws Exception { Response response = new Response( "* (\"name\", \"test\", \"version\", \"1.0\")"); String[] list = response.readStringList(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.